X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Fser_macros.rs;h=d509995b04f7b7f997a2d37ee60a8f6f73af7018;hb=refs%2Fheads%2F2024-03-fix-upgradable-enum;hp=94990fcb8a17c8056dfd01d00b18db78d58e466f;hpb=dfbebbf4c31135791dd402a4fc64abc7e0b8e158;p=rust-lightning diff --git a/lightning/src/util/ser_macros.rs b/lightning/src/util/ser_macros.rs index 94990fcb..e1f4762e 100644 --- a/lightning/src/util/ser_macros.rs +++ b/lightning/src/util/ser_macros.rs @@ -7,17 +7,45 @@ // You may not use this file except in accordance with one or both of these // licenses. -macro_rules! encode_tlv { +//! Some macros that implement [`Readable`]/[`Writeable`] traits for lightning messages. +//! They also handle serialization and deserialization of TLVs. +//! +//! [`Readable`]: crate::util::ser::Readable +//! [`Writeable`]: crate::util::ser::Writeable + +// There are quite a few TLV serialization "types" which behave differently. We currently only +// publicly document the `optional` and `required` types, not supporting anything else publicly and +// changing them at will. +// +// Some of the other types include: +// * (default_value, $default) - reads optionally, reading $default if no TLV is present +// * (static_value, $value) - ignores any TLVs, always using $value +// * required_vec - reads into a Vec without a length prefix, failing if no TLV is present. +// * optional_vec - reads into an Option without a length prefix, continuing if no TLV is +// present. Writes from a Vec directly, only if any elements are present. Note +// that the struct deserialization macros return a Vec, not an Option. +// * upgradable_option - reads via MaybeReadable. +// * upgradable_required - reads via MaybeReadable, requiring a TLV be present but may return None +// if MaybeReadable::read() returns None. + +/// Implements serialization for a single TLV record. +/// This is exported for use by other exported macros, do not use directly. +#[doc(hidden)] +#[macro_export] +macro_rules! _encode_tlv { ($stream: expr, $type: expr, $field: expr, (default_value, $default: expr)) => { - encode_tlv!($stream, $type, $field, required) + $crate::_encode_tlv!($stream, $type, $field, required) + }; + ($stream: expr, $type: expr, $field: expr, (static_value, $value: expr)) => { + let _ = &$field; // Ensure we "use" the $field }; ($stream: expr, $type: expr, $field: expr, required) => { BigSize($type).write($stream)?; BigSize($field.serialized_length() as u64).write($stream)?; $field.write($stream)?; }; - ($stream: expr, $type: expr, $field: expr, vec_type) => { - encode_tlv!($stream, $type, ::util::ser::VecWriteWrapper(&$field), required); + ($stream: expr, $type: expr, $field: expr, required_vec) => { + $crate::_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 { @@ -26,38 +54,140 @@ macro_rules! encode_tlv { field.write($stream)?; } }; + ($stream: expr, $type: expr, $field: expr, optional_vec) => { + if !$field.is_empty() { + $crate::_encode_tlv!($stream, $type, $field, required_vec); + } + }; + ($stream: expr, $type: expr, $field: expr, upgradable_required) => { + $crate::_encode_tlv!($stream, $type, $field, required); + }; + ($stream: expr, $type: expr, $field: expr, upgradable_option) => { + $crate::_encode_tlv!($stream, $type, $field, option); + }; + ($stream: expr, $type: expr, $field: expr, (option, encoding: ($fieldty: ty, $encoding: ident))) => { + $crate::_encode_tlv!($stream, $type, $field.map(|f| $encoding(f)), option); + }; + ($stream: expr, $type: expr, $field: expr, (option, encoding: $fieldty: ty)) => { + $crate::_encode_tlv!($stream, $type, $field, option); + }; + ($stream: expr, $type: expr, $field: expr, (option: $trait: ident $(, $read_arg: expr)?)) => { + // Just a read-mapped type + $crate::_encode_tlv!($stream, $type, $field, option); + }; +} + +/// Panics if the last seen TLV type is not numerically less than the TLV type currently being checked. +/// This is exported for use by other exported macros, do not use directly. +#[doc(hidden)] +#[macro_export] +macro_rules! _check_encoded_tlv_order { + ($last_type: expr, $type: expr, (static_value, $value: expr)) => { }; + ($last_type: expr, $type: expr, $fieldty: tt) => { + if let Some(t) = $last_type { + #[allow(unused_comparisons)] // Note that $type may be 0 making the following comparison always false + (debug_assert!(t < $type)) + } + $last_type = Some($type); + }; } +/// Implements the TLVs serialization part in a [`Writeable`] implementation of a struct. +/// +/// This should be called inside a method which returns `Result<_, `[`io::Error`]`>`, such as +/// [`Writeable::write`]. It will only return an `Err` if the stream `Err`s or [`Writeable::write`] +/// on one of the fields `Err`s. +/// +/// `$stream` must be a `&mut `[`Writer`] which will receive the bytes for each TLV in the stream. +/// +/// Fields MUST be sorted in `$type`-order. +/// +/// Note that the lightning TLV requirements require that a single type not appear more than once, +/// that TLVs are sorted in type-ascending order, and that any even types be understood by the +/// decoder. +/// +/// Any `option` fields which have a value of `None` will not be serialized at all. +/// +/// For example, +/// ``` +/// # use lightning::encode_tlv_stream; +/// # fn write (stream: &mut W) -> Result<(), lightning::io::Error> { +/// let mut required_value = 0u64; +/// let mut optional_value: Option = None; +/// encode_tlv_stream!(stream, { +/// (0, required_value, required), +/// (1, Some(42u64), option), +/// (2, optional_value, option), +/// }); +/// // At this point `required_value` has been written as a TLV of type 0, `42u64` has been written +/// // as a TLV of type 1 (indicating the reader may ignore it if it is not understood), and *no* +/// // TLV is written with type 2. +/// # Ok(()) +/// # } +/// ``` +/// +/// [`Writeable`]: crate::util::ser::Writeable +/// [`io::Error`]: crate::io::Error +/// [`Writeable::write`]: crate::util::ser::Writeable::write +/// [`Writer`]: crate::util::ser::Writer +#[macro_export] macro_rules! encode_tlv_stream { + ($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),* $(,)*}) => { + $crate::_encode_tlv_stream!($stream, {$(($type, $field, $fieldty)),*}) + } +} + +/// Implementation of [`encode_tlv_stream`]. +/// This is exported for use by other exported macros, do not use directly. +#[doc(hidden)] +#[macro_export] +macro_rules! _encode_tlv_stream { ($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),* $(,)*}) => { { + $crate::_encode_tlv_stream!($stream, { $(($type, $field, $fieldty)),* }, &[]) + } }; + ($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),* $(,)*}, $extra_tlvs: expr) => { { #[allow(unused_imports)] - use { + use $crate::{ ln::msgs::DecodeError, util::ser, util::ser::BigSize, + util::ser::Writeable, }; $( - encode_tlv!($stream, $type, $field, $fieldty); + $crate::_encode_tlv!($stream, $type, $field, $fieldty); )* + for tlv in $extra_tlvs { + let (typ, value): &(u64, Vec) = tlv; + $crate::_encode_tlv!($stream, *typ, *value, required_vec); + } #[allow(unused_mut, unused_variables, unused_assignments)] #[cfg(debug_assertions)] { let mut last_seen: Option = None; $( - if let Some(t) = last_seen { - debug_assert!(t <= $type); - } - last_seen = Some($type); + $crate::_check_encoded_tlv_order!(last_seen, $type, $fieldty); )* + for tlv in $extra_tlvs { + let (typ, _): &(u64, Vec) = tlv; + $crate::_check_encoded_tlv_order!(last_seen, *typ, required_vec); + } } - } } + } }; } -macro_rules! get_varint_length_prefixed_tlv_length { +/// Adds the length of the serialized field to a [`LengthCalculatingWriter`]. +/// This is exported for use by other exported macros, do not use directly. +/// +/// [`LengthCalculatingWriter`]: crate::util::ser::LengthCalculatingWriter +#[doc(hidden)] +#[macro_export] +macro_rules! _get_varint_length_prefixed_tlv_length { ($len: expr, $type: expr, $field: expr, (default_value, $default: expr)) => { - get_varint_length_prefixed_tlv_length!($len, $type, $field, required) + $crate::_get_varint_length_prefixed_tlv_length!($len, $type, $field, required) + }; + ($len: expr, $type: expr, $field: expr, (static_value, $value: expr)) => { }; ($len: expr, $type: expr, $field: expr, required) => { BigSize($type).write(&mut $len).expect("No in-memory data may fail to serialize"); @@ -65,8 +195,8 @@ macro_rules! get_varint_length_prefixed_tlv_length { BigSize(field_len as u64).write(&mut $len).expect("No in-memory data may fail to serialize"); $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); + ($len: expr, $type: expr, $field: expr, required_vec) => { + $crate::_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 { @@ -76,120 +206,321 @@ macro_rules! get_varint_length_prefixed_tlv_length { $len.0 += field_len; } }; + ($len: expr, $type: expr, $field: expr, optional_vec) => { + if !$field.is_empty() { + $crate::_get_varint_length_prefixed_tlv_length!($len, $type, $field, required_vec); + } + }; + ($len: expr, $type: expr, $field: expr, (option: $trait: ident $(, $read_arg: expr)?)) => { + $crate::_get_varint_length_prefixed_tlv_length!($len, $type, $field, option); + }; + ($len: expr, $type: expr, $field: expr, (option, encoding: ($fieldty: ty, $encoding: ident))) => { + $crate::_get_varint_length_prefixed_tlv_length!($len, $type, $field.map(|f| $encoding(f)), option); + }; + ($len: expr, $type: expr, $field: expr, upgradable_required) => { + $crate::_get_varint_length_prefixed_tlv_length!($len, $type, $field, required); + }; + ($len: expr, $type: expr, $field: expr, upgradable_option) => { + $crate::_get_varint_length_prefixed_tlv_length!($len, $type, $field, option); + }; } -macro_rules! encode_varint_length_prefixed_tlv { +/// See the documentation of [`write_tlv_fields`]. +/// This is exported for use by other exported macros, do not use directly. +#[doc(hidden)] +#[macro_export] +macro_rules! _encode_varint_length_prefixed_tlv { ($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),*}) => { { - use util::ser::BigSize; + $crate::_encode_varint_length_prefixed_tlv!($stream, {$(($type, $field, $fieldty)),*}, &[]) + } }; + ($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),*}, $extra_tlvs: expr) => { { + extern crate alloc; + use $crate::util::ser::BigSize; + use alloc::vec::Vec; 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); + $crate::_get_varint_length_prefixed_tlv_length!(len, $type, $field, $fieldty); )* + for tlv in $extra_tlvs { + let (typ, value): &(u64, Vec) = tlv; + $crate::_get_varint_length_prefixed_tlv_length!(len, *typ, *value, required_vec); + } len.0 }; BigSize(len as u64).write($stream)?; - encode_tlv_stream!($stream, { $(($type, $field, $fieldty)),* }); - } } + $crate::_encode_tlv_stream!($stream, { $(($type, $field, $fieldty)),* }, $extra_tlvs); + } }; } -macro_rules! check_tlv_order { +/// Errors if there are missing required TLV types between the last seen type and the type currently being processed. +/// This is exported for use by other exported macros, do not use directly. +#[doc(hidden)] +#[macro_export] +macro_rules! _check_decoded_tlv_order { ($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, (default_value, $default: expr)) => {{ - #[allow(unused_comparisons)] // Note that $type may be 0 making the second comparison always true + #[allow(unused_comparisons)] // Note that $type may be 0 making the second comparison always false let invalid_order = ($last_seen_type.is_none() || $last_seen_type.unwrap() < $type) && $typ.0 > $type; if invalid_order { $field = $default.into(); } }}; + ($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, (static_value, $value: expr)) => { + }; ($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, required) => {{ - #[allow(unused_comparisons)] // Note that $type may be 0 making the second comparison always true + #[allow(unused_comparisons)] // Note that $type may be 0 making the second comparison always false let invalid_order = ($last_seen_type.is_none() || $last_seen_type.unwrap() < $type) && $typ.0 > $type; if invalid_order { return Err(DecodeError::InvalidValue); } }}; + ($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, (required: $trait: ident $(, $read_arg: expr)?)) => {{ + $crate::_check_decoded_tlv_order!($last_seen_type, $typ, $type, $field, required); + }}; ($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, option) => {{ // no-op }}; - ($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, vec_type) => {{ + ($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, required_vec) => {{ + $crate::_check_decoded_tlv_order!($last_seen_type, $typ, $type, $field, required); + }}; + ($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, optional_vec) => {{ // no-op }}; - ($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, ignorable) => {{ + ($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, upgradable_required) => {{ + _check_decoded_tlv_order!($last_seen_type, $typ, $type, $field, required) + }}; + ($last_seen_type: expr, $typ: expr, $type: expr, $field: ident, upgradable_option) => {{ // 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 { +/// Errors if there are missing required TLV types after the last seen type. +/// This is exported for use by other exported macros, do not use directly. +#[doc(hidden)] +#[macro_export] +macro_rules! _check_missing_tlv { ($last_seen_type: expr, $type: expr, $field: ident, (default_value, $default: expr)) => {{ - #[allow(unused_comparisons)] // Note that $type may be 0 making the second comparison always true + #[allow(unused_comparisons)] // Note that $type may be 0 making the second comparison always false let missing_req_type = $last_seen_type.is_none() || $last_seen_type.unwrap() < $type; if missing_req_type { $field = $default.into(); } }}; + ($last_seen_type: expr, $type: expr, $field: expr, (static_value, $value: expr)) => { + $field = $value; + }; ($last_seen_type: expr, $type: expr, $field: ident, required) => {{ - #[allow(unused_comparisons)] // Note that $type may be 0 making the second comparison always true + #[allow(unused_comparisons)] // Note that $type may be 0 making the second comparison always false let missing_req_type = $last_seen_type.is_none() || $last_seen_type.unwrap() < $type; if missing_req_type { return Err(DecodeError::InvalidValue); } }}; - ($last_seen_type: expr, $type: expr, $field: ident, vec_type) => {{ - // no-op + ($last_seen_type: expr, $type: expr, $field: ident, (required: $trait: ident $(, $read_arg: expr)?)) => {{ + $crate::_check_missing_tlv!($last_seen_type, $type, $field, required); + }}; + ($last_seen_type: expr, $type: expr, $field: ident, required_vec) => {{ + $crate::_check_missing_tlv!($last_seen_type, $type, $field, required); }}; ($last_seen_type: expr, $type: expr, $field: ident, option) => {{ // no-op }}; - ($last_seen_type: expr, $type: expr, $field: ident, ignorable) => {{ + ($last_seen_type: expr, $type: expr, $field: ident, optional_vec) => {{ + // no-op + }}; + ($last_seen_type: expr, $type: expr, $field: ident, upgradable_required) => {{ + _check_missing_tlv!($last_seen_type, $type, $field, required) + }}; + ($last_seen_type: expr, $type: expr, $field: ident, upgradable_option) => {{ // 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 { - ($reader: expr, $field: ident, (default_value, $default: expr)) => {{ - decode_tlv!($reader, $field, required) +/// Implements deserialization for a single TLV record. +/// This is exported for use by other exported macros, do not use directly. +#[doc(hidden)] +#[macro_export] +macro_rules! _decode_tlv { + ($outer_reader: expr, $reader: expr, $field: ident, (default_value, $default: expr)) => {{ + $crate::_decode_tlv!($outer_reader, $reader, $field, required) + }}; + ($outer_reader: expr, $reader: expr, $field: ident, (static_value, $value: expr)) => {{ }}; - ($reader: expr, $field: ident, required) => {{ - $field = ser::Readable::read(&mut $reader)?; + ($outer_reader: expr, $reader: expr, $field: ident, required) => {{ + $field = $crate::util::ser::Readable::read(&mut $reader)?; }}; - ($reader: expr, $field: ident, vec_type) => {{ - let f: ::util::ser::VecReadWrapper<_> = ser::Readable::read(&mut $reader)?; + ($outer_reader: expr, $reader: expr, $field: ident, (required: $trait: ident $(, $read_arg: expr)?)) => {{ + $field = $trait::read(&mut $reader $(, $read_arg)*)?; + }}; + ($outer_reader: expr, $reader: expr, $field: ident, required_vec) => {{ + let f: $crate::util::ser::WithoutLength> = $crate::util::ser::Readable::read(&mut $reader)?; + $field = f.0; + }}; + ($outer_reader: expr, $reader: expr, $field: ident, option) => {{ + $field = Some($crate::util::ser::Readable::read(&mut $reader)?); + }}; + ($outer_reader: expr, $reader: expr, $field: ident, optional_vec) => {{ + let f: $crate::util::ser::WithoutLength> = $crate::util::ser::Readable::read(&mut $reader)?; $field = Some(f.0); }}; - ($reader: expr, $field: ident, option) => {{ - $field = Some(ser::Readable::read(&mut $reader)?); + // `upgradable_required` indicates we're reading a required TLV that may have been upgraded + // without backwards compat. We'll error if the field is missing, and return `Ok(None)` if the + // field is present but we can no longer understand it. + // Note that this variant can only be used within a `MaybeReadable` read. + ($outer_reader: expr, $reader: expr, $field: ident, upgradable_required) => {{ + $field = match $crate::util::ser::MaybeReadable::read(&mut $reader)? { + Some(res) => res, + None => { + // If we successfully read a value but we don't know how to parse it, we give up + // and immediately return `None`. However, we need to make sure we read the correct + // number of bytes for this TLV stream, which is implicitly the end of the stream. + // Thus, we consume everything left in the `$outer_reader` here, ensuring that if + // we're being read as a part of another TLV stream we don't spuriously fail to + // deserialize the outer object due to a TLV length mismatch. + $crate::io_extras::copy($outer_reader, &mut $crate::io_extras::sink()).unwrap(); + return Ok(None) + }, + }; }}; - ($reader: expr, $field: ident, ignorable) => {{ - $field = ser::MaybeReadable::read(&mut $reader)?; + // `upgradable_option` indicates we're reading an Option-al TLV that may have been upgraded + // without backwards compat. $field will be None if the TLV is missing or if the field is present + // but we can no longer understand it. + ($outer_reader: expr, $reader: expr, $field: ident, upgradable_option) => {{ + $field = $crate::util::ser::MaybeReadable::read(&mut $reader)?; + if $field.is_none() { + #[cfg(not(debug_assertions))] { + // In general, MaybeReadable implementations are required to consume all the bytes + // of the object even if they don't understand it, but due to a bug in the + // serialization format for `impl_writeable_tlv_based_enum_upgradable` we sometimes + // don't know how many bytes that is. In such cases, we'd like to spuriously allow + // TLV length mismatches, which we do here by calling `eat_remaining` so that the + // `s.bytes_remain()` check in `_decode_tlv_stream_range` doesn't fail. + $reader.eat_remaining()?; + } + } }}; - ($reader: expr, $field: ident, (option: $trait: ident $(, $read_arg: expr)?)) => {{ + ($outer_reader: expr, $reader: expr, $field: ident, (option: $trait: ident $(, $read_arg: expr)?)) => {{ $field = Some($trait::read(&mut $reader $(, $read_arg)*)?); }}; + ($outer_reader: expr, $reader: expr, $field: ident, (option, encoding: ($fieldty: ty, $encoding: ident, $encoder:ty))) => {{ + $crate::_decode_tlv!($outer_reader, $reader, $field, (option, encoding: ($fieldty, $encoding))); + }}; + ($outer_reader: expr, $reader: expr, $field: ident, (option, encoding: ($fieldty: ty, $encoding: ident))) => {{ + $field = { + let field: $encoding<$fieldty> = ser::Readable::read(&mut $reader)?; + Some(field.0) + }; + }}; + ($outer_reader: expr, $reader: expr, $field: ident, (option, encoding: $fieldty: ty)) => {{ + $crate::_decode_tlv!($outer_reader, $reader, $field, option); + }}; +} + +/// Checks if `$val` matches `$type`. +/// This is exported for use by other exported macros, do not use directly. +#[doc(hidden)] +#[macro_export] +macro_rules! _decode_tlv_stream_match_check { + ($val: ident, $type: expr, (static_value, $value: expr)) => { false }; + ($val: ident, $type: expr, $fieldty: tt) => { $val == $type } } +/// Implements the TLVs deserialization part in a [`Readable`] implementation of a struct. +/// +/// This should be called inside a method which returns `Result<_, `[`DecodeError`]`>`, such as +/// [`Readable::read`]. It will either return an `Err` or ensure all `required` fields have been +/// read and optionally read `optional` fields. +/// +/// `$stream` must be a [`Read`] and will be fully consumed, reading until no more bytes remain +/// (i.e. it returns [`DecodeError::ShortRead`]). +/// +/// Fields MUST be sorted in `$type`-order. +/// +/// Note that the lightning TLV requirements require that a single type not appear more than once, +/// that TLVs are sorted in type-ascending order, and that any even types be understood by the +/// decoder. +/// +/// For example, +/// ``` +/// # use lightning::decode_tlv_stream; +/// # fn read (stream: R) -> Result<(), lightning::ln::msgs::DecodeError> { +/// let mut required_value = 0u64; +/// let mut optional_value: Option = None; +/// decode_tlv_stream!(stream, { +/// (0, required_value, required), +/// (2, optional_value, option), +/// }); +/// // At this point, `required_value` has been overwritten with the TLV with type 0. +/// // `optional_value` may have been overwritten, setting it to `Some` if a TLV with type 2 was +/// // present. +/// # Ok(()) +/// # } +/// ``` +/// +/// [`Readable`]: crate::util::ser::Readable +/// [`DecodeError`]: crate::ln::msgs::DecodeError +/// [`Readable::read`]: crate::util::ser::Readable::read +/// [`Read`]: crate::io::Read +/// [`DecodeError::ShortRead`]: crate::ln::msgs::DecodeError::ShortRead +#[macro_export] 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)),* $(,)*}) => { + let rewind = |_, _| { unreachable!() }; + $crate::_decode_tlv_stream_range!($stream, .., rewind, {$(($type, $field, $fieldty)),*}); + } +} + +/// Similar to [`decode_tlv_stream`] with a custom TLV decoding capabilities. +/// +/// `$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. +/// +/// [`FixedLengthReader`]: crate::util::ser::FixedLengthReader +/// [`DecodeError`]: crate::ln::msgs::DecodeError +macro_rules! decode_tlv_stream_with_custom_tlv_decode { + ($stream: expr, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*} + $(, $decode_custom_tlv: expr)?) => { { + let rewind = |_, _| { unreachable!() }; + _decode_tlv_stream_range!( + $stream, .., rewind, {$(($type, $field, $fieldty)),*} $(, $decode_custom_tlv)? + ); + } } +} + +#[doc(hidden)] +#[macro_export] +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 = 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 = { // We track whether any bytes were read during the consensus_decode call to // determine whether we should break or return ShortRead if we get an // UnexpectedEof. This should in every case be largely cosmetic, but its nice to - // pass the TLV test vectors exactly, which requre this distinction. + // pass the TLV test vectors exactly, which require 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; @@ -198,7 +529,15 @@ macro_rules! decode_tlv_stream { } }, Err(e) => return Err(e), - Ok(t) => t, + Ok(t) => if core::ops::RangeBounds::contains(&$range, &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; + }, } }; @@ -209,51 +548,90 @@ macro_rules! decode_tlv_stream { }, _ => {}, } - // As we read types, make sure we hit every required type: + // As we read types, make sure we hit every required type between `last_seen_type` and `typ`: $({ - check_tlv_order!(last_seen_type, typ, $type, $field, $fieldty); + $crate::_check_decoded_tlv_order!(last_seen_type, typ, $type, $field, $fieldty); })* 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 => { - decode_tlv!(s, $field, $fieldty); + $(_t if $crate::_decode_tlv_stream_match_check!(_t, $type, $fieldty) => { + $crate::_decode_tlv!($stream, s, $field, $fieldty); if s.bytes_remain() { s.eat_remaining()?; // Return ShortRead if there's actually not enough bytes 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()?; } // Make sure we got to each required type after we've read every TLV: $({ - check_missing_tlv!(last_seen_type, $type, $field, $fieldty); + $crate::_check_missing_tlv!(last_seen_type, $type, $field, $fieldty); })* } } } +/// Implements [`Readable`]/[`Writeable`] for a message struct that may include non-TLV and +/// TLV-encoded parts. +/// +/// This is useful to implement a [`CustomMessageReader`]. +/// +/// Currently `$fieldty` may only be `option`, i.e., `$tlvfield` is optional field. +/// +/// For example, +/// ``` +/// # use lightning::impl_writeable_msg; +/// struct MyCustomMessage { +/// pub field_1: u32, +/// pub field_2: bool, +/// pub field_3: String, +/// pub tlv_optional_integer: Option, +/// } +/// +/// impl_writeable_msg!(MyCustomMessage, { +/// field_1, +/// field_2, +/// field_3 +/// }, { +/// (1, tlv_optional_integer, option), +/// }); +/// ``` +/// +/// [`Readable`]: crate::util::ser::Readable +/// [`Writeable`]: crate::util::ser::Writeable +/// [`CustomMessageReader`]: crate::ln::wire::CustomMessageReader +#[macro_export] macro_rules! impl_writeable_msg { ($st:ident, {$($field:ident),* $(,)*}, {$(($type: expr, $tlvfield: ident, $fieldty: tt)),* $(,)*}) => { - impl ::util::ser::Writeable for $st { - fn write(&self, w: &mut W) -> Result<(), $crate::io::Error> { + impl $crate::util::ser::Writeable for $st { + fn write(&self, w: &mut W) -> Result<(), $crate::io::Error> { $( self.$field.write(w)?; )* - encode_tlv_stream!(w, {$(($type, self.$tlvfield, $fieldty)),*}); + $crate::encode_tlv_stream!(w, {$(($type, self.$tlvfield.as_ref(), $fieldty)),*}); Ok(()) } } - impl ::util::ser::Readable for $st { - fn read(r: &mut R) -> Result { - $(let $field = ::util::ser::Readable::read(r)?;)* - $(init_tlv_field_var!($tlvfield, $fieldty);)* - decode_tlv_stream!(r, {$(($type, $tlvfield, $fieldty)),*}); + impl $crate::util::ser::Readable for $st { + fn read(r: &mut R) -> Result { + $(let $field = $crate::util::ser::Readable::read(r)?;)* + $($crate::_init_tlv_field_var!($tlvfield, $fieldty);)* + $crate::decode_tlv_stream!(r, {$(($type, $tlvfield, $fieldty)),*}); Ok(Self { $($field),*, $($tlvfield),* @@ -265,8 +643,8 @@ macro_rules! impl_writeable_msg { macro_rules! impl_writeable { ($st:ident, {$($field:ident),*}) => { - impl ::util::ser::Writeable for $st { - fn write(&self, w: &mut W) -> Result<(), $crate::io::Error> { + impl $crate::util::ser::Writeable for $st { + fn write(&self, w: &mut W) -> Result<(), $crate::io::Error> { $( self.$field.write(w)?; )* Ok(()) } @@ -279,10 +657,10 @@ macro_rules! impl_writeable { } } - impl ::util::ser::Readable for $st { - fn read(r: &mut R) -> Result { + impl $crate::util::ser::Readable for $st { + fn read(r: &mut R) -> Result { Ok(Self { - $($field: ::util::ser::Readable::read(r)?),* + $($field: $crate::util::ser::Readable::read(r)?),* }) } } @@ -290,18 +668,20 @@ macro_rules! impl_writeable { } /// Write out two bytes to indicate the version of an object. +/// /// $this_version represents a unique version of a type. Incremented whenever the type's -/// serialization format has changed or has a new interpretation. Used by a type's -/// reader to determine how to interpret fields or if it can understand a serialized -/// object. +/// serialization format has changed or has a new interpretation. Used by a type's reader to +/// determine how to interpret fields or if it can understand a serialized object. +/// /// $min_version_that_can_read_this is the minimum reader version which can understand this -/// serialized object. Previous versions will simply err with a -/// DecodeError::UnknownVersion. +/// serialized object. Previous versions will simply err with a [`DecodeError::UnknownVersion`]. /// -/// Updates to either $this_version or $min_version_that_can_read_this should be included in +/// Updates to either `$this_version` or `$min_version_that_can_read_this` should be included in /// release notes. /// /// Both version fields can be specific to this type of object. +/// +/// [`DecodeError::UnknownVersion`]: crate::ln::msgs::DecodeError::UnknownVersion macro_rules! write_ver_prefix { ($stream: expr, $this_version: expr, $min_version_that_can_read_this: expr) => { $stream.write_all(&[$this_version; 1])?; @@ -309,23 +689,26 @@ macro_rules! write_ver_prefix { } } -/// Writes out a suffix to an object which contains potentially backwards-compatible, optional -/// fields which old nodes can happily ignore. +/// Writes out a suffix to an object as a length-prefixed TLV stream which contains potentially +/// backwards-compatible, optional fields which old nodes can happily ignore. /// /// It is written out in TLV format and, as with all TLV fields, unknown even fields cause a -/// DecodeError::UnknownRequiredFeature error, with unknown odd fields ignored. +/// [`DecodeError::UnknownRequiredFeature`] error, with unknown odd fields ignored. /// /// This is the preferred method of adding new fields that old nodes can ignore and still function /// correctly. +/// +/// [`DecodeError::UnknownRequiredFeature`]: crate::ln::msgs::DecodeError::UnknownRequiredFeature +#[macro_export] macro_rules! write_tlv_fields { ($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),* $(,)*}) => { - encode_varint_length_prefixed_tlv!($stream, {$(($type, $field, $fieldty)),*}) + $crate::_encode_varint_length_prefixed_tlv!($stream, {$(($type, $field, $fieldty)),*}) } } -/// Reads a prefix added by write_ver_prefix!(), above. Takes the current version of the +/// Reads a prefix added by [`write_ver_prefix`], above. Takes the current version of the /// serialization logic for this object. This is compared against the -/// $min_version_that_can_read_this added by write_ver_prefix!(). +/// `$min_version_that_can_read_this` added by [`write_ver_prefix`]. macro_rules! read_ver_prefix { ($stream: expr, $this_version: expr) => { { let ver: u8 = Readable::read($stream)?; @@ -337,56 +720,164 @@ macro_rules! read_ver_prefix { } } } -/// Reads a suffix added by write_tlv_fields. +/// Reads a suffix added by [`write_tlv_fields`]. +/// +/// [`write_tlv_fields`]: crate::write_tlv_fields +#[macro_export] 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); - decode_tlv_stream!(&mut rd, {$(($type, $field, $fieldty)),*}); - rd.eat_remaining().map_err(|_| ::ln::msgs::DecodeError::ShortRead)?; + 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); + $crate::decode_tlv_stream!(&mut rd, {$(($type, $field, $fieldty)),*}); + rd.eat_remaining().map_err(|_| $crate::ln::msgs::DecodeError::ShortRead)?; } } } -macro_rules! init_tlv_based_struct_field { +/// Initializes the struct fields. +/// +/// This is exported for use by other exported macros, do not use directly. +#[doc(hidden)] +#[macro_export] +macro_rules! _init_tlv_based_struct_field { ($field: ident, (default_value, $default: expr)) => { $field.0.unwrap() }; + ($field: ident, (static_value, $value: expr)) => { + $field + }; ($field: ident, option) => { $field }; + ($field: ident, (option: $trait: ident $(, $read_arg: expr)?)) => { + $crate::_init_tlv_based_struct_field!($field, option) + }; + ($field: ident, upgradable_required) => { + $field.0.unwrap() + }; + ($field: ident, upgradable_option) => { + $field + }; ($field: ident, required) => { $field.0.unwrap() }; - ($field: ident, vec_type) => { + ($field: ident, required_vec) => { + $field + }; + ($field: ident, optional_vec) => { $field.unwrap() }; } -macro_rules! init_tlv_field_var { +/// Initializes the variable we are going to read the TLV into. +/// +/// This is exported for use by other exported macros, do not use directly. +#[doc(hidden)] +#[macro_export] +macro_rules! _init_tlv_field_var { ($field: ident, (default_value, $default: expr)) => { - let mut $field = ::util::ser::OptionDeserWrapper(None); + let mut $field = $crate::util::ser::RequiredWrapper(None); + }; + ($field: ident, (static_value, $value: expr)) => { + let $field; }; ($field: ident, required) => { - let mut $field = ::util::ser::OptionDeserWrapper(None); + let mut $field = $crate::util::ser::RequiredWrapper(None); }; - ($field: ident, vec_type) => { - let mut $field = Some(Vec::new()); + ($field: ident, (required: $trait: ident $(, $read_arg: expr)?)) => { + $crate::_init_tlv_field_var!($field, required); + }; + ($field: ident, required_vec) => { + let mut $field = Vec::new(); }; ($field: ident, option) => { let mut $field = None; }; + ($field: ident, optional_vec) => { + let mut $field = Some(Vec::new()); + }; + ($field: ident, (option, encoding: ($fieldty: ty, $encoding: ident))) => { + $crate::_init_tlv_field_var!($field, option); + }; + ($field: ident, (option: $trait: ident $(, $read_arg: expr)?)) => { + $crate::_init_tlv_field_var!($field, option); + }; + ($field: ident, upgradable_required) => { + let mut $field = $crate::util::ser::UpgradableRequired(None); + }; + ($field: ident, upgradable_option) => { + let mut $field = None; + }; } -/// Implements Readable/Writeable for a struct storing it as a set of TLVs -/// If $fieldty is `required`, then $field is a required field that is not an Option nor a Vec. -/// If $fieldty is `option`, then $field is optional field. -/// if $fieldty is `vec_type`, then $field is a Vec, which needs to have its individual elements -/// serialized. +/// Equivalent to running [`_init_tlv_field_var`] then [`read_tlv_fields`]. +/// +/// If any unused values are read, their type MUST be specified or else `rustc` will read them as an +/// `i64`. +/// +/// This is exported for use by other exported macros, do not use directly. +#[doc(hidden)] +#[macro_export] +macro_rules! _init_and_read_len_prefixed_tlv_fields { + ($reader: ident, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}) => { + $( + $crate::_init_tlv_field_var!($field, $fieldty); + )* + + $crate::read_tlv_fields!($reader, { + $(($type, $field, $fieldty)),* + }); + } +} + +/// Equivalent to running [`_init_tlv_field_var`] then [`decode_tlv_stream`]. +/// +/// If any unused values are read, their type MUST be specified or else `rustc` will read them as an +/// `i64`. +macro_rules! _init_and_read_tlv_stream { + ($reader: ident, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}) => { + $( + $crate::_init_tlv_field_var!($field, $fieldty); + )* + + $crate::decode_tlv_stream!($reader, { + $(($type, $field, $fieldty)),* + }); + } +} + +/// Implements [`Readable`]/[`Writeable`] for a struct storing it as a set of TLVs +/// If `$fieldty` is `required`, then `$field` is a required field that is not an [`Option`] nor a [`Vec`]. +/// If `$fieldty` is `(default_value, $default)`, then `$field` will be set to `$default` if not present. +/// If `$fieldty` is `option`, then `$field` is optional field. +/// If `$fieldty` is `optional_vec`, then `$field` is a [`Vec`], which needs to have its individual elements serialized. +/// Note that for `optional_vec` no bytes are written if the vec is empty +/// +/// For example, +/// ``` +/// # use lightning::impl_writeable_tlv_based; +/// struct LightningMessage { +/// tlv_integer: u32, +/// tlv_default_integer: u32, +/// tlv_optional_integer: Option, +/// tlv_vec_type_integer: Vec, +/// } +/// +/// impl_writeable_tlv_based!(LightningMessage, { +/// (0, tlv_integer, required), +/// (1, tlv_default_integer, (default_value, 7)), +/// (2, tlv_optional_integer, option), +/// (3, tlv_vec_type_integer, optional_vec), +/// }); +/// ``` +/// +/// [`Readable`]: crate::util::ser::Readable +/// [`Writeable`]: crate::util::ser::Writeable +#[macro_export] macro_rules! impl_writeable_tlv_based { ($st: ident, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}) => { - impl ::util::ser::Writeable for $st { - fn write(&self, writer: &mut W) -> Result<(), $crate::io::Error> { - write_tlv_fields!(writer, { + impl $crate::util::ser::Writeable for $st { + fn write(&self, writer: &mut W) -> Result<(), $crate::io::Error> { + $crate::write_tlv_fields!(writer, { $(($type, self.$field, $fieldty)),* }); Ok(()) @@ -394,32 +885,88 @@ macro_rules! impl_writeable_tlv_based { #[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); + $crate::_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(reader: &mut R) -> Result { + impl $crate::util::ser::Readable for $st { + fn read(reader: &mut R) -> Result { + $crate::_init_and_read_len_prefixed_tlv_fields!(reader, { + $(($type, $field, $fieldty)),* + }); + Ok(Self { + $( + $field: $crate::_init_tlv_based_struct_field!($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(super) struct $name { + $( + pub(super) $field: Option, + )* + } + + #[cfg_attr(test, derive(PartialEq))] + #[derive(Debug)] + pub(crate) struct $nameref<'a> { + $( + pub(super) $field: Option, + )* + } + + impl<'a> $crate::util::ser::Writeable for $nameref<'a> { + fn write(&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(reader: &mut R) -> Result { $( - init_tlv_field_var!($field, $fieldty); + _init_tlv_field_var!($field, option); )* - read_tlv_fields!(reader, { - $(($type, $field, $fieldty)),* + 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: init_tlv_based_struct_field!($field, $fieldty) + $field: $field ),* }) } @@ -427,19 +974,38 @@ macro_rules! impl_writeable_tlv_based { } } +macro_rules! tlv_record_type { + (($type:ty, $wrapper:ident)) => { $type }; + (($type:ty, $wrapper:ident, $encoder:ty)) => { $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, $wrapper:ident, $encoder:ty)) => { $encoder }; + ($type:ty) => { &'a $type }; +} + +#[doc(hidden)] +#[macro_export] 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(&self, writer: &mut W) -> Result<(), $crate::io::Error> { + impl $crate::util::ser::Writeable for $st { + fn write(&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)),* + $crate::write_tlv_fields!(writer, { + $(($type, *$field, $fieldty)),* }); }),* $($st::$tuple_variant_name (ref field) => { @@ -454,104 +1020,121 @@ macro_rules! _impl_writeable_tlv_based_enum_common { } } -/// Implement MaybeReadable and Writeable for an enum, with struct variants stored as TLVs and -/// tuple variants stored directly. +/// Implement [`Readable`] and [`Writeable`] for an enum, with struct variants stored as TLVs and tuple +/// variants stored directly. +/// The format is, for example +/// ```ignore +/// impl_writeable_tlv_based_enum!(EnumName, +/// (0, StructVariantA) => {(0, required_variant_field, required), (1, optional_variant_field, option)}, +/// (1, StructVariantB) => {(0, variant_field_a, required), (1, variant_field_b, required), (2, variant_vec_field, optional_vec)}; +/// (2, TupleVariantA), (3, TupleVariantB), +/// ); +/// ``` +/// The type is written as a single byte, followed by any variant data. +/// Attempts to read an unknown type byte result in [`DecodeError::UnknownRequiredFeature`]. /// -/// This is largely identical to `impl_writeable_tlv_based_enum`, except that odd variants will -/// return `Ok(None)` instead of `Err(UnknownRequiredFeature)`. It should generally be preferred -/// when `MaybeReadable` is practical instead of just `Readable` as it provides an upgrade path for -/// new variants to be added which are simply ignored by existing clients. -macro_rules! impl_writeable_tlv_based_enum_upgradable { +/// [`Readable`]: crate::util::ser::Readable +/// [`Writeable`]: crate::util::ser::Writeable +/// [`DecodeError::UnknownRequiredFeature`]: crate::ln::msgs::DecodeError::UnknownRequiredFeature +#[macro_export] +macro_rules! impl_writeable_tlv_based_enum { ($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, + ),* $(,)*; + $(($tuple_variant_id: expr, $tuple_variant_name: ident)),* $(,)*) => { + $crate::_impl_writeable_tlv_based_enum_common!($st, $(($variant_id, $variant_name) => {$(($type, $field, $fieldty)),*}),*; - $($(($tuple_variant_id, $tuple_variant_name)),*)*); + $(($tuple_variant_id, $tuple_variant_name)),*); - impl ::util::ser::MaybeReadable for $st { - fn read(reader: &mut R) -> Result, ::ln::msgs::DecodeError> { - let id: u8 = ::util::ser::Readable::read(reader)?; + impl $crate::util::ser::Readable for $st { + fn read(reader: &mut R) -> Result { + 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 // in the same function body. Instead, we define a closure and call it. let f = || { - $( - init_tlv_field_var!($field, $fieldty); - )* - read_tlv_fields!(reader, { + $crate::_init_and_read_len_prefixed_tlv_fields!(reader, { $(($type, $field, $fieldty)),* }); - Ok(Some($st::$variant_name { + Ok($st::$variant_name { $( - $field: init_tlv_based_struct_field!($field, $fieldty) + $field: $crate::_init_tlv_based_struct_field!($field, $fieldty) ),* - })) + }) }; f() }),* - $($($tuple_variant_id => { - Ok(Some($st::$tuple_variant_name(Readable::read(reader)?))) - }),*)* - _ if id % 2 == 1 => Ok(None), - _ => Err(DecodeError::UnknownRequiredFeature), + $($tuple_variant_id => { + Ok($st::$tuple_variant_name($crate::util::ser::Readable::read(reader)?)) + }),* + _ => { + Err($crate::ln::msgs::DecodeError::UnknownRequiredFeature) + }, } } } - } } -/// Implement Readable and Writeable for an enum, with struct variants stored as TLVs and tuple -/// variants stored directly. -/// The format is, for example -/// impl_writeable_tlv_based_enum!(EnumName, -/// (0, StructVariantA) => {(0, required_variant_field, required), (1, optional_variant_field, option)}, -/// (1, StructVariantB) => {(0, variant_field_a, required), (1, variant_field_b, required), (2, variant_vec_field, vec_type)}; -/// (2, TupleVariantA), (3, TupleVariantB), -/// ); -/// The type is written as a single byte, followed by any variant data. -/// Attempts to read an unknown type byte result in DecodeError::UnknownRequiredFeature. -macro_rules! impl_writeable_tlv_based_enum { +/// Implement [`MaybeReadable`] and [`Writeable`] for an enum, with struct variants stored as TLVs and +/// tuple variants stored directly. +/// +/// This is largely identical to [`impl_writeable_tlv_based_enum`], except that odd variants will +/// return `Ok(None)` instead of `Err(`[`DecodeError::UnknownRequiredFeature`]`)`. It should generally be preferred +/// when [`MaybeReadable`] is practical instead of just [`Readable`] as it provides an upgrade path for +/// new variants to be added which are simply ignored by existing clients. +/// +/// Note that only struct and unit variants (not tuple variants) will support downgrading, thus any +/// new odd variants MUST be non-tuple (i.e. described using `$variant_id` and `$variant_name` not +/// `$tuple_variant_id` and `$tuple_variant_name`). +/// +/// [`MaybeReadable`]: crate::util::ser::MaybeReadable +/// [`Writeable`]: crate::util::ser::Writeable +/// [`DecodeError::UnknownRequiredFeature`]: crate::ln::msgs::DecodeError::UnknownRequiredFeature +/// [`Readable`]: crate::util::ser::Readable +#[macro_export] +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, + ),* $(,)* + $(; + $(($tuple_variant_id: expr, $tuple_variant_name: ident)),* $(,)*)*) => { + $crate::_impl_writeable_tlv_based_enum_common!($st, $(($variant_id, $variant_name) => {$(($type, $field, $fieldty)),*}),*; - $(($tuple_variant_id, $tuple_variant_name)),*); + $($(($tuple_variant_id, $tuple_variant_name)),*)*); - impl ::util::ser::Readable for $st { - fn read(reader: &mut R) -> Result { - let id: u8 = ::util::ser::Readable::read(reader)?; + impl $crate::util::ser::MaybeReadable for $st { + fn read(reader: &mut R) -> Result, $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 // in the same function body. Instead, we define a closure and call it. let f = || { - $( - init_tlv_field_var!($field, $fieldty); - )* - read_tlv_fields!(reader, { + $crate::_init_and_read_len_prefixed_tlv_fields!(reader, { $(($type, $field, $fieldty)),* }); - Ok($st::$variant_name { + Ok(Some($st::$variant_name { $( - $field: init_tlv_based_struct_field!($field, $fieldty) + $field: $crate::_init_tlv_based_struct_field!($field, $fieldty) ),* - }) + })) }; f() }),* - $($tuple_variant_id => { - Ok($st::$tuple_variant_name(Readable::read(reader)?)) - }),* - _ => { - Err(DecodeError::UnknownRequiredFeature) + $($($tuple_variant_id => { + Ok(Some($st::$tuple_variant_name(Readable::read(reader)?))) + }),*)* + _ if id % 2 == 1 => { + // Assume that a $variant_id was written, not a $tuple_variant_id, and read + // the length prefix and discard the correct number of bytes. + let tlv_len: $crate::util::ser::BigSize = $crate::util::ser::Readable::read(reader)?; + let mut rd = $crate::util::ser::FixedLengthReader::new(reader, tlv_len.0); + rd.eat_remaining().map_err(|_| $crate::ln::msgs::DecodeError::ShortRead)?; + Ok(None) }, + _ => Err($crate::ln::msgs::DecodeError::UnknownRequiredFeature), } } } @@ -560,10 +1143,11 @@ macro_rules! impl_writeable_tlv_based_enum { #[cfg(test)] mod tests { - use io::{self, Cursor}; - use prelude::*; - use ln::msgs::DecodeError; - use util::ser::{Writeable, HighZeroBytesDroppedBigSize, VecWriter}; + use crate::io::{self, Cursor}; + use crate::prelude::*; + use crate::ln::msgs::DecodeError; + use crate::util::ser::{Writeable, HighZeroBytesDroppedBigSize, VecWriter}; + use bitcoin::hashes::hex::FromHex; use bitcoin::secp256k1::PublicKey; // The BOLT TLV test cases don't include any tests which use our "required-value" logic since @@ -581,7 +1165,7 @@ mod tests { #[test] fn tlv_v_short_read() { // We only expect a u32 for type 3 (which we are given), but the L says its 8 bytes. - if let Err(DecodeError::ShortRead) = tlv_reader(&::hex::decode( + if let Err(DecodeError::ShortRead) = tlv_reader(&>::from_hex( concat!("0100", "0208deadbeef1badbeef", "0308deadbeef") ).unwrap()[..]) { } else { panic!(); } @@ -589,12 +1173,12 @@ mod tests { #[test] fn tlv_types_out_of_order() { - if let Err(DecodeError::InvalidValue) = tlv_reader(&::hex::decode( + if let Err(DecodeError::InvalidValue) = tlv_reader(&>::from_hex( concat!("0100", "0304deadbeef", "0208deadbeef1badbeef") ).unwrap()[..]) { } else { panic!(); } // ...even if its some field we don't understand - if let Err(DecodeError::InvalidValue) = tlv_reader(&::hex::decode( + if let Err(DecodeError::InvalidValue) = tlv_reader(&>::from_hex( concat!("0208deadbeef1badbeef", "0100", "0304deadbeef") ).unwrap()[..]) { } else { panic!(); } @@ -603,17 +1187,17 @@ mod tests { #[test] fn tlv_req_type_missing_or_extra() { // It's also bad if they included even fields we don't understand - if let Err(DecodeError::UnknownRequiredFeature) = tlv_reader(&::hex::decode( + if let Err(DecodeError::UnknownRequiredFeature) = tlv_reader(&>::from_hex( concat!("0100", "0208deadbeef1badbeef", "0304deadbeef", "0600") ).unwrap()[..]) { } else { panic!(); } // ... or if they're missing fields we need - if let Err(DecodeError::InvalidValue) = tlv_reader(&::hex::decode( + if let Err(DecodeError::InvalidValue) = tlv_reader(&>::from_hex( concat!("0100", "0208deadbeef1badbeef") ).unwrap()[..]) { } else { panic!(); } // ... even if that field is even - if let Err(DecodeError::InvalidValue) = tlv_reader(&::hex::decode( + if let Err(DecodeError::InvalidValue) = tlv_reader(&>::from_hex( concat!("0304deadbeef", "0500") ).unwrap()[..]) { } else { panic!(); } @@ -621,16 +1205,57 @@ mod tests { #[test] fn tlv_simple_good_cases() { - assert_eq!(tlv_reader(&::hex::decode( + assert_eq!(tlv_reader(&>::from_hex( concat!("0208deadbeef1badbeef", "03041bad1dea") ).unwrap()[..]).unwrap(), (0xdeadbeef1badbeef, 0x1bad1dea, None)); - assert_eq!(tlv_reader(&::hex::decode( + assert_eq!(tlv_reader(&>::from_hex( concat!("0208deadbeef1badbeef", "03041bad1dea", "040401020304") ).unwrap()[..]).unwrap(), (0xdeadbeef1badbeef, 0x1bad1dea, Some(0x01020304))); } + #[derive(Debug, PartialEq)] + struct TestUpgradable { + a: u32, + b: u32, + c: Option, + } + + fn upgradable_tlv_reader(s: &[u8]) -> Result, DecodeError> { + let mut s = Cursor::new(s); + let mut a = 0; + let mut b = 0; + let mut c: Option = None; + decode_tlv_stream!(&mut s, {(2, a, upgradable_required), (3, b, upgradable_required), (4, c, upgradable_option)}); + Ok(Some(TestUpgradable { a, b, c, })) + } + + #[test] + fn upgradable_tlv_simple_good_cases() { + assert_eq!(upgradable_tlv_reader(&>::from_hex( + concat!("0204deadbeef", "03041bad1dea", "0404deadbeef") + ).unwrap()[..]).unwrap(), + Some(TestUpgradable { a: 0xdeadbeef, b: 0x1bad1dea, c: Some(0xdeadbeef) })); + + assert_eq!(upgradable_tlv_reader(&>::from_hex( + concat!("0204deadbeef", "03041bad1dea") + ).unwrap()[..]).unwrap(), + Some(TestUpgradable { a: 0xdeadbeef, b: 0x1bad1dea, c: None})); + } + + #[test] + fn missing_required_upgradable() { + if let Err(DecodeError::InvalidValue) = upgradable_tlv_reader(&>::from_hex( + concat!("0100", "0204deadbeef") + ).unwrap()[..]) { + } else { panic!(); } + if let Err(DecodeError::InvalidValue) = upgradable_tlv_reader(&>::from_hex( + concat!("0100", "03041bad1dea") + ).unwrap()[..]) { + } else { panic!(); } + } + // BOLT TLV test cases fn tlv_reader_n1(s: &[u8]) -> Result<(Option>, Option, Option<(PublicKey, u64, u64)>, Option), DecodeError> { let mut s = Cursor::new(s); @@ -646,7 +1271,7 @@ mod tests { fn bolt_tlv_bogus_stream() { macro_rules! do_test { ($stream: expr, $reason: ident) => { - if let Err(DecodeError::$reason) = tlv_reader_n1(&::hex::decode($stream).unwrap()[..]) { + if let Err(DecodeError::$reason) = tlv_reader_n1(&>::from_hex($stream).unwrap()[..]) { } else { panic!(); } } } @@ -671,7 +1296,7 @@ mod tests { fn bolt_tlv_bogus_n1_stream() { macro_rules! do_test { ($stream: expr, $reason: ident) => { - if let Err(DecodeError::$reason) = tlv_reader_n1(&::hex::decode($stream).unwrap()[..]) { + if let Err(DecodeError::$reason) = tlv_reader_n1(&>::from_hex($stream).unwrap()[..]) { } else { panic!(); } } } @@ -711,7 +1336,7 @@ mod tests { fn bolt_tlv_valid_n1_stream() { macro_rules! do_test { ($stream: expr, $tlv1: expr, $tlv2: expr, $tlv3: expr, $tlv4: expr) => { - if let Ok((tlv1, tlv2, tlv3, tlv4)) = tlv_reader_n1(&::hex::decode($stream).unwrap()[..]) { + if let Ok((tlv1, tlv2, tlv3, tlv4)) = tlv_reader_n1(&>::from_hex($stream).unwrap()[..]) { assert_eq!(tlv1.map(|v| v.0), $tlv1); assert_eq!(tlv2, $tlv2); assert_eq!(tlv3, $tlv3); @@ -740,7 +1365,7 @@ mod tests { do_test!(concat!("02", "08", "0000000000000226"), None, Some((0 << 30) | (0 << 5) | (550 << 0)), None, None); do_test!(concat!("03", "31", "023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb00000000000000010000000000000002"), None, None, Some(( - PublicKey::from_slice(&::hex::decode("023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb").unwrap()[..]).unwrap(), 1, 2)), + PublicKey::from_slice(&>::from_hex("023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb").unwrap()[..]).unwrap(), 1, 2)), None); do_test!(concat!("fd00fe", "02", "0226"), None, None, None, Some(550)); } @@ -749,28 +1374,28 @@ mod tests { let mut stream = VecWriter(Vec::new()); stream.0.clear(); - encode_varint_length_prefixed_tlv!(&mut stream, {(1, 1u8, required), (42, None::, option)}); - assert_eq!(stream.0, ::hex::decode("03010101").unwrap()); + _encode_varint_length_prefixed_tlv!(&mut stream, {(1, 1u8, required), (42, None::, option)}); + assert_eq!(stream.0, >::from_hex("03010101").unwrap()); stream.0.clear(); - encode_varint_length_prefixed_tlv!(&mut stream, {(1, Some(1u8), option)}); - assert_eq!(stream.0, ::hex::decode("03010101").unwrap()); + _encode_varint_length_prefixed_tlv!(&mut stream, {(1, Some(1u8), option)}); + assert_eq!(stream.0, >::from_hex("03010101").unwrap()); stream.0.clear(); - encode_varint_length_prefixed_tlv!(&mut stream, {(4, 0xabcdu16, required), (42, None::, option)}); - assert_eq!(stream.0, ::hex::decode("040402abcd").unwrap()); + _encode_varint_length_prefixed_tlv!(&mut stream, {(4, 0xabcdu16, required), (42, None::, option)}); + assert_eq!(stream.0, >::from_hex("040402abcd").unwrap()); stream.0.clear(); - encode_varint_length_prefixed_tlv!(&mut stream, {(42, None::, option), (0xff, 0xabcdu16, required)}); - assert_eq!(stream.0, ::hex::decode("06fd00ff02abcd").unwrap()); + _encode_varint_length_prefixed_tlv!(&mut stream, {(42, None::, option), (0xff, 0xabcdu16, required)}); + assert_eq!(stream.0, >::from_hex("06fd00ff02abcd").unwrap()); stream.0.clear(); - encode_varint_length_prefixed_tlv!(&mut stream, {(0, 1u64, required), (42, None::, option), (0xff, HighZeroBytesDroppedBigSize(0u64), required)}); - assert_eq!(stream.0, ::hex::decode("0e00080000000000000001fd00ff00").unwrap()); + _encode_varint_length_prefixed_tlv!(&mut stream, {(0, 1u64, required), (42, None::, option), (0xff, HighZeroBytesDroppedBigSize(0u64), required)}); + assert_eq!(stream.0, >::from_hex("0e00080000000000000001fd00ff00").unwrap()); stream.0.clear(); - encode_varint_length_prefixed_tlv!(&mut stream, {(0, Some(1u64), option), (0xff, HighZeroBytesDroppedBigSize(0u64), required)}); - assert_eq!(stream.0, ::hex::decode("0e00080000000000000001fd00ff00").unwrap()); + _encode_varint_length_prefixed_tlv!(&mut stream, {(0, Some(1u64), option), (0xff, HighZeroBytesDroppedBigSize(0u64), required)}); + assert_eq!(stream.0, >::from_hex("0e00080000000000000001fd00ff00").unwrap()); Ok(()) }