clippytime

5 files changed, 20 insertions, 20 deletions

diff --git a/benches/criterion.rs b/benches/criterion.rs
index e4e6c94..1ccf9bc 100644
--- a/benches/criterion.rs
+++ b/benches/criterion.rs
@@ -74,7 +74,7 @@ fn benchmarks(c: &mut Criterion) {
 
     c.bench("peer_handshake_response", Benchmark::new("peer_handshake_response", |b| {
         let (mut peer_init, init_priv, mut peer_resp, resp_priv) = connected_peers();
-        let (init, _) = peer_init.initiate_new_session(&init_priv).expect("initiate");
+        let (_, init, _, _) = peer_init.initiate_new_session(&init_priv).expect("initiate");
         let addr = ([127, 0, 0, 1], 443).into();
         b.iter(move || {
             peer_resp.last_handshake_tai64n = None;
@@ -84,14 +84,14 @@ fn benchmarks(c: &mut Criterion) {
     }).throughput(Throughput::Elements(1)));
 
     c.bench("peer_transport_outgoing", Benchmark::new("peer_transport_outgoing", |b| {
-        let (mut peer_init, init_priv, mut peer_resp, resp_priv) = connected_peers();
+        let (mut peer_init, _, _, _) = connected_peers();
         b.iter(move || {
             peer_init.handle_outgoing_transport(&[1u8; 1420]).expect("handle_outgoing_transport")
         });
     }).throughput(Throughput::Bytes(1452)));
 
     c.bench("peer_transport_incoming", Benchmark::new("peer_transport_incoming", |b| {
-        let (mut peer_init, init_priv, mut peer_resp, resp_priv) = connected_peers();
+        let (mut peer_init, _, mut peer_resp, _) = connected_peers();
         b.iter_with_setup(move || {
             peer_init.handle_outgoing_transport(&[1u8; 1420]).expect("SETUP handle_outgoing_transport")
         }, move |(addr, packet)| {
diff --git a/src/interface/mod.rs b/src/interface/mod.rs
index e75c25c..e5bdf95 100644
--- a/src/interface/mod.rs
+++ b/src/interface/mod.rs
@@ -33,6 +33,7 @@ pub fn trace_packet(header: &str, packet: &[u8]) {
 pub type SharedPeer = Rc<RefCell<Peer>>;
 pub type SharedState = Rc<RefCell<State>>;
 
+#[derive(Default)]
 pub struct State {
     pubkey_map: HashMap<[u8; 32], SharedPeer>,
     index_map: HashMap<u32, SharedPeer>,
@@ -97,12 +98,7 @@ impl UtunCodec for VecUtunCodec {
 
 impl Interface {
     pub fn new(name: &str) -> Self {
-        let state = State {
-            pubkey_map: HashMap::new(),
-            index_map: HashMap::new(),
-            router: Router::new(),
-            interface_info: InterfaceInfo::default(),
-        };
+        let state = State::default();
         Interface {
             name: name.to_owned(),
             state: Rc::new(RefCell::new(state)),
diff --git a/src/interface/peer_server.rs b/src/interface/peer_server.rs
index 4a26930..0ad4cde 100644
--- a/src/interface/peer_server.rs
+++ b/src/interface/peer_server.rs
@@ -66,7 +66,7 @@ impl PeerServer {
         socket.set_only_v6(false)?;
         socket.set_nonblocking(true)?;
         socket.bind(&SocketAddr::from((Ipv6Addr::unspecified(), 0)).into())?;
-        let timer = Timer::new();
+        let timer = Timer::default();
         let socket = UdpSocket::from_socket(socket.into_udp_socket(), &handle.clone())?;
         let (udp_sink, udp_stream) = socket.framed(VecUdpCodec{}).split();
         let (udp_tx, udp_rx) = unsync::mpsc::channel::<(SocketAddr, Vec<u8>)>(1024);
@@ -158,7 +158,7 @@ impl PeerServer {
 
                 if let Some(persistent_keep_alive) = peer.info.keep_alive_interval {
                     self.timer.spawn_delayed(&self.handle,
-                                             Duration::from_secs(persistent_keep_alive as u64),
+                                             Duration::from_secs(u64::from(persistent_keep_alive)),
                                              TimerMessage::PersistentKeepAlive(peer_ref.clone(), our_index));
                 }
             },
@@ -174,7 +174,7 @@ impl PeerServer {
 
                 let (raw_packet, dead_index) = {
                     let mut peer = peer_ref.borrow_mut();
-                    peer.handle_incoming_transport(addr, &packet)?
+                    peer.handle_incoming_transport(addr, packet)?
                 };
 
                 if let Some(index) = dead_index {
@@ -196,7 +196,7 @@ impl PeerServer {
         Ok(())
     }
 
-    fn send_handshake_init(&mut self, peer_ref: SharedPeer) -> Result<u32, Error> {
+    fn send_handshake_init(&mut self, peer_ref: &SharedPeer) -> Result<u32, Error> {
         let mut state       = self.shared_state.borrow_mut();
         let mut peer        = peer_ref.borrow_mut();
         let     private_key = &state.interface_info.private_key.ok_or_else(|| err_msg("no private key!"))?;
@@ -256,7 +256,7 @@ impl PeerServer {
                     }
                 }
 
-                let new_index = self.send_handshake_init(peer_ref.clone())?;
+                let new_index = self.send_handshake_init(&peer_ref)?;
                 debug!("sent handshake init (Rekey timer) ({} -> {})", our_index, new_index);
 
             },
@@ -310,7 +310,7 @@ impl PeerServer {
 
                 if let Some(persistent_keepalive) = peer.info.keep_alive_interval {
                     self.timer.spawn_delayed(&self.handle,
-                                             Duration::from_secs(persistent_keepalive as u64),
+                                             Duration::from_secs(u64::from(persistent_keepalive)),
                                              TimerMessage::PersistentKeepAlive(peer_ref.clone(), our_index));
 
                 }
@@ -355,7 +355,7 @@ impl PeerServer {
             },
             Decision::Handshake(peer_ref) => {
                 debug!("kicking off handshake because there are pending outgoing packets");
-                self.send_handshake_init(peer_ref)?;
+                self.send_handshake_init(&peer_ref)?;
                 Ok(false)
             },
             Decision::Drop => {
diff --git a/src/router.rs b/src/router.rs
index dc6443e..85cc539 100644
--- a/src/router.rs
+++ b/src/router.rs
@@ -10,14 +10,16 @@ pub struct Router {
     ip6_map: IpLookupTable<Ipv6Addr, SharedPeer>,
 }
 
-impl Router {
-    pub fn new() -> Self {
+impl Default for Router {
+    fn default() -> Self {
         Self {
             ip4_map: IpLookupTable::new(),
             ip6_map: IpLookupTable::new(),
         }
     }
+}
 
+impl Router {
     pub fn add_allowed_ips(&mut self, allowed_ips: &[(IpAddr, u32)], peer: &SharedPeer) {
         for &(ip_addr, mask) in allowed_ips {
             self.add_allowed_ip(ip_addr, mask, peer.clone());
diff --git a/src/timer.rs b/src/timer.rs
index f96d1de..6f8a64a 100644
--- a/src/timer.rs
+++ b/src/timer.rs
@@ -18,13 +18,15 @@ pub struct Timer {
     rx: unsync::mpsc::Receiver<TimerMessage>,
 }
 
-impl Timer {
-    pub fn new() -> Self {
+impl Default for Timer {
+    fn default() -> Self {
         let (tx, rx) = unsync::mpsc::channel::<TimerMessage>(1024);
         let timer = tokio_timer::Timer::default();
         Self { timer, tx, rx }
     }
+}
 
+impl Timer {
     pub fn spawn_delayed(&mut self, handle: &Handle, delay: Duration, message: TimerMessage) {
         trace!("queuing timer message {:?}", &message);
         let timer = self.timer.sleep(delay);