Fix bug in early-HTLC-fulfill handling

[rust-lightning] / fuzz / fuzz_targets / full_stack_target.rs

diff --git a/fuzz/fuzz_targets/full_stack_target.rs b/fuzz/fuzz_targets/full_stack_target.rs
index 25d539922e0ea2cc16d3c8f2f0317d061781e00d..8f7ec2df0a76013918e2ec7b154deceed7057cab 100644 (file)
--- a/fuzz/fuzz_targets/full_stack_target.rs
+++ b/fuzz/fuzz_targets/full_stack_target.rs
@@ -21,6 +21,11 @@ use lightning::ln::peer_handler::{MessageHandler,PeerManager,SocketDescriptor};
 use lightning::ln::router::Router;
 use lightning::util::events::{EventsProvider,Event};
 use lightning::util::reset_rng_state;
+use lightning::util::logger::Logger;
+
+mod utils;
+
+use utils::test_logger;
 
 use secp256k1::key::{PublicKey,SecretKey};
 use secp256k1::Secp256k1;
@@ -84,10 +89,10 @@ struct FuzzEstimator {
        input: Arc<InputData>,
 }
 impl FeeEstimator for FuzzEstimator {
-       fn get_est_sat_per_vbyte(&self, _: ConfirmationTarget) -> u64 {
+       fn get_est_sat_per_1000_weight(&self, _: ConfirmationTarget) -> u64 {
                //TODO: We should actually be testing at least much more than 64k...
                match self.input.get_slice(2) {
-                       Some(slice) => slice_to_be16(slice) as u64,
+                       Some(slice) => slice_to_be16(slice) as u64 * 250,
                        None => 0
                }
        }
@@ -169,18 +174,19 @@ pub fn do_test(data: &[u8]) {
                Err(_) => return,
        };
 
+       let logger: Arc<Logger> = Arc::new(test_logger::TestLogger::new());
        let monitor = Arc::new(TestChannelMonitor{});
-       let watch = Arc::new(ChainWatchInterfaceUtil::new());
+       let watch = Arc::new(ChainWatchInterfaceUtil::new(Arc::clone(&logger)));
        let broadcast = Arc::new(TestBroadcaster{});
 
-       let channelmanager = ChannelManager::new(our_network_key, slice_to_be32(get_slice!(4)), get_slice!(1)[0] != 0, Network::Bitcoin, fee_est.clone(), monitor.clone(), watch.clone(), broadcast.clone()).unwrap();
-       let router = Arc::new(Router::new(PublicKey::from_secret_key(&secp_ctx, &our_network_key).unwrap()));
+       let channelmanager = ChannelManager::new(our_network_key, slice_to_be32(get_slice!(4)), get_slice!(1)[0] != 0, Network::Bitcoin, fee_est.clone(), monitor.clone(), watch.clone(), broadcast.clone(), Arc::clone(&logger)).unwrap();
+       let router = Arc::new(Router::new(PublicKey::from_secret_key(&secp_ctx, &our_network_key).unwrap(), Arc::clone(&logger)));
 
        let peers = RefCell::new([false; 256]);
        let handler = PeerManager::new(MessageHandler {
                chan_handler: channelmanager.clone(),
                route_handler: router.clone(),
-       }, our_network_key);
+       }, our_network_key, Arc::clone(&logger));
 
        let mut should_forward = false;
        let mut payments_received = Vec::new();
@@ -263,7 +269,7 @@ pub fn do_test(data: &[u8]) {
                        },
                        7 => {
                                if should_forward {
-                                       channelmanager.process_pending_htlc_forward();
+                                       channelmanager.process_pending_htlc_forwards();
                                        handler.process_events();
                                        should_forward = false;
                                }
@@ -368,29 +374,11 @@ fn main() {
        }
 }
 
+extern crate hex;
 #[cfg(test)]
 mod tests {
-       fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
-               let mut b = 0;
-               for (idx, c) in hex.as_bytes().iter().enumerate() {
-                       b <<= 4;
-                       match *c {
-                               b'A'...b'F' => b |= c - b'A' + 10,
-                               b'a'...b'f' => b |= c - b'a' + 10,
-                               b'0'...b'9' => b |= c - b'0',
-                               _ => panic!("Bad hex"),
-                       }
-                       if (idx & 1) == 1 {
-                               out.push(b);
-                               b = 0;
-                       }
-               }
-       }
-
        #[test]
        fn duplicate_crash() {
-               let mut a = Vec::new();
-               extend_vec_from_hex("00", &mut a);
-               super::do_test(&a);
+               super::do_test(&::hex::decode("00").unwrap());
        }
 }