Formatting

9 files changed, 45 insertions, 42 deletions

diff --git a/src/wireguard/router/device.rs b/src/wireguard/router/device.rs
index 9bba199..febea45 100644
--- a/src/wireguard/router/device.rs
+++ b/src/wireguard/router/device.rs
@@ -20,8 +20,8 @@ use super::peer::{new_peer, Peer, PeerHandle};
 use super::types::{Callbacks, RouterError};
 use super::SIZE_MESSAGE_PREFIX;
 
-use super::runq::RunQueue;
 use super::route::RoutingTable;
+use super::runq::RunQueue;
 
 use super::super::{tun, udp, Endpoint, KeyPair};
 use super::queue::ParallelQueue;
@@ -137,7 +137,7 @@ impl<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>> DeviceHandle<
                 run_outbound: RunQueue::new(),
                 recv: RwLock::new(HashMap::new()),
                 table: RoutingTable::new(),
-            })
+            }),
         };
 
         // start worker threads
diff --git a/src/wireguard/router/inbound.rs b/src/wireguard/router/inbound.rs
index 9b15750..5a27c95 100644
--- a/src/wireguard/router/inbound.rs
+++ b/src/wireguard/router/inbound.rs
@@ -1,11 +1,11 @@
 use super::device::DecryptionState;
+use super::device::Device;
 use super::messages::TransportHeader;
 use super::peer::Peer;
 use super::pool::*;
+use super::runq::RunQueue;
 use super::types::Callbacks;
 use super::{tun, udp, Endpoint};
-use super::device::Device;
-use super::runq::RunQueue;
 
 use ring::aead::{Aad, LessSafeKey, Nonce, UnboundKey, CHACHA20_POLY1305};
 use zerocopy::{AsBytes, LayoutVerified};
@@ -47,10 +47,10 @@ pub fn parallel<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>>(
     // run queue to schedule
     fn queue<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>>(
         device: &Device<E, C, T, B>,
-    ) -> &RunQueue<Peer<E, C, T, B>>  {
+    ) -> &RunQueue<Peer<E, C, T, B>> {
         &device.run_inbound
     }
-    
+
     // parallel work to apply
     fn work<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>>(
         peer: &Peer<E, C, T, B>,
@@ -130,7 +130,7 @@ pub fn sequential<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>>(
     // sequential work to apply
     fn work<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>>(
         peer: &Peer<E, C, T, B>,
-        body: &mut Inbound<E, C, T, B>
+        body: &mut Inbound<E, C, T, B>,
     ) {
         log::trace!("worker, sequential section, obtained job");
 
diff --git a/src/wireguard/router/mod.rs b/src/wireguard/router/mod.rs
index 35efe4c..49a4f96 100644
--- a/src/wireguard/router/mod.rs
+++ b/src/wireguard/router/mod.rs
@@ -9,8 +9,8 @@ mod peer;
 mod pool;
 mod queue;
 mod route;
-mod types;
 mod runq;
+mod types;
 
 // mod workers;
 
diff --git a/src/wireguard/router/outbound.rs b/src/wireguard/router/outbound.rs
index 6c42d8f..9ecffd8 100644
--- a/src/wireguard/router/outbound.rs
+++ b/src/wireguard/router/outbound.rs
@@ -1,3 +1,4 @@
+use super::device::Device;
 use super::messages::{TransportHeader, TYPE_TRANSPORT};
 use super::peer::Peer;
 use super::pool::*;
@@ -5,7 +6,6 @@ use super::types::Callbacks;
 use super::KeyPair;
 use super::REJECT_AFTER_MESSAGES;
 use super::{tun, udp, Endpoint};
-use super::device::Device;
 
 use std::sync::mpsc::Receiver;
 use std::sync::Arc;
@@ -35,7 +35,6 @@ impl Outbound {
 pub fn parallel<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>>(
     device: Device<E, C, T, B>,
     receiver: Receiver<Job<Peer<E, C, T, B>, Outbound>>,
-   
 ) {
     fn work<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>>(
         _peer: &Peer<E, C, T, B>,
@@ -67,8 +66,9 @@ pub fn parallel<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>>(
         let nonce = Nonce::assume_unique_for_key(nonce);
 
         // do the weird ring AEAD dance
-        let key =
-            LessSafeKey::new(UnboundKey::new(&CHACHA20_POLY1305, &body.keypair.send.key[..]).unwrap());
+        let key = LessSafeKey::new(
+            UnboundKey::new(&CHACHA20_POLY1305, &body.keypair.send.key[..]).unwrap(),
+        );
 
         // encrypt content of transport message in-place
         let end = packet.len() - SIZE_TAG;
@@ -83,7 +83,6 @@ pub fn parallel<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>>(
     worker_parallel(device, |dev| &dev.run_outbound, receiver, work);
 }
 
-
 #[inline(always)]
 pub fn sequential<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>>(
     device: Device<E, C, T, B>,
@@ -105,4 +104,4 @@ pub fn sequential<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>>(
             );
         });
     });
-}
\ No newline at end of file
+}
diff --git a/src/wireguard/router/peer.rs b/src/wireguard/router/peer.rs
index a00ce1a..ebc0aac 100644
--- a/src/wireguard/router/peer.rs
+++ b/src/wireguard/router/peer.rs
@@ -18,9 +18,9 @@ use super::device::EncryptionState;
 use super::messages::TransportHeader;
 
 use super::constants::*;
+use super::runq::ToKey;
 use super::types::{Callbacks, RouterError};
 use super::SIZE_MESSAGE_PREFIX;
-use super::runq::ToKey;
 
 // worker pool related
 use super::inbound::Inbound;
@@ -86,8 +86,7 @@ impl<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>> Deref for Pee
     }
 }
 
-
-/* A peer handle is a specially designated peer pointer 
+/* A peer handle is a specially designated peer pointer
  * which removes the peer from the device when dropped.
  */
 pub struct PeerHandle<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>> {
diff --git a/src/wireguard/router/pool.rs b/src/wireguard/router/pool.rs
index 98b1144..07a9bfa 100644
--- a/src/wireguard/router/pool.rs
+++ b/src/wireguard/router/pool.rs
@@ -1,8 +1,8 @@
 use arraydeque::ArrayDeque;
 use spin::{Mutex, MutexGuard};
+use std::mem;
 use std::sync::mpsc::Receiver;
 use std::sync::Arc;
-use std::mem;
 
 use super::runq::{RunQueue, ToKey};
 
@@ -76,7 +76,7 @@ impl<P, B> InorderQueue<P, B> {
                     return;
                 }
             };
-            
+
             // apply function if job complete
             let ret = if let Some(mut guard) = elem.complete() {
                 mem::drop(queue);
@@ -100,9 +100,9 @@ impl<P, B> InorderQueue<P, B> {
 /// Applicable for both decryption and encryption workers.
 #[inline(always)]
 pub fn worker_parallel<
-    P : ToKey, // represents a peer (atomic reference counted pointer)
-    B, // inner body type (message buffer, key material, ...)
-    D, // device
+    P: ToKey, // represents a peer (atomic reference counted pointer)
+    B,        // inner body type (message buffer, key material, ...)
+    D,        // device
     W: Fn(&P, &mut B),
     Q: Fn(&D) -> &RunQueue<P>,
 >(
@@ -131,8 +131,8 @@ pub fn worker_parallel<
             work(&peer, &mut job.body);
             peer
         };
-        
+
         // process inorder jobs for peer
         queue(&device).insert(peer);
     }
-}
\ No newline at end of file
+}
diff --git a/src/wireguard/router/route.rs b/src/wireguard/router/route.rs
index 56ad32f..7256232 100644
--- a/src/wireguard/router/route.rs
+++ b/src/wireguard/router/route.rs
@@ -110,7 +110,7 @@ impl<T: Eq + Clone> RoutingTable<T> {
             v => {
                 log::trace!("router, invalid IP version {}", v);
                 None
-            },
+            }
         }
     }
 
diff --git a/src/wireguard/router/runq.rs b/src/wireguard/router/runq.rs
index 6d96490..936a53c 100644
--- a/src/wireguard/router/runq.rs
+++ b/src/wireguard/router/runq.rs
@@ -1,6 +1,6 @@
+use std::hash::Hash;
 use std::mem;
 use std::sync::{Condvar, Mutex};
-use std::hash::Hash;
 
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
@@ -11,18 +11,18 @@ pub trait ToKey {
     fn to_key(&self) -> Self::Key;
 }
 
-pub struct RunQueue<T : ToKey> {
+pub struct RunQueue<T: ToKey> {
     cvar: Condvar,
     inner: Mutex<Inner<T>>,
 }
 
-struct Inner<T : ToKey> {
+struct Inner<T: ToKey> {
     stop: bool,
     queue: VecDeque<T>,
     members: HashMap<T::Key, usize>,
 }
 
-impl<T : ToKey> RunQueue<T> {
+impl<T: ToKey> RunQueue<T> {
     pub fn close(&self) {
         let mut inner = self.inner.lock().unwrap();
         inner.stop = true;
@@ -33,7 +33,7 @@ impl<T : ToKey> RunQueue<T> {
         RunQueue {
             cvar: Condvar::new(),
             inner: Mutex::new(Inner {
-                stop:false,
+                stop: false,
                 queue: VecDeque::new(),
                 members: HashMap::new(),
             }),
@@ -111,8 +111,8 @@ impl<T : ToKey> RunQueue<T> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::thread;
     use std::sync::Arc;
+    use std::thread;
     use std::time::Duration;
 
     /*
@@ -142,4 +142,4 @@ mod tests {
 
     }
     */
-}
\ No newline at end of file
+}
diff --git a/src/wireguard/router/tests.rs b/src/wireguard/router/tests.rs
index fe1fbbe..3d5c79b 100644
--- a/src/wireguard/router/tests.rs
+++ b/src/wireguard/router/tests.rs
@@ -157,7 +157,7 @@ mod tests {
         let dst = dst.parse().unwrap();
         let src = match dst {
             IpAddr::V4(_) => "127.0.0.1".parse().unwrap(),
-            IpAddr::V6(_) => "::1".parse().unwrap()
+            IpAddr::V6(_) => "::1".parse().unwrap(),
         };
         let msg = make_packet_padded(1024, src, dst, 0);
 
@@ -204,7 +204,13 @@ mod tests {
         ];
 
         for (num, (mask, len, dst, okay)) in tests.iter().enumerate() {
-            println!("Check: {} {} {}/{}", dst, if *okay { "\\in" } else { "\\notin" }, mask, len);
+            println!(
+                "Check: {} {} {}/{}",
+                dst,
+                if *okay { "\\in" } else { "\\notin" },
+                mask,
+                len
+            );
             for set_key in vec![true, false] {
                 debug!("index = {}, set_key = {}", num, set_key);
 
@@ -223,7 +229,7 @@ mod tests {
                 let dst = dst.parse().unwrap();
                 let src = match dst {
                     IpAddr::V4(_) => "127.0.0.1".parse().unwrap(),
-                    IpAddr::V6(_) => "::1".parse().unwrap()
+                    IpAddr::V6(_) => "::1".parse().unwrap(),
                 };
                 let msg = make_packet_padded(1024, src, dst, 0);
 
@@ -432,13 +438,12 @@ mod tests {
                     // 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
-                        );
+                    let msg = make_packet_padded(
+                        1024,
+                        ip2.parse().unwrap(), // src
+                        ip1.parse().unwrap(), // dst
+                        id,
+                    );
                     router1.send(msg).unwrap();
 
                     wait();