fix pedantic clippies (#122)

* Fix a lot of pedantic clippy warnings
* Manual review and allow of possible truncations, wraps and los of sign
* Fix all pointer casting clippy warnings
* Make pedantic clippy the default

Author: andrewdavidmackenzie

Makefile

@@ -3,7 +3,7 @@ all: clippy run-tests build-docs
 
 .PHONY: clippy
 clippy:
-	cargo clippy --all --tests --all-targets --all-features -- -D warnings
+	cargo clippy --all --tests --all-targets --all-features -- --warn clippy::pedantic -D warnings
 
 .PHONY: configure-coverage
 configure-coverage:

src/libproc/file_info.rs

@@ -10,23 +10,23 @@ use self::libc::c_void;
 #[cfg(target_os = "macos")]
 use crate::osx_libproc_bindings::proc_pidfdinfo;
 
-/// Flavor of Pid FileDescriptor info for different types of File Descriptors
+/// Flavor of Pid `FileDescriptor` info for different types of File Descriptors
 pub enum PIDFDInfoFlavor {
-    /// VNode Info
+    /// `VNodeInfo`
     VNodeInfo = 1,
-    /// VNode Path Info
+    /// `VNodePathInfo`
     VNodePathInfo = 2,
-    /// Socket info
+    /// `SocketInfo`
     SocketInfo = 3,
-    /// PSEM Info
+    /// `PSEMInfo`
     PSEMInfo = 4,
-    /// PSHM Info
+    /// `PSHMInfo`
     PSHMInfo = 5,
-    /// Pipe Info
+    /// `PipeInfo`
     PipeInfo = 6,
-    /// KQueue Info
+    /// `KQueueInfo`
     KQueueInfo = 7,
-    /// Apple Talk Info
+    /// `AppleTalkInfo`
     ATalkInfo = 8,
 }
 
@@ -35,22 +35,24 @@ pub struct ListFDs;
 
 impl ListPIDInfo for ListFDs {
     type Item = ProcFDInfo;
-    fn flavor() -> PidInfoFlavor { PidInfoFlavor::ListFDs }
+    fn flavor() -> PidInfoFlavor {
+        PidInfoFlavor::ListFDs
+    }
 }
 
-/// Struct to hold info about a Processes FileDescriptor Info
+/// Struct to hold info about a Processes `FileDescriptor` Info
 #[repr(C)]
 pub struct ProcFDInfo {
-    /// File Descriptor
+    /// `FileDescriptor`
     pub proc_fd: i32,
-    /// File Descriptor type
+    /// `FileDescriptor` type
     pub proc_fdtype: u32,
 }
 
-/// Enum for different File Descriptor types
+/// Enum for different `FileDescriptor` types
 #[derive(Copy, Clone, Debug)]
 pub enum ProcFDType {
-    /// AppleTalk
+    /// `AppleTalk`
     ATalk = 0,
     /// Vnode
     VNode = 1,
@@ -64,8 +66,10 @@ pub enum ProcFDType {
     KQueue = 5,
     /// Pipe
     Pipe = 6,
-    /// FSEvents
+    /// `FSEvents`
     FSEvents = 7,
+    /// `NetPolicy`
+    NetPolicy = 9,
     /// Unknown
     Unknown,
 }
@@ -95,6 +99,10 @@ pub trait PIDFDInfo: Default {
 
 /// Returns the information about file descriptors of the process that match pid passed in.
 ///
+/// # Errors
+///
+/// Will return `Err`if the underlying Darwin method `proc_pidfdinfo` returns 0
+///
 /// # Examples
 ///
 /// ```
@@ -153,9 +161,11 @@ pub trait PIDFDInfo: Default {
 #[cfg(target_os = "macos")]
 pub fn pidfdinfo<T: PIDFDInfo>(pid: i32, fd: i32) -> Result<T, String> {
     let flavor = T::flavor() as i32;
+    // No `T` will have size greater than `i32::MAX` so no truncation
+    #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
     let buffer_size = mem::size_of::<T>() as i32;
     let mut pidinfo = T::default();
-    let buffer_ptr = &mut pidinfo as *mut _ as *mut c_void;
+    let buffer_ptr = std::ptr::from_mut::<T>(&mut pidinfo).cast::<c_void>();
     let ret: i32;
 
     unsafe {
@@ -184,23 +194,26 @@ mod test {
     use super::pidfdinfo;
 
     #[test]
+    #[allow(clippy::cast_possible_wrap)]
     fn pidfdinfo_test() {
-        use std::process;
         use std::net::TcpListener;
+        use std::process;
         let pid = process::id() as i32;
 
         let _listener = TcpListener::bind("127.0.0.1:65535");
 
         let info = pidinfo::<BSDInfo>(pid, 0).expect("pidinfo() failed");
-        let fds = listpidinfo::<ListFDs>(pid, info.pbi_nfiles as usize).expect("listpidinfo() failed");
+        let fds =
+            listpidinfo::<ListFDs>(pid, info.pbi_nfiles as usize).expect("listpidinfo() failed");
         for fd in fds {
             if let ProcFDType::Socket = fd.proc_fdtype.into() {
-                let socket = pidfdinfo::<SocketFDInfo>(pid, fd.proc_fd).expect("pidfdinfo() failed");
+                let socket =
+                    pidfdinfo::<SocketFDInfo>(pid, fd.proc_fd).expect("pidfdinfo() failed");
                 if let SocketInfoKind::Tcp = socket.psi.soi_kind.into() {
                     unsafe {
                         let info = socket.psi.soi_proto.pri_tcp;
                         assert_eq!(socket.psi.soi_protocol, libc::IPPROTO_TCP);
-                        assert_eq!(info.tcpsi_ini.insi_lport as u32, 65535);
+                        assert_eq!(info.tcpsi_ini.insi_lport, 65535);
                     }
                 }
             }

src/libproc/helpers.rs

@@ -4,7 +4,7 @@ use std::fs::File;
 #[cfg(any(target_os = "linux", target_os = "redox", target_os = "android"))]
 use std::io::{BufRead, BufReader};
 
-/// Helper function to get errno and return a String with the passed in return_code, the error
+/// Helper function to get errno and return a String with the passed in `return_code`, the error
 /// number and a possible message
 pub fn get_errno_with_message(return_code: i32) -> String {
     let e = errno();
@@ -19,26 +19,29 @@ pub fn check_errno(ret: i32, buf: &mut Vec<u8>) -> Result<String, String> {
     if ret <= 0 {
         Err(get_errno_with_message(ret))
     } else {
+        // `ret` mucg be greater than 0 here so no sign-loss
+        #[allow(clippy::cast_sign_loss)]
         unsafe {
             buf.set_len(ret as usize);
         }
 
-        match String::from_utf8(buf.to_vec()) {
+        match String::from_utf8(buf.clone()) {
             Ok(return_value) => Ok(return_value),
-            Err(e) => Err(format!("Invalid UTF-8 sequence: {e}"))
+            Err(e) => Err(format!("Invalid UTF-8 sequence: {e}")),
         }
     }
 }
 
 #[cfg(any(target_os = "linux", target_os = "redox", target_os = "android"))]
 /// A helper function for finding named fields in specific /proc FS files for processes
 /// This will be more useful when implementing more linux functions
-pub fn procfile_field(filename: &str, field_name: &str) -> Result<String, String> {
+pub(crate) fn procfile_field(filename: &str, field_name: &str) -> Result<String, String> {
     const SEPARATOR: &str = ":";
     let line_header = format!("{field_name}{SEPARATOR}");
 
     // Open the file in read-only mode (ignoring errors).
-    let file = File::open(filename).map_err(|_| format!("Could not open /proc file '{filename}'"))?;
+    let file =
+        File::open(filename).map_err(|_| format!("Could not open /proc file '{filename}'"))?;
     let reader = BufReader::new(file);
 
     // Read the file line by line using the lines() iterator from std::io::BufRead.
@@ -50,7 +53,9 @@ pub fn procfile_field(filename: &str, field_name: &str) -> Result<String, String
         }
     }
 
-    Err(format!("Could not find the field named '{field_name}' in the /proc FS file name '{filename}'"))
+    Err(format!(
+        "Could not find the field named '{field_name}' in the /proc FS file name '{filename}'"
+    ))
 }
 
 #[cfg(any(target_os = "linux", target_os = "redox", target_os = "android"))]
@@ -59,42 +64,43 @@ pub fn procfile_field(filename: &str, field_name: &str) -> Result<String, String
 pub fn parse_memory_string(line: &str) -> Result<u64, String> {
     let parts: Vec<&str> = line.trim().split(' ').collect();
     if parts.is_empty() {
-        return Err(format!("Could not parse Memory String: {line}"))
+        return Err(format!("Could not parse Memory String: {line}"));
     }
     let multiplier: u64 = if parts.len() == 2 {
-        match parts[1] {
-            "MB" => 1024 * 1024,
-            "kB" => 1024,
-            "B" => 1,
-            _ => return Err(format!("Could not parse units of Memory String: {line}"))
+        match parts.get(1) {
+            Some(&"MB") => 1024 * 1024,
+            Some(&"kB") => 1024,
+            Some(&"B") => 1,
+            _ => return Err(format!("Could not parse units of Memory String: {line}")),
         }
     } else {
         1
     };
 
-    let value:u64 = parts[0].parse()
+    let value: u64 = parts[0]
+        .parse()
         .map_err(|_| "Could not parse value as integer")?;
 
     Ok(value * multiplier)
 }
 
 #[cfg(test)]
 mod test {
-    use crate::errno::{set_errno, Errno};
     use super::check_errno;
+    use crate::errno::{set_errno, Errno};
 
     #[cfg(any(target_os = "linux", target_os = "redox", target_os = "android"))]
     mod linux {
         use crate::libproc::helpers::parse_memory_string;
 
         #[test]
         fn test_valid_memory_string() {
-            assert_eq!(parse_memory_string("220844 kB"), Ok(226144256));
+            assert_eq!(parse_memory_string("220844 kB"), Ok(226_144_256));
         }
 
         #[test]
         fn test_valid_memory_string_spaces() {
-            assert_eq!(parse_memory_string("  220844 kB  "), Ok(226144256));
+            assert_eq!(parse_memory_string("  220844 kB  "), Ok(226_144_256));
         }
 
         #[test]
@@ -109,17 +115,20 @@ mod test {
 
         #[test]
         fn test_invalid_memory_string_empty() {
-            assert!(parse_memory_string("gobble dee gook").is_err())
+            assert!(parse_memory_string("gobble dee gook").is_err());
         }
     }
 
     #[test]
     fn invalid_utf8() {
-        let mut buf: Vec<u8> = vec!(255, 0, 0);
+        let mut buf: Vec<u8> = vec![255, 0, 0];
 
-        // Test
+        // Test - small test buffer so no problem truncating
+        #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
         if let Err(msg) = check_errno(buf.len() as i32, &mut buf) {
-            assert!(msg.contains("Invalid UTF-8 sequence: invalid utf-8 sequence of 1 bytes from index 0"))
+            assert!(msg.contains(
+                "Invalid UTF-8 sequence: invalid utf-8 sequence of 1 bytes from index 0"
+            ));
         }
     }
 
@@ -128,15 +137,16 @@ mod test {
         let message = "custom message";
         let mut buf: Vec<u8> = Vec::from(message.as_bytes());
 
-        // Test
+        // Test - small test buffer so no problem truncating
+        #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
         if let Ok(msg) = check_errno(buf.len() as i32, &mut buf) {
             assert!(msg.contains(message));
         }
     }
 
     #[test]
     fn negative_ret() {
-        let mut buf: Vec<u8> = vec!();
+        let mut buf: Vec<u8> = vec![];
         set_errno(Errno(-1));
 
         // Test
@@ -147,12 +157,12 @@ mod test {
 
     #[test]
     fn zero_ret() {
-        let mut buf: Vec<u8> = vec!();
+        let mut buf: Vec<u8> = vec![];
         set_errno(Errno(2));
 
         // Test
         if let Err(mes) = check_errno(0, &mut buf) {
-            assert!(mes.contains("return code = 0, errno = 2"))
+            assert!(mes.contains("return code = 0, errno = 2"));
         }
     }
 }