Fix TLV serialization to work with large types.

[rust-lightning] / lightning / src / ln / channel.rs

diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs
index 51872337801559f5d5630ddada69d3952b3952e0..80240d0aa9d6fdffb13deba853274f5038affddb 100644 (file)
--- a/lightning/src/ln/channel.rs
+++ b/lightning/src/ln/channel.rs
@@ -40,6 +40,7 @@ use util::errors::APIError;
 use util::config::{UserConfig,ChannelConfig};
 use util::scid_utils::scid_from_parts;
 
+use prelude::*;
 use core::{cmp,mem,fmt};
 use core::ops::Deref;
 #[cfg(any(test, feature = "fuzztarget"))]
@@ -1427,9 +1428,6 @@ impl<Signer: Sign> Channel<Signer> {
                if msg.channel_reserve_satoshis > self.channel_value_satoshis {
                        return Err(ChannelError::Close(format!("Bogus channel_reserve_satoshis ({}). Must not be greater than ({})", msg.channel_reserve_satoshis, self.channel_value_satoshis)));
                }
-               if msg.dust_limit_satoshis > msg.channel_reserve_satoshis {
-                       return Err(ChannelError::Close(format!("Bogus channel_reserve ({}) and dust_limit ({})", msg.channel_reserve_satoshis, msg.dust_limit_satoshis)));
-               }
                if msg.channel_reserve_satoshis < self.holder_dust_limit_satoshis {
                        return Err(ChannelError::Close(format!("Peer never wants payout outputs? channel_reserve_satoshis was ({}). dust_limit is ({})", msg.channel_reserve_satoshis, self.holder_dust_limit_satoshis)));
                }
@@ -4381,37 +4379,11 @@ fn is_unsupported_shutdown_script(their_features: &InitFeatures, script: &Script
 const SERIALIZATION_VERSION: u8 = 1;
 const MIN_SERIALIZATION_VERSION: u8 = 1;
 
-impl Writeable for InboundHTLCRemovalReason {
-       fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
-               match self {
-                       &InboundHTLCRemovalReason::FailRelay(ref error_packet) => {
-                               0u8.write(writer)?;
-                               error_packet.write(writer)?;
-                       },
-                       &InboundHTLCRemovalReason::FailMalformed((ref onion_hash, ref err_code)) => {
-                               1u8.write(writer)?;
-                               onion_hash.write(writer)?;
-                               err_code.write(writer)?;
-                       },
-                       &InboundHTLCRemovalReason::Fulfill(ref payment_preimage) => {
-                               2u8.write(writer)?;
-                               payment_preimage.write(writer)?;
-                       },
-               }
-               Ok(())
-       }
-}
-
-impl Readable for InboundHTLCRemovalReason {
-       fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
-               Ok(match <u8 as Readable>::read(reader)? {
-                       0 => InboundHTLCRemovalReason::FailRelay(Readable::read(reader)?),
-                       1 => InboundHTLCRemovalReason::FailMalformed((Readable::read(reader)?, Readable::read(reader)?)),
-                       2 => InboundHTLCRemovalReason::Fulfill(Readable::read(reader)?),
-                       _ => return Err(DecodeError::InvalidValue),
-               })
-       }
-}
+impl_writeable_tlv_based_enum!(InboundHTLCRemovalReason,;
+       (0, FailRelay),
+       (1, FailMalformed),
+       (2, Fulfill),
+);
 
 impl Writeable for ChannelUpdateStatus {
        fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
@@ -4518,9 +4490,10 @@ impl<Signer: Sign> Writeable for Channel<Signer> {
                                &OutboundHTLCState::Committed => {
                                        1u8.write(writer)?;
                                },
-                               &OutboundHTLCState::RemoteRemoved(ref fail_reason) => {
-                                       2u8.write(writer)?;
-                                       fail_reason.write(writer)?;
+                               &OutboundHTLCState::RemoteRemoved(_) => {
+                                       // Treat this as a Committed because we haven't received the CS - they'll
+                                       // resend the claim/fail on reconnect as we all (hopefully) the missing CS.
+                                       1u8.write(writer)?;
                                },
                                &OutboundHTLCState::AwaitingRemoteRevokeToRemove(ref fail_reason) => {
                                        3u8.write(writer)?;
@@ -4633,7 +4606,7 @@ impl<Signer: Sign> Writeable for Channel<Signer> {
 
                self.channel_update_status.write(writer)?;
 
-               write_tlv_fields!(writer, {}, {(0, self.announcement_sigs)});
+               write_tlv_fields!(writer, {(0, self.announcement_sigs, option)});
 
                Ok(())
        }
@@ -4806,7 +4779,7 @@ impl<'a, Signer: Sign, K: Deref> ReadableArgs<&'a K> for Channel<Signer>
                let channel_update_status = Readable::read(reader)?;
 
                let mut announcement_sigs = None;
-               read_tlv_fields!(reader, {}, {(0, announcement_sigs)});
+               read_tlv_fields!(reader, {(0, announcement_sigs, option)});
 
                let mut secp_ctx = Secp256k1::new();
                secp_ctx.seeded_randomize(&keys_source.get_secure_random_bytes());
@@ -4928,6 +4901,7 @@ mod tests {
        use bitcoin::hashes::Hash;
        use bitcoin::hash_types::{Txid, WPubkeyHash};
        use std::sync::Arc;
+       use prelude::*;
 
        struct TestFeeEstimator {
                fee_est: u32