-f fix new Matt's comments

[rust-lightning] / lightning / src / util / events.rs

diff --git a/lightning/src/util/events.rs b/lightning/src/util/events.rs
index c6691826ee6457615d6597fcfb5f899c3d79e1fe..2e54e2f3f15b7a6f0162dcd3ac0492a466024b27 100644 (file)
--- a/lightning/src/util/events.rs
+++ b/lightning/src/util/events.rs
@@ -16,6 +16,7 @@
 
 use chain::keysinterface::SpendableOutputDescriptor;
 use ln::msgs;
+use ln::msgs::DecodeError;
 use ln::{PaymentPreimage, PaymentHash, PaymentSecret};
 use routing::network_graph::NetworkUpdate;
 use util::ser::{Writeable, Writer, MaybeReadable, Readable, VecReadWrapper, VecWriteWrapper};
@@ -26,7 +27,6 @@ use bitcoin::secp256k1::key::PublicKey;
 
 use io;
 use prelude::*;
-use core::cmp;
 use core::time::Duration;
 use core::ops::Deref;
 
@@ -69,6 +69,38 @@ pub enum PaymentPurpose {
        SpontaneousPayment(PaymentPreimage),
 }
 
+#[derive(Clone, Debug)]
+/// Some information provided on the closure source of the channel halting.
+pub enum ClosureReason {
+       /// Closure generated from receiving a peer error message by ChannelManager::handle_error
+       CounterpartyForceClosed {
+               /// The error is coming from the peer, there *might* be a human-readable msg
+               peer_msg: Option<String>,
+       },
+       /// Closure generated from ChannelManager::force_close_channel
+       HolderForceClosed,
+       /// Closure generated from receiving a peer's ClosingSigned message. Note the shutdown
+       /// sequence might have been initially initiated by us.
+       CooperativeClosure,
+       /// Closure generated from receiving chain::Watch's CommitmentTxBroadcast event.
+       CommitmentTxBroadcasted,
+       /// Closure generated from processing an event, likely a HTLC forward/relay/reception.
+       ProcessingError {
+               err: String,
+       },
+       /// Closure generated from ChannelManager::peer_disconnected.
+       DisconnectedPeer,
+}
+
+impl_writeable_tlv_based_enum_upgradable!(ClosureReason,
+       (0, CounterpartyForceClosed) => { (1, peer_msg, option) },
+       (2, HolderForceClosed) => {},
+       (6, CommitmentTxBroadcasted) => {},
+       (4, CooperativeClosure) => {},
+       (8, ProcessingError) => { (1, err, required) },
+       (10, DisconnectedPeer) => {},
+);
+
 /// An Event which you should probably take some action in response to.
 ///
 /// Note that while Writeable and Readable are implemented for Event, you probably shouldn't use
@@ -190,13 +222,13 @@ pub enum Event {
                /// transaction.
                claim_from_onchain_tx: bool,
        },
-       /// Used to indicate that a channel was closed at the given timestamp.
+       /// Used to indicate that a channel with the given `channel_id` is in the process of closure.
        ChannelClosed  {
                /// The channel_id which has been barren from further off-chain updates but
                /// funding output might still be not resolved yet.
                channel_id: [u8; 32],
-               /// A human-readable error message
-               err: String
+               /// A machine-readable error message
+               err: ClosureReason
        }
 }
 
@@ -275,10 +307,9 @@ impl Writeable for Event {
                                });
                        },
                        &Event::ChannelClosed { ref channel_id, ref err } => {
-                               6u8.write(writer)?;
+                               8u8.write(writer)?;
                                channel_id.write(writer)?;
-                               (err.len() as u16).write(writer)?;
-                               writer.write_all(err.as_bytes())?;
+                               err.write(writer)?;
                                write_tlv_fields!(writer, {});
                        },
                }
@@ -394,26 +425,15 @@ impl MaybeReadable for Event {
                                };
                                f()
                        },
+                       8u8 => {
+                               let channel_id = Readable::read(reader)?;
+                               let err = MaybeReadable::read(reader)?;
+                               read_tlv_fields!(reader, {});
+                               if err.is_none() { return Ok(None); }
+                               Ok(Some(Event::ChannelClosed { channel_id, err: err.unwrap() }))
+                       },
                        // Versions prior to 0.0.100 did not ignore odd types, instead returning InvalidValue.
                        x if x % 2 == 1 => Ok(None),
-                       6u8 => {
-                               let f = || {
-                                       let channel_id = Readable::read(reader)?;
-                                       let err = {
-                                               let mut size: usize = <u16 as Readable>::read(reader)? as usize;
-                                               let mut data = vec![];
-                                               let data_len = reader.read_to_end(&mut data)?;
-                                               size = cmp::min(data_len, size);
-                                               match String::from_utf8(data[..size as usize].to_vec()) {
-                                                       Ok(s) => s,
-                                                       Err(_) => return Err(msgs::DecodeError::InvalidValue),
-                                               }
-                                       };
-                                       read_tlv_fields!(reader, {});
-                                       Ok(Some(Event::ChannelClosed { channel_id, err: err }))
-                               };
-                               f()
-                       },
                        _ => Err(msgs::DecodeError::InvalidValue)
                }
        }