From 4ff328b7da876fb3305fefd83865553af9c8ab2c Mon Sep 17 00:00:00 2001
From: Mathias Hall-Andersen <mathias@hall-andersen.dk>
Date: Mon, 28 Oct 2019 14:48:24 +0100
Subject: First full test of pure WireGuard

---
 src/platform/dummy/bind.rs | 29 ++++++++++++++++++++++++++++-
 src/platform/dummy/tun.rs  | 27 ++++++++++++++++++++++++++-
 2 files changed, 54 insertions(+), 2 deletions(-)

(limited to 'src/platform/dummy')

diff --git a/src/platform/dummy/bind.rs b/src/platform/dummy/bind.rs
index 984b886..3497656 100644
--- a/src/platform/dummy/bind.rs
+++ b/src/platform/dummy/bind.rs
@@ -1,7 +1,12 @@
+use hex;
 use std::error::Error;
 use std::fmt;
 use std::marker;
 
+use log::debug;
+use rand::rngs::OsRng;
+use rand::Rng;
+
 use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
 use std::sync::Arc;
 use std::sync::Mutex;
@@ -95,6 +100,7 @@ impl VoidBind {
 
 #[derive(Clone)]
 pub struct PairReader<E> {
+    id: u32,
     recv: Arc<Mutex<Receiver<Vec<u8>>>>,
     _marker: marker::PhantomData<E>,
 }
@@ -110,13 +116,25 @@ impl Reader<UnitEndpoint> for PairReader<UnitEndpoint> {
             .map_err(|_| BindError::Disconnected)?;
         let len = vec.len();
         buf[..len].copy_from_slice(&vec[..]);
-        Ok((vec.len(), UnitEndpoint {}))
+        debug!(
+            "dummy({}): read ({}, {})",
+            self.id,
+            len,
+            hex::encode(&buf[..len])
+        );
+        Ok((len, UnitEndpoint {}))
     }
 }
 
 impl Writer<UnitEndpoint> for PairWriter<UnitEndpoint> {
     type Error = BindError;
     fn write(&self, buf: &[u8], _dst: &UnitEndpoint) -> Result<(), Self::Error> {
+        debug!(
+            "dummy({}): write ({}, {})",
+            self.id,
+            buf.len(),
+            hex::encode(buf)
+        );
         let owned = buf.to_owned();
         match self.send.lock().unwrap().send(owned) {
             Err(_) => Err(BindError::Disconnected),
@@ -127,6 +145,7 @@ impl Writer<UnitEndpoint> for PairWriter<UnitEndpoint> {
 
 #[derive(Clone)]
 pub struct PairWriter<E> {
+    id: u32,
     send: Arc<Mutex<SyncSender<Vec<u8>>>>,
     _marker: marker::PhantomData<E>,
 }
@@ -139,25 +158,33 @@ impl PairBind {
         (PairReader<E>, PairWriter<E>),
         (PairReader<E>, PairWriter<E>),
     ) {
+        let mut rng = OsRng::new().unwrap();
+        let id1: u32 = rng.gen();
+        let id2: u32 = rng.gen();
+
         let (tx1, rx1) = sync_channel(128);
         let (tx2, rx2) = sync_channel(128);
         (
             (
                 PairReader {
+                    id: id1,
                     recv: Arc::new(Mutex::new(rx1)),
                     _marker: marker::PhantomData,
                 },
                 PairWriter {
+                    id: id1,
                     send: Arc::new(Mutex::new(tx2)),
                     _marker: marker::PhantomData,
                 },
             ),
             (
                 PairReader {
+                    id: id2,
                     recv: Arc::new(Mutex::new(rx2)),
                     _marker: marker::PhantomData,
                 },
                 PairWriter {
+                    id: id2,
                     send: Arc::new(Mutex::new(tx1)),
                     _marker: marker::PhantomData,
                 },
diff --git a/src/platform/dummy/tun.rs b/src/platform/dummy/tun.rs
index fb87d2f..185b328 100644
--- a/src/platform/dummy/tun.rs
+++ b/src/platform/dummy/tun.rs
@@ -1,3 +1,8 @@
+use hex;
+use log::debug;
+use rand::rngs::OsRng;
+use rand::Rng;
+
 use std::cmp::min;
 use std::error::Error;
 use std::fmt;
@@ -61,16 +66,19 @@ impl fmt::Display for TunError {
 pub struct TunTest {}
 
 pub struct TunFakeIO {
+    id: u32,
     store: bool,
     tx: SyncSender<Vec<u8>>,
     rx: Receiver<Vec<u8>>,
 }
 
 pub struct TunReader {
+    id: u32,
     rx: Receiver<Vec<u8>>,
 }
 
 pub struct TunWriter {
+    id: u32,
     store: bool,
     tx: Mutex<SyncSender<Vec<u8>>>,
 }
@@ -88,6 +96,12 @@ impl Reader for TunReader {
             Ok(msg) => {
                 let n = min(buf.len() - offset, msg.len());
                 buf[offset..offset + n].copy_from_slice(&msg[..n]);
+                debug!(
+                    "dummy::TUN({}) : read ({}, {})",
+                    self.id,
+                    n,
+                    hex::encode(&buf[offset..offset + n])
+                );
                 Ok(n)
             }
             Err(_) => Err(TunError::Disconnected),
@@ -99,6 +113,12 @@ impl Writer for TunWriter {
     type Error = TunError;
 
     fn write(&self, src: &[u8]) -> Result<(), Self::Error> {
+        debug!(
+            "dummy::TUN({}) : write ({}, {})",
+            self.id,
+            src.len(),
+            hex::encode(src)
+        );
         if self.store {
             let m = src.to_owned();
             match self.tx.lock().unwrap().send(m) {
@@ -149,13 +169,18 @@ impl TunTest {
             sync_channel(1)
         };
 
+        let mut rng = OsRng::new().unwrap();
+        let id: u32 = rng.gen();
+
         let fake = TunFakeIO {
+            id,
             tx: tx1,
             rx: rx2,
             store,
         };
-        let reader = TunReader { rx: rx1 };
+        let reader = TunReader { id, rx: rx1 };
         let writer = TunWriter {
+            id,
             tx: Mutex::new(tx2),
             store,
         };
-- 
cgit v1.2.3-59-g8ed1b