X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Fser_macros.rs;h=5d5171adbb4401c1dd1fb5faf3b1f8afab919db2;hb=57feb2630779410b5977ccb3c12dd482a20440fc;hp=766d4ee2d78ff90a774049e8cc13d9731b490d18;hpb=3c9e8c9d773db3ffaf18bec01bde56e32b871a5f;p=rust-lightning diff --git a/lightning/src/util/ser_macros.rs b/lightning/src/util/ser_macros.rs index 766d4ee2..5d5171ad 100644 --- a/lightning/src/util/ser_macros.rs +++ b/lightning/src/util/ser_macros.rs @@ -1,39 +1,139 @@ +// This file is Copyright its original authors, visible in version control +// history. +// +// This file is licensed under the Apache License, Version 2.0 or the MIT license +// , at your option. +// You may not use this file except in accordance with one or both of these +// licenses. + macro_rules! encode_tlv { - ($stream: expr, {$(($type: expr, $field: expr)),*}) => { { - use util::ser::{BigSize, LengthCalculatingWriter}; + ($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, $optional_type: expr, $optional_field: expr, option) => { + if let Some(ref field) = $optional_field { + BigSize($optional_type).write($stream)?; + BigSize(field.serialized_length() as u64).write($stream)?; + field.write($stream)?; + } + }; +} + +macro_rules! encode_tlv_stream { + ($stream: expr, {$(($type: expr, $field: expr, $fieldty: ident)),*}) => { { + #[allow(unused_imports)] + use { + ln::msgs::DecodeError, + util::ser, + util::ser::BigSize, + }; + $( - BigSize($type).write($stream)?; - let mut len_calc = LengthCalculatingWriter(0); - $field.write(&mut len_calc)?; - BigSize(len_calc.0 as u64).write($stream)?; - $field.write($stream)?; + encode_tlv!($stream, $type, $field, $fieldty); )* + + #[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); + )* + } } } } +macro_rules! get_varint_length_prefixed_tlv_length { + ($len: expr, $type: expr, $field: expr, required) => { + BigSize($type).write(&mut $len).expect("No in-memory data may fail to serialize"); + let field_len = $field.serialized_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, $optional_type: expr, $optional_field: expr, option) => { + if let Some(ref field) = $optional_field { + BigSize($optional_type).write(&mut $len).expect("No in-memory data may fail to serialize"); + let field_len = field.serialized_length(); + BigSize(field_len as u64).write(&mut $len).expect("No in-memory data may fail to serialize"); + $len.0 += field_len; + } + }; +} + macro_rules! encode_varint_length_prefixed_tlv { - ($stream: expr, {$(($type: expr, $field: expr)),*}) => { { - use util::ser::{BigSize, LengthCalculatingWriter}; - let mut len = LengthCalculatingWriter(0); - { + ($stream: expr, {$(($type: expr, $field: expr, $fieldty: ident)),*}) => { { + use util::ser::BigSize; + let len = { + #[allow(unused_mut)] + let mut len = ::util::ser::LengthCalculatingWriter(0); $( - BigSize($type).write(&mut len)?; - let mut field_len = LengthCalculatingWriter(0); - $field.write(&mut field_len)?; - BigSize(field_len.0 as u64).write(&mut len)?; - len.0 += field_len.0; + get_varint_length_prefixed_tlv_length!(len, $type, $field, $fieldty); )* + len.0 + }; + BigSize(len as u64).write($stream)?; + encode_tlv_stream!($stream, { $(($type, $field, $fieldty)),* }); + } } +} + +macro_rules! check_tlv_order { + ($last_seen_type: expr, $typ: expr, $type: expr, required) => {{ + #[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 { + return Err(DecodeError::InvalidValue); } + }}; + ($last_seen_type: expr, $typ: expr, $type: expr, option) => {{ + // no-op + }}; + ($last_seen_type: expr, $typ: expr, $type: expr, vec_type) => {{ + // no-op + }}; +} - BigSize(len.0 as u64).write($stream)?; - encode_tlv!($stream, { - $(($type, $field)),* - }); - } } +macro_rules! check_missing_tlv { + ($last_seen_type: expr, $type: expr, required) => {{ + #[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 { + return Err(DecodeError::InvalidValue); + } + }}; + ($last_seen_type: expr, $type: expr, vec_type) => {{ + // no-op + }}; + ($last_seen_type: expr, $type: expr, option) => {{ + // no-op + }}; } macro_rules! decode_tlv { - ($stream: expr, {$(($reqtype: expr, $reqfield: ident)),*}, {$(($type: expr, $field: ident)),*}) => { { + ($reader: expr, $field: ident, required) => {{ + $field = ser::Readable::read(&mut $reader)?; + }}; + ($reader: expr, $field: ident, vec_type) => {{ + $field = Some(ser::Readable::read(&mut $reader)?); + }}; + ($reader: expr, $field: ident, option) => {{ + $field = Some(ser::Readable::read(&mut $reader)?); + }}; +} + +macro_rules! decode_tlv_stream { + ($stream: expr, {$(($type: expr, $field: ident, $fieldty: ident)),* $(,)*}) => { { use ln::msgs::DecodeError; let mut last_seen_type: Option = None; 'tlv_read: loop { @@ -49,12 +149,12 @@ macro_rules! decode_tlv { match ser::Readable::read(&mut tracking_reader) { Err(DecodeError::ShortRead) => { if !tracking_reader.have_read { - break 'tlv_read + break 'tlv_read; } else { - Err(DecodeError::ShortRead)? + return Err(DecodeError::ShortRead); } }, - Err(e) => Err(e)?, + Err(e) => return Err(e), Ok(t) => t, } }; @@ -62,44 +162,37 @@ macro_rules! decode_tlv { // Types must be unique and monotonically increasing: match last_seen_type { Some(t) if typ.0 <= t => { - Err(DecodeError::InvalidValue)? + return Err(DecodeError::InvalidValue); }, _ => {}, } // As we read types, make sure we hit every required type: - $(if (last_seen_type.is_none() || last_seen_type.unwrap() < $reqtype) && typ.0 > $reqtype { - Err(DecodeError::InvalidValue)? + $({ + check_tlv_order!(last_seen_type, typ, $type, $fieldty); })* last_seen_type = Some(typ.0); // Finally, read the length and value itself: - let length: ser::BigSize = Readable::read($stream)?; + let length: ser::BigSize = ser::Readable::read($stream)?; let mut s = ser::FixedLengthReader::new($stream, length.0); match typ.0 { - $($reqtype => { - $reqfield = ser::Readable::read(&mut s)?; - if s.bytes_remain() { - s.eat_remaining()?; // Return ShortRead if there's actually not enough bytes - Err(DecodeError::InvalidValue)? - } - },)* $($type => { - $field = Some(ser::Readable::read(&mut s)?); + decode_tlv!(s, $field, $fieldty); if s.bytes_remain() { s.eat_remaining()?; // Return ShortRead if there's actually not enough bytes - Err(DecodeError::InvalidValue)? + return Err(DecodeError::InvalidValue); } },)* x if x % 2 == 0 => { - Err(DecodeError::UnknownRequiredFeature)? + return Err(DecodeError::UnknownRequiredFeature); }, _ => {}, } s.eat_remaining()?; } // Make sure we got to each required type after we've read every TLV: - $(if last_seen_type.is_none() || last_seen_type.unwrap() < $reqtype { - Err(DecodeError::InvalidValue)? + $({ + check_missing_tlv!(last_seen_type, $type, $fieldty); })* } } } @@ -107,17 +200,42 @@ macro_rules! decode_tlv { macro_rules! impl_writeable { ($st:ident, $len: expr, {$($field:ident),*}) => { impl ::util::ser::Writeable for $st { - fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> { + fn write(&self, w: &mut W) -> Result<(), $crate::io::Error> { if $len != 0 { w.size_hint($len); } + #[cfg(any(test, feature = "fuzztarget"))] + { + // In tests, assert that the hard-coded length matches the actual one + if $len != 0 { + let mut len_calc = ::util::ser::LengthCalculatingWriter(0); + $( self.$field.write(&mut len_calc).expect("No in-memory data may fail to serialize"); )* + assert_eq!(len_calc.0, $len); + assert_eq!(self.serialized_length(), $len); + } + } $( self.$field.write(w)?; )* Ok(()) } + + #[inline] + fn serialized_length(&self) -> usize { + if $len == 0 || cfg!(any(test, feature = "fuzztarget")) { + let mut len_calc = 0; + $( len_calc += self.$field.serialized_length(); )* + if $len != 0 { + // In tests, assert that the hard-coded length matches the actual one + assert_eq!(len_calc, $len); + } else { + return len_calc; + } + } + $len + } } - impl ::util::ser::Readable for $st { - fn read(r: &mut R) -> Result { + impl ::util::ser::Readable for $st { + fn read(r: &mut R) -> Result { Ok(Self { $($field: ::util::ser::Readable::read(r)?),* }) @@ -126,33 +244,267 @@ macro_rules! impl_writeable { } } macro_rules! impl_writeable_len_match { - ($st:ident, {$({$m: pat, $l: expr}),*}, {$($field:ident),*}) => { - impl Writeable for $st { - fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> { - w.size_hint(match *self { - $($m => $l,)* - }); + ($struct: ident, $cmp: tt, ($calc_len: expr), {$({$match: pat, $length: expr}),*}, {$($field:ident),*}) => { + impl Writeable for $struct { + fn write(&self, w: &mut W) -> Result<(), $crate::io::Error> { + let len = match *self { + $($match => $length,)* + }; + w.size_hint(len); + #[cfg(any(test, feature = "fuzztarget"))] + { + // In tests, assert that the hard-coded length matches the actual one + let mut len_calc = ::util::ser::LengthCalculatingWriter(0); + $( self.$field.write(&mut len_calc).expect("No in-memory data may fail to serialize"); )* + assert!(len_calc.0 $cmp len); + assert_eq!(len_calc.0, self.serialized_length()); + } $( self.$field.write(w)?; )* Ok(()) } + + #[inline] + fn serialized_length(&self) -> usize { + if $calc_len || cfg!(any(test, feature = "fuzztarget")) { + let mut len_calc = 0; + $( len_calc += self.$field.serialized_length(); )* + if !$calc_len { + assert_eq!(len_calc, match *self { + $($match => $length,)* + }); + } + return len_calc + } + match *self { + $($match => $length,)* + } + } } - impl Readable for $st { - fn read(r: &mut R) -> Result { + impl ::util::ser::Readable for $struct { + fn read(r: &mut R) -> Result { Ok(Self { $($field: Readable::read(r)?),* }) } } + }; + ($struct: ident, $cmp: tt, {$({$match: pat, $length: expr}),*}, {$($field:ident),*}) => { + impl_writeable_len_match!($struct, $cmp, (true), { $({ $match, $length }),* }, { $($field),* }); + }; + ($struct: ident, {$({$match: pat, $length: expr}),*}, {$($field:ident),*}) => { + impl_writeable_len_match!($struct, ==, (false), { $({ $match, $length }),* }, { $($field),* }); + } +} + +/// 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. +/// $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. +/// +/// 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. +macro_rules! write_ver_prefix { + ($stream: expr, $this_version: expr, $min_version_that_can_read_this: expr) => { + $stream.write_all(&[$this_version; 1])?; + $stream.write_all(&[$min_version_that_can_read_this; 1])?; + } +} + +/// Writes out a suffix to an object 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. +/// +/// This is the preferred method of adding new fields that old nodes can ignore and still function +/// correctly. +macro_rules! write_tlv_fields { + ($stream: expr, {$(($type: expr, $field: expr, $fieldty: ident)),* $(,)*}) => { + encode_varint_length_prefixed_tlv!($stream, {$(($type, $field, $fieldty)),*}); + } +} + +/// 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!(). +macro_rules! read_ver_prefix { + ($stream: expr, $this_version: expr) => { { + let ver: u8 = Readable::read($stream)?; + let min_ver: u8 = Readable::read($stream)?; + if min_ver > $this_version { + return Err(DecodeError::UnknownVersion); + } + ver + } } +} + +/// Reads a suffix added by write_tlv_fields. +macro_rules! read_tlv_fields { + ($stream: expr, {$(($type: expr, $field: ident, $fieldty: ident)),* $(,)*}) => { { + let tlv_len = ::util::ser::BigSize::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)?; + } } +} + +macro_rules! init_tlv_based_struct_field { + ($field: ident, option) => { + $field + }; + ($field: ident, required) => { + $field.0.unwrap() + }; + ($field: ident, vec_type) => { + $field.unwrap().0 + }; +} + +macro_rules! init_tlv_field_var { + ($field: ident, required) => { + let mut $field = ::util::ser::OptionDeserWrapper(None); + }; + ($field: ident, vec_type) => { + let mut $field = Some(::util::ser::VecReadWrapper(Vec::new())); + }; + ($field: ident, 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. +macro_rules! impl_writeable_tlv_based { + ($st: ident, {$(($type: expr, $field: ident, $fieldty: ident)),* $(,)*}) => { + impl ::util::ser::Writeable for $st { + fn write(&self, writer: &mut W) -> Result<(), $crate::io::Error> { + write_tlv_fields!(writer, { + $(($type, self.$field, $fieldty)),* + }); + Ok(()) + } + + #[inline] + fn serialized_length(&self) -> usize { + use util::ser::BigSize; + let len = { + #[allow(unused_mut)] + let mut len = ::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); + 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 { + $( + init_tlv_field_var!($field, $fieldty); + )* + read_tlv_fields!(reader, { + $(($type, $field, $fieldty)),* + }); + Ok(Self { + $( + $field: init_tlv_based_struct_field!($field, $fieldty) + ),* + }) + } + } + } +} + +/// 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 { + ($st: ident, $(($variant_id: expr, $variant_name: ident) => + {$(($type: expr, $field: ident, $fieldty: ident)),* $(,)*} + ),* $(,)*; + $(($tuple_variant_id: expr, $tuple_variant_name: ident)),* $(,)*) => { + impl ::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)),* + }); + }),* + $($st::$tuple_variant_name (ref field) => { + let id: u8 = $tuple_variant_id; + id.write(writer)?; + field.write(writer)?; + }),* + } + Ok(()) + } + } + + impl ::util::ser::Readable for $st { + fn read(reader: &mut R) -> Result { + let id: u8 = ::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, { + $(($type, $field, $fieldty)),* + }); + Ok($st::$variant_name { + $( + $field: init_tlv_based_struct_field!($field, $fieldty) + ),* + }) + }; + f() + }),* + $($tuple_variant_id => { + Ok($st::$tuple_variant_name(Readable::read(reader)?)) + }),* + _ => { + Err(DecodeError::UnknownRequiredFeature) + }, + } + } + } } } #[cfg(test)] mod tests { - use std::io::{Cursor, Read}; + use io::{self, Cursor}; + use prelude::*; use ln::msgs::DecodeError; - use util::ser::{Readable, Writeable, HighZeroBytesDroppedVarInt, VecWriter}; - use secp256k1::PublicKey; + use util::ser::{Writeable, HighZeroBytesDroppedVarInt, VecWriter}; + use bitcoin::secp256k1::PublicKey; // The BOLT TLV test cases don't include any tests which use our "required-value" logic since // the encoding layer in the BOLTs has no such concept, though it makes our macros easier to @@ -162,7 +514,7 @@ mod tests { let mut a: u64 = 0; let mut b: u32 = 0; let mut c: Option = None; - decode_tlv!(&mut s, {(2, a), (3, b)}, {(4, c)}); + decode_tlv_stream!(&mut s, {(2, a, required), (3, b, required), (4, c, option)}); Ok((a, b, c)) } @@ -219,13 +571,6 @@ mod tests { (0xdeadbeef1badbeef, 0x1bad1dea, Some(0x01020304))); } - impl Readable for (PublicKey, u64, u64) { - #[inline] - fn read(reader: &mut R) -> Result<(PublicKey, u64, u64), DecodeError> { - Ok((Readable::read(reader)?, Readable::read(reader)?, Readable::read(reader)?)) - } - } - // 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); @@ -233,7 +578,7 @@ mod tests { let mut tlv2: Option = None; let mut tlv3: Option<(PublicKey, u64, u64)> = None; let mut tlv4: Option = None; - decode_tlv!(&mut s, {}, {(1, tlv1), (2, tlv2), (3, tlv3), (254, tlv4)}); + decode_tlv_stream!(&mut s, {(1, tlv1, option), (2, tlv2, option), (3, tlv3, option), (254, tlv4, option)}); Ok((tlv1, tlv2, tlv3, tlv4)) } @@ -340,23 +685,31 @@ mod tests { do_test!(concat!("fd00fe", "02", "0226"), None, None, None, Some(550)); } - fn do_simple_test_tlv_write() -> Result<(), ::std::io::Error> { + fn do_simple_test_tlv_write() -> Result<(), io::Error> { let mut stream = VecWriter(Vec::new()); stream.0.clear(); - encode_varint_length_prefixed_tlv!(&mut stream, { (1, 1u8) }); + encode_varint_length_prefixed_tlv!(&mut stream, {(1, 1u8, required), (42, None::, option)}); assert_eq!(stream.0, ::hex::decode("03010101").unwrap()); stream.0.clear(); - encode_varint_length_prefixed_tlv!(&mut stream, { (4, 0xabcdu16) }); + encode_varint_length_prefixed_tlv!(&mut stream, {(1, Some(1u8), option)}); + assert_eq!(stream.0, ::hex::decode("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()); stream.0.clear(); - encode_varint_length_prefixed_tlv!(&mut stream, { (0xff, 0xabcdu16) }); + encode_varint_length_prefixed_tlv!(&mut stream, {(42, None::, option), (0xff, 0xabcdu16, required)}); assert_eq!(stream.0, ::hex::decode("06fd00ff02abcd").unwrap()); stream.0.clear(); - encode_varint_length_prefixed_tlv!(&mut stream, { (0, 1u64), (0xff, HighZeroBytesDroppedVarInt(0u64)) }); + encode_varint_length_prefixed_tlv!(&mut stream, {(0, 1u64, required), (42, None::, option), (0xff, HighZeroBytesDroppedVarInt(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)}); assert_eq!(stream.0, ::hex::decode("0e00080000000000000001fd00ff00").unwrap()); Ok(())