Fix some clippy warnings

Signed-off-by: Quang Luong <quangio@outlook.com>

6 files changed, 39 insertions, 37 deletions

diff --git a/src/wireguard/router/device.rs b/src/wireguard/router/device.rs
index 62ef932..54e5149 100644
--- a/src/wireguard/router/device.rs
+++ b/src/wireguard/router/device.rs
@@ -4,7 +4,6 @@ use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
 use std::thread;
 
-use log;
 use spin::{Mutex, RwLock};
 use zerocopy::LayoutVerified;
 
@@ -31,7 +30,7 @@ pub struct DeviceInner<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer
     pub(super) outbound: RwLock<(bool, Option<B>)>,
 
     // routing
-    pub(super) recv: RwLock<HashMap<u32, Arc<DecryptionState<E, C, T, B>>>>, // receiver id -> decryption state
+    pub(super) recv: RwLock<HashMap<u32, Arc<DecryptionState<E, C, T, B>>>>, /* receiver id -> decryption state */
     pub(super) table: RoutingTable<Peer<E, C, T, B>>,
 
     // work queue
@@ -141,7 +140,7 @@ impl<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>> DeviceHandle<
                 return bind.write(msg, dst);
             }
         }
-        return Ok(());
+        Ok(())
     }
 
     /// Brings the router down.
@@ -178,7 +177,6 @@ impl<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>> DeviceHandle<
     /// # Arguments
     ///
     /// - msg: IP packet to crypt-key route
-    ///
     pub fn send(&self, msg: Vec<u8>) -> Result<(), RouterError> {
         debug_assert!(msg.len() > SIZE_MESSAGE_PREFIX);
         log::trace!(
@@ -209,8 +207,6 @@ impl<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>> DeviceHandle<
     /// - msg: Encrypted transport message
     ///
     /// # Returns
-    ///
-    ///
     pub fn recv(&self, src: E, msg: Vec<u8>) -> Result<(), RouterError> {
         log::trace!("receive, src: {}", src.into_address());
 
@@ -253,8 +249,6 @@ impl<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>> DeviceHandle<
     }
 
     /// Set outbound writer
-    ///
-    ///
     pub fn set_outbound_writer(&self, new: B) {
         self.state.outbound.write().1 = Some(new);
     }
diff --git a/src/wireguard/router/peer.rs b/src/wireguard/router/peer.rs
index d960da0..0803b13 100644
--- a/src/wireguard/router/peer.rs
+++ b/src/wireguard/router/peer.rs
@@ -26,7 +26,6 @@ use std::fmt;
 use std::net::{IpAddr, SocketAddr};
 
 use arraydeque::{ArrayDeque, Wrapping};
-use log;
 use spin::Mutex;
 
 pub struct KeyWheel {
@@ -155,11 +154,17 @@ impl<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>> Drop for Peer
         let mut keys = peer.keys.lock();
         let mut release = Vec::with_capacity(3);
 
-        keys.next.as_ref().map(|k| release.push(k.recv.id));
-        keys.current.as_ref().map(|k| release.push(k.recv.id));
-        keys.previous.as_ref().map(|k| release.push(k.recv.id));
+        if let Some(k) = keys.next.as_ref() {
+            release.push(k.recv.id)
+        }
+        if let Some(k) = keys.current.as_ref() {
+            release.push(k.recv.id)
+        }
+        if let Some(k) = keys.previous.as_ref() {
+            release.push(k.recv.id)
+        }
 
-        if release.len() > 0 {
+        if !release.is_empty() {
             let mut recv = peer.device.recv.write();
             for id in &release {
                 recv.remove(id);
@@ -185,7 +190,6 @@ pub fn new_peer<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>>(
 ) -> PeerHandle<E, C, T, B> {
     // allocate peer object
     let peer = {
-        let device = device.clone();
         Peer {
             inner: Arc::new(PeerInner {
                 opaque,
@@ -245,7 +249,6 @@ impl<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>> Peer<E, C, T,
     ///
     /// - `msg` : A padded vector holding the message (allows in-place construction of the transport header)
     /// - `stage`: Should the message be staged if no key is available
-    ///
     pub(super) fn send(&self, msg: Vec<u8>, stage: bool) {
         // check if key available
         let (job, need_key) = {
@@ -385,9 +388,15 @@ impl<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>> PeerHandle<E,
 
         // update key-wheel
 
-        mem::replace(&mut keys.next, None).map(|k| release.push(k.local_id()));
-        mem::replace(&mut keys.current, None).map(|k| release.push(k.local_id()));
-        mem::replace(&mut keys.previous, None).map(|k| release.push(k.local_id()));
+        if let Some(k) = mem::replace(&mut keys.next, None) {
+            release.push(k.local_id())
+        }
+        if let Some(k) = mem::replace(&mut keys.current, None) {
+            release.push(k.local_id())
+        }
+        if let Some(k) = mem::replace(&mut keys.previous, None) {
+            release.push(k.local_id())
+        }
         keys.retired.extend(&release[..]);
 
         // update inbound "recv" map
@@ -439,11 +448,11 @@ impl<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>> PeerHandle<E,
                 *self.peer.enc_key.lock() = Some(EncryptionState::new(&new));
 
                 // move current into previous
-                keys.previous = keys.current.as_ref().map(|v| v.clone());
+                keys.previous = keys.current.as_ref().cloned();
                 keys.current = Some(new.clone());
             } else {
                 // store the key and await confirmation
-                keys.previous = keys.next.as_ref().map(|v| v.clone());
+                keys.previous = keys.next.as_ref().cloned();
                 keys.next = Some(new.clone());
             };
 
@@ -453,10 +462,10 @@ impl<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>> PeerHandle<E,
                 let mut recv = self.peer.device.recv.write();
 
                 // purge recv map of previous id
-                keys.previous.as_ref().map(|k| {
+                if let Some(k) = &keys.previous {
                     recv.remove(&k.local_id());
                     release.push(k.local_id());
-                });
+                }
 
                 // map new id to decryption state
                 debug_assert!(!recv.contains_key(&new.recv.id));
@@ -531,7 +540,9 @@ impl<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>> PeerHandle<E,
     }
 
     pub fn clear_src(&self) {
-        (*self.peer.endpoint.lock()).as_mut().map(|e| e.clear_src());
+        if let Some(e) = (*self.peer.endpoint.lock()).as_mut() {
+            e.clear_src()
+        }
     }
 
     pub fn purge_staged_packets(&self) {
diff --git a/src/wireguard/router/queue.rs b/src/wireguard/router/queue.rs
index d5d657a..b266a57 100644
--- a/src/wireguard/router/queue.rs
+++ b/src/wireguard/router/queue.rs
@@ -67,9 +67,7 @@ impl<J: SequentialJob> Queue<J> {
                 match queue.front() {
                     None => break,
                     Some(job) => {
-                        if job.is_ready() {
-                            ()
-                        } else {
+                        if !job.is_ready() {
                             break;
                         }
                     }
diff --git a/src/wireguard/router/route.rs b/src/wireguard/router/route.rs
index a556010..7e50153 100644
--- a/src/wireguard/router/route.rs
+++ b/src/wireguard/router/route.rs
@@ -88,7 +88,7 @@ impl<T: Eq + Clone> RoutingTable<T> {
                 self.ipv4
                     .read()
                     .longest_match(Ipv4Addr::from(header.f_destination))
-                    .and_then(|(_, _, p)| Some(p.clone()))
+                    .map(|(_, _, p)| p.clone())
             }
             VERSION_IP6 => {
                 // check length and cast to IPv6 header
@@ -104,7 +104,7 @@ impl<T: Eq + Clone> RoutingTable<T> {
                 self.ipv6
                     .read()
                     .longest_match(Ipv6Addr::from(header.f_destination))
-                    .and_then(|(_, _, p)| Some(p.clone()))
+                    .map(|(_, _, p)| p.clone())
             }
             v => {
                 log::trace!("router, invalid IP version {}", v);
diff --git a/src/wireguard/router/types.rs b/src/wireguard/router/types.rs
index e0cd459..e44963f 100644
--- a/src/wireguard/router/types.rs
+++ b/src/wireguard/router/types.rs
@@ -15,16 +15,16 @@ impl<T> Opaque for T where T: Send + Sync + 'static {}
 /// * `0`, a reference to the opaque value assigned to the peer
 /// * `1`, a bool indicating whether the message contained data (not just keepalive)
 /// * `2`, a bool indicating whether the message was transmitted (i.e. did the peer have an associated endpoint?)
-pub trait Callback<T>: Fn(&T, usize, bool) -> () + Sync + Send + 'static {}
+pub trait Callback<T>: Fn(&T, usize, bool) + Sync + Send + 'static {}
 
-impl<T, F> Callback<T> for F where F: Fn(&T, usize, bool) -> () + Sync + Send + 'static {}
+impl<T, F> Callback<T> for F where F: Fn(&T, usize, bool) + Sync + Send + 'static {}
 
 /// A key callback takes 1 argument
 ///
 /// * `0`, a reference to the opaque value assigned to the peer
-pub trait KeyCallback<T>: Fn(&T) -> () + Sync + Send + 'static {}
+pub trait KeyCallback<T>: Fn(&T) + Sync + Send + 'static {}
 
-impl<T, F> KeyCallback<T> for F where F: Fn(&T) -> () + Sync + Send + 'static {}
+impl<T, F> KeyCallback<T> for F where F: Fn(&T) + Sync + Send + 'static {}
 
 pub trait Callbacks: Send + Sync + 'static {
     type Opaque: Opaque;
@@ -58,11 +58,11 @@ impl fmt::Display for RouterError {
 }
 
 impl Error for RouterError {
-    fn description(&self) -> &str {
-        "Generic Handshake Error"
-    }
-
     fn source(&self) -> Option<&(dyn Error + 'static)> {
         None
     }
+
+    fn description(&self) -> &str {
+        "Generic Handshake Error"
+    }
 }
diff --git a/src/wireguard/router/worker.rs b/src/wireguard/router/worker.rs
index 4913a21..99c2a1d 100644
--- a/src/wireguard/router/worker.rs
+++ b/src/wireguard/router/worker.rs
@@ -6,7 +6,6 @@ use super::super::{tun, udp, Endpoint};
 use super::types::Callbacks;
 
 use crossbeam_channel::Receiver;
-use log;
 
 pub enum JobUnion<E: Endpoint, C: Callbacks, T: tun::Writer, B: udp::Writer<E>> {
     Outbound(SendJob<E, C, T, B>),