Work on Linux platform code

10 files changed, 14 insertions, 17 deletions

diff --git a/src/router/anti_replay.rs b/src/wireguard/router/anti_replay.rs
index b0838bd..b0838bd 100644
--- a/src/router/anti_replay.rs
+++ b/src/wireguard/router/anti_replay.rs
diff --git a/src/router/constants.rs b/src/wireguard/router/constants.rs
index 0ca824a..0ca824a 100644
--- a/src/router/constants.rs
+++ b/src/wireguard/router/constants.rs
diff --git a/src/router/device.rs b/src/wireguard/router/device.rs
index 989c2c2..455020c 100644
--- a/src/router/device.rs
+++ b/src/wireguard/router/device.rs
@@ -21,9 +21,9 @@ use super::types::{Callbacks, RouterError};
 use super::workers::{worker_parallel, JobParallel, Operation};
 use super::SIZE_MESSAGE_PREFIX;
 
-use super::super::types::{KeyPair, Endpoint, bind, tun};
+use super::super::types::{bind, tun, Endpoint, KeyPair};
 
-pub struct DeviceInner<E : Endpoint, C: Callbacks, T: tun::Writer, B: bind::Writer<E>> {
+pub struct DeviceInner<E: Endpoint, C: Callbacks, T: tun::Writer, B: bind::Writer<E>> {
     // inbound writer (TUN)
     pub inbound: T,
 
@@ -47,7 +47,7 @@ pub struct EncryptionState {
     pub death: Instant, // (birth + reject-after-time - keepalive-timeout - rekey-timeout)
 }
 
-pub struct DecryptionState<E : Endpoint, C: Callbacks, T: tun::Writer, B: bind::Writer<E>> {
+pub struct DecryptionState<E: Endpoint, C: Callbacks, T: tun::Writer, B: bind::Writer<E>> {
     pub keypair: Arc<KeyPair>,
     pub confirmed: AtomicBool,
     pub protector: Mutex<AntiReplay>,
@@ -55,12 +55,12 @@ pub struct DecryptionState<E : Endpoint, C: Callbacks, T: tun::Writer, B: bind::
     pub death: Instant, // time when the key can no longer be used for decryption
 }
 
-pub struct Device<E : Endpoint, C: Callbacks, T: tun::Writer, B: bind::Writer<E>> {
-    state: Arc<DeviceInner<E, C, T, B>>,     // reference to device state
+pub struct Device<E: Endpoint, C: Callbacks, T: tun::Writer, B: bind::Writer<E>> {
+    state: Arc<DeviceInner<E, C, T, B>>,  // reference to device state
     handles: Vec<thread::JoinHandle<()>>, // join handles for workers
 }
 
-impl<E : Endpoint, C: Callbacks, T: tun::Writer, B: bind::Writer<E>> Drop for Device<E, C, T, B> {
+impl<E: Endpoint, C: Callbacks, T: tun::Writer, B: bind::Writer<E>> Drop for Device<E, C, T, B> {
     fn drop(&mut self) {
         debug!("router: dropping device");
 
@@ -85,7 +85,7 @@ impl<E : Endpoint, C: Callbacks, T: tun::Writer, B: bind::Writer<E>> Drop for De
 }
 
 #[inline(always)]
-fn get_route<E : Endpoint, C: Callbacks, T: tun::Writer, B: bind::Writer<E>>(
+fn get_route<E: Endpoint, C: Callbacks, T: tun::Writer, B: bind::Writer<E>>(
     device: &Arc<DeviceInner<E, C, T, B>>,
     packet: &[u8],
 ) -> Option<Arc<PeerInner<E, C, T, B>>> {
@@ -124,10 +124,10 @@ fn get_route<E : Endpoint, C: Callbacks, T: tun::Writer, B: bind::Writer<E>>(
     }
 }
 
-impl<E : Endpoint, C: Callbacks, T: tun::Writer, B: bind::Writer<E>> Device<E, C, T, B> {
+impl<E: Endpoint, C: Callbacks, T: tun::Writer, B: bind::Writer<E>> Device<E, C, T, B> {
     pub fn new(num_workers: usize, tun: T) -> Device<E, C, T, B> {
         // allocate shared device state
-        let mut inner = DeviceInner {
+        let inner = DeviceInner {
             inbound: tun,
             outbound: RwLock::new(None),
             queues: Mutex::new(Vec::with_capacity(num_workers)),
@@ -235,9 +235,9 @@ impl<E : Endpoint, C: Callbacks, T: tun::Writer, B: bind::Writer<E>> Device<E, C
     }
 
     /// Set outbound writer
-    /// 
-    /// 
-    pub fn set_outbound_writer(&self, new : B) {
+    ///
+    ///
+    pub fn set_outbound_writer(&self, new: B) {
         *self.state.outbound.write() = Some(new);
     }
 }
diff --git a/src/router/ip.rs b/src/wireguard/router/ip.rs
index e66144f..e66144f 100644
--- a/src/router/ip.rs
+++ b/src/wireguard/router/ip.rs
diff --git a/src/router/messages.rs b/src/wireguard/router/messages.rs
index bf4d13b..bf4d13b 100644
--- a/src/router/messages.rs
+++ b/src/wireguard/router/messages.rs
diff --git a/src/router/mod.rs b/src/wireguard/router/mod.rs
index 7a29cd9..7a29cd9 100644
--- a/src/router/mod.rs
+++ b/src/wireguard/router/mod.rs
diff --git a/src/router/peer.rs b/src/wireguard/router/peer.rs
index 13e5af4..4f47604 100644
--- a/src/router/peer.rs
+++ b/src/wireguard/router/peer.rs
@@ -291,7 +291,7 @@ impl<E: Endpoint, C: Callbacks, T: tun::Writer, B: bind::Writer<E>> PeerInner<E,
         &self,
         src: E,
         dec: Arc<DecryptionState<E, C, T, B>>,
-        mut msg: Vec<u8>,
+        msg: Vec<u8>,
     ) -> Option<JobParallel> {
         let (tx, rx) = oneshot();
         let key = dec.keypair.recv.key;
diff --git a/src/router/tests.rs b/src/wireguard/router/tests.rs
index 6c385a8..fbee39e 100644
--- a/src/router/tests.rs
+++ b/src/wireguard/router/tests.rs
@@ -10,7 +10,6 @@ use pnet::packet::ipv4::MutableIpv4Packet;
 use pnet::packet::ipv6::MutableIpv6Packet;
 
 use super::super::types::bind::*;
-use super::super::types::tun::*;
 use super::super::types::*;
 
 use super::{Callbacks, Device, SIZE_MESSAGE_PREFIX};
@@ -146,7 +145,7 @@ mod tests {
 
         // create device
         let (_fake, _reader, tun_writer, _mtu) = dummy::TunTest::create(1500, false);
-        let router: Device< _, BencherCallbacks, dummy::TunWriter, dummy::VoidBind> =
+        let router: Device<_, BencherCallbacks, dummy::TunWriter, dummy::VoidBind> =
             Device::new(num_cpus::get(), tun_writer);
 
         // add new peer
diff --git a/src/router/types.rs b/src/wireguard/router/types.rs
index 4a72c27..b7c3ae0 100644
--- a/src/router/types.rs
+++ b/src/wireguard/router/types.rs
@@ -1,8 +1,6 @@
 use std::error::Error;
 use std::fmt;
 
-use super::super::types::Endpoint;
-
 pub trait Opaque: Send + Sync + 'static {}
 
 impl<T> Opaque for T where T: Send + Sync + 'static {}
diff --git a/src/router/workers.rs b/src/wireguard/router/workers.rs
index 2e89bb0..2e89bb0 100644
--- a/src/router/workers.rs
+++ b/src/wireguard/router/workers.rs