make nopstate public so that it can be used as reproducer (#1888)

libafl/src/executors/command.rs

@@ -693,7 +693,7 @@ mod tests {
         fuzzer::test::NopFuzzer,
         inputs::BytesInput,
         monitors::SimpleMonitor,
-        state::test::NopState,
+        state::NopState,
     };
 
     #[test]

libafl/src/executors/inprocess_fork.rs

@@ -560,7 +560,7 @@ mod tests {
                 inprocess_fork::GenericInProcessForkExecutor, Executor,
             },
             fuzzer::test::NopFuzzer,
-            state::test::NopState,
+            state::NopState,
         };
 
         let provider = StdShMemProvider::new().unwrap();

libafl/src/executors/mod.rs

@@ -174,7 +174,7 @@ pub mod test {
         executors::{Executor, ExitKind},
         fuzzer::test::NopFuzzer,
         inputs::{BytesInput, HasTargetBytes},
-        state::{test::NopState, HasExecutions, State, UsesState},
+        state::{HasExecutions, NopState, State, UsesState},
     };
 
     /// A simple executor that does nothing.

libafl/src/feedbacks/differential.rs

@@ -163,7 +163,7 @@ mod tests {
         feedbacks::{differential::DiffResult, DiffFeedback, Feedback},
         inputs::{BytesInput, UsesInput},
         observers::Observer,
-        state::{test::NopState, State, UsesState},
+        state::{NopState, State, UsesState},
     };
 
     #[derive(Debug)]

libafl/src/mutators/tuneable.rs

@@ -376,7 +376,7 @@ mod test {
     use crate::{
         inputs::BytesInput,
         mutators::{ByteRandMutator, ScheduledMutator},
-        state::test::NopState,
+        state::NopState,
     };
 
     #[test]

libafl/src/state/mod.rs

@@ -14,7 +14,7 @@ use std::{
 };
 
 use libafl_bolts::{
-    rands::Rand,
+    rands::{Rand, StdRand},
     serdeany::{NamedSerdeAnyMap, SerdeAny, SerdeAnyMap},
 };
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
@@ -998,37 +998,16 @@ impl<I, C, R, SC> HasScalabilityMonitor for StdState<I, C, R, SC> {
     }
 }
 
-#[cfg(test)]
+/// A very simple state without any bells or whistles, for testing.
-pub mod test {
+#[derive(Debug, Serialize, Deserialize, Default)]
-    use core::{marker::PhantomData, time::Duration};
+pub struct NopState<I> {
-
-    use libafl_bolts::{rands::StdRand, serdeany::SerdeAnyMap, Error};
-    use serde::{Deserialize, Serialize};
-
-    use crate::{
-        corpus::{CorpusId, HasCurrentCorpusIdx, InMemoryCorpus},
-        inputs::{Input, NopInput, UsesInput},
-        stages::test::{test_resume, test_resume_stages},
-        state::{
-            HasCurrentStage, HasExecutions, HasLastReportTime, HasMetadata, HasRand, State,
-            StdState,
-        },
-    };
-    #[cfg(feature = "introspection")]
-    use crate::{monitors::ClientPerfMonitor, state::HasClientPerfMonitor};
-    #[cfg(feature = "scalability_introspection")]
-    use crate::{monitors::ScalabilityMonitor, state::HasScalabilityMonitor};
-
-    /// A very simple state without any bells or whistles, for testing.
-    #[derive(Debug, Serialize, Deserialize, Default)]
-    pub struct NopState<I> {
     metadata: SerdeAnyMap,
     execution: usize,
     rand: StdRand,
     phantom: PhantomData<I>,
-    }
+}
 
-    impl<I> NopState<I> {
+impl<I> NopState<I> {
     /// Create a new State that does nothing (for tests)
     #[must_use]
     pub fn new() -> Self {
@@ -1039,16 +1018,16 @@ pub mod test {
             phantom: PhantomData,
         }
     }
-    }
+}
 
-    impl<I> UsesInput for NopState<I>
+impl<I> UsesInput for NopState<I>
-    where
+where
     I: Input,
-    {
+{
     type Input = I;
-    }
+}
 
-    impl<I> HasExecutions for NopState<I> {
+impl<I> HasExecutions for NopState<I> {
     fn executions(&self) -> &usize {
         &self.execution
     }
@@ -1056,9 +1035,9 @@ pub mod test {
     fn executions_mut(&mut self) -> &mut usize {
         &mut self.execution
     }
-    }
+}
 
-    impl<I> HasLastReportTime for NopState<I> {
+impl<I> HasLastReportTime for NopState<I> {
     fn last_report_time(&self) -> &Option<Duration> {
         unimplemented!();
     }
@@ -1066,9 +1045,9 @@ pub mod test {
     fn last_report_time_mut(&mut self) -> &mut Option<Duration> {
         unimplemented!();
     }
-    }
+}
 
-    impl<I> HasMetadata for NopState<I> {
+impl<I> HasMetadata for NopState<I> {
     fn metadata_map(&self) -> &SerdeAnyMap {
         &self.metadata
     }
@@ -1076,9 +1055,9 @@ pub mod test {
     fn metadata_map_mut(&mut self) -> &mut SerdeAnyMap {
         &mut self.metadata
     }
-    }
+}
 
-    impl<I> HasRand for NopState<I> {
+impl<I> HasRand for NopState<I> {
     type Rand = StdRand;
 
     fn rand(&self) -> &Self::Rand {
@@ -1088,11 +1067,11 @@ pub mod test {
     fn rand_mut(&mut self) -> &mut Self::Rand {
         &mut self.rand
     }
-    }
+}
 
-    impl<I> State for NopState<I> where I: Input {}
+impl<I> State for NopState<I> where I: Input {}
 
-    impl<I> HasCurrentCorpusIdx for NopState<I> {
+impl<I> HasCurrentCorpusIdx for NopState<I> {
     fn set_corpus_idx(&mut self, _idx: CorpusId) -> Result<(), Error> {
         Ok(())
     }
@@ -1104,9 +1083,9 @@ pub mod test {
     fn current_corpus_idx(&self) -> Result<Option<CorpusId>, Error> {
         Ok(None)
     }
-    }
+}
 
-    impl<I> HasCurrentStage for NopState<I> {
+impl<I> HasCurrentStage for NopState<I> {
     fn set_stage(&mut self, _idx: usize) -> Result<(), Error> {
         Ok(())
     }
@@ -1118,10 +1097,10 @@ pub mod test {
     fn current_stage(&self) -> Result<Option<usize>, Error> {
         Ok(None)
     }
-    }
+}
 
-    #[cfg(feature = "introspection")]
+#[cfg(feature = "introspection")]
-    impl<I> HasClientPerfMonitor for NopState<I> {
+impl<I> HasClientPerfMonitor for NopState<I> {
     fn introspection_monitor(&self) -> &ClientPerfMonitor {
         unimplemented!();
     }
@@ -1129,10 +1108,10 @@ pub mod test {
     fn introspection_monitor_mut(&mut self) -> &mut ClientPerfMonitor {
         unimplemented!();
     }
-    }
+}
 
-    #[cfg(feature = "scalability_introspection")]
+#[cfg(feature = "scalability_introspection")]
-    impl<I> HasScalabilityMonitor for NopState<I> {
+impl<I> HasScalabilityMonitor for NopState<I> {
     fn scalability_monitor(&self) -> &ScalabilityMonitor {
         unimplemented!();
     }
@@ -1140,7 +1119,18 @@ pub mod test {
     fn scalability_monitor_mut(&mut self) -> &mut ScalabilityMonitor {
         unimplemented!();
     }
-    }
+}
+
+#[cfg(test)]
+pub mod test {
+    use libafl_bolts::rands::StdRand;
+
+    use super::StdState;
+    use crate::{
+        corpus::InMemoryCorpus,
+        inputs::{Input, NopInput},
+        stages::test::{test_resume, test_resume_stages},
+    };
 
     #[must_use]
     pub fn test_std_state<I: Input>() -> StdState<I, InMemoryCorpus<I>, StdRand, InMemoryCorpus<I>>

libafl_qemu/src/hooks.rs

@@ -10,7 +10,11 @@ use core::{
     ptr::{self, addr_of, addr_of_mut},
 };
 
-use libafl::{executors::hooks::inprocess::inprocess_get_state, inputs::UsesInput};
+use libafl::{
+    executors::{hooks::inprocess::inprocess_get_state, ExitKind},
+    inputs::UsesInput,
+    state::NopState,
+};
 
 pub use crate::emu::SyscallHookResult;
 use crate::{
@@ -337,6 +341,7 @@ where
 }
 
 static mut HOOKS_IS_INITIALIZED: bool = false;
+static mut FIRST_EXEC: bool = true;
 
 pub struct QemuHooks<QT, S>
 where
@@ -361,6 +366,36 @@ where
     }
 }
 
+impl<I, QT> QemuHooks<QT, NopState<I>>
+where
+    QT: QemuHelperTuple<NopState<I>>,
+    NopState<I>: UsesInput<Input = I>,
+{
+    pub fn reproducer(emulator: Emulator, helpers: QT) -> Box<Self> {
+        Self::new(emulator, helpers)
+    }
+
+    pub fn repro_run<H>(&mut self, harness: &mut H, input: &I) -> ExitKind
+    where
+        H: FnMut(&I) -> ExitKind,
+    {
+        unsafe {
+            if FIRST_EXEC {
+                self.helpers.first_exec_all(self);
+                FIRST_EXEC = false;
+            }
+        }
+        self.helpers.pre_exec_all(&self.emulator, input);
+
+        let mut exit_kind = harness(input);
+
+        self.helpers
+            .post_exec_all(&self.emulator, input, &mut (), &mut exit_kind);
+
+        exit_kind
+    }
+}
+
 impl<QT, S> QemuHooks<QT, S>
 where
     QT: QemuHelperTuple<S>,