From db02609334482cf391dbf665559ca60654ed4398 Mon Sep 17 00:00:00 2001 From: Mathias Hall-Andersen Date: Thu, 20 Feb 2020 13:21:37 +0100 Subject: More comprehensive unit tests for router --- src/wireguard/router/tests.rs | 814 +++++++++++++++++++++++------------------- 1 file changed, 441 insertions(+), 373 deletions(-) (limited to 'src/wireguard/router/tests.rs') diff --git a/src/wireguard/router/tests.rs b/src/wireguard/router/tests.rs index 3d5c79b..3afa422 100644 --- a/src/wireguard/router/tests.rs +++ b/src/wireguard/router/tests.rs @@ -1,229 +1,264 @@ +use super::KeyPair; +use super::SIZE_MESSAGE_PREFIX; +use super::{Callbacks, Device}; + +use super::SIZE_KEEPALIVE; + +use super::super::dummy; +use super::super::dummy_keypair; +use super::super::tests::make_packet; + +use crate::platform::udp::Reader; + use std::net::IpAddr; +use std::ops::Deref; +use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; +use std::sync::mpsc::{channel, Receiver, RecvTimeoutError, Sender}; use std::sync::Arc; use std::sync::Mutex; -use std::thread; use std::time::Duration; +use env_logger; use num_cpus; - -use super::super::dummy; -use super::super::dummy_keypair; -use super::super::tests::make_packet; -use super::super::udp::*; -use super::KeyPair; -use super::SIZE_MESSAGE_PREFIX; -use super::{Callbacks, Device}; +use test::Bencher; extern crate test; -const SIZE_KEEPALIVE: usize = 32; - -#[cfg(test)] -mod tests { - use super::*; - use env_logger; - use log::debug; - use std::sync::atomic::AtomicUsize; - use test::Bencher; - - // type for tracking events inside the router module - struct Flags { - send: Mutex>, - recv: Mutex>, - need_key: Mutex>, - key_confirmed: Mutex>, - } +const SIZE_MSG: usize = 1024; - #[derive(Clone)] - struct Opaque(Arc); +const TIMEOUT: Duration = Duration::from_millis(1000); - struct TestCallbacks(); +struct EventTracker { + rx: Mutex>, + tx: Mutex>, +} - impl Opaque { - fn new() -> Opaque { - Opaque(Arc::new(Flags { - send: Mutex::new(vec![]), - recv: Mutex::new(vec![]), - need_key: Mutex::new(vec![]), - key_confirmed: Mutex::new(vec![]), - })) +impl EventTracker { + fn new() -> Self { + let (tx, rx) = channel(); + EventTracker { + rx: Mutex::new(rx), + tx: Mutex::new(tx), } + } - fn reset(&self) { - self.0.send.lock().unwrap().clear(); - self.0.recv.lock().unwrap().clear(); - self.0.need_key.lock().unwrap().clear(); - self.0.key_confirmed.lock().unwrap().clear(); - } + fn log(&self, e: E) { + self.tx.lock().unwrap().send(e).unwrap(); + } - fn send(&self) -> Option<(usize, bool)> { - self.0.send.lock().unwrap().pop() + fn wait(&self, timeout: Duration) -> Option { + match self.rx.lock().unwrap().recv_timeout(timeout) { + Ok(v) => Some(v), + Err(RecvTimeoutError::Timeout) => None, + Err(RecvTimeoutError::Disconnected) => panic!("Disconnect"), } + } - fn recv(&self) -> Option<(usize, bool)> { - self.0.recv.lock().unwrap().pop() - } + fn now(&self) -> Option { + self.wait(Duration::from_millis(0)) + } +} - fn need_key(&self) -> Option<()> { - self.0.need_key.lock().unwrap().pop() - } +// type for tracking events inside the router module +struct Inner { + send: EventTracker<(usize, bool)>, + recv: EventTracker<(usize, bool)>, + need_key: EventTracker<()>, + key_confirmed: EventTracker<()>, +} - fn key_confirmed(&self) -> Option<()> { - self.0.key_confirmed.lock().unwrap().pop() - } +#[derive(Clone)] +struct Opaque { + inner: Arc, +} - // has all events been accounted for by assertions? - fn is_empty(&self) -> bool { - let send = self.0.send.lock().unwrap(); - let recv = self.0.recv.lock().unwrap(); - let need_key = self.0.need_key.lock().unwrap(); - let key_confirmed = self.0.key_confirmed.lock().unwrap(); - send.is_empty() && recv.is_empty() && need_key.is_empty() & key_confirmed.is_empty() - } - } +impl Deref for Opaque { + type Target = Inner; - impl Callbacks for TestCallbacks { - type Opaque = Opaque; + fn deref(&self) -> &Self::Target { + &self.inner + } +} - fn send(t: &Self::Opaque, size: usize, sent: bool, _keypair: &Arc, _counter: u64) { - t.0.send.lock().unwrap().push((size, sent)) +struct TestCallbacks(); + +impl Opaque { + fn new() -> Opaque { + Opaque { + inner: Arc::new(Inner { + send: EventTracker::new(), + recv: EventTracker::new(), + need_key: EventTracker::new(), + key_confirmed: EventTracker::new(), + }), } + } +} - fn recv(t: &Self::Opaque, size: usize, sent: bool, _keypair: &Arc) { - t.0.recv.lock().unwrap().push((size, sent)) - } +macro_rules! no_events { + ($opq:expr) => { + assert_eq!($opq.send.now(), None, "unexpected send event"); + assert_eq!($opq.recv.now(), None, "unexpected recv event"); + assert_eq!($opq.need_key.now(), None, "unexpected need_key event"); + assert_eq!( + $opq.key_confirmed.now(), + None, + "unexpected key_confirmed event" + ); + }; +} - fn need_key(t: &Self::Opaque) { - t.0.need_key.lock().unwrap().push(()); - } +impl Callbacks for TestCallbacks { + type Opaque = Opaque; - fn key_confirmed(t: &Self::Opaque) { - t.0.key_confirmed.lock().unwrap().push(()); - } + fn send(t: &Self::Opaque, size: usize, sent: bool, _keypair: &Arc, _counter: u64) { + t.send.log((size, sent)) } - // wait for scheduling - fn wait() { - thread::sleep(Duration::from_millis(15)); + fn recv(t: &Self::Opaque, size: usize, sent: bool, _keypair: &Arc) { + t.recv.log((size, sent)) } - fn init() { - let _ = env_logger::builder().is_test(true).try_init(); + fn need_key(t: &Self::Opaque) { + t.need_key.log(()); } - fn make_packet_padded(size: usize, src: IpAddr, dst: IpAddr, id: u64) -> Vec { - let p = make_packet(size, src, dst, id); - let mut o = vec![0; p.len() + SIZE_MESSAGE_PREFIX]; - o[SIZE_MESSAGE_PREFIX..SIZE_MESSAGE_PREFIX + p.len()].copy_from_slice(&p[..]); - o + fn key_confirmed(t: &Self::Opaque) { + t.key_confirmed.log(()); } +} - #[bench] - fn bench_outbound(b: &mut Bencher) { - struct BencherCallbacks {} - impl Callbacks for BencherCallbacks { - type Opaque = Arc; - fn send( - t: &Self::Opaque, - size: usize, - _sent: bool, - _keypair: &Arc, - _counter: u64, - ) { - t.fetch_add(size, Ordering::SeqCst); - } - fn recv(_: &Self::Opaque, _size: usize, _sent: bool, _keypair: &Arc) {} - fn need_key(_: &Self::Opaque) {} - fn key_confirmed(_: &Self::Opaque) {} - } - - // create device - let (_fake, _reader, tun_writer, _mtu) = dummy::TunTest::create(false); - let router: Device<_, BencherCallbacks, dummy::TunWriter, dummy::VoidBind> = - Device::new(num_cpus::get(), tun_writer); - - // add new peer - let opaque = Arc::new(AtomicUsize::new(0)); - let peer = router.new_peer(opaque.clone()); - peer.add_keypair(dummy_keypair(true)); - - // add subnet to peer - let (mask, len, dst) = ("192.168.1.0", 24, "192.168.1.20"); - let mask: IpAddr = mask.parse().unwrap(); - peer.add_allowed_ip(mask, len); - - // create "IP packet" - let dst = dst.parse().unwrap(); - let src = match dst { - IpAddr::V4(_) => "127.0.0.1".parse().unwrap(), - IpAddr::V6(_) => "::1".parse().unwrap(), - }; - let msg = make_packet_padded(1024, src, dst, 0); - - // every iteration sends 10 GB - b.iter(|| { - opaque.store(0, Ordering::SeqCst); - while opaque.load(Ordering::Acquire) < 10 * 1024 * 1024 { - router.send(msg.to_vec()).unwrap(); - } - }); - } +fn init() { + let _ = env_logger::builder().is_test(true).try_init(); +} - #[test] - fn test_outbound() { - init(); +fn make_packet_padded(size: usize, src: IpAddr, dst: IpAddr, id: u64) -> Vec { + let p = make_packet(size, src, dst, id); + let mut o = vec![0; p.len() + SIZE_MESSAGE_PREFIX]; + o[SIZE_MESSAGE_PREFIX..SIZE_MESSAGE_PREFIX + p.len()].copy_from_slice(&p[..]); + o +} - // create device - let (_fake, _reader, tun_writer, _mtu) = dummy::TunTest::create(false); - let router: Device<_, TestCallbacks, _, _> = Device::new(1, tun_writer); - router.set_outbound_writer(dummy::VoidBind::new()); +#[bench] +fn bench_outbound(b: &mut Bencher) { + struct BencherCallbacks {} + impl Callbacks for BencherCallbacks { + type Opaque = Arc; + fn send( + t: &Self::Opaque, + size: usize, + _sent: bool, + _keypair: &Arc, + _counter: u64, + ) { + t.fetch_add(size, Ordering::SeqCst); + } + fn recv(_: &Self::Opaque, _size: usize, _sent: bool, _keypair: &Arc) {} + fn need_key(_: &Self::Opaque) {} + fn key_confirmed(_: &Self::Opaque) {} + } - let tests = vec![ - ("192.168.1.0", 24, "192.168.1.20", true), - ("172.133.133.133", 32, "172.133.133.133", true), - ("172.133.133.133", 32, "172.133.133.132", false), - ( - "2001:db8::ff00:42:0000", - 112, - "2001:db8::ff00:42:3242", - true, - ), - ( - "2001:db8::ff00:42:8000", - 113, - "2001:db8::ff00:42:0660", - false, - ), - ( - "2001:db8::ff00:42:8000", - 113, - "2001:db8::ff00:42:ffff", - true, - ), - ]; + // create device + let (_fake, _reader, tun_writer, _mtu) = dummy::TunTest::create(false); + let router: Device<_, BencherCallbacks, dummy::TunWriter, dummy::VoidBind> = + Device::new(num_cpus::get(), tun_writer); + + // add new peer + let opaque = Arc::new(AtomicUsize::new(0)); + let peer = router.new_peer(opaque.clone()); + peer.add_keypair(dummy_keypair(true)); + + // add subnet to peer + let (mask, len, dst) = ("192.168.1.0", 24, "192.168.1.20"); + let mask: IpAddr = mask.parse().unwrap(); + peer.add_allowed_ip(mask, len); + + // create "IP packet" + let dst = dst.parse().unwrap(); + let src = match dst { + IpAddr::V4(_) => "127.0.0.1".parse().unwrap(), + IpAddr::V6(_) => "::1".parse().unwrap(), + }; + let msg = make_packet_padded(1024, src, dst, 0); + + // every iteration sends 10 GB + b.iter(|| { + opaque.store(0, Ordering::SeqCst); + while opaque.load(Ordering::Acquire) < 10 * 1024 * 1024 { + router.send(msg.to_vec()).unwrap(); + } + }); +} - for (num, (mask, len, dst, okay)) in tests.iter().enumerate() { - println!( - "Check: {} {} {}/{}", - dst, - if *okay { "\\in" } else { "\\notin" }, - mask, - len - ); - for set_key in vec![true, false] { - debug!("index = {}, set_key = {}", num, set_key); +#[test] +fn test_outbound() { + init(); + + // create device + let (_fake, _reader, tun_writer, _mtu) = dummy::TunTest::create(false); + let router: Device<_, TestCallbacks, _, _> = Device::new(1, tun_writer); + router.set_outbound_writer(dummy::VoidBind::new()); + + let tests = vec![ + ("192.168.1.0", 24, "192.168.1.20", true), + ("172.133.133.133", 32, "172.133.133.133", true), + ("172.133.133.133", 32, "172.133.133.132", false), + ( + "2001:db8::ff00:42:0000", + 112, + "2001:db8::ff00:42:3242", + true, + ), + ( + "2001:db8::ff00:42:8000", + 113, + "2001:db8::ff00:42:0660", + false, + ), + ( + "2001:db8::ff00:42:8000", + 113, + "2001:db8::ff00:42:ffff", + true, + ), + ]; + + for (mask, len, dst, okay) in tests.iter() { + let len = *len; + let okay = *okay; + + println!( + "Check: {} {} {}/{}", + dst, + if okay { "\\in" } else { "\\notin" }, + mask, + len + ); + + for set_key in vec![true, false] { + for confirm_with_staged_packet in vec![true, false] { + let send_keepalive = (!confirm_with_staged_packet || !okay) && set_key; + let send_payload = okay && set_key; + let need_key = ((confirm_with_staged_packet && set_key) || !set_key) && okay; + + println!( + " confirm_with_staged_packet = {}, send_keepalive = {}, set_key = {}", + confirm_with_staged_packet, send_keepalive, set_key + ); // add new peer let opaque = Opaque::new(); let peer = router.new_peer(opaque.clone()); let mask: IpAddr = mask.parse().unwrap(); - if set_key { + + // confirm using keepalive + if set_key && (!confirm_with_staged_packet) { peer.add_keypair(dummy_keypair(true)); } // map subnet to peer - peer.add_allowed_ip(mask, *len); + peer.add_allowed_ip(mask, len); // create "IP packet" let dst = dst.parse().unwrap(); @@ -231,246 +266,279 @@ mod tests { IpAddr::V4(_) => "127.0.0.1".parse().unwrap(), IpAddr::V6(_) => "::1".parse().unwrap(), }; - let msg = make_packet_padded(1024, src, dst, 0); + let msg = make_packet_padded(SIZE_MSG, src, dst, 0); - // cryptkey route the IP packet + // crypto-key route the IP packet let res = router.send(msg); + assert_eq!( + res.is_ok(), + okay, + "crypto-routing / destination lookup failure" + ); - // allow some scheduling - wait(); + // confirm using staged packet + if set_key && confirm_with_staged_packet { + peer.add_keypair(dummy_keypair(true)); + } - if *okay { - // cryptkey routing succeeded - assert!(res.is_ok(), "crypt-key routing should succeed: {:?}", res); + // check for key-material request + if need_key { assert_eq!( - opaque.need_key().is_some(), - !set_key, + opaque.need_key.wait(TIMEOUT), + Some(()), "should have requested a new key, if no encryption state was set" ); + } + + // check for keepalive + if send_keepalive { assert_eq!( - opaque.send().is_some(), - set_key, - "transmission should have been attempted" - ); - assert!( - opaque.recv().is_none(), - "no messages should have been marked as received" - ); - } else { - // no such cryptkey route - assert!(res.is_err(), "crypt-key routing should fail"); - assert!( - opaque.need_key().is_none(), - "should not request a new-key if crypt-key routing failed" + opaque.send.wait(TIMEOUT), + Some((SIZE_KEEPALIVE, false)), + "keepalive should be sent before transport message" ); + } + + // check for encryption of payload + if send_payload { assert_eq!( - opaque.send(), - if set_key { - Some((SIZE_KEEPALIVE, false)) - } else { - None - }, - "transmission should only happen if key was set (keepalive)", - ); - assert!( - opaque.recv().is_none(), - "no messages should have been marked as received", - ); + opaque.send.wait(TIMEOUT), + Some((SIZE_KEEPALIVE + SIZE_MSG, false)), + "message buffer should be encrypted" + ) } + + // check that we handled all events + no_events!(opaque); } } - - println!("Test complete, drop device"); } +} - #[test] - fn test_bidirectional() { - init(); +#[test] +fn test_bidirectional() { + init(); - let tests = [ + let tests = [ + ( + ("192.168.1.0", 24, "192.168.1.20", true), + ("172.133.133.133", 32, "172.133.133.133", true), + ), + ( + ("192.168.1.0", 24, "192.168.1.20", true), + ("172.133.133.133", 32, "172.133.133.133", true), + ), + ( ( - ("192.168.1.0", 24, "192.168.1.20", true), - ("172.133.133.133", 32, "172.133.133.133", true), + "2001:db8::ff00:42:8000", + 113, + "2001:db8::ff00:42:ffff", + true, ), ( - ("192.168.1.0", 24, "192.168.1.20", true), - ("172.133.133.133", 32, "172.133.133.133", true), + "2001:db8::ff40:42:8000", + 113, + "2001:db8::ff40:42:ffff", + true, ), + ), + ( ( - ( - "2001:db8::ff00:42:8000", - 113, - "2001:db8::ff00:42:ffff", - true, - ), - ( - "2001:db8::ff40:42:8000", - 113, - "2001:db8::ff40:42:ffff", - true, - ), + "2001:db8::ff00:42:8000", + 113, + "2001:db8::ff00:42:ffff", + true, ), ( - ( - "2001:db8::ff00:42:8000", - 113, - "2001:db8::ff00:42:ffff", - true, - ), - ( - "2001:db8::ff40:42:8000", - 113, - "2001:db8::ff40:42:ffff", - true, - ), + "2001:db8::ff40:42:8000", + 113, + "2001:db8::ff40:42:ffff", + true, ), - ]; + ), + ]; - for stage in vec![true, false] { - for (p1, p2) in tests.iter() { - let ((bind_reader1, bind_writer1), (bind_reader2, bind_writer2)) = - dummy::PairBind::pair(); + for (p1, p2) in tests.iter() { + for confirm_with_staged_packet in vec![true, false] { + println!( + "peer1 = {:?}, peer2 = {:?}, confirm_with_staged_packet = {}", + p1, p2, confirm_with_staged_packet + ); - // create matching device - let (_fake, _, tun_writer1, _) = dummy::TunTest::create(false); - let (_fake, _, tun_writer2, _) = dummy::TunTest::create(false); + let ((bind_reader1, bind_writer1), (bind_reader2, bind_writer2)) = + dummy::PairBind::pair(); - let router1: Device<_, TestCallbacks, _, _> = Device::new(1, tun_writer1); - router1.set_outbound_writer(bind_writer1); + let confirm_packet_size = if confirm_with_staged_packet { + SIZE_KEEPALIVE + SIZE_MSG + } else { + SIZE_KEEPALIVE + }; - let router2: Device<_, TestCallbacks, _, _> = Device::new(1, tun_writer2); - router2.set_outbound_writer(bind_writer2); + // create matching device + let (_fake, _, tun_writer1, _) = dummy::TunTest::create(false); + let (_fake, _, tun_writer2, _) = dummy::TunTest::create(false); - // prepare opaque values for tracing callbacks + let router1: Device<_, TestCallbacks, _, _> = Device::new(1, tun_writer1); + router1.set_outbound_writer(bind_writer1); - let opaque1 = Opaque::new(); - let opaque2 = Opaque::new(); + let router2: Device<_, TestCallbacks, _, _> = Device::new(1, tun_writer2); + router2.set_outbound_writer(bind_writer2); - // create peers with matching keypairs and assign subnets + // prepare opaque values for tracing callbacks - let peer1 = router1.new_peer(opaque1.clone()); - let peer2 = router2.new_peer(opaque2.clone()); + let opaque1 = Opaque::new(); + let opaque2 = Opaque::new(); - { - let (mask, len, _ip, _okay) = p1; - let mask: IpAddr = mask.parse().unwrap(); - peer1.add_allowed_ip(mask, *len); - peer1.add_keypair(dummy_keypair(false)); - } + // create peers with matching keypairs and assign subnets - { - let (mask, len, _ip, _okay) = p2; - let mask: IpAddr = mask.parse().unwrap(); - peer2.add_allowed_ip(mask, *len); - peer2.set_endpoint(dummy::UnitEndpoint::new()); - } + let peer1 = router1.new_peer(opaque1.clone()); + let peer2 = router2.new_peer(opaque2.clone()); - if stage { - println!("confirm using staged packet"); - - // create IP packet - let (_mask, _len, ip1, _okay) = p1; - let (_mask, _len, ip2, _okay) = p2; - let msg = make_packet_padded( - 1024, - ip1.parse().unwrap(), // src - ip2.parse().unwrap(), // dst - 0, - ); + { + let (mask, len, _ip, _okay) = p1; + let mask: IpAddr = mask.parse().unwrap(); + peer1.add_allowed_ip(mask, *len); + peer1.add_keypair(dummy_keypair(false)); + } + + { + let (mask, len, _ip, _okay) = p2; + let mask: IpAddr = mask.parse().unwrap(); + peer2.add_allowed_ip(mask, *len); + peer2.set_endpoint(dummy::UnitEndpoint::new()); + } - // stage packet for sending - router2.send(msg).expect("failed to sent staged packet"); - wait(); + if confirm_with_staged_packet { + // create IP packet + let (_mask, _len, ip1, _okay) = p1; + let (_mask, _len, ip2, _okay) = p2; + let msg = make_packet_padded( + SIZE_MSG, + ip1.parse().unwrap(), // src + ip2.parse().unwrap(), // dst + 0, + ); - // validate events - assert!(opaque2.recv().is_none()); - assert!( - opaque2.send().is_none(), - "sending should fail as not key is set" - ); - assert!( - opaque2.need_key().is_some(), - "a new key should be requested since a packet was attempted transmitted" - ); - assert!(opaque2.is_empty(), "callbacks should only run once"); - } + // stage packet for sending + router2.send(msg).expect("failed to sent staged packet"); - // this should cause a key-confirmation packet (keepalive or staged packet) - // this also causes peer1 to learn the "endpoint" for peer2 - assert!(peer1.get_endpoint().is_none()); - peer2.add_keypair(dummy_keypair(true)); + // a new key should have been requested from the handshake machine + assert_eq!( + opaque2.need_key.wait(TIMEOUT), + Some(()), + "a new key should be requested since a packet was attempted transmitted" + ); - wait(); - assert!(opaque2.send().is_some()); - assert!(opaque2.is_empty(), "events on peer2 should be 'send'"); - assert!(opaque1.is_empty(), "nothing should happened on peer1"); + no_events!(opaque1); + no_events!(opaque2); + } - // read confirming message received by the other end ("across the internet") - let mut buf = vec![0u8; 2048]; - let (len, from) = bind_reader1.read(&mut buf).unwrap(); - buf.truncate(len); - router1.recv(from, buf).unwrap(); - - wait(); - assert!(opaque1.recv().is_some()); - assert!(opaque1.key_confirmed().is_some()); - assert!( - opaque1.is_empty(), - "events on peer1 should be 'recv' and 'key_confirmed'" + // add a keypair + assert_eq!(peer1.get_endpoint(), None, "no endpoint has yet been set"); + peer2.add_keypair(dummy_keypair(true)); + + // this should cause a key-confirmation packet (keepalive or staged packet) + assert_eq!( + opaque2.send.wait(TIMEOUT), + Some((confirm_packet_size, true)), + "expected successful transmission of a confirmation packet" + ); + + // no other events should fire + no_events!(opaque1); + no_events!(opaque2); + + // read confirming message received by the other end ("across the internet") + let mut buf = vec![0u8; SIZE_MSG * 2]; + let (len, from) = bind_reader1.read(&mut buf).unwrap(); + buf.truncate(len); + + assert_eq!( + len, + if confirm_with_staged_packet { + SIZE_MSG + SIZE_KEEPALIVE + } else { + SIZE_KEEPALIVE + }, + "unexpected size of confirmation message" + ); + + // pass to the router for processing + router1 + .recv(from, buf) + .expect("failed to receive confirmation message"); + + // check that a receive event is fired + assert_eq!( + opaque1.recv.wait(TIMEOUT), + Some((confirm_packet_size, true)), + "we expect processing to be successful" + ); + + // the key is confirmed + assert_eq!( + opaque1.key_confirmed.wait(TIMEOUT), + Some(()), + "confirmation message should confirm the key" + ); + + // peer1 learns the endpoint + assert!( + peer1.get_endpoint().is_some(), + "peer1 should learn the endpoint of peer2 from the confirmation message (roaming)" + ); + + // no other events should fire + no_events!(opaque1); + no_events!(opaque2); + // now that peer1 has an endpoint + // route packets in the other direction: peer1 -> peer2 + for id in 1..11 { + println!("packet: {}", id); + + let message_size = 1024; + + // pass IP packet to router + let (_mask, _len, ip1, _okay) = p1; + let (_mask, _len, ip2, _okay) = p2; + let msg = make_packet_padded( + message_size, + ip2.parse().unwrap(), // src + ip1.parse().unwrap(), // dst + id, ); - assert!(peer1.get_endpoint().is_some()); - assert!(opaque2.is_empty(), "nothing should happened on peer2"); - // now that peer1 has an endpoint - // route packets : peer1 -> peer2 + router1 + .send(msg) + .expect("we expect routing to be successful"); - for id in 1..11 { - println!("round: {}", id); - assert!( - opaque1.is_empty(), - "we should have asserted a value for every callback on peer1" - ); - assert!( - opaque2.is_empty(), - "we should have asserted a value for every callback on peer2" - ); + // encryption succeeds and the correct size is logged + assert_eq!( + opaque1.send.wait(TIMEOUT), + Some((message_size + SIZE_KEEPALIVE, true)), + "expected send event for peer1 -> peer2 payload" + ); - // pass IP packet to router - let (_mask, _len, ip1, _okay) = p1; - let (_mask, _len, ip2, _okay) = p2; - let msg = make_packet_padded( - 1024, - ip2.parse().unwrap(), // src - ip1.parse().unwrap(), // dst - id, - ); - router1.send(msg).unwrap(); + // otherwise no events + no_events!(opaque1); + no_events!(opaque2); - wait(); - assert!(opaque1.send().is_some(), "encryption should succeed"); - assert!( - opaque1.recv().is_none(), - "receiving callback should not be called" - ); - assert!(opaque1.need_key().is_none()); - - // receive ("across the internet") on the other end - let mut buf = vec![0u8; 2048]; - let (len, from) = bind_reader2.read(&mut buf).unwrap(); - buf.truncate(len); - router2.recv(from, buf).unwrap(); - - wait(); - assert!( - opaque2.send().is_none(), - "sending callback should not be called" - ); - assert!( - opaque2.recv().is_some(), - "decryption and routing should succeed" - ); - assert!(opaque2.need_key().is_none()); - } + // receive ("across the internet") on the other end + let mut buf = vec![0u8; 2048]; + let (len, from) = bind_reader2.read(&mut buf).unwrap(); + buf.truncate(len); + router2.recv(from, buf).unwrap(); + + // check that decryption succeeds + assert_eq!( + opaque2.recv.wait(TIMEOUT), + Some((message_size + SIZE_KEEPALIVE, true)), + "decryption and routing should succeed" + ); + + // otherwise no events + no_events!(opaque1); + no_events!(opaque2); } } } -- cgit v1.2.3-59-g8ed1b