1 files changed, 113 insertions, 59 deletions

diff --git a/src/types/dummy.rs b/src/types/dummy.rs
index e15abb0..40a3bdd 100644
--- a/src/types/dummy.rs
+++ b/src/types/dummy.rs
@@ -5,8 +5,9 @@ use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
 use std::sync::Arc;
 use std::sync::Mutex;
 use std::time::Instant;
+use std::marker;
 
-use super::{Bind, Endpoint, Key, KeyPair, Tun};
+use super::*;
 
 /* This submodule provides pure/dummy implementations of the IO interfaces
  * for use in unit tests thoughout the project.
@@ -72,104 +73,103 @@ impl Endpoint for UnitEndpoint {
     }
 }
 
+impl UnitEndpoint {
+    pub fn new() -> UnitEndpoint {
+        UnitEndpoint{}
+    }
+}
+
+/* */
+
 #[derive(Clone, Copy)]
 pub struct TunTest {}
 
-impl Tun for TunTest {
+impl tun::Reader for TunTest {
     type Error = TunError;
 
+    fn read(&self, _buf: &mut [u8], _offset: usize) -> Result<usize, Self::Error> {
+        Ok(0)
+    }
+}
+
+impl tun::MTU for TunTest {
     fn mtu(&self) -> usize {
         1500
     }
+}
 
-    fn read(&self, _buf: &mut [u8], _offset: usize) -> Result<usize, Self::Error> {
-        Ok(0)
-    }
+impl tun::Writer for TunTest {
+    type Error = TunError;
 
     fn write(&self, _src: &[u8]) -> Result<(), Self::Error> {
         Ok(())
     }
 }
 
+impl tun::Tun for TunTest {
+    type Writer = TunTest;
+    type Reader = TunTest;
+    type MTU = TunTest;
+    type Error = TunError;
+}
+
 impl TunTest {
-    pub fn new() -> TunTest {
-        TunTest {}
+    pub fn create(_name: &str) -> Result<(TunTest, TunTest, TunTest), TunError> {
+        Ok((TunTest {},TunTest {}, TunTest{}))
     }
 }
 
-/* Bind implemenentations */
+/* Void Bind */
 
 #[derive(Clone, Copy)]
 pub struct VoidBind {}
 
-impl Bind for VoidBind {
+impl bind::Reader<UnitEndpoint> for VoidBind {
     type Error = BindError;
-    type Endpoint = UnitEndpoint;
 
-    fn new() -> VoidBind {
-        VoidBind {}
-    }
-
-    fn set_port(&self, _port: u16) -> Result<(), Self::Error> {
-        Ok(())
-    }
-
-    fn get_port(&self) -> Option<u16> {
-        None
-    }
-
-    fn recv(&self, _buf: &mut [u8]) -> Result<(usize, Self::Endpoint), Self::Error> {
+    fn read(&self, _buf: &mut [u8]) -> Result<(usize, UnitEndpoint), Self::Error> {
         Ok((0, UnitEndpoint {}))
     }
-
-    fn send(&self, _buf: &[u8], _dst: &Self::Endpoint) -> Result<(), Self::Error> {
-        Ok(())
-    }
 }
 
-#[derive(Clone)]
-pub struct PairBind {
-    send: Arc<Mutex<SyncSender<Vec<u8>>>>,
-    recv: Arc<Mutex<Receiver<Vec<u8>>>>,
-}
+impl bind::Writer<UnitEndpoint> for VoidBind {
+    type Error = BindError;
 
-impl PairBind {
-    pub fn pair() -> (PairBind, PairBind) {
-        let (tx1, rx1) = sync_channel(128);
-        let (tx2, rx2) = sync_channel(128);
-        (
-            PairBind {
-                send: Arc::new(Mutex::new(tx1)),
-                recv: Arc::new(Mutex::new(rx2)),
-            },
-            PairBind {
-                send: Arc::new(Mutex::new(tx2)),
-                recv: Arc::new(Mutex::new(rx1)),
-            },
-        )
+    fn write(&self, _buf: &[u8], _dst: &UnitEndpoint) -> Result<(), Self::Error> {
+        Ok(())
     }
 }
 
-impl Bind for PairBind {
+impl bind::Bind for VoidBind {
     type Error = BindError;
     type Endpoint = UnitEndpoint;
 
-    fn new() -> PairBind {
-        PairBind {
-            send: Arc::new(Mutex::new(sync_channel(0).0)),
-            recv: Arc::new(Mutex::new(sync_channel(0).1)),
-        }
-    }
+    type Reader = VoidBind;
+    type Writer = VoidBind;
+    type Closer = ();
 
-    fn set_port(&self, _port: u16) -> Result<(), Self::Error> {
-        Ok(())
+    fn bind(_ : u16) -> Result<(Self::Reader, Self::Writer, Self::Closer, u16), Self::Error> {
+        Ok((VoidBind{}, VoidBind{}, (), 2600))
     }
+}
 
-    fn get_port(&self) -> Option<u16> {
-        None
+impl VoidBind {
+    pub fn new() -> VoidBind {
+        VoidBind{}
     }
+}
 
-    fn recv(&self, buf: &mut [u8]) -> Result<(usize, Self::Endpoint), Self::Error> {
+/* Pair Bind */
+
+#[derive(Clone)]
+pub struct PairReader<E> {
+    recv: Arc<Mutex<Receiver<Vec<u8>>>>,
+    _marker: marker::PhantomData<E>,
+}
+
+impl bind::Reader<UnitEndpoint> for PairReader<UnitEndpoint> {
+    type Error = BindError;
+    fn read(&self, buf: &mut [u8]) -> Result<(usize, UnitEndpoint), Self::Error> {
         let vec = self
             .recv
             .lock()
@@ -180,8 +180,11 @@ impl Bind for PairBind {
         buf[..len].copy_from_slice(&vec[..]);
         Ok((vec.len(), UnitEndpoint {}))
     }
+}
 
-    fn send(&self, buf: &[u8], _dst: &Self::Endpoint) -> Result<(), Self::Error> {
+impl bind::Writer<UnitEndpoint> for PairWriter<UnitEndpoint> {
+    type Error = BindError;
+    fn write(&self, buf: &[u8], _dst: &UnitEndpoint) -> Result<(), Self::Error> {
         let owned = buf.to_owned();
         match self.send.lock().unwrap().send(owned) {
             Err(_) => Err(BindError::Disconnected),
@@ -190,6 +193,57 @@ impl Bind for PairBind {
     }
 }
 
+#[derive(Clone)]
+pub struct PairWriter<E> {
+    send: Arc<Mutex<SyncSender<Vec<u8>>>>,
+    _marker: marker::PhantomData<E>,
+}
+
+#[derive(Clone)]
+pub struct PairBind {}
+
+impl PairBind {
+    pub fn pair<E>() -> ((PairReader<E>, PairWriter<E>), (PairReader<E>, PairWriter<E>)) {
+        let (tx1, rx1) = sync_channel(128);
+        let (tx2, rx2) = sync_channel(128);
+        (
+            (
+                PairReader{ 
+                    
+                    recv: Arc::new(Mutex::new(rx1)), 
+                    _marker: marker::PhantomData 
+                }, 
+                PairWriter{ 
+                    send: Arc::new(Mutex::new(tx2)),
+                    _marker: marker::PhantomData
+                }
+            ),
+            (
+                PairReader{ 
+                    recv: Arc::new(Mutex::new(rx2)),
+                    _marker: marker::PhantomData 
+                }, 
+                PairWriter{ 
+                    send: Arc::new(Mutex::new(tx1)),
+                    _marker: marker::PhantomData 
+                }
+            ),
+        )
+    }
+}
+
+impl bind::Bind for PairBind {
+    type Closer = ();
+    type Error = BindError;
+    type Endpoint = UnitEndpoint;
+    type Reader = PairReader<Self::Endpoint>;
+    type Writer = PairWriter<Self::Endpoint>;
+    
+    fn bind(_port: u16) -> Result<(Self::Reader, Self::Writer, Self::Closer, u16), Self::Error> {
+        Err(BindError::Disconnected)
+    }
+}
+
 pub fn keypair(initiator: bool) -> KeyPair {
     let k1 = Key {
         key: [0x53u8; 32],