Make clippy happy

Author: rklaehn

src/keylog.rs

@@ -60,6 +60,12 @@ impl KeyLogFile {
     }
 }
 
+impl Default for KeyLogFile {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl KeyLog for KeyLogFile {
     fn log(&self, label: &str, client_random: &[u8], secret: &[u8]) {
         match self

src/session.rs

@@ -85,8 +85,8 @@ pub struct NoiseConfig {
 impl ClientConfig for NoiseConfig {
     fn start_session(
         self: Arc<Self>,
-        version: u32,
-        server_name: &str,
+        _version: u32,
+        _server_name: &str,
         params: &TransportParameters,
     ) -> Result<Box<dyn Session>, ConnectError> {
         Ok(Box::new(NoiseConfig::start_session(
@@ -100,17 +100,17 @@ impl ClientConfig for NoiseConfig {
 impl ServerConfig for NoiseConfig {
     fn start_session(
         self: Arc<Self>,
-        version: u32,
+        _version: u32,
         params: &TransportParameters,
     ) -> Box<dyn Session> {
         Box::new(NoiseConfig::start_session(&self, Side::Server, params))
     }
 
     fn initial_keys(
         &self,
-        version: u32,
-        dst_cid: &ConnectionId,
-        side: Side,
+        _version: u32,
+        _dst_cid: &ConnectionId,
+        _side: Side,
     ) -> Result<Keys, quinn_proto::crypto::UnsupportedVersion> {
         Ok(Keys {
             header: header_keypair(),
@@ -121,7 +121,7 @@ impl ServerConfig for NoiseConfig {
         })
     }
 
-    fn retry_tag(&self, version: u32, orig_dst_cid: &ConnectionId, packet: &[u8]) -> [u8; 16] {
+    fn retry_tag(&self, _version: u32, orig_dst_cid: &ConnectionId, packet: &[u8]) -> [u8; 16] {
         let mut pseudo_packet = Vec::with_capacity(packet.len() + orig_dst_cid.len() + 1);
         pseudo_packet.push(orig_dst_cid.len() as u8);
         pseudo_packet.extend_from_slice(orig_dst_cid);
@@ -318,7 +318,7 @@ impl Session for NoiseSession {
                 }
                 let (remote_s, rest) = rest.split_at(32);
                 let mut s = [0; 32];
-                self.xoodyak.decrypt(&remote_s, &mut s);
+                self.xoodyak.decrypt(remote_s, &mut s);
                 let s = PublicKey::from_bytes(&s)
                     .map_err(|_| connection_refused("invalid static public key"))?;
                 self.remote_s = Some(s);
@@ -343,9 +343,8 @@ impl Session for NoiseSession {
                     .supported_protocols
                     .as_ref()
                     .expect("invalid config")
-                    .into_iter()
-                    .find(|proto| proto.as_slice() == alpn)
-                    .is_some();
+                    .iter()
+                    .any(|proto| proto.as_slice() == alpn);
                 if !is_supported {
                     return Err(connection_refused("unsupported alpn"));
                 }
@@ -356,11 +355,11 @@ impl Session for NoiseSession {
                 }
                 let (params, auth) = rest.split_at(rest.len() - 16);
                 let mut transport_parameters = vec![0; params.len()];
-                self.xoodyak.decrypt(&params, &mut transport_parameters);
+                self.xoodyak.decrypt(params, &mut transport_parameters);
                 // check tag
                 let mut tag = [0; 16];
                 self.xoodyak.squeeze(&mut tag);
-                if !bool::from(tag.ct_eq(&auth)) {
+                if !bool::from(tag.ct_eq(auth)) {
                     return Err(connection_refused("invalid authentication tag"));
                 }
                 self.remote_transport_parameters = Some(TransportParameters::read(
@@ -377,7 +376,7 @@ impl Session for NoiseSession {
                 }
                 let (remote_e, rest) = handshake.split_at(32);
                 let mut e = [0; 32];
-                self.xoodyak.decrypt(&remote_e, &mut e);
+                self.xoodyak.decrypt(remote_e, &mut e);
                 let e = PublicKey::from_bytes(&e)
                     .map_err(|_| connection_refused("invalid ephemeral public key"))?;
                 self.remote_e = Some(e);
@@ -393,11 +392,11 @@ impl Session for NoiseSession {
                 }
                 let (params, auth) = rest.split_at(rest.len() - 16);
                 let mut transport_parameters = vec![0; params.len()];
-                self.xoodyak.decrypt(&params, &mut transport_parameters);
+                self.xoodyak.decrypt(params, &mut transport_parameters);
                 // check tag
                 let mut tag = [0; 16];
                 self.xoodyak.squeeze(&mut tag);
-                if !bool::from(tag.ct_eq(&auth)) {
+                if !bool::from(tag.ct_eq(auth)) {
                     return Err(connection_refused("invalid authentication tag"));
                 }
                 self.remote_transport_parameters = Some(TransportParameters::read(