Fix clippy warnings

jtt · jtt · commit 1078999517fe · 2025-12-23T13:12:55.000+02:00
Fix warnings produced by cargo clippy --all-targets
diff --git a/.github/workflows/rust_stable.yml b/.github/workflows/rust_stable.yml
@@ -21,5 +21,5 @@ jobs:
       - uses: sensorfu/setup-rust-action@v1
         with:
           components: clippy,rustfmt
-      - run: cargo clippy -- -D warnings
+      - run: cargo clippy -- -D warnings --all-targets
       - run: cargo fmt --all -- --check
diff --git a/luomu-common/src/addr_pair.rs b/luomu-common/src/addr_pair.rs
@@ -446,7 +446,9 @@ mod tests {
     }
 
     #[test]
-    #[should_panic]
+    #[should_panic(
+        expected = "IPPair::new() invalid IP address families provided. src: Source(192.0.2.5), dst: Destination(2001:db8:42::12:765)"
+    )]
     fn test_ip_pair_fail() {
         let ip1: IpAddr = "192.0.2.5".parse().unwrap();
         let ip2: IpAddr = "2001:db8:42::12:765".parse().unwrap();
diff --git a/luomu-common/src/ipaddr.rs b/luomu-common/src/ipaddr.rs
@@ -204,12 +204,12 @@ mod tests {
 
     // 0.0.0.0/32 "This host on this network" [RFC1122], Section 3.2.1.3
     // 0.0.0.0/8 "This network" [RFC791], Section 3.2
-    const V4_THIS_NETWORK: &[Ipv4Addr] = &[Ipv4Addr::new(0, 0, 0, 0), Ipv4Addr::new(0, 255, 255, 255)];
+    const V4_THIS_NETWORK: &[Ipv4Addr] = &[Ipv4Addr::UNSPECIFIED, Ipv4Addr::new(0, 255, 255, 255)];
 
     // 127.0.0.0/8 Loopback [RFC1122] Section 3.2.1.3
     const V4_LOOPBACKS: &[Ipv4Addr] = &[
         Ipv4Addr::new(127, 0, 0, 0),
-        Ipv4Addr::new(127, 0, 0, 1),
+        Ipv4Addr::LOCALHOST,
         Ipv4Addr::new(127, 255, 255, 255),
     ];
 
@@ -240,7 +240,7 @@ mod tests {
         Ipv4Addr::new(240, 0, 0, 0),
         Ipv4Addr::new(254, 255, 255, 255),
         Ipv4Addr::new(255, 0, 0, 0),
-        Ipv4Addr::new(255, 255, 255, 255),
+        Ipv4Addr::BROADCAST,
     ];
 
     // ::ffff:0:0/96 IPv4-mapped Address [RFC4291]
@@ -270,7 +270,7 @@ mod tests {
             .chain(V4_IETF_PROTOCOL_ASSIGNMENTS)
             .chain(V4_DOCUMENTATION)
             .chain(V4_RESERVED)
-            .cloned()
+            .copied()
     }
 
     fn yield_invalid_destination_ip4() -> impl Iterator<Item = Ipv4Addr> {
@@ -281,7 +281,7 @@ mod tests {
             .chain(V4_DOCUMENTATION)
             .chain(V4_RESERVED)
             .filter(|ip| **ip != Ipv4Addr::BROADCAST)
-            .cloned()
+            .copied()
     }
 
     fn yield_invalid_forwardable_ip4() -> impl Iterator<Item = Ipv4Addr> {
@@ -293,25 +293,25 @@ mod tests {
 
         // If the value of "Destination" is FALSE, the values of "Forwardable"
         // and "Globally Reachable" must also be false.
-        yield_invalid_destination_ip4().chain(OTHERS.iter().cloned())
+        yield_invalid_destination_ip4().chain(OTHERS.iter().copied())
     }
 
     fn yield_invalid_source_ip6() -> impl Iterator<Item = Ipv6Addr> {
         const OTHERS: &[Ipv6Addr] = &[Ipv6Addr::LOCALHOST];
 
-        V6_V4_MAPPED.iter().chain(V6_DOCUMENTATION).chain(OTHERS).cloned()
+        V6_V4_MAPPED.iter().chain(V6_DOCUMENTATION).chain(OTHERS).copied()
     }
 
     fn yield_invalid_destination_ip6() -> impl Iterator<Item = Ipv6Addr> {
         const OTHERS: &[Ipv6Addr] = &[Ipv6Addr::UNSPECIFIED, Ipv6Addr::LOCALHOST];
 
-        V6_V4_MAPPED.iter().chain(V6_DOCUMENTATION).chain(OTHERS).cloned()
+        V6_V4_MAPPED.iter().chain(V6_DOCUMENTATION).chain(OTHERS).copied()
     }
 
     fn yield_invalid_forwardable_ip6() -> impl Iterator<Item = Ipv6Addr> {
         // If the value of "Destination" is FALSE, the values of "Forwardable"
         // and "Globally Reachable" must also be false.
-        yield_invalid_destination_ip6().chain(V6_LINK_LOCAL_UNICAST.iter().cloned())
+        yield_invalid_destination_ip6().chain(V6_LINK_LOCAL_UNICAST.iter().copied())
     }
 
     fn yield_valid_ip4() -> impl Iterator<Item = Ipv4Addr> {
diff --git a/luomu-common/src/macaddr.rs b/luomu-common/src/macaddr.rs
@@ -305,7 +305,7 @@ mod tests {
     #[test]
     fn test_fmt_debug() {
         let mac: MacAddr = [0x00, 0xff, 0x11, 0xee, 0x22, 0xdd].into();
-        let debug = format!("{:?}", mac);
+        let debug = format!("{mac:?}");
         assert_eq!(&debug, "MacAddr(00:ff:11:ee:22:dd)");
     }
 
@@ -319,22 +319,22 @@ mod tests {
 
     #[test]
     fn test_try_from_u64_bounds() {
-        let i0 = 0x0000000000000000;
+        let i0 = 0x0000_0000_0000_0000;
         assert!(MacAddr::try_from(i0).is_ok());
 
-        let i1 = 0x0000FFFFFFFFFFFF;
+        let i1 = 0x0000_FFFF_FFFF_FFFF;
         assert!(MacAddr::try_from(i1).is_ok());
 
-        let i2 = 0x0001000000000000;
+        let i2 = 0x0001_0000_0000_0000;
         assert!(MacAddr::try_from(i2).is_err());
 
-        let i3 = 0xFFFFFFFFFFFFFFFF;
+        let i3 = 0xFFFF_FFFF_FFFF_FFFF;
         assert!(MacAddr::try_from(i3).is_err());
     }
 
     #[test]
     fn test_try_from_u64_byteoder() {
-        let i = 0x0000123456789ABC;
+        let i = 0x0000_1234_5678_9ABC;
         let mac = MacAddr::try_from(i).unwrap();
         let b: [u8; 6] = mac.as_array();
         assert_eq!(&b, &[0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC]);
@@ -429,7 +429,7 @@ mod tests {
         addr2.push_tag(1337).unwrap();
         addr3.push_tag(42).unwrap();
 
-        let mut v = vec![addr1, addr2, addr3];
+        let mut v = [addr1, addr2, addr3];
         v.sort();
 
         assert_eq!(v[0], addr3);
diff --git a/luomu-common/src/tagged_macaddr.rs b/luomu-common/src/tagged_macaddr.rs
@@ -209,7 +209,7 @@ mod tests {
         let mac: MacAddr = "11:22:33:AA:BB:CC".parse().unwrap();
         let tagged_mac: TaggedMacAddr = mac.into();
 
-        assert_eq!(tagged_mac.mac().is_unspecified(), false);
+        assert!(!tagged_mac.mac().is_unspecified());
     }
 
     #[test]
diff --git a/luomu-getifaddrs/examples/interfaces.rs b/luomu-getifaddrs/examples/interfaces.rs
@@ -1,8 +1,6 @@
 //! List all interfaces and their information
 
 fn main() -> std::io::Result<()> {
-    luomu_getifaddrs::getifaddrs()?
-        .into_iter()
-        .for_each(|ifaddr| println!("{:#?}", ifaddr.ifaddress()));
+    luomu_getifaddrs::getifaddrs()?.for_each(|ifaddr| println!("{:#?}", ifaddr.ifaddress()));
     Ok(())
 }
diff --git a/luomu-getifaddrs/examples/ipaddresses.rs b/luomu-getifaddrs/examples/ipaddresses.rs
@@ -17,7 +17,7 @@ fn main() -> std::io::Result<()> {
             .collect::<Box<[String]>>()
             .join(", ");
 
-        println!("{name}: {addrs_text}")
+        println!("{name}: {addrs_text}");
     }
 
     Ok(())
diff --git a/luomu-libpcap/examples/capture.rs b/luomu-libpcap/examples/capture.rs
@@ -1,6 +1,6 @@
 #![allow(missing_docs)]
-
 use luomu_libpcap::{Packet, Pcap, Result};
+use std::fmt::Write;
 
 fn main() -> Result<()> {
     tracing_subscriber::fmt::init();
@@ -26,20 +26,21 @@ fn main() -> Result<()> {
                 if i % 32 == 0 {
                     hex.push('\n');
                 }
-                hex.push_str(&format!("{:02x}", packet[i]));
+                let _ = write!(hex, "{:02x}", packet[i]);
             }
             count += 1;
-            println!("{}", hex);
+            println!("{hex}");
             hex.clear();
-            if count % 100 == 0 && count != 0 {
-                if let Ok(stats) = pcap.stats() {
-                    println!(
-                        "\nStats: received: {} packets, dropped: {} packets, dropped on interface {} packets",
-                        stats.packets_received(),
-                        stats.packets_dropped(),
-                        stats.packets_dropped_interface()
-                    );
-                }
+            if count % 100 == 0
+                && count != 0
+                && let Ok(stats) = pcap.stats()
+            {
+                println!(
+                    "\nStats: received: {} packets, dropped: {} packets, dropped on interface {} packets",
+                    stats.packets_received(),
+                    stats.packets_dropped(),
+                    stats.packets_dropped_interface()
+                );
             }
         }
     }
diff --git a/luomu-libpcap/examples/list-ifs.rs b/luomu-libpcap/examples/list-ifs.rs
@@ -7,7 +7,7 @@ fn main() -> Result<()> {
 
     let pcap_ifs = PcapIfT::new()?;
     for interface in pcap_ifs.get_interfaces() {
-        println!("{:#?}", interface);
+        println!("{interface:#?}");
     }
 
     Ok(())
diff --git a/luomu-libpcap/examples/offline.rs b/luomu-libpcap/examples/offline.rs
@@ -1,18 +1,16 @@
 #![allow(missing_docs)]
 
 use std::env;
+use std::fmt::Write;
 
 use luomu_libpcap::{Packet, Pcap};
 
 fn main() {
     tracing_subscriber::fmt::init();
 
-    let fname = match env::args().nth(1) {
-        None => {
-            tracing::error!("No PCAP file name given");
-            return;
-        }
-        Some(n) => n,
+    let Some(fname) = env::args().nth(1) else {
+        tracing::error!("No PCAP file name given");
+        return;
     };
 
     let pcap = Pcap::offline(&fname).unwrap();
@@ -26,7 +24,7 @@ fn main() {
             if i % 32 == 0 {
                 hex.push('\n');
             }
-            hex.push_str(&format!("{:02x}", packet[i]));
+            let _ = write!(hex, "{:02x}", packet[i]);
         }
         println!("Packet {} ({} bytes): {}", count + 1, packet.len(), hex);
     }
diff --git a/luomu-libpcap/examples/tokio-capture.rs b/luomu-libpcap/examples/tokio-capture.rs
@@ -36,7 +36,7 @@ async fn capture(interface: &'static str) -> Result<()> {
 async fn ticker() {
     let mut counter = 0;
     loop {
-        println!("tick {}", counter);
+        println!("tick {counter}");
         counter += 1;
         tokio::time::sleep(Duration::from_secs(1)).await;
     }
diff --git a/luomu-libpcap/src/packet.rs b/luomu-libpcap/src/packet.rs
@@ -160,12 +160,18 @@ mod tests {
     };
     const PKTHDR: pcap_pkthdr = pcap_pkthdr {
         ts: TS,
+        #[allow(clippy::cast_possible_truncation)]
         caplen: LEN as u32,
+        #[allow(clippy::cast_possible_truncation)]
         len: LEN as u32,
     };
 
     fn timestamp() -> SystemTime {
-        SystemTime::UNIX_EPOCH + Duration::new(TS.tv_sec as u64, 1000 * TS.tv_usec as u32)
+        SystemTime::UNIX_EPOCH
+            + Duration::new(
+                TS.tv_sec as u64,
+                1000 * u32::try_from(TS.tv_usec).expect("usec value too large"),
+            )
     }
 
     fn borrowed_packet() -> BorrowedPacket {
diff --git a/luomu-libpcap/src/tokio.rs b/luomu-libpcap/src/tokio.rs
@@ -48,10 +48,11 @@ impl Stream for AsyncCapture {
     }
 }
 
+#[allow(clippy::needless_pass_by_value)]
 fn capture_loop(pcap: crate::Pcap, tx: UnboundedSender<crate::Result<OwnedPacket>>) {
     loop {
         match next_packet(&pcap) {
-            Poll::Pending => continue,
+            Poll::Pending => (),
             Poll::Ready(ret) => {
                 let is_err = ret.is_err();
                 if tx.send(ret).is_err() {
diff --git a/luomu-libpcap/tests/pcap-interfaces.rs b/luomu-libpcap/tests/pcap-interfaces.rs
@@ -31,9 +31,8 @@ fn test_compile_pcap_filter() -> Result<()> {
 }
 
 #[test]
-fn test_compile_invalid_pcap_filter() -> Result<()> {
+fn test_compile_invalid_pcap_filter() {
     let filter = "foo";
     let res = PcapFilter::compile(filter);
     assert!(res.is_err());
-    Ok(())
 }
diff --git a/luomu-tpacketv3/examples/demo.rs b/luomu-tpacketv3/examples/demo.rs
@@ -10,19 +10,17 @@ mod linux {
     use std::thread;
     use std::time::Duration;
 
+    #[allow(clippy::needless_pass_by_value)]
     fn packet_consumer(ch: mpsc::Receiver<Vec<u8>>, stop: Arc<AtomicBool>) {
         let mut pkt_count = 0;
         while !stop.load(std::sync::atomic::Ordering::SeqCst) {
             match ch.recv_timeout(std::time::Duration::from_secs(1)) {
-                Err(e) => match e {
-                    mpsc::RecvTimeoutError::Timeout => {
-                        continue;
-                    }
-                    _ => {
+                Err(e) => {
+                    if e != mpsc::RecvTimeoutError::Timeout {
                         tracing::warn!("Channel closed, stopping");
                         break;
                     }
-                },
+                }
                 Ok(_) => pkt_count += 1,
             }
         }
@@ -35,6 +33,7 @@ mod linux {
         }
     }
 
+    #[allow(clippy::needless_pass_by_value)]
     fn packet_producer(mut reader: tpacketv3::Reader<'_>, ch: mpsc::Sender<Vec<u8>>, stop: Arc<AtomicBool>) {
         let mut false_wakes: u128 = 0;
         let mut wakes: u128 = 0;
@@ -196,7 +195,7 @@ mod linux {
             let p_ifname = ifname.clone();
             producers.push(
                 thread::Builder::new()
-                    .name(format!("producer-{}-{}", p_ifname, i))
+                    .name(format!("producer-{p_ifname}-{i}"))
                     .spawn(move || worker(p, &p_ifname, tx_chan, flag))
                     .unwrap(),
             );
@@ -215,10 +214,10 @@ mod linux {
 
 #[cfg(target_os = "linux")]
 fn main() {
-    linux::main()
+    linux::main();
 }
 
 #[cfg(not(target_os = "linux"))]
 fn main() {
-    println!("tpacket only available on linux")
+    println!("tpacket only available on linux");
 }

Original file line number	Diff line number	Diff line change
`@@ -209,7 +209,7 @@ mod tests {`
`209`	`209`	`let mac: MacAddr = "11:22:33:AA:BB:CC".parse().unwrap();`
`210`	`210`	`let tagged_mac: TaggedMacAddr = mac.into();`
`211`	`211`
`212`		`- assert_eq!(tagged_mac.mac().is_unspecified(), false);`
	`212`	`+ assert!(!tagged_mac.mac().is_unspecified());`
`213`	`213`	`}`
`214`	`214`
`215`	`215`	`#[test]`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,6 @@`
`1`	`1`	`//! List all interfaces and their information`
`2`	`2`
`3`	`3`	`fn main() -> std::io::Result<()> {`
`4`		`- luomu_getifaddrs::getifaddrs()?`
`5`		`- .into_iter()`
`6`		`- .for_each(\|ifaddr\| println!("{:#?}", ifaddr.ifaddress()));`
	`4`	`+ luomu_getifaddrs::getifaddrs()?.for_each(\|ifaddr\| println!("{:#?}", ifaddr.ifaddress()));`
`7`	`5`	`Ok(())`
`8`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ fn main() -> std::io::Result<()> {`
`17`	`17`	`.collect::<Box<[String]>>()`
`18`	`18`	`.join(", ");`
`19`	`19`
`20`		`- println!("{name}: {addrs_text}")`
	`20`	`+ println!("{name}: {addrs_text}");`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ fn main() -> Result<()> {`
`7`	`7`
`8`	`8`	`let pcap_ifs = PcapIfT::new()?;`
`9`	`9`	`for interface in pcap_ifs.get_interfaces() {`
`10`		`- println!("{:#?}", interface);`
	`10`	`+ println!("{interface:#?}");`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`Ok(())`