X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Fser_macros.rs;h=312fe7d9f98424ea2a0ad3dc3231cd765d50e624;hb=3a9fe209e104e048921ad50be77a80b18a98b45c;hp=a68dae39cdc65319b910f1f2af6b5fb905511e96;hpb=83f0dbc0021335dce183450d7dce7e9f284ff0b6;p=rust-lightning diff --git a/lightning/src/util/ser_macros.rs b/lightning/src/util/ser_macros.rs index a68dae39..312fe7d9 100644 --- a/lightning/src/util/ser_macros.rs +++ b/lightning/src/util/ser_macros.rs @@ -231,9 +231,10 @@ macro_rules! _get_varint_length_prefixed_tlv_length { #[macro_export] macro_rules! _encode_varint_length_prefixed_tlv { ($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)),*}, &[]) } }; ($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 = { @@ -790,10 +791,13 @@ macro_rules! _init_tlv_field_var { /// 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_tlv_fields { +macro_rules! _init_and_read_len_prefixed_tlv_fields { ($reader: ident, {$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}) => { $( $crate::_init_tlv_field_var!($field, $fieldty); @@ -805,6 +809,22 @@ macro_rules! _init_and_read_tlv_fields { } } +/// 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. @@ -814,8 +834,7 @@ macro_rules! _init_and_read_tlv_fields { /// /// For example, /// ``` -/// # use lightning::{impl_writeable_tlv_based, _encode_varint_length_prefixed_tlv}; -/// # extern crate alloc; +/// # use lightning::impl_writeable_tlv_based; /// struct LightningMessage { /// tlv_integer: u32, /// tlv_default_integer: u32, @@ -863,7 +882,7 @@ macro_rules! impl_writeable_tlv_based { impl $crate::util::ser::Readable for $st { fn read(reader: &mut R) -> Result { - $crate::_init_and_read_tlv_fields!(reader, { + $crate::_init_and_read_len_prefixed_tlv_fields!(reader, { $(($type, $field, $fieldty)),* }); Ok(Self { @@ -898,7 +917,7 @@ macro_rules! tlv_stream { #[cfg_attr(test, derive(PartialEq))] #[derive(Debug)] - pub(super) struct $nameref<'a> { + pub(crate) struct $nameref<'a> { $( pub(super) $field: Option, )* @@ -1014,8 +1033,8 @@ macro_rules! impl_writeable_tlv_based_enum { $($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 = || { - $crate::_init_and_read_tlv_fields!(reader, { + let mut f = || { + $crate::_init_and_read_len_prefixed_tlv_fields!(reader, { $(($type, $field, $fieldty)),* }); Ok($st::$variant_name { @@ -1068,8 +1087,8 @@ macro_rules! impl_writeable_tlv_based_enum_upgradable { $($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 = || { - $crate::_init_and_read_tlv_fields!(reader, { + let mut f = || { + $crate::_init_and_read_len_prefixed_tlv_fields!(reader, { $(($type, $field, $fieldty)),* }); Ok(Some($st::$variant_name { @@ -1093,10 +1112,13 @@ macro_rules! impl_writeable_tlv_based_enum_upgradable { #[cfg(test)] mod tests { - use crate::io::{self, Cursor}; + #[allow(unused_imports)] use crate::prelude::*; + + use crate::io::{self, Cursor}; 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 @@ -1114,7 +1136,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!(); } @@ -1122,12 +1144,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!(); } @@ -1136,17 +1158,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!(); } @@ -1154,11 +1176,11 @@ 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))); @@ -1182,12 +1204,12 @@ mod tests { #[test] fn upgradable_tlv_simple_good_cases() { - assert_eq!(upgradable_tlv_reader(&::hex::decode( + 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(&::hex::decode( + assert_eq!(upgradable_tlv_reader(&>::from_hex( concat!("0204deadbeef", "03041bad1dea") ).unwrap()[..]).unwrap(), Some(TestUpgradable { a: 0xdeadbeef, b: 0x1bad1dea, c: None})); @@ -1195,11 +1217,11 @@ mod tests { #[test] fn missing_required_upgradable() { - if let Err(DecodeError::InvalidValue) = upgradable_tlv_reader(&::hex::decode( + if let Err(DecodeError::InvalidValue) = upgradable_tlv_reader(&>::from_hex( concat!("0100", "0204deadbeef") ).unwrap()[..]) { } else { panic!(); } - if let Err(DecodeError::InvalidValue) = upgradable_tlv_reader(&::hex::decode( + if let Err(DecodeError::InvalidValue) = upgradable_tlv_reader(&>::from_hex( concat!("0100", "03041bad1dea") ).unwrap()[..]) { } else { panic!(); } @@ -1220,7 +1242,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!(); } } } @@ -1245,7 +1267,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!(); } } } @@ -1285,7 +1307,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); @@ -1314,7 +1336,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)); } @@ -1324,27 +1346,27 @@ mod tests { stream.0.clear(); _encode_varint_length_prefixed_tlv!(&mut stream, {(1, 1u8, required), (42, None::, option)}); - assert_eq!(stream.0, ::hex::decode("03010101").unwrap()); + 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()); + 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()); + 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()); + 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()); + 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()); + assert_eq!(stream.0, >::from_hex("0e00080000000000000001fd00ff00").unwrap()); Ok(()) }