Cleanup path parameters (#3526)

* Cleanup all paths

* fix

* Cargo update

Author: domenukk

Cargo.lock

@@ -1,6 +1,6 @@
 //! `LibAFL` functionality for filesystem interaction
 
-use alloc::{borrow::ToOwned, string::String, sync::Arc, vec::Vec};
+use alloc::{string::String, sync::Arc, vec::Vec};
 use core::{
     sync::atomic::{AtomicU64, Ordering},
     time::Duration,
@@ -44,23 +44,21 @@ pub fn write_file_atomic<P>(path: P, bytes: &[u8]) -> Result<(), Error>
 where
     P: AsRef<Path>,
 {
-    fn inner(path: &Path, bytes: &[u8]) -> Result<(), Error> {
-        let mut tmpfile_name = path.to_path_buf();
-        tmpfile_name.set_file_name(format!(
-            ".{}.tmp",
-            tmpfile_name.file_name().unwrap().to_string_lossy()
-        ));
-
-        let mut tmpfile = OpenOptions::new()
-            .write(true)
-            .create_new(true)
-            .open(&tmpfile_name)?;
-
-        tmpfile.write_all(bytes)?;
-        fs::rename(&tmpfile_name, path)?;
-        Ok(())
-    }
-    inner(path.as_ref(), bytes)
+    let path = path.as_ref();
+    let mut tmpfile_name = path.to_path_buf();
+    tmpfile_name.set_file_name(format!(
+        ".{}.tmp",
+        tmpfile_name.file_name().unwrap().to_string_lossy()
+    ));
+
+    let mut tmpfile = OpenOptions::new()
+        .write(true)
+        .create_new(true)
+        .open(&tmpfile_name)?;
+
+    tmpfile.write_all(bytes)?;
+    fs::rename(&tmpfile_name, path)?;
+    Ok(())
 }
 
 /// An [`InputFile`] to write fuzzer input to.
@@ -99,16 +97,17 @@ impl InputFile {
     /// Creates a new [`InputFile`], or truncates if it already exists
     pub fn create<P>(filename: P) -> Result<Self, Error>
     where
-        P: AsRef<Path>,
+        P: Into<PathBuf>,
     {
+        let filename = filename.into();
         let f = OpenOptions::new()
             .create(true)
             .read(true)
             .write(true)
             .truncate(true)
             .open(&filename)?;
         Ok(Self {
-            path: filename.as_ref().to_owned(),
+            path: filename,
             file: f,
             rc: Arc::new(()),
         })
@@ -145,11 +144,11 @@ impl InputFile {
 /// This method works recursively.
 /// If `last` is `None`, it'll load all file.
 pub fn find_new_files_rec<P: AsRef<Path>>(
-    dir: P,
+    dir_path: P,
     last_check: &Option<Duration>,
 ) -> Result<Vec<PathBuf>, Error> {
     let mut new_files = Vec::<PathBuf>::new();
-    for entry in fs::read_dir(dir)? {
+    for entry in fs::read_dir(dir_path)? {
         let entry = entry?;
         let path = entry.path();
         let attributes = fs::metadata(&path);

crates/libafl_bolts/src/fs.rs

@@ -3,7 +3,7 @@
 use alloc::{borrow::ToOwned, vec::Vec};
 use std::{
     ffi::{OsStr, OsString},
-    path::Path,
+    path::PathBuf,
 };
 
 use crate::fs::{InputFile, get_unique_std_input_file};
@@ -120,14 +120,14 @@ pub trait StdTargetArgs: Sized {
     /// Note: If you use this, you should ensure that there is only one instance using this
     /// file at any given time.
     #[must_use]
-    fn arg_input_file<P: AsRef<Path>>(self, path: P) -> Self {
-        let mut moved = self.arg(path.as_ref());
+    fn arg_input_file<P: Into<PathBuf>>(self, path: P) -> Self {
+        let path = path.into();
+        let mut moved = self.arg(&path);
         assert!(
             match &moved.inner().input_location {
-                InputLocation::File { out_file } => out_file.path.as_path() == path.as_ref(),
-                InputLocation::StdIn { input_file } => input_file
-                    .as_ref()
-                    .is_none_or(|of| of.path.as_path() == path.as_ref()),
+                InputLocation::File { out_file } => out_file.path == path,
+                InputLocation::StdIn { input_file } =>
+                    input_file.as_ref().is_none_or(|of| of.path == path),
                 InputLocation::Arg { argnum: _ } => false,
             },
             "Already specified an input file under a different name. This is not supported"

crates/libafl_bolts/src/target_args.rs

@@ -1,7 +1,7 @@
 //! Generates `DrCov` traces
 use alloc::rc::Rc;
 use core::hash::{BuildHasher, Hasher};
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 
 use ahash::RandomState;
 use frida_gum::ModuleMap;
@@ -78,9 +78,9 @@ impl DrCovRuntime {
     }
 
     /// Create a new [`DrCovRuntime`] that writes coverage to the specified directory
-    pub fn with_path<P: AsRef<Path>>(path: P) -> Self {
+    pub fn with_path<P: Into<PathBuf>>(path: P) -> Self {
         Self {
-            coverage_directory: path.as_ref().into(),
+            coverage_directory: path.into(),
             ..Self::default()
         }
     }

crates/libafl_frida/src/drcov_rt.rs

@@ -2,7 +2,7 @@ use core::{
     fmt,
     fmt::{Display, Formatter},
 };
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 
 use getset::Getters;
 use libafl_derive;
@@ -228,11 +228,9 @@ impl Display for Bios {
 }
 
 #[cfg(feature = "systemmode")]
-impl<R: AsRef<Path>> From<R> for Bios {
-    fn from(path: R) -> Self {
-        Self {
-            path: path.as_ref().to_path_buf(),
-        }
+impl<P: Into<Path>> From<P> for Bios {
+    fn from(path: P) -> Self {
+        Self { path: path.into() }
     }
 }
 
@@ -250,11 +248,9 @@ impl Display for Kernel {
 }
 
 #[cfg(feature = "systemmode")]
-impl<R: AsRef<Path>> From<R> for Kernel {
-    fn from(path: R) -> Self {
-        Self {
-            path: path.as_ref().to_path_buf(),
-        }
+impl<P: Into<PathBuf>> From<P> for Kernel {
+    fn from(path: P) -> Self {
+        Self { path: path.into() }
     }
 }
 
@@ -294,11 +290,9 @@ impl Display for InitRD {
 }
 
 #[cfg(feature = "systemmode")]
-impl<R: AsRef<Path>> From<R> for InitRD {
-    fn from(path: R) -> Self {
-        Self {
-            path: path.as_ref().to_path_buf(),
-        }
+impl<P: Into<PathBuf>> From<P> for InitRD {
+    fn from(path: P) -> Self {
+        Self { path: path.into() }
     }
 }
 
@@ -313,11 +307,9 @@ impl Display for LoadVM {
     }
 }
 
-impl<R: AsRef<Path>> From<R> for LoadVM {
-    fn from(path: R) -> Self {
-        Self {
-            path: path.as_ref().to_path_buf(),
-        }
+impl<P: Into<PathBuf>> From<P> for LoadVM {
+    fn from(path: P) -> Self {
+        Self { path: path.into() }
     }
 }
 
@@ -492,11 +484,9 @@ impl Display for Program {
 }
 
 #[cfg(feature = "usermode")]
-impl<R: AsRef<Path>> From<R> for Program {
-    fn from(path: R) -> Self {
-        Self {
-            path: path.as_ref().to_path_buf(),
-        }
+impl<P: Into<PathBuf>> From<P> for Program {
+    fn from(path: P) -> Self {
+        Self { path: path.into() }
     }
 }
 

crates/libafl_qemu/src/qemu/config.rs

@@ -272,8 +272,8 @@ fn parse_path(s: &str) -> PathBuf {
 
 impl DrCovReader {
     /// Parse a `drcov` file to memory.
-    pub fn read<P: AsRef<Path> + ?Sized>(file: &P) -> Result<Self, Error> {
-        let f = File::open(file)?;
+    pub fn read<P: AsRef<Path> + ?Sized>(path: &P) -> Result<Self, Error> {
+        let f = File::open(path.as_ref())?;
         let mut reader = BufReader::new(f);
 
         let mut header = String::new();

crates/libafl_targets/src/drcov.rs

@@ -780,10 +780,10 @@ pub mod unix_shmem {
             /// This will *NOT* automatically delete the shmem files, meaning that it's user's responsibility to delete them after fuzzing
             pub fn new(
                 map_size: usize,
-                filename: impl AsRef<Path>,
+                path: impl AsRef<Path>,
                 use_fd_as_id: bool,
             ) -> Result<Self, Error> {
-                let filename_bytes = filename.as_ref().as_os_str().as_encoded_bytes();
+                let filename_bytes = path.as_ref().as_os_str().as_encoded_bytes();
 
                 let mut filename_path: [u8; 20] = [0_u8; MAX_MMAP_FILENAME_LEN];
                 // Keep room for the leading slash and trailing NULL.
@@ -1038,9 +1038,9 @@ pub mod unix_shmem {
             pub fn new_shmem_with_id(
                 &mut self,
                 map_size: usize,
-                id: impl AsRef<Path>,
+                id_path: impl AsRef<Path>,
             ) -> Result<MmapShMem, Error> {
-                MmapShMem::new(map_size, id, self.use_fd_as_id)
+                MmapShMem::new(map_size, id_path, self.use_fd_as_id)
             }
 
             /// Create a new [`MmapShMemProvider`] where filename is used as the shmem id.

crates/shmem_providers/src/lib.rs

@@ -179,10 +179,10 @@ fn is_instrumented(mmap: &Mmap, shmem_env_var: &str) -> bool {
     mmap_has_substr(mmap, shmem_env_var)
 }
 
-fn find_executable_in_path<P: AsRef<Path>>(executable: &P) -> Option<PathBuf> {
+fn find_executable_in_path<P: AsRef<Path>>(executable_path: &P) -> Option<PathBuf> {
     std::env::var_os("PATH").and_then(|paths| {
         std::env::split_paths(&paths).find_map(|dir| {
-            let full_path = dir.join(executable);
+            let full_path = dir.join(executable_path);
             if full_path.is_file() {
                 Some(full_path)
             } else {