Change the runner behavior

.gitignore

@@ -13,4 +13,7 @@ target/
 # MSVC Windows builds of rustc generate these, which store debugging information
 *.pdb
 
-core
+core
+
+# Profiler files generated during coverage
+*.profraw

Cargo.toml

@@ -23,7 +23,7 @@ cli = [
     "cargo_metadata",
     "twox-hash",
 ]
-coverage = ["fork", "libc"]
+coverage = []
 
 [dependencies]
 afl = { version = "0.17.0", default-features = false, optional = true }

README.md

@@ -60,7 +60,7 @@ ziggy = { version = "1.4.0", default-features = false }
 
 Then use the `fuzz!` macro inside your `main` to create a harness.
 
-```rust
+```rust ignore
 fn main() {
     ziggy::fuzz!(|data: &[u8]| {
         println!("{data:?}");

src/bin/cargo-ziggy/coverage.rs

@@ -31,15 +31,12 @@ impl Cover {
             Cover::clean_old_cov()?;
         }
 
-        let mut shared_corpus = PathBuf::new();
-
-        shared_corpus.push(
+        let input_path = PathBuf::from(
             self.input
                 .display()
                 .to_string()
                 .replace("{ziggy_output}", &self.ziggy_output.display().to_string())
-                .replace("{target_name}", &self.target)
-                .as_str(),
+                .replace("{target_name}", &self.target),
         );
 
         // Get the absolute path for the coverage directory to ensure .profraw files
@@ -49,13 +46,24 @@ impl Cover {
             .join("target/coverage/debug/deps");
         let profile_file = coverage_target_dir.join("coverage-%p-%m.profraw");
 
-        let _ = process::Command::new(format!("./target/coverage/debug/{}", &self.target))
-            .arg(format!("{}", shared_corpus.display()))
-            .env("LLVM_PROFILE_FILE", profile_file.display().to_string())
-            .spawn()
-            .unwrap()
-            .wait_with_output()
-            .unwrap();
+        let coverage_corpus = match input_path.is_dir() {
+            true => fs::read_dir(input_path)
+                .unwrap()
+                .flatten()
+                .map(|e| e.path())
+                .collect(),
+            false => vec![input_path],
+        };
+
+        for file in coverage_corpus {
+            let _ = process::Command::new(format!("./target/coverage/debug/{}", &self.target))
+                .arg(file.display().to_string())
+                .env("LLVM_PROFILE_FILE", profile_file.display().to_string())
+                .spawn()
+                .unwrap()
+                .wait_with_output()
+                .unwrap();
+        }
 
         let source_or_workspace_root = match &self.source {
             Some(s) => s.display().to_string(),

src/bin/cargo-ziggy/main.rs

@@ -200,10 +200,6 @@ pub struct Run {
     #[clap(value_name = "TARGET", default_value = DEFAULT_UNMODIFIED_TARGET)]
     target: String,
 
-    /// Maximum length of input
-    #[clap(short = 'G', long = "maxlength", default_value_t = 1048576)]
-    max_length: u64,
-
     /// Input directories and/or files to run
     #[clap(short, long, value_name = "DIR", default_value = DEFAULT_CORPUS_DIR)]
     inputs: Vec<PathBuf>,
@@ -225,6 +221,10 @@ pub struct Run {
     /// Activate these features on the target
     #[clap(short = 'F', long, num_args = 0..)]
     features: Vec<String>,
+
+    /// Stop the run after the first crash is encountered
+    #[clap(short = 'x', long)]
+    stop_on_crash: bool,
 }
 
 #[derive(Args, Clone)]

src/bin/cargo-ziggy/run.rs

@@ -67,14 +67,26 @@ impl Run {
             }
         }
 
-        let run_args: Vec<String> = self
+        let input_files: Vec<PathBuf> = self
             .inputs
             .iter()
-            .map(|x| {
-                x.display()
+            .flat_map(|x| {
+                let canonical_name = x
+                    .display()
                     .to_string()
                     .replace("{ziggy_output}", &self.ziggy_output.display().to_string())
-                    .replace("{target_name}", &target)
+                    .replace("{target_name}", &target);
+                // For each directory we read, we get all files in that directory
+                let path = PathBuf::from(canonical_name);
+                match path.is_dir() {
+                    true => fs::read_dir(path)
+                        .expect("could not read directory")
+                        .filter_map(|entry| entry.ok())
+                        .map(|entry| entry.path())
+                        .filter(|path| path.is_file())
+                        .collect::<Vec<_>>(),
+                    false => vec![path],
+                }
             })
             .collect();
 
@@ -83,21 +95,26 @@ impl Run {
             false => format!("./target/runner/debug/{}", target),
         };
 
-        let res = process::Command::new(runner_path)
-            .args(run_args)
-            .env("RUST_BACKTRACE", "full")
-            .spawn()
-            .context("⚠️  couldn't spawn the runner process")?
-            .wait()
-            .context("⚠️  couldn't wait for the runner process")?;
+        for file in input_files {
+            let res = process::Command::new(&runner_path)
+                .arg(file)
+                .env("RUST_BACKTRACE", "full")
+                .spawn()
+                .context("⚠️  couldn't spawn the runner process")?
+                .wait()
+                .context("⚠️  couldn't wait for the runner process")?;
 
-        if !res.success() {
-            if let Some(signal) = res.signal() {
-                println!("⚠️  input terminated with signal {:?}!", signal);
-            } else if let Some(exit_code) = res.code() {
-                println!("⚠️  input terminated with code {:?}!", exit_code);
-            } else {
-                println!("⚠️  input terminated but we do not know why!");
+            if !res.success() {
+                if let Some(signal) = res.signal() {
+                    println!("⚠️  input terminated with signal {:?}!", signal);
+                } else if let Some(exit_code) = res.code() {
+                    println!("⚠️  input terminated with code {:?}!", exit_code);
+                } else {
+                    println!("⚠️  input terminated but we do not know why!");
+                }
+                if self.stop_on_crash {
+                    return Ok(());
+                }
             }
         }