Add some trace logging in peer_handler

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

diff --git a/src/ln/msgs.rs b/src/ln/msgs.rs
index 415af4c4dfa9954eb3bf06f396127f3bf2287779..14c16e94b94de76e109baa50bb1044b0460150a5 100644 (file)
--- a/src/ln/msgs.rs
+++ b/src/ln/msgs.rs
@@ -37,6 +37,9 @@ pub enum DecodeError {
        ShortRead,
        /// node_announcement included more than one address of a given type!
        ExtraAddressesPerType,
+       /// A length descriptor in the packet didn't describe the later data correctly
+       /// (currently only generated in node_announcement)
+       BadLengthDescriptor,
 }
 pub trait MsgDecodable: Sized {
        fn decode(v: &[u8]) -> Result<Self, DecodeError>;
@@ -502,6 +505,7 @@ impl Error for DecodeError {
                        DecodeError::BadText => "Invalid text in packet",
                        DecodeError::ShortRead => "Packet extended beyond the provided bytes",
                        DecodeError::ExtraAddressesPerType => "More than one address of a single type",
+                       DecodeError::BadLengthDescriptor => "A length descriptor in the packet didn't describe the later data correctly",
                }
        }
 }
@@ -933,7 +937,7 @@ impl MsgDecodable for UpdateAddHTLC {
 }
 impl MsgEncodable for UpdateAddHTLC {
        fn encode(&self) -> Vec<u8> {
-               let mut res = Vec::with_capacity(32+8+8+32+4+1+1366);
+               let mut res = Vec::with_capacity(32+8+8+32+4+1366);
                res.extend_from_slice(&self.channel_id);
                res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id));
                res.extend_from_slice(&byte_utils::be64_to_array(self.amount_msat));
@@ -1204,20 +1208,21 @@ impl MsgDecodable for UnsignedNodeAnnouncement {
                if v.len() < start + 74 + addrlen {
                        return Err(DecodeError::ShortRead);
                }
+               let addr_read_limit = start + 74 + addrlen;
 
                let mut addresses = Vec::with_capacity(4);
                let mut read_pos = start + 74;
                loop {
-                       if v.len() <= read_pos { break; }
+                       if addr_read_limit <= read_pos { break; }
                        match v[read_pos] {
                                0 => { read_pos += 1; },
                                1 => {
-                                       if v.len() < read_pos + 1 + 6 {
-                                               return Err(DecodeError::ShortRead);
-                                       }
                                        if addresses.len() > 0 {
                                                return Err(DecodeError::ExtraAddressesPerType);
                                        }
+                                       if addr_read_limit < read_pos + 1 + 6 {
+                                               return Err(DecodeError::BadLengthDescriptor);
+                                       }
                                        let mut addr = [0; 4];
                                        addr.copy_from_slice(&v[read_pos + 1..read_pos + 5]);
                                        addresses.push(NetAddress::IPv4 {
@@ -1227,12 +1232,12 @@ impl MsgDecodable for UnsignedNodeAnnouncement {
                                        read_pos += 1 + 6;
                                },
                                2 => {
-                                       if v.len() < read_pos + 1 + 18 {
-                                               return Err(DecodeError::ShortRead);
-                                       }
                                        if addresses.len() > 1 || (addresses.len() == 1 && addresses[0].get_id() != 1) {
                                                return Err(DecodeError::ExtraAddressesPerType);
                                        }
+                                       if addr_read_limit < read_pos + 1 + 18 {
+                                               return Err(DecodeError::BadLengthDescriptor);
+                                       }
                                        let mut addr = [0; 16];
                                        addr.copy_from_slice(&v[read_pos + 1..read_pos + 17]);
                                        addresses.push(NetAddress::IPv6 {
@@ -1242,12 +1247,12 @@ impl MsgDecodable for UnsignedNodeAnnouncement {
                                        read_pos += 1 + 18;
                                },
                                3 => {
-                                       if v.len() < read_pos + 1 + 12 {
-                                               return Err(DecodeError::ShortRead);
-                                       }
                                        if addresses.len() > 2 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 2) {
                                                return Err(DecodeError::ExtraAddressesPerType);
                                        }
+                                       if addr_read_limit < read_pos + 1 + 12 {
+                                               return Err(DecodeError::BadLengthDescriptor);
+                                       }
                                        let mut addr = [0; 10];
                                        addr.copy_from_slice(&v[read_pos + 1..read_pos + 11]);
                                        addresses.push(NetAddress::OnionV2 {
@@ -1257,12 +1262,12 @@ impl MsgDecodable for UnsignedNodeAnnouncement {
                                        read_pos += 1 + 12;
                                },
                                4 => {
-                                       if v.len() < read_pos + 1 + 37 {
-                                               return Err(DecodeError::ShortRead);
-                                       }
                                        if addresses.len() > 3 || (addresses.len() > 0 && addresses.last().unwrap().get_id() > 3) {
                                                return Err(DecodeError::ExtraAddressesPerType);
                                        }
+                                       if addr_read_limit < read_pos + 1 + 37 {
+                                               return Err(DecodeError::BadLengthDescriptor);
+                                       }
                                        let mut ed25519_pubkey = [0; 32];
                                        ed25519_pubkey.copy_from_slice(&v[read_pos + 1..read_pos + 33]);
                                        addresses.push(NetAddress::OnionV3 {
@@ -1643,7 +1648,7 @@ impl MsgDecodable for ErrorMessage {
 
 #[cfg(test)]
 mod tests {
-       use bitcoin::util::misc::hex_bytes;
+       use hex;
        use ln::msgs::MsgEncodable;
        use ln::msgs;
        use secp256k1::key::{PublicKey,SecretKey};
@@ -1653,7 +1658,7 @@ mod tests {
        fn encoding_channel_reestablish_no_secret() {
                let public_key = {
                        let secp_ctx = Secp256k1::new();
-                       PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex_bytes("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap()).unwrap()
+                       PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap()).unwrap()
                };
 
                let cr = msgs::ChannelReestablish {
@@ -1675,7 +1680,7 @@ mod tests {
        fn encoding_channel_reestablish_with_secret() {
                let public_key = {
                        let secp_ctx = Secp256k1::new();
-                       PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex_bytes("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap()).unwrap()
+                       PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap()).unwrap()
                };
 
                let cr = msgs::ChannelReestablish {