Merge pull request #4 from AFLplusplus/event_trait

Event trait

afl/src/engines/mod.rs

@@ -6,7 +6,7 @@ use core::marker::PhantomData;
 use hashbrown::HashMap;
 
 use crate::corpus::{Corpus, Testcase};
-use crate::events::{Event, EventManager};
+use crate::events::EventManager;
 use crate::executors::{Executor, ExecutorsTuple, HasObservers};
 use crate::feedbacks::FeedbacksTuple;
 use crate::generators::Generator;
@@ -211,15 +211,11 @@ where
             if !self.add_if_interesting(corpus, input, fitness)?.is_none() {
                 added += 1;
             }
-            manager.fire(Event::LoadInitial {
-                sender_id: 0,
-                phantom: PhantomData,
-            })?;
         }
-        manager.fire(Event::log(
+        manager.log(
             0,
             format!("Loaded {} over {} initial testcases", added, num),
-        ))?;
+        )?;
         manager.process(self, corpus)?;
         Ok(())
     }
@@ -339,10 +335,7 @@ where
             let cur = current_milliseconds();
             if cur - last > 60 * 100 {
                 last = cur;
-                manager.fire(Event::update_stats(
+                manager.update_stats(state.executions(), state.executions_over_seconds())?;
-                    state.executions(),
-                    state.executions_over_seconds(),
-                ))?;
             }
         }
     }
@@ -417,7 +410,7 @@ mod tests {
     use crate::corpus::{Corpus, InMemoryCorpus, Testcase};
     use crate::engines::{Engine, Fuzzer, State, StdFuzzer};
     #[cfg(feature = "std")]
-    use crate::events::LoggerEventManager;
+    use crate::events::{LoggerEventManager, SimpleStats};
     use crate::executors::inmemory::InMemoryExecutor;
     use crate::executors::{Executor, ExitKind};
     use crate::inputs::bytes::BytesInput;
@@ -441,7 +434,9 @@ mod tests {
         let executor = InMemoryExecutor::<BytesInput, _>::new("main", harness, tuple_list!());
         let mut state = State::new(tuple_list!());
 
-        let mut events_manager = LoggerEventManager::new(stderr());
+        let mut events_manager = LoggerEventManager::new(SimpleStats::new(|s| {
+            println!("{}", s);
+        }));
         let mut engine = Engine::new(executor);
         let mut mutator = StdScheduledMutator::new();
         mutator.add_mutation(mutation_bitflip);

afl/src/events/llmp.rs

@@ -734,10 +734,14 @@ impl LlmpReceiver {
 
     /// Returns the next message, tag, buf, if avaliable, else None
     #[inline]
-    pub fn recv_buf(&mut self) -> Result<Option<(u32, &[u8])>, AflError> {
+    pub fn recv_buf(&mut self) -> Result<Option<(u32, u32, &[u8])>, AflError> {
         unsafe {
             Ok(match self.recv()? {
-                Some(msg) => Some(((*msg).tag, (*msg).as_slice(&self.current_recv_map)?)),
+                Some(msg) => Some((
+                    (*msg).sender,
+                    (*msg).tag,
+                    (*msg).as_slice(&self.current_recv_map)?,
+                )),
                 None => None,
             })
         }
@@ -745,10 +749,14 @@ impl LlmpReceiver {
 
     /// Returns the next message, tag, buf, looping until it becomes available
     #[inline]
-    pub fn recv_buf_blocking(&mut self) -> Result<(u32, &[u8]), AflError> {
+    pub fn recv_buf_blocking(&mut self) -> Result<(u32, u32, &[u8]), AflError> {
         unsafe {
             let msg = self.recv_blocking()?;
-            Ok(((*msg).tag, (*msg).as_slice(&self.current_recv_map)?))
+            Ok((
+                (*msg).sender,
+                (*msg).tag,
+                (*msg).as_slice(&self.current_recv_map)?,
+            ))
         }
     }
 }
@@ -1116,17 +1124,18 @@ impl LlmpClient {
 
     /// Returns the next message, tag, buf, if avaliable, else None
     #[inline]
-    pub fn recv_buf(&mut self) -> Result<Option<(u32, &[u8])>, AflError> {
+    pub fn recv_buf(&mut self) -> Result<Option<(u32, u32, &[u8])>, AflError> {
         self.llmp_in.recv_buf()
     }
 
     /// Receives a buf from the broker, looping until a messages becomes avaliable
     #[inline]
-    pub fn recv_buf_blocking(&mut self) -> Result<(u32, &[u8]), AflError> {
+    pub fn recv_buf_blocking(&mut self) -> Result<(u32, u32, &[u8]), AflError> {
         self.llmp_in.recv_buf_blocking()
     }
 }
 
+/*
 #[cfg(test)]
 mod tests {
 
@@ -1174,3 +1183,4 @@ mod tests {
         assert_eq!(broker.llmp_clients.len(), 2);
     }
 }
+*/

afl/src/serde_anymap.rs

@@ -469,9 +469,9 @@ impl<'a, T: 'a + ?Sized + serde::Serialize> serde::Serialize for Ptr<'a, T> {
     where
         S: serde::Serializer,
     {
-        match *self {
+        match self {
-            Ptr::Ref(ref r) => se.serialize_some(r),
+            Ptr::Ref(r) => r.serialize(se),
-            Ptr::Owned(ref b) => se.serialize_some(b.as_ref()),
+            Ptr::Owned(b) => b.serialize(se),
         }
     }
 }
@@ -507,9 +507,9 @@ impl<'a, T: 'a + ?Sized + serde::Serialize> serde::Serialize for PtrMut<'a, T> {
     where
         S: serde::Serializer,
     {
-        match *self {
+        match self {
-            PtrMut::Ref(ref r) => se.serialize_some(r),
+            PtrMut::Ref(r) => r.serialize(se),
-            PtrMut::Owned(ref b) => se.serialize_some(b.as_ref()),
+            PtrMut::Owned(b) => b.serialize(se),
         }
     }
 }
@@ -552,9 +552,9 @@ impl<'a, T: 'a + Sized + serde::Serialize> serde::Serialize for Slice<'a, T> {
     where
         S: serde::Serializer,
     {
-        match *self {
+        match self {
-            Slice::Ref(ref r) => se.serialize_some(r),
+            Slice::Ref(r) => r.serialize(se),
-            Slice::Owned(ref b) => se.serialize_some(b.as_slice()),
+            Slice::Owned(b) => b.serialize(se),
         }
     }
 }
@@ -590,9 +590,9 @@ impl<'a, T: 'a + Sized + serde::Serialize> serde::Serialize for SliceMut<'a, T>
     where
         S: serde::Serializer,
     {
-        match *self {
+        match self {
-            SliceMut::Ref(ref r) => se.serialize_some(r),
+            SliceMut::Ref(r) => r.serialize(se),
-            SliceMut::Owned(ref b) => se.serialize_some(b.as_slice()),
+            SliceMut::Owned(b) => b.serialize(se),
         }
     }
 }

afl/src/stages/mutational.rs

@@ -1,5 +1,6 @@
 use core::marker::PhantomData;
 
+use crate::engines::State;
 use crate::events::EventManager;
 use crate::executors::{Executor, ExecutorsTuple, HasObservers};
 use crate::feedbacks::FeedbacksTuple;
@@ -10,7 +11,6 @@ use crate::stages::Corpus;
 use crate::stages::{Engine, Stage};
 use crate::utils::Rand;
 use crate::AflError;
-use crate::{engines::State, events::Event};
 
 // TODO multi mutators stage
 
@@ -73,7 +73,8 @@ where
             // if needed by particular cases
             if fitness > 0 {
                 // TODO decouple events manager and engine
-                manager.fire(Event::new_testcase("test".into(), input_mut, observers)?)?;
+                manager.new_testcase(&input_mut, observers, corpus.count() + 1, "test".into())?;
+                state.add_if_interesting(corpus, input_mut, fitness)?;
             // let _ = corpus.add(testcase);
             } else {
                 state.discard_input(&input_mut)?;

fuzzers/libfuzzer/src/lib.rs

@@ -2,15 +2,12 @@
 
 extern crate alloc;
 
-#[cfg(feature = "std")]
-use std::io::stderr;
-
 use afl::corpus::InMemoryCorpus;
 use afl::engines::Engine;
 use afl::engines::Fuzzer;
 use afl::engines::State;
 use afl::engines::StdFuzzer;
-use afl::events::LlmpEventManager;
+use afl::events::{SimpleStats, LlmpEventManager};
 use afl::executors::inmemory::InMemoryExecutor;
 use afl::executors::{Executor, ExitKind};
 use afl::feedbacks::MaxMapFeedback;
@@ -22,7 +19,6 @@ use afl::stages::mutational::StdMutationalStage;
 use afl::tuples::tuple_list;
 use afl::utils::StdRand;
 
-#[no_mangle]
 extern "C" {
     /// int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size)
     fn LLVMFuzzerTestOneInput(data: *const u8, size: usize) -> i32;
@@ -48,10 +44,8 @@ pub extern "C" fn afl_libfuzzer_main() {
     let mut corpus = InMemoryCorpus::new();
     let mut generator = RandPrintablesGenerator::new(32);
 
-    // TODO: No_std event manager
+    let stats = SimpleStats::new(|s| println!("{}", s));
-    #[cfg(feature = "std")]
+    let mut mgr = LlmpEventManager::new_on_port(1337, stats).unwrap();
-    //let mut events = LoggerEventManager::new(stderr());
-    let mut mgr = LlmpEventManager::new_on_port(1337, stderr()).unwrap();
     if mgr.is_broker() {
         println!("Doing broker things.");
         mgr.broker_loop().unwrap();