communicate with python over a pipe to increase fuzzing performance

fuzz/fuzz.rs

@@ -2,49 +2,83 @@ use core::slice;
 use gentoo_utils::{Parseable, atom::Atom};
 use mon::{Parser, ParserFinishedError, input::InputIter};
 use std::{
-    io::Write,
+    io::{BufRead, BufReader, Write},
-    process::{Command, Stdio},
+    process::{ChildStdin, ChildStdout, Command, Stdio},
+    sync::{LazyLock, Mutex},
 };
 
+struct PyProcess {
+    stdin: Mutex<ChildStdin>,
+    stdout: Mutex<BufReader<ChildStdout>>,
+    buffer: Mutex<String>,
+}
+
 #[allow(clippy::missing_safety_doc, clippy::needless_return)]
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn LLVMFuzzerTestOneInput(input: *const u8, len: usize) -> i32 {
+    static PY_PROCESS: LazyLock<PyProcess> = LazyLock::new(|| {
+        #[allow(clippy::zombie_processes)]
+        let mut proc = Command::new("atom.py")
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .spawn()
+            .expect("failed to spawn atom.py");
+
+        let stdin = Mutex::new(proc.stdin.take().unwrap());
+        let stdout = Mutex::new(BufReader::new(proc.stdout.take().unwrap()));
+
+        PyProcess {
+            stdin,
+            stdout,
+            buffer: Mutex::new(String::new()),
+        }
+    });
+
     let slice = unsafe { slice::from_raw_parts(input, len) };
 
-    let atom = match str::from_utf8(slice) {
+    let str = match str::from_utf8(slice) {
-        Ok(str) => str.trim(),
+        Ok(str) => str,
-        _ => return -1,
+        Err(_) => return -1,
     };
 
-    let mut proc = Command::new("atom.py")
+    let atom = str.trim();
-        .stdin(Stdio::piped())
-        .spawn()
-        .expect("failed to start atom.py");
 
-    proc.stdin
+    let mut stdin = PY_PROCESS.stdin.lock().expect("failed to get stdin lock");
-        .as_mut()
-        .unwrap()
-        .write_all(atom.as_bytes())
-        .unwrap();
 
-    let status = proc.wait().unwrap();
+    writeln!(&mut stdin, "{atom}").expect("failed to write to python stdin");
 
-    let result = Atom::parser().check_finished(InputIter::new(atom));
+    let mut stdout = PY_PROCESS.stdout.lock().expect("failed to get stdout lock");
 
-    match (status.success(), result) {
+    let mut buffer = PY_PROCESS.buffer.lock().expect("failed to get buffer lock");
-        (true, Ok(_)) => {
+
+    buffer.clear();
+
+    stdout
+        .read_line(&mut buffer)
+        .expect("failed to readline from python");
+
+    let portage_result = match buffer.as_str().trim() {
+        "0" => true,
+        "1" => false,
+        result => panic!("got unexpected result from python: {result}"),
+    };
+
+    let gentoo_utils_result = Atom::parser().check_finished(InputIter::new(atom)).is_ok();
+
+    match (portage_result, gentoo_utils_result) {
+        (true, true) => {
             eprintln!("agreement that {atom} is valid");
-            return 0;
         }
-        (true, Err(ParserFinishedError::Err(it) | ParserFinishedError::Unfinished(it))) => {
+        (false, false) => {
-            panic!("gentoo-utils rejected valid atom: {atom}: {}", it.rest());
-        }
-        (false, Err(_)) => {
             eprintln!("agreement that {atom} is invalid");
-            return -1;
         }
-        (false, Ok(_)) => {
+        (true, false) => {
-            panic!("gentoo-utils accepted invalid atom: {atom}");
+            panic!("rejected valid atom: {atom}");
+        }
+        (false, true) => {
+            panic!("accpeted invalid atom: {atom}")
         }
     }
+
+    return 0;
 }

scripts/atom.py

@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 
 import sys
-import portage.dep as dep
+from portage.dep import Atom
 
-input = sys.stdin.read().strip()
+for line in sys.stdin.buffer:
-
+    try:
-try:
+        Atom(line.decode().strip())
-    dep.Atom(input)
+        sys.stdout.buffer.write(b"0\n")
-except Exception as e:
+    except:
-    sys.exit(1)
+        sys.stdout.buffer.write(b"1\n")
-
+    finally:
-sys.exit(0)
+        sys.stdout.buffer.flush()