return last error from observers, if any, code fmt

src/executors/mod.rs

@@ -1,19 +1,17 @@
-use crate::AflError;
 use crate::inputs::Input;
 use crate::observers::Observer;
+use crate::AflError;
 
 use std::ptr;
-use std::iter;
 
 pub enum ExitKind {
     Ok,
     Crash,
     OOM,
-    Timeout
+    Timeout,
 }
 
 pub trait Executor {
-
     fn run_target(&mut self) -> Result<ExitKind, AflError>;
 
     fn place_input(&mut self, input: Box<dyn Input>) -> Result<(), AflError>;
@@ -23,41 +21,39 @@ pub trait Executor {
     fn post_exec_observers(&mut self) -> Result<(), AflError>;
 
     fn add_observer(&mut self, observer: Box<dyn Observer>);
-
 }
 
 // TODO abstract classes? how?
 pub struct ExecutorBase {
-
     observers: Vec<Box<dyn Observer>>,
-    cur_input: Option<Box<dyn Input>>
+    cur_input: Option<Box<dyn Input>>,
-
 }
 
 type HarnessFunction = fn(&dyn Executor, &[u8]) -> ExitKind;
 
 pub struct InMemoryExecutor {
-
     base: ExecutorBase,
     harness: HarnessFunction,
-
 }
 
 static mut CURRENT_INMEMORY_EXECUTOR_PTR: *const InMemoryExecutor = ptr::null();
 
 impl Executor for InMemoryExecutor {
-
     fn run_target(&mut self) -> Result<ExitKind, AflError> {
         let bytes = match self.base.cur_input.as_ref() {
             Some(i) => i.serialize(),
-            None => return Err(AflError::Unknown)
+            None => return Err(AflError::Unknown),
         };
-        unsafe { CURRENT_INMEMORY_EXECUTOR_PTR = self as *const InMemoryExecutor; }
+        unsafe {
+            CURRENT_INMEMORY_EXECUTOR_PTR = self as *const InMemoryExecutor;
+        }
         let ret = match bytes {
             Ok(b) => Ok((self.harness)(self, b)),
-            Err(e) => Err(e)
+            Err(e) => Err(e),
         };
-        unsafe { CURRENT_INMEMORY_EXECUTOR_PTR = ptr::null(); }
+        unsafe {
+            CURRENT_INMEMORY_EXECUTOR_PTR = ptr::null();
+        }
         ret
     }
 
@@ -74,12 +70,14 @@ impl Executor for InMemoryExecutor {
     }
 
     fn post_exec_observers(&mut self) -> Result<(), AflError> {
-        self.base.observers.iter_mut().map(|x| x.post_exec());
+        self.base
-        Ok(())
+            .observers
+            .iter_mut()
+            .map(|x| x.post_exec())
+            .fold(Ok(()), |acc, x| if x.is_err() { x } else { acc })
     }
 
     fn add_observer(&mut self, observer: Box<dyn Observer>) {
         self.base.observers.push(observer);
     }
-
 }

src/lib.rs

@@ -8,9 +8,9 @@ pub mod feedbacks;
 pub mod inputs;
 pub mod monitors;
 pub mod mutators;
+pub mod observers;
 pub mod stages;
 pub mod utils;
-pub mod observers;
 
 #[derive(Error, Debug)]
 pub enum AflError {

src/observers/mod.rs

@@ -1,8 +1,6 @@
 use crate::AflError;
-use crate::executors::Executor;
 
 pub trait Observer {
-
     fn flush(&mut self) -> Result<(), AflError> {
         Ok(())
     }
@@ -12,5 +10,4 @@ pub trait Observer {
     fn post_exec(&mut self) -> Result<(), AflError> {
         Ok(())
     }
-
 }