chore: clippy fix (#1695)

crates/shadowsocks-service/src/local/loadbalancing/ping_balancer.rs

@@ -875,10 +875,8 @@ impl PingChecker {
         let mut headers = [httparse::EMPTY_HEADER; 1];
         let mut response = httparse::Response::new(&mut headers);
 
-        if let Ok(..) = response.parse(&buf) {
-            if matches!(response.code, Some(204)) {
-                return Ok(());
-            }
+        if response.parse(&buf).is_ok() && matches!(response.code, Some(204)) {
+            return Ok(());
         }
 
         Err(Error::new(
@@ -916,10 +914,8 @@ impl PingChecker {
         let mut headers = [httparse::EMPTY_HEADER; 1];
         let mut response = httparse::Response::new(&mut headers);
 
-        if let Ok(..) = response.parse(&buf) {
-            if matches!(response.code, Some(200) | Some(204)) {
-                return Ok(());
-            }
+        if response.parse(&buf).is_ok() && matches!(response.code, Some(200) | Some(204)) {
+            return Ok(());
         }
 
         Err(Error::new(

crates/shadowsocks-service/src/local/loadbalancing/server_data.rs

@@ -53,7 +53,7 @@ impl ServerScore {
     pub async fn push_score_fetch_statistic(&self, score: Score) -> (u32, ServerStatData) {
         let (updated_score, data) = {
             let mut stat = self.stat_data.lock().await;
-            (stat.push_score(score), stat.data().clone())
+            (stat.push_score(score), *stat.data())
         };
         self.score.store(updated_score, Ordering::Release);
         (updated_score, data)
@@ -66,7 +66,7 @@ impl ServerScore {
 
     /// Get statistic data
     pub async fn stat_data(&self) -> ServerStatData {
-        self.stat_data.lock().await.data().clone()
+        *self.stat_data.lock().await.data()
     }
 }
 

crates/shadowsocks-service/src/local/loadbalancing/server_stat.rs

@@ -188,7 +188,7 @@ impl ServerStat {
                 // MAD
                 let mut vlat_abs_diff: Vec<u32> = vlat
                     .iter()
-                    .map(|s| (*s as i32 - self.data.latency_median as i32).abs() as u32)
+                    .map(|s| (*s as i32 - self.data.latency_median as i32).unsigned_abs())
                     .collect();
                 vlat_abs_diff.sort_unstable();
 

crates/shadowsocks-service/src/local/redir/udprelay/sys/unix/linux.rs

@@ -73,17 +73,9 @@ impl UdpRedirSocket {
         socket.set_reuse_address(true)?;
         if reuse_port {
             if let Err(err) = socket.set_reuse_port(true) {
-                if let Some(errno) = err.raw_os_error() {
-                    match errno {
-                        libc::ENOPROTOOPT => {
-                            // SO_REUSEPORT is supported after 3.9
-                            trace!("failed to set SO_REUSEPORT, error: {}", err);
-                        }
-                        _ => {
-                            error!("failed to set SO_REUSEPORT, error: {}", err);
-                            return Err(err);
-                        }
-                    }
+                if let Some(libc::ENOPROTOOPT) = err.raw_os_error() {
+                    // SO_REUSEPORT is supported after 3.9
+                    trace!("failed to set SO_REUSEPORT, error: {}", err);
                 } else {
                     error!("failed to set SO_REUSEPORT, error: {}", err);
                     return Err(err);

crates/shadowsocks-service/src/local/socks/server/mod.rs

@@ -114,8 +114,8 @@ impl SocksBuilder {
         let udp_associate_addr: ServerAddr = self
             .udp_associate_addr
             .as_ref()
-            .or_else(|| self.udp_bind_addr.as_ref())
-            .unwrap_or_else(|| &self.client_config)
+            .or(self.udp_bind_addr.as_ref())
+            .unwrap_or(&self.client_config)
             .clone();
 
         let mut udp_server = None;

crates/shadowsocks-service/src/local/tun/tcp.rs

@@ -169,7 +169,7 @@ impl AsyncRead for TcpConnection {
             return Poll::Pending;
         }
 
-        let recv_buf = unsafe { mem::transmute::<_, &mut [u8]>(buf.unfilled_mut()) };
+        let recv_buf = unsafe { mem::transmute::<&mut [mem::MaybeUninit<u8>], &mut [u8]>(buf.unfilled_mut()) };
         let n = control.recv_buffer.dequeue_slice(recv_buf);
         buf.advance(n);
 

crates/shadowsocks/src/context.rs

@@ -123,7 +123,6 @@ impl Context {
     }
 
     /// Resolves DNS address to `SocketAddr`s
-    #[allow(clippy::needless_lifetimes)]
     pub async fn dns_resolve<'a>(&self, addr: &'a str, port: u16) -> io::Result<impl Iterator<Item = SocketAddr> + 'a> {
         self.dns_resolver.resolve(addr, port).await
     }
@@ -143,7 +142,7 @@ impl Context {
         self.replay_policy = replay_policy;
     }
 
-    /// Get policy against replay attach
+    /// Get policy against replay attack
     pub fn replay_attack_policy(&self) -> ReplayAttackPolicy {
         self.replay_policy
     }

crates/shadowsocks/src/dns_resolver/resolver.rs

@@ -286,7 +286,6 @@ impl DnsResolver {
     }
 
     /// Resolve address into `SocketAddr`s
-    #[allow(clippy::needless_lifetimes)]
     pub async fn resolve<'a>(&self, addr: &'a str, port: u16) -> io::Result<impl Iterator<Item = SocketAddr> + 'a> {
         struct ResolverLogger<'x, 'y> {
             resolver: &'x DnsResolver,

crates/shadowsocks/src/relay/udprelay/compat.rs

@@ -171,16 +171,17 @@ impl<'a, S: DatagramSend + ?Sized> Future for SendReadyFut<'a, S> {
 /// Extension methods for `DatagramReceive`
 pub trait DatagramReceiveExt: DatagramReceive {
     /// Async method for `poll_recv`
-    fn recv<'a, 'b>(&'a self, buf: &'a mut [u8]) -> RecvFut<'a, Self> {
+    fn recv<'a>(&'a self, buf: &'a mut [u8]) -> RecvFut<'a, Self> {
         RecvFut { io: self, buf }
     }
 
     /// Async method for `poll_recv_from`
-    fn recv_from<'a, 'b>(&'a self, buf: &'a mut [u8]) -> RecvFromFut<'a, Self> {
+    fn recv_from<'a>(&'a self, buf: &'a mut [u8]) -> RecvFromFut<'a, Self> {
         RecvFromFut { io: self, buf }
     }
 
     /// Async method for `poll_recv_ready`
+    #[allow(clippy::needless_lifetimes)]
     fn recv_ready<'a>(&'a self) -> RecvReadyFut<'a, Self> {
         RecvReadyFut { io: self }
     }
@@ -201,6 +202,7 @@ pub trait DatagramSendExt: DatagramSend {
     }
 
     /// Async method for `poll_send_ready`
+    #[allow(clippy::needless_lifetimes)]
     fn send_ready<'a>(&'a self) -> SendReadyFut<'a, Self> {
         SendReadyFut { io: self }
     }

crates/shadowsocks/src/security/replay/mod.rs

@@ -17,7 +17,7 @@ use self::ppbloom::PingPongBloom;
 #[cfg(feature = "security-replay-attack-detect")]
 mod ppbloom;
 
-/// A Bloom Filter based protector against replay attach
+/// A Bloom Filter based protector against replay attack
 pub struct ReplayProtector {
     // Check for duplicated IV/Nonce, for prevent replay attack
     // https://github.com/shadowsocks/shadowsocks-org/issues/44

crates/shadowsocks/tests/udp.rs

@@ -125,7 +125,7 @@ async fn udp_tunnel_echo(
     let socket = UdpSocket::bind("0.0.0.0:0").await?;
     socket.connect(local_addr).await?;
 
-    static SEND_PAYLOAD: &[u8] = b"HELLO WORLD. \012345";
+    static SEND_PAYLOAD: &[u8] = b"HELLO WORLD. \x0012345";
     socket.send(SEND_PAYLOAD).await?;
 
     let mut buffer = [0u8; 65536];

tests/udp.rs

@@ -1,4 +1,3 @@
-#![cfg_attr(clippy, allow(blacklisted_name))]
 #![cfg(all(feature = "local", feature = "server"))]
 
 use std::net::SocketAddr;