make clippy happy

Author: ssrlive

examples/demo-client.rs

@@ -17,7 +17,7 @@ async fn main() -> Result<()> {
     // read http response
     let mut buf = vec![0; 1024];
     let n = stream.read(&mut buf).await?;
-    println!("read {} bytes", n);
+    println!("read {n} bytes");
     println!("{}", String::from_utf8_lossy(&buf[..n]));
 
     Ok(())

examples/dns-query.rs

@@ -75,7 +75,7 @@ async fn main() -> Result<()> {
     assert_eq!(&domain, &opt.domain);
 
     let addr = dns::extract_ipaddr_from_dns_message(&message)?;
-    println!("{}", addr);
+    println!("{addr}");
 
     Ok(())
 }
@@ -100,7 +100,7 @@ async fn dns_query_from_server(opt: &CmdOpt, msg_buf: &[u8]) -> Result<Vec<u8>>
             // read dns response
             let mut buf = vec![0; 1500];
             let n = tokio::time::timeout(timeout, stream.read(&mut buf)).await??;
-            log::trace!("read {} bytes", n);
+            log::trace!("read {n} bytes");
             buf.truncate(n);
             buf
         }

examples/echo-server.rs

@@ -25,21 +25,21 @@ async fn tcp_main<A: ToSocketAddrs>(addr: A, tcp_timeout: u64) -> std::io::Resul
         tokio::spawn(async move {
             let block = async move {
                 let mut buf = vec![0; 1024];
-                log::info!("[TCP] incoming peer {}", peer);
+                log::info!("[TCP] incoming peer {peer}");
                 loop {
                     let duration = std::time::Duration::from_secs(tcp_timeout);
                     let n = tokio::time::timeout(duration, socket.read(&mut buf)).await??;
                     if n == 0 {
-                        log::info!("[TCP] {} exit", peer);
+                        log::info!("[TCP] {peer} exit");
                         break;
                     }
                     let amt = socket.write(&buf[0..n]).await?;
-                    log::info!("[TCP] Echoed {}/{} bytes to {}", amt, n, peer);
+                    log::info!("[TCP] Echoed {amt}/{n} bytes to {peer}");
                 }
                 Ok::<(), std::io::Error>(())
             };
             if let Err(err) = block.await {
-                log::info!("[TCP] {}", err);
+                log::info!("[TCP] {err}");
             }
         });
     }
@@ -55,7 +55,7 @@ async fn udp_main<A: ToSocketAddrs>(addr: A) -> std::io::Result<()> {
     loop {
         if let Some((size, peer)) = to_send {
             let amt = socket.send_to(&buf[..size], &peer).await?;
-            log::info!("[UDP] Echoed {}/{} bytes to {}", amt, size, peer);
+            log::info!("[UDP] Echoed {amt}/{size} bytes to {peer}");
         }
 
         to_send = Some(socket.recv_from(&mut buf).await?);

examples/s5-server.rs

@@ -216,7 +216,7 @@ pub(crate) async fn handle_s5_upd_associate(associate: UdpAssociate<associate::N
                         }
                     },
                     _ = reply_listener.wait_until_closed() => {
-                        log::trace!("[UDP] {} listener closed", listen_addr);
+                        log::trace!("[UDP] {listen_addr} listener closed");
                         break Ok::<_, Error>(());
                     },
                 };

src/client/mod.rs

@@ -62,7 +62,7 @@ pub trait Socks5Reader: AsyncReadExt + Unpin {
         let value = self.read_u8().await?;
         match Reply::try_from(value)? {
             Reply::Succeeded => Ok(()),
-            reply => Err(format!("{}", reply).into()),
+            reply => Err(format!("{reply}").into()),
         }
     }
 
@@ -555,7 +555,7 @@ mod tests {
             Ok::<_, Error>(())
         };
         if let Err(e) = run_block.await {
-            println!("{:?}", e);
+            println!("{e:?}");
         }
     }
 

src/protocol/address.rs

@@ -21,7 +21,7 @@ pub enum AddressType {
 impl TryFrom<u8> for AddressType {
     type Error = std::io::Error;
     fn try_from(code: u8) -> core::result::Result<Self, Self::Error> {
-        let err = format!("Unsupported address type code {0:#x}", code);
+        let err = format!("Unsupported address type code {code:#x}");
         match code {
             0x01 => Ok(AddressType::IPv4),
             0x03 => Ok(AddressType::Domain),

src/protocol/command.rs

@@ -9,7 +9,7 @@ impl TryFrom<u8> for Command {
     type Error = std::io::Error;
 
     fn try_from(code: u8) -> std::result::Result<Self, Self::Error> {
-        let err = format!("Unsupported command code {0:#x}", code);
+        let err = format!("Unsupported command code {code:#x}");
         match code {
             0x01 => Ok(Command::Connect),
             0x02 => Ok(Command::Bind),

src/protocol/handshake/auth_method.rs

@@ -55,8 +55,8 @@ impl std::fmt::Display for AuthMethod {
             AuthMethod::NoAuth => write!(f, "NoAuth"),
             AuthMethod::GssApi => write!(f, "GssApi"),
             AuthMethod::UserPass => write!(f, "UserPass"),
-            AuthMethod::IanaReserved(value) => write!(f, "IanaReserved({0:#x})", value),
-            AuthMethod::Private(value) => write!(f, "Private({0:#x})", value),
+            AuthMethod::IanaReserved(value) => write!(f, "IanaReserved({value:#x})"),
+            AuthMethod::Private(value) => write!(f, "Private({value:#x})"),
             AuthMethod::NoAcceptableMethods => write!(f, "NoAcceptableMethods"),
         }
     }

src/protocol/handshake/password_method/mod.rs

@@ -26,7 +26,7 @@ impl std::fmt::Display for UserKey {
             (false, false) => {
                 let username = percent_encode(self.username.as_bytes(), NON_ALPHANUMERIC).to_string();
                 let password = percent_encode(self.password.as_bytes(), NON_ALPHANUMERIC).to_string();
-                write!(f, "{}:{}", username, password)
+                write!(f, "{username}:{password}")
             }
         }
     }

src/protocol/handshake/password_method/request.rs

@@ -33,7 +33,7 @@ impl StreamOperation for Request {
         let ver = ver[0];
 
         if ver != super::SUBNEGOTIATION_VERSION {
-            let err = format!("Unsupported sub-negotiation version {0:#x}", ver);
+            let err = format!("Unsupported sub-negotiation version {ver:#x}");
             return Err(std::io::Error::new(std::io::ErrorKind::Unsupported, err));
         }
 
@@ -82,7 +82,7 @@ impl AsyncStreamOperation for Request {
         let ver = r.read_u8().await?;
 
         if ver != super::SUBNEGOTIATION_VERSION {
-            let err = format!("Unsupported sub-negotiation version {0:#x}", ver);
+            let err = format!("Unsupported sub-negotiation version {ver:#x}");
             return Err(std::io::Error::new(std::io::ErrorKind::Unsupported, err));
         }