refactor(clippy): fix warnings

Author: kurnevsky

examples/echo.rs

@@ -104,8 +104,6 @@ async fn main() -> Result<(), Error> {
     net_crypto.set_tcp_sink(net_crypto_tcp_tx).await;
 
     let friend_connections = FriendConnections::new(
-        real_sk,
-        real_pk,
         dht_server.clone(),
         tcp_connections.clone(),
         onion_client.clone(),

tox_core/src/dht/kbucket.rs

@@ -249,7 +249,7 @@ where
                 if self.is_full() {
                     debug!(target: "Kbucket",
                         "No free space left in the kbucket, the last (bad) node removed.");
-                    let eviction_index = Node::eviction_index(&self.nodes).unwrap_or_else(|| self.nodes.len() - 1);
+                    let eviction_index = Node::eviction_index(&self.nodes).unwrap_or(self.nodes.len() - 1);
                     self.nodes.remove(eviction_index);
                     let index = index - if eviction_index < index { 1 } else { 0 };
                     self.nodes.insert(index, new_node.into());

tox_core/src/dht/server/mod.rs

@@ -71,14 +71,16 @@ pub const PRECOMPUTED_LRU_CACHE_SIZE: usize = KBUCKET_DEFAULT_SIZE as usize * KB
 /// How often DHT main loop should be called.
 const MAIN_LOOP_INTERVAL: u64 = 1;
 
+type MotdCallback = dyn Fn(&Server) -> Vec<u8> + Send + Sync;
+
 /// Struct that contains necessary data for `BootstrapInfo` packet.
 #[derive(Clone)]
 struct ServerBootstrapInfo {
     /// Version of tox core which will be sent with `BootstrapInfo` packet.
     version: u32,
     /// Callback to get the message of the day which will be sent with
     /// `BootstrapInfo` packet.
-    motd_cb: Arc<dyn Fn(&Server) -> Vec<u8> + Send + Sync>,
+    motd_cb: Arc<MotdCallback>,
 }
 
 /// DHT server state.
@@ -1358,7 +1360,7 @@ impl Server {
     }
 
     /// Set toxcore version and message of the day callback.
-    pub fn set_bootstrap_info(&mut self, version: u32, motd_cb: Box<dyn Fn(&Server) -> Vec<u8> + Send + Sync>) {
+    pub fn set_bootstrap_info(&mut self, version: u32, motd_cb: Box<MotdCallback>) {
         self.bootstrap_info = Some(ServerBootstrapInfo {
             version,
             motd_cb: motd_cb.into(),

tox_core/src/friend_connection/mod.rs

@@ -90,10 +90,6 @@ impl Friend {
 /// Friend connections module that handles friends and their connections.
 #[derive(Clone)]
 pub struct FriendConnections {
-    /// Our long term `SecretKey`.
-    real_sk: SecretKey,
-    /// Our long term `PublicKey`.
-    real_pk: PublicKey,
     /// List of friends we want to be connected to.
     friends: Arc<RwLock<HashMap<PublicKey, Friend>>>,
     /// Sink to send a connection status when it becomes connected or
@@ -112,16 +108,12 @@ pub struct FriendConnections {
 impl FriendConnections {
     /// Create new `FriendConnections`.
     pub fn new(
-        real_sk: SecretKey,
-        real_pk: PublicKey,
         dht: DhtServer,
         tcp_connections: TcpConnections,
         onion_client: OnionClient,
         net_crypto: NetCrypto,
     ) -> Self {
         FriendConnections {
-            real_sk,
-            real_pk,
             friends: Arc::new(RwLock::new(HashMap::new())),
             connection_status_tx: Arc::new(RwLock::new(None)),
             dht,
@@ -450,13 +442,11 @@ mod tests {
             lossy_tx,
             dht_pk,
             dht_sk,
-            real_pk: real_pk.clone(),
-            real_sk: real_sk.clone(),
+            real_pk,
+            real_sk,
             precomputed_keys,
         });
         let friend_connections = FriendConnections::new(
-            real_sk,
-            real_pk,
             dht,
             tcp_connections,
             onion_client,
@@ -961,7 +951,7 @@ mod tests {
         let run_future = friend_connections.run()
             .map(Result::unwrap);
 
-        let precomputed_key = SalsaBox::new(&friend_connections.real_pk, &friend_sk);
+        let precomputed_key = SalsaBox::new(friend_connections.net_crypto.real_pk(), &friend_sk);
         let cookie = friend_connections.net_crypto.get_cookie(&mut rng, friend_pk.clone(), friend_dht_pk);
         let sent_nonce = SalsaBox::generate_nonce(&mut rng).into();
         let friend_session_sk = SecretKey::generate(&mut rng);

tox_core/src/net_crypto/crypto_connection.rs

@@ -228,7 +228,7 @@ impl RecvPacket {
 }
 
 /// UDP address of a connection with the time when last UDP packet was received
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct ConnectionAddr<T: Into<SocketAddr> + Copy> {
     /// Address to send UDP packets directly to the peer
     pub addr: T,

tox_core/src/net_crypto/mod.rs

@@ -1135,6 +1135,10 @@ mod tests {
     use crypto_box::{SalsaBox, aead::{AeadCore, generic_array::typenum::marker_traits::Unsigned}};
 
     impl NetCrypto {
+        pub fn real_pk(&self) -> &PublicKey {
+            &self.real_pk
+        }
+
         pub async fn has_friend(&self, pk: &PublicKey) -> bool {
             self.friends.read().await.contains(pk)
         }

tox_core/src/relay/client/client.rs

@@ -28,7 +28,7 @@ const CLIENT_CHANNEL_SIZE: usize = 2;
 
 /// Packet that can be received from a TCP relay and should be handled outside
 /// of connections module.
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub enum IncomingPacket {
     /// Data packet with sender's `PublicKey`.
     Data(PublicKey, DataPayload),

tox_core/src/relay/handshake/mod.rs

@@ -33,7 +33,7 @@ pub fn create_client_handshake(client_pk: &PublicKey,
 
     let common_key = SalsaBox::new(server_pk, client_sk);
     let nonce = SalsaBox::generate_nonce(&mut rand::thread_rng());
-    let encrypted_payload = common_key.encrypt(&nonce, &serialized_payload[..]).unwrap();
+    let encrypted_payload = common_key.encrypt(&nonce, &*serialized_payload).unwrap();
 
     let handshake = ClientHandshake {
         pk: client_pk.clone(),
@@ -70,7 +70,7 @@ pub fn handle_client_handshake(server_sk: &SecretKey,
     let (serialized_payload, _) = server_payload.to_bytes((&mut serialized_payload, 0)).unwrap();
 
     let nonce = SalsaBox::generate_nonce(&mut rand::thread_rng());
-    let server_encrypted_payload = common_key.encrypt(&nonce, &serialized_payload[..]).unwrap();
+    let server_encrypted_payload = common_key.encrypt(&nonce, &*serialized_payload).unwrap();
 
     let server_handshake = ServerHandshake {
         nonce: nonce.into(),

tox_core/src/relay/handshake/packet.rs

@@ -21,7 +21,7 @@ Length  | Contents
 
 */
 
-#[derive(PartialEq, Debug, Clone)]
+#[derive(PartialEq, Eq, Debug, Clone)]
 pub struct ClientHandshake {
     /// Client's Public Key
     pub pk: PublicKey,
@@ -68,7 +68,7 @@ Length  | Contents
 
 */
 
-#[derive(PartialEq, Debug, Clone)]
+#[derive(PartialEq, Eq, Debug, Clone)]
 pub struct ServerHandshake {
     /// Nonce of the encrypted payload
     pub nonce: Nonce,

tox_core/src/relay/links.rs

@@ -9,7 +9,7 @@ use std::collections::HashMap;
 pub const MAX_LINKS_N: u8 = 240;
 
 /// The status of the Link
-#[derive(Debug, PartialEq, Clone, Copy)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum LinkStatus {
     /// The link is registered on one side only.
     ///