remove generics from EventManager

afl/src/engines/mod.rs

@@ -71,7 +71,7 @@ where
         E: Executor<BytesInput> + HasObservers<OT>,
         OT: ObserversTuple,
         ET: ExecutorsTuple<BytesInput>,
-        EM: EventManager<C, E, FT, BytesInput, R>,
+        EM: EventManager<BytesInput>,
     {
         for entry in fs::read_dir(in_dir)? {
             let entry = entry?;
@@ -114,7 +114,7 @@ where
         E: Executor<BytesInput> + HasObservers<OT>,
         OT: ObserversTuple,
         ET: ExecutorsTuple<BytesInput>,
-        EM: EventManager<C, E, FT, BytesInput, R>,
+        EM: EventManager<BytesInput>,
     {
         for in_dir in in_dirs {
             self.load_from_directory(corpus, generator, engine, manager, in_dir)?;
@@ -294,7 +294,7 @@ where
         E: Executor<I> + HasObservers<OT>,
         OT: ObserversTuple,
         ET: ExecutorsTuple<I>,
-        EM: EventManager<C, E, FT, I, R>,
+        EM: EventManager<I>,
     {
         let mut added = 0;
         for _ in 0..num {
@@ -384,7 +384,7 @@ where
 pub trait Fuzzer<ST, EM, E, OT, FT, ET, C, I, R>
 where
     ST: StagesTuple<EM, E, OT, FT, ET, C, I, R>,
-    EM: EventManager<C, E, FT, I, R>,
+    EM: EventManager<I>,
     E: Executor<I> + HasObservers<OT>,
     OT: ObserversTuple,
     FT: FeedbacksTuple<I>,
@@ -438,7 +438,7 @@ where
 pub struct StdFuzzer<ST, EM, E, OT, FT, ET, C, I, R>
 where
     ST: StagesTuple<EM, E, OT, FT, ET, C, I, R>,
-    EM: EventManager<C, E, FT, I, R>,
+    EM: EventManager<I>,
     E: Executor<I> + HasObservers<OT>,
     OT: ObserversTuple,
     FT: FeedbacksTuple<I>,
@@ -455,7 +455,7 @@ impl<ST, EM, E, OT, FT, ET, C, I, R> Fuzzer<ST, EM, E, OT, FT, ET, C, I, R>
     for StdFuzzer<ST, EM, E, OT, FT, ET, C, I, R>
 where
     ST: StagesTuple<EM, E, OT, FT, ET, C, I, R>,
-    EM: EventManager<C, E, FT, I, R>,
+    EM: EventManager<I>,
     E: Executor<I> + HasObservers<OT>,
     OT: ObserversTuple,
     FT: FeedbacksTuple<I>,
@@ -476,7 +476,7 @@ where
 impl<ST, EM, E, OT, FT, ET, C, I, R> StdFuzzer<ST, EM, E, OT, FT, ET, C, I, R>
 where
     ST: StagesTuple<EM, E, OT, FT, ET, C, I, R>,
-    EM: EventManager<C, E, FT, I, R>,
+    EM: EventManager<I>,
     E: Executor<I> + HasObservers<OT>,
     OT: ObserversTuple,
     FT: FeedbacksTuple<I>,

afl/src/events/mod.rs

@@ -222,24 +222,23 @@ where
         R: Rand;
 }
 
-pub trait EventManager<C, E, FT, I, R>
+pub trait EventManager<I>
 where
-    C: Corpus<I, R>,
-    E: Executor<I>,
-    FT: FeedbacksTuple<I>,
     I: Input,
-    R: Rand,
 {
     /// Fire an Event
     //fn fire<'a>(&mut self, event: Event<I>) -> Result<(), AflError>;
 
     /// Lookup for incoming events and process them.
     /// Return the number of processes events or an error
-    fn process(
+    fn process<C, FT, R>(
         &mut self,
         state: &mut State<I, R, FT>,
         corpus: &mut C,
-    ) -> Result<usize, AflError>;
+    ) -> Result<usize, AflError> where
+        C: Corpus<I, R>,
+        FT: FeedbacksTuple<I>,
+        R: Rand;
 
     fn serialize_observers<OT>(&mut self, observers: &OT) -> Result<Vec<u8>, AflError> where OT: ObserversTuple {
         Ok(postcard::to_allocvec(observers)?)
@@ -402,38 +401,30 @@ where
 }
 
 #[derive(Clone, Debug)]
-pub struct LoggerEventManager<C, E, FT, I, R, ST>
+pub struct LoggerEventManager<I, ST>
 where
-    C: Corpus<I, R>,
-    E: Executor<I>,
-    FT: FeedbacksTuple<I>,
     I: Input,
-    R: Rand,
-    ST: Stats,
     //CE: CustomEvent<I, OT>,
 {
     stats: ST,
     events: Vec<LoggerEvent<I>>,
-    // stats (maybe we need a separated struct?)
-    phantom: PhantomData<(C, E, I, R, FT)>,
 }
 
-impl<C, E, FT, I, R, ST> EventManager<C, E, FT, I, R>
+impl<I, ST> EventManager<I>
-    for LoggerEventManager<C, E, FT, I, R, ST>
+    for LoggerEventManager<I, ST>
 where
-    C: Corpus<I, R>,
-    E: Executor<I>,
-    FT: FeedbacksTuple<I>,
     I: Input,
-    R: Rand,
     ST: Stats,
     //CE: CustomEvent<I, OT>,
 {
-    fn process(
+    fn process<C, FT, R>(
         &mut self,
         state: &mut State<I, R, FT>,
         corpus: &mut C,
-    ) -> Result<usize, AflError> {
+    ) -> Result<usize, AflError> where
+        C: Corpus<I, R>,
+        FT: FeedbacksTuple<I>,
+        R: Rand {
         let count = self.events.len();
         self.events
             .drain(..)
@@ -508,20 +499,15 @@ where
     }
 }
 
-impl<C, E, FT, I, R, ST> LoggerEventManager<C, E, FT, I, R, ST>
+impl<I, ST> LoggerEventManager<I, ST>
 where
-    C: Corpus<I, R>,
     I: Input,
-    E: Executor<I>,
-    FT: FeedbacksTuple<I>,
-    R: Rand,
     ST: Stats,
     //TODO CE: CustomEvent,
 {
     pub fn new(stats: ST) -> Self {
         Self {
             stats: stats,
-            phantom: PhantomData,
             events: vec![],
         }
     }
@@ -699,30 +685,22 @@ const _LLMP_TAG_EVENT_TO_BROKER: llmp::Tag = 0x2B80438;
 const LLMP_TAG_EVENT_TO_BOTH: llmp::Tag = 0x2B0741;
 
 #[derive(Clone, Debug)]
-pub struct LlmpEventManager<C, E, FT, I, R, SH, ST>
+pub struct LlmpEventManager<I, SH, ST>
 where
-    C: Corpus<I, R>,
-    E: Executor<I>,
-    FT: FeedbacksTuple<I>,
     I: Input,
-    R: Rand,
     SH: ShMem,
     ST: Stats,
     //CE: CustomEvent<I>,
 {
     llmp: llmp::LlmpConnection<SH>,
     stats: ST,
-    phantom: PhantomData<(C, E, FT, I, R)>,
+    phantom: PhantomData<I>,
 }
 
 #[cfg(feature = "std")]
-impl<C, E, FT, I, R, ST> LlmpEventManager<C, E, FT, I, R, AflShmem, ST>
+impl<I, ST> LlmpEventManager<I, AflShmem, ST>
 where
-    C: Corpus<I, R>,
-    E: Executor<I>,
-    FT: FeedbacksTuple<I>,
     I: Input,
-    R: Rand,
     ST: Stats,
 {
     /// Create llmp on a port
@@ -745,13 +723,9 @@ where
     }
 }
 
-impl<C, E, FT, I, R, SH, ST> LlmpEventManager<C, E, FT, I, R, SH, ST>
+impl<I, ST, SH> LlmpEventManager<I, SH, ST>
 where
-    C: Corpus<I, R>,
-    E: Executor<I>,
-    FT: FeedbacksTuple<I>,
     I: Input,
-    R: Rand,
     SH: ShMem,
     ST: Stats,
 {
@@ -849,23 +823,22 @@ where
     }
 }
 
-impl<C, E, FT, I, R, SH, ST> EventManager<C, E, FT, I, R>
+impl<I, ST, SH> EventManager<I>
-    for LlmpEventManager<C, E, FT, I, R, SH, ST>
+    for LlmpEventManager<I, SH, ST>
 where
-    C: Corpus<I, R>,
-    E: Executor<I>,
-    FT: FeedbacksTuple<I>,
     I: Input,
-    R: Rand,
     SH: ShMem,
     ST: Stats,
     //CE: CustomEvent<I>,
 {
-    fn process(
+    fn process<C, FT, R>(
         &mut self,
         state: &mut State<I, R, FT>,
         corpus: &mut C,
-    ) -> Result<usize, AflError> {
+    ) -> Result<usize, AflError> where
+        C: Corpus<I, R>,
+        FT: FeedbacksTuple<I>,
+        R: Rand {
         // TODO: Get around local event copy by moving handle_in_client
         Ok(match &mut self.llmp {
             llmp::LlmpConnection::IsClient { client } => {

afl/src/executors/inmemory.rs

@@ -1,5 +1,5 @@
 use alloc::{boxed::Box, string::ToString, vec::Vec};
-use core::{marker::PhantomData, ffi::c_void, ptr};
+use core::{ffi::c_void, ptr};
 
 use crate::{
     corpus::Corpus,
@@ -31,13 +31,12 @@ type HarnessFunction<I> = fn(&dyn Executor<I>, &[u8]) -> ExitKind;
 type OnCrashFunction<I, C, EM, FT, R> = dyn FnMut(ExitKind, &I, &State<I, R, FT>, &C, &mut EM);
 
 /// The inmem executor simply calls a target function, then returns afterwards.
-pub struct InMemoryExecutor<I, OT, C, E, EM, FT, R>
+pub struct InMemoryExecutor<I, OT, C, EM, FT, R>
 where
     I: Input + HasTargetBytes,
     OT: ObserversTuple,
     C: Corpus<I, R>,
-    E: Executor<I>,
+    EM: EventManager<I>,
-    EM: EventManager<C, E, FT, I, R>,
     FT: FeedbacksTuple<I>,
     R: Rand,
 {
@@ -49,17 +48,14 @@ where
     observers: OT,
     /// A special function being called right before the process crashes. It may save state to restore fuzzing after respawn.
     on_crash_fn: Box<OnCrashFunction<I, C, EM, FT, R>>,
-    
-    phantom: PhantomData<E>
 }
 
-impl<I, OT, C, E, EM, FT, R> Executor<I> for InMemoryExecutor<I, OT, C, E, EM, FT, R>
+impl<I, OT, C, EM, FT, R> Executor<I> for InMemoryExecutor<I, OT, C, EM, FT, R>
 where
     I: Input + HasTargetBytes,
     OT: ObserversTuple,
     C: Corpus<I, R>,
-    E: Executor<I>,
+    EM: EventManager<I>,
-    EM: EventManager<C, E, FT, I, R>,
     FT: FeedbacksTuple<I>,
     R: Rand,
 {
@@ -79,13 +75,12 @@ where
     }
 }
 
-impl<I, OT, C, E, EM, FT, R> Named for InMemoryExecutor<I, OT, C, E, EM, FT, R>
+impl<I, OT, C, EM, FT, R> Named for InMemoryExecutor<I, OT, C, EM, FT, R>
 where
     I: Input + HasTargetBytes,
     OT: ObserversTuple,
     C: Corpus<I, R>,
-    E: Executor<I>,
+    EM: EventManager<I>,
-    EM: EventManager<C, E, FT, I, R>,
     FT: FeedbacksTuple<I>,
     R: Rand,
 {
@@ -94,13 +89,12 @@ where
     }
 }
 
-impl<I, OT, C, E, EM, FT, R> HasObservers<OT> for InMemoryExecutor<I, OT, C, E, EM, FT, R>
+impl<I, OT, C, EM, FT, R> HasObservers<OT> for InMemoryExecutor<I, OT, C, EM, FT, R>
 where
     I: Input + HasTargetBytes,
     OT: ObserversTuple,
     C: Corpus<I, R>,
-    E: Executor<I>,
+    EM: EventManager<I>,
-    EM: EventManager<C, E, FT, I, R>,
     FT: FeedbacksTuple<I>,
     R: Rand,
 {
@@ -115,13 +109,12 @@ where
     }
 }
 
-impl<I, OT, C, E, EM, FT, R> InMemoryExecutor<I, OT, C, E, EM, FT, R>
+impl<I, OT, C, EM, FT, R> InMemoryExecutor<I, OT, C, EM, FT, R>
 where
     I: Input + HasTargetBytes,
     OT: ObserversTuple,
     C: Corpus<I, R>,
-    E: Executor<I>,
+    EM: EventManager<I>,
-    EM: EventManager<C, E, FT, I, R>,
     FT: FeedbacksTuple<I>,
     R: Rand,
 {
@@ -138,6 +131,8 @@ where
         harness_fn: HarnessFunction<I>,
         observers: OT,
         on_crash_fn: Box<OnCrashFunction<I, C, EM, FT, R>>,
+        _state: &State<I, R, FT>,
+        _corpus: &C,
         _event_mgr: &EM,
     ) -> Self
     {
@@ -154,7 +149,6 @@ where
             on_crash_fn,
             observers,
             name,
-            phantom: PhantomData
         }
     }
 }
@@ -228,9 +222,8 @@ pub mod unix_signals {
         info: siginfo_t,
         _void: c_void,
     ) where
-        EM: EventManager<C, E, FT, I, R>,
+        EM: EventManager<I>,
         C: Corpus<I, R>,
-        E: Executor<I>,
         OT: ObserversTuple,
         FT: FeedbacksTuple<I>,
         I: Input,
@@ -271,9 +264,8 @@ pub mod unix_signals {
         _info: siginfo_t,
         _void: c_void,
     ) where
-        EM: EventManager<C, E, FT, I, R>,
+        EM: EventManager<I>,
         C: Corpus<I, R>,
-        E: Executor<I>,
         OT: ObserversTuple,
         FT: FeedbacksTuple<I>,
         I: Input,
@@ -309,9 +301,8 @@ pub mod unix_signals {
     // TODO clearly state that manager should be static (maybe put the 'static lifetime?)
     pub unsafe fn setup_crash_handlers<EM, C, E, OT, FT, I, R>(state: &State<I, R, FT>, corpus: &C, manager: &mut EM)
     where
-        EM: EventManager<C, E, FT, I, R>,
+        EM: EventManager<I>,
         C: Corpus<I, R>,
-        E: Executor<I>,
         OT: ObserversTuple,
         FT: FeedbacksTuple<I>,
         I: Input,

afl/src/stages/mod.rs

@@ -16,7 +16,7 @@ use crate::AflError;
 /// Multiple stages will be scheduled one by one for each input.
 pub trait Stage<EM, E, OT, FT, ET, C, I, R>
 where
-    EM: EventManager<C, E, FT, I, R>,
+    EM: EventManager<I>,
     E: Executor<I> + HasObservers<OT>,
     OT: ObserversTuple,
     FT: FeedbacksTuple<I>,
@@ -39,7 +39,7 @@ where
 
 pub trait StagesTuple<EM, E, OT, FT, ET, C, I, R>
 where
-    EM: EventManager<C, E, FT, I, R>,
+    EM: EventManager<I>,
     E: Executor<I> + HasObservers<OT>,
     OT: ObserversTuple,
     FT: FeedbacksTuple<I>,
@@ -63,7 +63,7 @@ where
 
 impl<EM, E, OT, FT, ET, C, I, R> StagesTuple<EM, E, OT, FT, ET, C, I, R> for ()
 where
-    EM: EventManager<C, E, FT, I, R>,
+    EM: EventManager<I>,
     E: Executor<I> + HasObservers<OT>,
     OT: ObserversTuple,
     FT: FeedbacksTuple<I>,
@@ -92,7 +92,7 @@ impl<Head, Tail, EM, E, OT, FT, ET, C, I, R> StagesTuple<EM, E, OT, FT, ET, C, I
 where
     Head: Stage<EM, E, OT, FT, ET, C, I, R>,
     Tail: StagesTuple<EM, E, OT, FT, ET, C, I, R> + TupleList,
-    EM: EventManager<C, E, FT, I, R>,
+    EM: EventManager<I>,
     E: Executor<I> + HasObservers<OT>,
     OT: ObserversTuple,
     FT: FeedbacksTuple<I>,

afl/src/stages/mutational.rs

@@ -21,7 +21,7 @@ pub trait MutationalStage<M, EM, E, OT, FT, ET, C, I, R>:
     Stage<EM, E, OT, FT, ET, C, I, R>
 where
     M: Mutator<C, I, R>,
-    EM: EventManager<C, E, FT, I, R>,
+    EM: EventManager<I>,
     E: Executor<I> + HasObservers<OT>,
     OT: ObserversTuple,
     FT: FeedbacksTuple<I>,
@@ -89,7 +89,7 @@ where
 pub struct StdMutationalStage<M, EM, E, OT, FT, ET, C, I, R>
 where
     M: Mutator<C, I, R>,
-    EM: EventManager<C, E, FT, I, R>,
+    EM: EventManager<I>,
     E: Executor<I> + HasObservers<OT>,
     OT: ObserversTuple,
     FT: FeedbacksTuple<I>,
@@ -106,7 +106,7 @@ impl<M, EM, E, OT, FT, ET, C, I, R> MutationalStage<M, EM, E, OT, FT, ET, C, I,
     for StdMutationalStage<M, EM, E, OT, FT, ET, C, I, R>
 where
     M: Mutator<C, I, R>,
-    EM: EventManager<C, E, FT, I, R>,
+    EM: EventManager<I>,
     E: Executor<I> + HasObservers<OT>,
     OT: ObserversTuple,
     FT: FeedbacksTuple<I>,
@@ -132,7 +132,7 @@ impl<M, EM, E, OT, FT, ET, C, I, R> Stage<EM, E, OT, FT, ET, C, I, R>
     for StdMutationalStage<M, EM, E, OT, FT, ET, C, I, R>
 where
     M: Mutator<C, I, R>,
-    EM: EventManager<C, E, FT, I, R>,
+    EM: EventManager<I>,
     E: Executor<I> + HasObservers<OT>,
     OT: ObserversTuple,
     FT: FeedbacksTuple<I>,
@@ -158,7 +158,7 @@ where
 impl<M, EM, E, OT, FT, ET, C, I, R> StdMutationalStage<M, EM, E, OT, FT, ET, C, I, R>
 where
     M: Mutator<C, I, R>,
-    EM: EventManager<C, E, FT, I, R>,
+    EM: EventManager<I>,
     E: Executor<I> + HasObservers<OT>,
     OT: ObserversTuple,
     FT: FeedbacksTuple<I>,

fuzzers/libfuzzer_libpng/src/mod.rs

@@ -12,7 +12,7 @@ use afl::{
         llmp::LlmpReceiver,
         llmp::LlmpSender,
         shmem::{AflShmem, ShMem},
-        LlmpEventManager, SimpleStats,
+        EventManager, LlmpEventManager, SimpleStats,
     },
     executors::{
         inmemory::{serialize_state_corpus, deserialize_state_corpus, InMemoryExecutor},
@@ -142,12 +142,14 @@ fn fuzz(input: Option<Vec<PathBuf>>, broker_port: u16) -> Result<(), AflError> {
         tuple_list!(edges_observer),
         Box::new(move |exit_kind, input, state, corpus, mgr| {
             match exit_kind {
-                ExitKind::Timeout => mgr.timeout(input).expect("Error sending Timeout event for input {:?}", input),
+                ExitKind::Timeout => mgr.timeout(input).expect(&format!("Error sending Timeout event for input {:?}", input)),
-                ExitKind::Crash  => mgr.crash(input).expect("Error sending crash event for input {:?}", input),
+                ExitKind::Crash  => mgr.crash(input).expect(&format!("Error sending crash event for input {:?}", input)),
             }
             let state_corpus_serialized = serialize_state_corpus(state, corpus).unwrap();
             sender.send_buf(0x1, &state_corpus_serialized).unwrap();
         }),
+        &state,
+        &corpus,
         &mgr,
     );