$field.write($stream)?;
};
($stream: expr, $type: expr, $field: expr, vec_type) => {
- encode_tlv!($stream, $type, ::util::ser::VecWriteWrapper(&$field), required);
+ encode_tlv!($stream, $type, $crate::util::ser::WithoutLength(&$field), required);
};
($stream: expr, $optional_type: expr, $optional_field: expr, option) => {
if let Some(ref field) = $optional_field {
field.write($stream)?;
}
};
+ ($stream: expr, $type: expr, $field: expr, (option, encoding: ($fieldty: ty, $encoding: ident))) => {
+ encode_tlv!($stream, $type, $field.map(|f| $encoding(f)), option);
+ };
+ ($stream: expr, $type: expr, $field: expr, (option, encoding: $fieldty: ty)) => {
+ encode_tlv!($stream, $type, $field, option);
+ };
}
macro_rules! encode_tlv_stream {
($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),* $(,)*}) => { {
#[allow(unused_imports)]
- use {
+ use $crate::{
ln::msgs::DecodeError,
util::ser,
util::ser::BigSize,
$len.0 += field_len;
};
($len: expr, $type: expr, $field: expr, vec_type) => {
- get_varint_length_prefixed_tlv_length!($len, $type, ::util::ser::VecWriteWrapper(&$field), required);
+ get_varint_length_prefixed_tlv_length!($len, $type, $crate::util::ser::WithoutLength(&$field), required);
};
($len: expr, $optional_type: expr, $optional_field: expr, option) => {
if let Some(ref field) = $optional_field {
macro_rules! encode_varint_length_prefixed_tlv {
($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),*}) => { {
- use util::ser::BigSize;
+ use $crate::util::ser::BigSize;
let len = {
#[allow(unused_mut)]
- let mut len = ::util::ser::LengthCalculatingWriter(0);
+ let mut len = $crate::util::ser::LengthCalculatingWriter(0);
$(
get_varint_length_prefixed_tlv_length!(len, $type, $field, $fieldty);
)*
#[allow(unused_comparisons)] // Note that $type may be 0 making the second comparison always true
let invalid_order = ($last_seen_type.is_none() || $last_seen_type.unwrap() < $type) && $typ.0 > $type;
if invalid_order {
- $field = $default;
+ $field = $default.into();
}
}};
($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, required) => {{
($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, ignorable) => {{
// no-op
}};
+ ($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, (option: $trait: ident $(, $read_arg: expr)?)) => {{
+ // no-op
+ }};
+ ($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, (option, encoding: $encoding: tt)) => {{
+ // no-op
+ }};
}
macro_rules! check_missing_tlv {
#[allow(unused_comparisons)] // Note that $type may be 0 making the second comparison always true
let missing_req_type = $last_seen_type.is_none() || $last_seen_type.unwrap() < $type;
if missing_req_type {
- $field = $default;
+ $field = $default.into();
}
}};
($last_seen_type: expr, $type: expr, $field: ident, required) => {{
($last_seen_type: expr, $type: expr, $field: ident, ignorable) => {{
// no-op
}};
+ ($last_seen_type: expr, $type: expr, $field: ident, (option: $trait: ident $(, $read_arg: expr)?)) => {{
+ // no-op
+ }};
+ ($last_seen_type: expr, $type: expr, $field: ident, (option, encoding: $encoding: tt)) => {{
+ // no-op
+ }};
}
macro_rules! decode_tlv {
decode_tlv!($reader, $field, required)
}};
($reader: expr, $field: ident, required) => {{
- $field = ser::Readable::read(&mut $reader)?;
+ $field = $crate::util::ser::Readable::read(&mut $reader)?;
}};
($reader: expr, $field: ident, vec_type) => {{
- $field = Some(ser::Readable::read(&mut $reader)?);
+ let f: $crate::util::ser::WithoutLength<Vec<_>> = $crate::util::ser::Readable::read(&mut $reader)?;
+ $field = Some(f.0);
}};
($reader: expr, $field: ident, option) => {{
- $field = Some(ser::Readable::read(&mut $reader)?);
+ $field = Some($crate::util::ser::Readable::read(&mut $reader)?);
}};
($reader: expr, $field: ident, ignorable) => {{
- $field = ser::MaybeReadable::read(&mut $reader)?;
+ $field = $crate::util::ser::MaybeReadable::read(&mut $reader)?;
+ }};
+ ($reader: expr, $field: ident, (option: $trait: ident $(, $read_arg: expr)?)) => {{
+ $field = Some($trait::read(&mut $reader $(, $read_arg)*)?);
+ }};
+ ($reader: expr, $field: ident, (option, encoding: ($fieldty: ty, $encoding: ident))) => {{
+ $field = {
+ let field: $encoding<$fieldty> = ser::Readable::read(&mut $reader)?;
+ Some(field.0)
+ };
+ }};
+ ($reader: expr, $field: ident, (option, encoding: $fieldty: ty)) => {{
+ decode_tlv!($reader, $field, option);
}};
}
+// `$decode_custom_tlv` is a closure that may be optionally provided to handle custom message types.
+// If it is provided, it will be called with the custom type and the `FixedLengthReader` containing
+// the message contents. It should return `Ok(true)` if the custom message is successfully parsed,
+// `Ok(false)` if the message type is unknown, and `Err(DecodeError)` if parsing fails.
macro_rules! decode_tlv_stream {
- ($stream: expr, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}) => { {
- use ln::msgs::DecodeError;
+ ($stream: expr, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}
+ $(, $decode_custom_tlv: expr)?) => { {
+ let rewind = |_, _| { unreachable!() };
+ use core::ops::RangeBounds;
+ decode_tlv_stream_range!(
+ $stream, .., rewind, {$(($type, $field, $fieldty)),*} $(, $decode_custom_tlv)?
+ );
+ } }
+}
+
+macro_rules! decode_tlv_stream_range {
+ ($stream: expr, $range: expr, $rewind: ident, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}
+ $(, $decode_custom_tlv: expr)?) => { {
+ use $crate::ln::msgs::DecodeError;
let mut last_seen_type: Option<u64> = None;
let mut stream_ref = $stream;
'tlv_read: loop {
- use util::ser;
+ use $crate::util::ser;
// First decode the type of this TLV:
let typ: ser::BigSize = {
// UnexpectedEof. This should in every case be largely cosmetic, but its nice to
// pass the TLV test vectors exactly, which requre this distinction.
let mut tracking_reader = ser::ReadTrackingReader::new(&mut stream_ref);
- match ser::Readable::read(&mut tracking_reader) {
+ match <$crate::util::ser::BigSize as $crate::util::ser::Readable>::read(&mut tracking_reader) {
Err(DecodeError::ShortRead) => {
if !tracking_reader.have_read {
break 'tlv_read;
}
},
Err(e) => return Err(e),
- Ok(t) => t,
+ Ok(t) => if $range.contains(&t.0) { t } else {
+ drop(tracking_reader);
+
+ // Assumes the type id is minimally encoded, which is enforced on read.
+ use $crate::util::ser::Writeable;
+ let bytes_read = t.serialized_length();
+ $rewind(stream_ref, bytes_read);
+ break 'tlv_read;
+ },
}
};
last_seen_type = Some(typ.0);
// Finally, read the length and value itself:
- let length: ser::BigSize = ser::Readable::read(&mut stream_ref)?;
+ let length: ser::BigSize = $crate::util::ser::Readable::read(&mut stream_ref)?;
let mut s = ser::FixedLengthReader::new(&mut stream_ref, length.0);
match typ.0 {
$($type => {
return Err(DecodeError::InvalidValue);
}
},)*
- x if x % 2 == 0 => {
- return Err(DecodeError::UnknownRequiredFeature);
- },
- _ => {},
+ t => {
+ $(
+ if $decode_custom_tlv(t, &mut s)? {
+ // If a custom TLV was successfully read (i.e. decode_custom_tlv returns true),
+ // continue to the next TLV read.
+ s.eat_remaining()?;
+ continue 'tlv_read;
+ }
+ )?
+ if t % 2 == 0 {
+ return Err(DecodeError::UnknownRequiredFeature);
+ }
+ }
}
s.eat_remaining()?;
}
} }
}
+macro_rules! impl_writeable_msg {
+ ($st:ident, {$($field:ident),* $(,)*}, {$(($type: expr, $tlvfield: ident, $fieldty: tt)),* $(,)*}) => {
+ impl $crate::util::ser::Writeable for $st {
+ fn write<W: $crate::util::ser::Writer>(&self, w: &mut W) -> Result<(), $crate::io::Error> {
+ $( self.$field.write(w)?; )*
+ encode_tlv_stream!(w, {$(($type, self.$tlvfield, $fieldty)),*});
+ Ok(())
+ }
+ }
+ impl $crate::util::ser::Readable for $st {
+ fn read<R: $crate::io::Read>(r: &mut R) -> Result<Self, $crate::ln::msgs::DecodeError> {
+ $(let $field = $crate::util::ser::Readable::read(r)?;)*
+ $(init_tlv_field_var!($tlvfield, $fieldty);)*
+ decode_tlv_stream!(r, {$(($type, $tlvfield, $fieldty)),*});
+ Ok(Self {
+ $($field),*,
+ $($tlvfield),*
+ })
+ }
+ }
+ }
+}
+
macro_rules! impl_writeable {
($st:ident, {$($field:ident),*}) => {
- impl ::util::ser::Writeable for $st {
- fn write<W: ::util::ser::Writer>(&self, w: &mut W) -> Result<(), $crate::io::Error> {
+ impl $crate::util::ser::Writeable for $st {
+ fn write<W: $crate::util::ser::Writer>(&self, w: &mut W) -> Result<(), $crate::io::Error> {
$( self.$field.write(w)?; )*
Ok(())
}
}
}
- impl ::util::ser::Readable for $st {
- fn read<R: $crate::io::Read>(r: &mut R) -> Result<Self, ::ln::msgs::DecodeError> {
+ impl $crate::util::ser::Readable for $st {
+ fn read<R: $crate::io::Read>(r: &mut R) -> Result<Self, $crate::ln::msgs::DecodeError> {
Ok(Self {
- $($field: ::util::ser::Readable::read(r)?),*
+ $($field: $crate::util::ser::Readable::read(r)?),*
})
}
}
/// correctly.
macro_rules! write_tlv_fields {
($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),* $(,)*}) => {
- encode_varint_length_prefixed_tlv!($stream, {$(($type, $field, $fieldty)),*});
+ encode_varint_length_prefixed_tlv!($stream, {$(($type, $field, $fieldty)),*})
}
}
/// Reads a suffix added by write_tlv_fields.
macro_rules! read_tlv_fields {
($stream: expr, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}) => { {
- let tlv_len: ::util::ser::BigSize = ::util::ser::Readable::read($stream)?;
- let mut rd = ::util::ser::FixedLengthReader::new($stream, tlv_len.0);
+ let tlv_len: $crate::util::ser::BigSize = $crate::util::ser::Readable::read($stream)?;
+ let mut rd = $crate::util::ser::FixedLengthReader::new($stream, tlv_len.0);
decode_tlv_stream!(&mut rd, {$(($type, $field, $fieldty)),*});
- rd.eat_remaining().map_err(|_| ::ln::msgs::DecodeError::ShortRead)?;
+ rd.eat_remaining().map_err(|_| $crate::ln::msgs::DecodeError::ShortRead)?;
} }
}
macro_rules! init_tlv_based_struct_field {
($field: ident, (default_value, $default: expr)) => {
- $field
+ $field.0.unwrap()
};
($field: ident, option) => {
$field
$field.0.unwrap()
};
($field: ident, vec_type) => {
- $field.unwrap().0
+ $field.unwrap()
};
}
macro_rules! init_tlv_field_var {
($field: ident, (default_value, $default: expr)) => {
- let mut $field = $default;
+ let mut $field = $crate::util::ser::OptionDeserWrapper(None);
};
($field: ident, required) => {
- let mut $field = ::util::ser::OptionDeserWrapper(None);
+ let mut $field = $crate::util::ser::OptionDeserWrapper(None);
};
($field: ident, vec_type) => {
- let mut $field = Some(::util::ser::VecReadWrapper(Vec::new()));
+ let mut $field = Some(Vec::new());
};
($field: ident, option) => {
let mut $field = None;
/// serialized.
macro_rules! impl_writeable_tlv_based {
($st: ident, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}) => {
- impl ::util::ser::Writeable for $st {
- fn write<W: ::util::ser::Writer>(&self, writer: &mut W) -> Result<(), $crate::io::Error> {
+ impl $crate::util::ser::Writeable for $st {
+ fn write<W: $crate::util::ser::Writer>(&self, writer: &mut W) -> Result<(), $crate::io::Error> {
write_tlv_fields!(writer, {
$(($type, self.$field, $fieldty)),*
});
#[inline]
fn serialized_length(&self) -> usize {
- use util::ser::BigSize;
+ use $crate::util::ser::BigSize;
let len = {
#[allow(unused_mut)]
- let mut len = ::util::ser::LengthCalculatingWriter(0);
+ let mut len = $crate::util::ser::LengthCalculatingWriter(0);
$(
get_varint_length_prefixed_tlv_length!(len, $type, self.$field, $fieldty);
)*
len.0
};
- let mut len_calc = ::util::ser::LengthCalculatingWriter(0);
+ let mut len_calc = $crate::util::ser::LengthCalculatingWriter(0);
BigSize(len as u64).write(&mut len_calc).expect("No in-memory data may fail to serialize");
len + len_calc.0
}
}
- impl ::util::ser::Readable for $st {
- fn read<R: $crate::io::Read>(reader: &mut R) -> Result<Self, ::ln::msgs::DecodeError> {
+ impl $crate::util::ser::Readable for $st {
+ fn read<R: $crate::io::Read>(reader: &mut R) -> Result<Self, $crate::ln::msgs::DecodeError> {
$(
init_tlv_field_var!($field, $fieldty);
)*
}
}
+/// Defines a struct for a TLV stream and a similar struct using references for non-primitive types,
+/// implementing [`Readable`] for the former and [`Writeable`] for the latter. Useful as an
+/// intermediary format when reading or writing a type encoded as a TLV stream. Note that each field
+/// representing a TLV record has its type wrapped with an [`Option`]. A tuple consisting of a type
+/// and a serialization wrapper may be given in place of a type when custom serialization is
+/// required.
+///
+/// [`Readable`]: crate::util::ser::Readable
+/// [`Writeable`]: crate::util::ser::Writeable
+macro_rules! tlv_stream {
+ ($name:ident, $nameref:ident, $range:expr, {
+ $(($type:expr, $field:ident : $fieldty:tt)),* $(,)*
+ }) => {
+ #[derive(Debug)]
+ pub(crate) struct $name {
+ $(
+ $field: Option<tlv_record_type!($fieldty)>,
+ )*
+ }
+
+ pub(crate) struct $nameref<'a> {
+ $(
+ pub(crate) $field: Option<tlv_record_ref_type!($fieldty)>,
+ )*
+ }
+
+ impl<'a> $crate::util::ser::Writeable for $nameref<'a> {
+ fn write<W: $crate::util::ser::Writer>(&self, writer: &mut W) -> Result<(), $crate::io::Error> {
+ encode_tlv_stream!(writer, {
+ $(($type, self.$field, (option, encoding: $fieldty))),*
+ });
+ Ok(())
+ }
+ }
+
+ impl $crate::util::ser::SeekReadable for $name {
+ fn read<R: $crate::io::Read + $crate::io::Seek>(reader: &mut R) -> Result<Self, $crate::ln::msgs::DecodeError> {
+ $(
+ init_tlv_field_var!($field, option);
+ )*
+ let rewind = |cursor: &mut R, offset: usize| {
+ cursor.seek($crate::io::SeekFrom::Current(-(offset as i64))).expect("");
+ };
+ decode_tlv_stream_range!(reader, $range, rewind, {
+ $(($type, $field, (option, encoding: $fieldty))),*
+ });
+
+ Ok(Self {
+ $(
+ $field: $field
+ ),*
+ })
+ }
+ }
+ }
+}
+
+macro_rules! tlv_record_type {
+ (($type:ty, $wrapper:ident)) => { $type };
+ ($type:ty) => { $type };
+}
+
+macro_rules! tlv_record_ref_type {
+ (char) => { char };
+ (u8) => { u8 };
+ ((u16, $wrapper: ident)) => { u16 };
+ ((u32, $wrapper: ident)) => { u32 };
+ ((u64, $wrapper: ident)) => { u64 };
+ (($type:ty, $wrapper:ident)) => { &'a $type };
+ ($type:ty) => { &'a $type };
+}
+
macro_rules! _impl_writeable_tlv_based_enum_common {
($st: ident, $(($variant_id: expr, $variant_name: ident) =>
{$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}
),* $(,)*;
$(($tuple_variant_id: expr, $tuple_variant_name: ident)),* $(,)*) => {
- impl ::util::ser::Writeable for $st {
- fn write<W: ::util::ser::Writer>(&self, writer: &mut W) -> Result<(), $crate::io::Error> {
+ impl $crate::util::ser::Writeable for $st {
+ fn write<W: $crate::util::ser::Writer>(&self, writer: &mut W) -> Result<(), $crate::io::Error> {
match self {
$($st::$variant_name { $(ref $field),* } => {
let id: u8 = $variant_id;
id.write(writer)?;
write_tlv_fields!(writer, {
- $(($type, $field, $fieldty)),*
+ $(($type, *$field, $fieldty)),*
});
}),*
$($st::$tuple_variant_name (ref field) => {
macro_rules! impl_writeable_tlv_based_enum_upgradable {
($st: ident, $(($variant_id: expr, $variant_name: ident) =>
{$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}
- ),* $(,)*) => {
+ ),* $(,)*
+ $(;
+ $(($tuple_variant_id: expr, $tuple_variant_name: ident)),* $(,)*)*) => {
_impl_writeable_tlv_based_enum_common!($st,
- $(($variant_id, $variant_name) => {$(($type, $field, $fieldty)),*}),*; );
+ $(($variant_id, $variant_name) => {$(($type, $field, $fieldty)),*}),*;
+ $($(($tuple_variant_id, $tuple_variant_name)),*)*);
- impl ::util::ser::MaybeReadable for $st {
- fn read<R: $crate::io::Read>(reader: &mut R) -> Result<Option<Self>, ::ln::msgs::DecodeError> {
- let id: u8 = ::util::ser::Readable::read(reader)?;
+ impl $crate::util::ser::MaybeReadable for $st {
+ fn read<R: $crate::io::Read>(reader: &mut R) -> Result<Option<Self>, $crate::ln::msgs::DecodeError> {
+ let id: u8 = $crate::util::ser::Readable::read(reader)?;
match id {
$($variant_id => {
// Because read_tlv_fields creates a labeled loop, we cannot call it twice
};
f()
}),*
+ $($($tuple_variant_id => {
+ Ok(Some($st::$tuple_variant_name(Readable::read(reader)?)))
+ }),*)*
_ if id % 2 == 1 => Ok(None),
_ => Err(DecodeError::UnknownRequiredFeature),
}
$(($variant_id, $variant_name) => {$(($type, $field, $fieldty)),*}),*;
$(($tuple_variant_id, $tuple_variant_name)),*);
- impl ::util::ser::Readable for $st {
- fn read<R: $crate::io::Read>(reader: &mut R) -> Result<Self, ::ln::msgs::DecodeError> {
- let id: u8 = ::util::ser::Readable::read(reader)?;
+ impl $crate::util::ser::Readable for $st {
+ fn read<R: $crate::io::Read>(reader: &mut R) -> Result<Self, $crate::ln::msgs::DecodeError> {
+ let id: u8 = $crate::util::ser::Readable::read(reader)?;
match id {
$($variant_id => {
// Because read_tlv_fields creates a labeled loop, we cannot call it twice
#[cfg(test)]
mod tests {
- use io::{self, Cursor};
- use prelude::*;
- use ln::msgs::DecodeError;
- use util::ser::{Writeable, HighZeroBytesDroppedVarInt, VecWriter};
+ use crate::io::{self, Cursor};
+ use crate::prelude::*;
+ use crate::ln::msgs::DecodeError;
+ use crate::util::ser::{Writeable, HighZeroBytesDroppedBigSize, VecWriter};
use bitcoin::secp256k1::PublicKey;
// The BOLT TLV test cases don't include any tests which use our "required-value" logic since
}
// BOLT TLV test cases
- fn tlv_reader_n1(s: &[u8]) -> Result<(Option<HighZeroBytesDroppedVarInt<u64>>, Option<u64>, Option<(PublicKey, u64, u64)>, Option<u16>), DecodeError> {
+ fn tlv_reader_n1(s: &[u8]) -> Result<(Option<HighZeroBytesDroppedBigSize<u64>>, Option<u64>, Option<(PublicKey, u64, u64)>, Option<u16>), DecodeError> {
let mut s = Cursor::new(s);
- let mut tlv1: Option<HighZeroBytesDroppedVarInt<u64>> = None;
+ let mut tlv1: Option<HighZeroBytesDroppedBigSize<u64>> = None;
let mut tlv2: Option<u64> = None;
let mut tlv3: Option<(PublicKey, u64, u64)> = None;
let mut tlv4: Option<u16> = None;
assert_eq!(stream.0, ::hex::decode("06fd00ff02abcd").unwrap());
stream.0.clear();
- encode_varint_length_prefixed_tlv!(&mut stream, {(0, 1u64, required), (42, None::<u64>, option), (0xff, HighZeroBytesDroppedVarInt(0u64), required)});
+ encode_varint_length_prefixed_tlv!(&mut stream, {(0, 1u64, required), (42, None::<u64>, option), (0xff, HighZeroBytesDroppedBigSize(0u64), required)});
assert_eq!(stream.0, ::hex::decode("0e00080000000000000001fd00ff00").unwrap());
stream.0.clear();
- encode_varint_length_prefixed_tlv!(&mut stream, {(0, Some(1u64), option), (0xff, HighZeroBytesDroppedVarInt(0u64), required)});
+ encode_varint_length_prefixed_tlv!(&mut stream, {(0, Some(1u64), option), (0xff, HighZeroBytesDroppedBigSize(0u64), required)});
assert_eq!(stream.0, ::hex::decode("0e00080000000000000001fd00ff00").unwrap());
Ok(())
projects / rust-lightning / blobdiff