make clippy happy

ssrlive · ssrlive · commit b6b255d8b4b9 · 2025-07-30T14:10:45.000+08:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -26,7 +26,7 @@ tokio = { version = "1.45", default-features = false, features = [
 
 [dev-dependencies]
 clap = { version = "4.5", features = ["derive"] }
-criterion = { version = "0.6" } # Benchmarks
+criterion = { version = "0.7" } # Benchmarks
 dotenvy = "0.15"
 env_logger = "0.11"
 tokio = { version = "1.45", default-features = false, features = [
diff --git a/examples/tun.rs b/examples/tun.rs
@@ -111,7 +111,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 let mut s = match TcpStream::connect(server_addr).await {
                     Ok(s) => s,
                     Err(e) => {
-                        log::info!("connect TCP server failed \"{}\"", e);
+                        log::info!("connect TCP server failed \"{e}\"");
                         continue;
                     }
                 };
@@ -120,13 +120,13 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 log::info!("#{number1} TCP connecting, session count {c}");
                 tokio::spawn(async move {
                     if let Err(err) = tokio::io::copy_bidirectional(&mut tcp, &mut s).await {
-                        log::info!("#{number1} TCP error: {}", err);
+                        log::info!("#{number1} TCP error: {err}");
                     }
                     if let Err(e) = s.shutdown().await {
-                        log::info!("#{number1} TCP upstream shutdown error: {}", e);
+                        log::info!("#{number1} TCP upstream shutdown error: {e}");
                     }
                     if let Err(e) = tcp.shutdown().await {
-                        log::info!("#{number1} TCP stack stream shutdown error: {}", e);
+                        log::info!("#{number1} TCP stack stream shutdown error: {e}");
                     }
                     let c = count.fetch_sub(1, std::sync::atomic::Ordering::Relaxed) - 1;
                     log::info!("#{number1} TCP closed, session count {c}");
@@ -136,7 +136,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 let mut s = match UdpStream::connect(server_addr).await {
                     Ok(s) => s,
                     Err(e) => {
-                        log::info!("connect UDP server failed \"{}\"", e);
+                        log::info!("connect UDP server failed \"{e}\"");
                         continue;
                     }
                 };
@@ -145,11 +145,11 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 log::info!("#{number2} UDP connecting, session count {c}");
                 tokio::spawn(async move {
                     if let Err(err) = tokio::io::copy_bidirectional(&mut udp, &mut s).await {
-                        log::info!("#{number2} UDP error: {}", err);
+                        log::info!("#{number2} UDP error: {err}");
                     }
                     s.shutdown();
                     if let Err(e) = udp.shutdown().await {
-                        log::info!("#{number2} UDP stack stream shutdown error: {}", e);
+                        log::info!("#{number2} UDP stack stream shutdown error: {e}");
                     }
                     let c = count.fetch_sub(1, std::sync::atomic::Ordering::Relaxed) - 1;
                     log::info!("#{number2} UDP closed, session count {c}");
diff --git a/examples/tun_wintun.rs b/examples/tun_wintun.rs
@@ -57,7 +57,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 let mut s = match TcpStream::connect(server_addr).await {
                     Ok(s) => s,
                     Err(e) => {
-                        println!("connect TCP server failed \"{}\"", e);
+                        println!("connect TCP server failed \"{e}\"");
                         continue;
                     }
                 };
@@ -73,7 +73,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 let mut s = match UdpStream::connect(server_addr).await {
                     Ok(s) => s,
                     Err(e) => {
-                        println!("connect UDP server failed \"{}\"", e);
+                        println!("connect UDP server failed \"{e}\"");
                         continue;
                     }
                 };
diff --git a/src/lib.rs b/src/lib.rs
@@ -119,9 +119,9 @@ fn run<Device: AsyncRead + AsyncWrite + Unpin + Send + 'static>(
                     if let Err(e) = process_device_read(&buffer[offset..n], sessions.clone(), u, &config, &accept_sender).await {
                         let io_err: std::io::Error = e.into();
                         if io_err.kind() == std::io::ErrorKind::ConnectionRefused {
-                            log::trace!("Received junk data: {}", io_err);
+                            log::trace!("Received junk data: {io_err}");
                         } else {
-                            log::warn!("process_device_read error: {}", io_err);
+                            log::warn!("process_device_read error: {io_err}");
                         }
                     }
                 }
@@ -164,7 +164,7 @@ async fn process_device_read(
     match sessions.lock().await.entry(network_tuple) {
         std::collections::hash_map::Entry::Occupied(entry) => {
             let len = packet.payload.as_ref().map(|p| p.len()).unwrap_or(0);
-            log::trace!("packet sent to stream: {} len {}", network_tuple, len);
+            log::trace!("packet sent to stream: {network_tuple} len {len}");
             entry.get().send(packet).map_err(std::io::Error::other)?;
         }
         std::collections::hash_map::Entry::Vacant(entry) => {
@@ -173,12 +173,12 @@ async fn process_device_read(
             tokio::spawn(async move {
                 rx.await.ok();
                 sessions_clone.lock().await.remove(&network_tuple);
-                log::debug!("session destroyed: {}", network_tuple);
+                log::debug!("session destroyed: {network_tuple}");
             });
             let packet_sender = ip_stack_stream.stream_sender()?;
             accept_sender.send(ip_stack_stream)?;
             entry.insert(packet_sender);
-            log::debug!("session created: {}", network_tuple);
+            log::debug!("session created: {network_tuple}");
         }
     }
     Ok(())
diff --git a/src/stream/seqnum.rs b/src/stream/seqnum.rs
@@ -37,7 +37,7 @@ impl TryFrom<usize> for SeqNum {
         if value > u32::MAX as usize {
             return Err(std::io::Error::new(
                 std::io::ErrorKind::InvalidInput,
-                format!("value 0x{:X} is too large to convert to SeqNum", value),
+                format!("value 0x{value:X} is too large to convert to SeqNum"),
             ));
         }
         Ok(Self(value as u32))
diff --git a/src/stream/tcb.rs b/src/stream/tcb.rs
@@ -429,7 +429,7 @@ mod tests {
         for i in 0..MAX_RETRANSMIT_COUNT {
             // Simulate a timeout for the first packet
             let timeout = tcb.inflight_packets.values().next().unwrap().retransmit_timeout + std::time::Duration::from_millis(100);
-            println!("timeout: {:?}", timeout);
+            println!("timeout: {timeout:?}");
             std::thread::sleep(timeout);
 
             let packets = tcb.collect_timed_out_inflight_packets();
diff --git a/src/stream/tcp.rs b/src/stream/tcp.rs
@@ -105,10 +105,10 @@ impl IpStackTcpStream {
         if !tcp.syn {
             if !tcp.rst {
                 if let Err(err) = write_packet_to_device(&up_packet_sender, tuple, &tcb, ACK | RST, None, None) {
-                    log::warn!("Error sending RST/ACK packet: {:?}", err);
+                    log::warn!("Error sending RST/ACK packet: {err}");
                 }
             }
-            let info = format!("Invalid TCP packet: {} {}", tuple, tcp_header_fmt(&tcp));
+            let info = format!("Invalid TCP packet: {tuple} {}", tcp_header_fmt(&tcp));
             return Err(IpStackError::IoError(std::io::Error::new(ConnectionRefused, info)));
         }
 
@@ -538,7 +538,7 @@ async fn tcp_main_logic_loop(
 
         let (state, seq, ack) = { (tcb.get_state(), tcb.get_seq(), tcb.get_ack()) };
         let (info, len) = (tcp_header_fmt(tcp_header), payload.len());
-        let l_info = format!("local {{ seq: {}, ack: {} }}", seq, ack);
+        let l_info = format!("local {{ seq: {seq}, ack: {ack} }}");
         log::trace!("{network_tuple} {state:?}: {l_info} {info}, {pkt_type:?}, len = {len}");
         if pkt_type == PacketType::Invalid {
             continue;
diff --git a/src/stream/unknown.rs b/src/stream/unknown.rs
@@ -46,7 +46,7 @@ impl IpStackUnknownTransport {
             let packet = self.create_rev_packet(&mut payload)?;
             self.packet_sender
                 .send(packet)
-                .map_err(|e| std::io::Error::other(format!("send error: {}", e)))?;
+                .map_err(|e| std::io::Error::other(format!("send error: {e}")))?;
             if payload.is_empty() {
                 return Ok(());
             }

Original file line number	Diff line number	Diff line change
`@@ -119,9 +119,9 @@ fn run<Device: AsyncRead + AsyncWrite + Unpin + Send + 'static>(`
`119`	`119`	`if let Err(e) = process_device_read(&buffer[offset..n], sessions.clone(), u, &config, &accept_sender).await {`
`120`	`120`	`let io_err: std::io::Error = e.into();`
`121`	`121`	`if io_err.kind() == std::io::ErrorKind::ConnectionRefused {`
`122`		`- log::trace!("Received junk data: {}", io_err);`
	`122`	`+ log::trace!("Received junk data: {io_err}");`
`123`	`123`	`} else {`
`124`		`- log::warn!("process_device_read error: {}", io_err);`
	`124`	`+ log::warn!("process_device_read error: {io_err}");`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`	`}`
`@@ -164,7 +164,7 @@ async fn process_device_read(`
`164`	`164`	`match sessions.lock().await.entry(network_tuple) {`
`165`	`165`	`std::collections::hash_map::Entry::Occupied(entry) => {`
`166`	`166`	`let len = packet.payload.as_ref().map(\|p\| p.len()).unwrap_or(0);`
`167`		`- log::trace!("packet sent to stream: {} len {}", network_tuple, len);`
	`167`	`+ log::trace!("packet sent to stream: {network_tuple} len {len}");`
`168`	`168`	`entry.get().send(packet).map_err(std::io::Error::other)?;`
`169`	`169`	`}`
`170`	`170`	`std::collections::hash_map::Entry::Vacant(entry) => {`
`@@ -173,12 +173,12 @@ async fn process_device_read(`
`173`	`173`	`tokio::spawn(async move {`
`174`	`174`	`rx.await.ok();`
`175`	`175`	`sessions_clone.lock().await.remove(&network_tuple);`
`176`		`- log::debug!("session destroyed: {}", network_tuple);`
	`176`	`+ log::debug!("session destroyed: {network_tuple}");`
`177`	`177`	`});`
`178`	`178`	`let packet_sender = ip_stack_stream.stream_sender()?;`
`179`	`179`	`accept_sender.send(ip_stack_stream)?;`
`180`	`180`	`entry.insert(packet_sender);`
`181`		`- log::debug!("session created: {}", network_tuple);`
	`181`	`+ log::debug!("session created: {network_tuple}");`
`182`	`182`	`}`
`183`	`183`	`}`
`184`	`184`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ impl TryFrom<usize> for SeqNum {`
`37`	`37`	`if value > u32::MAX as usize {`
`38`	`38`	`return Err(std::io::Error::new(`
`39`	`39`	`std::io::ErrorKind::InvalidInput,`
`40`		`- format!("value 0x{:X} is too large to convert to SeqNum", value),`
	`40`	`+ format!("value 0x{value:X} is too large to convert to SeqNum"),`
`41`	`41`	`));`
`42`	`42`	`}`
`43`	`43`	`Ok(Self(value as u32))`
Original file line number	Diff line number	Diff line change
`@@ -105,10 +105,10 @@ impl IpStackTcpStream {`
`105`	`105`	`if !tcp.syn {`
`106`	`106`	`if !tcp.rst {`
`107`	`107`	`if let Err(err) = write_packet_to_device(&up_packet_sender, tuple, &tcb, ACK \| RST, None, None) {`
`108`		`- log::warn!("Error sending RST/ACK packet: {:?}", err);`
	`108`	`+ log::warn!("Error sending RST/ACK packet: {err}");`
`109`	`109`	`}`
`110`	`110`	`}`
`111`		`- let info = format!("Invalid TCP packet: {} {}", tuple, tcp_header_fmt(&tcp));`
	`111`	`+ let info = format!("Invalid TCP packet: {tuple} {}", tcp_header_fmt(&tcp));`
`112`	`112`	`return Err(IpStackError::IoError(std::io::Error::new(ConnectionRefused, info)));`
`113`	`113`	`}`
`114`	`114`
`@@ -538,7 +538,7 @@ async fn tcp_main_logic_loop(`
`538`	`538`
`539`	`539`	`let (state, seq, ack) = { (tcb.get_state(), tcb.get_seq(), tcb.get_ack()) };`
`540`	`540`	`let (info, len) = (tcp_header_fmt(tcp_header), payload.len());`
`541`		`- let l_info = format!("local {{ seq: {}, ack: {} }}", seq, ack);`
	`541`	`+ let l_info = format!("local {{ seq: {seq}, ack: {ack} }}");`
`542`	`542`	`log::trace!("{network_tuple} {state:?}: {l_info} {info}, {pkt_type:?}, len = {len}");`
`543`	`543`	`if pkt_type == PacketType::Invalid {`
`544`	`544`	`continue;`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ impl IpStackUnknownTransport {`
`46`	`46`	`let packet = self.create_rev_packet(&mut payload)?;`
`47`	`47`	`self.packet_sender`
`48`	`48`	`.send(packet)`
`49`		`- .map_err(\|e\| std::io::Error::other(format!("send error: {}", e)))?;`
	`49`	`+ .map_err(\|e\| std::io::Error::other(format!("send error: {e}")))?;`
`50`	`50`	`if payload.is_empty() {`
`51`	`51`	`return Ok(());`
`52`	`52`	`}`