Trait libafl::executors::HasExecHooks

pub trait HasExecHooks<EM, I, S, Z> {
    fn pre_exec(
        &mut self, 
        _fuzzer: &mut Z, 
        _state: &mut S, 
        _mgr: &mut EM, 
        _input: &I
    ) -> Result<(), Error> { ... }
    fn post_exec(
        &mut self, 
        _fuzzer: &mut Z, 
        _state: &mut S, 
        _mgr: &mut EM, 
        _input: &I
    ) -> Result<(), Error> { ... }
}

Pre and post exec hooks

Provided methods

fn pre_exec(
    &mut self,
    _fuzzer: &mut Z,
    _state: &mut S,
    _mgr: &mut EM,
    _input: &I
) -> Result<(), Error>

Called right before exexution starts

fn post_exec(
    &mut self,
    _fuzzer: &mut Z,
    _state: &mut S,
    _mgr: &mut EM,
    _input: &I
) -> Result<(), Error>

Called right after execution finished.

Implementors

impl<'a, CM, EM, I, S, Z> HasExecHooks<EM, I, S, Z> for StdCmpObserver<'a, CM> where
    CM: CmpMap, 

fn pre_exec(
    &mut self,
    _fuzzer: &mut Z,
    _state: &mut S,
    _mgr: &mut EM,
    _input: &I
) -> Result<(), Error>

impl<'a, EM, H, I, OT, S, Z> HasExecHooks<EM, I, S, Z> for InProcessExecutor<'a, H, I, OT, S> where
    H: FnMut(&[u8]) -> ExitKind,
    I: Input + HasTargetBytes,
    OT: ObserversTuple, 

fn pre_exec(
    &mut self,
    _fuzzer: &mut Z,
    _state: &mut S,
    _event_mgr: &mut EM,
    _input: &I
) -> Result<(), Error>

fn post_exec(
    &mut self,
    _fuzzer: &mut Z,
    _state: &mut S,
    _event_mgr: &mut EM,
    _input: &I
) -> Result<(), Error>

impl<'a, EM, I, S, T, Z> HasExecHooks<EM, I, S, Z> for StdMapObserver<'a, T> where
    T: Default + Copy + 'static + Serialize + DeserializeOwned,
    Self: MapObserver<T>, 

fn pre_exec(
    &mut self,
    _fuzzer: &mut Z,
    _state: &mut S,
    _mgr: &mut EM,
    _input: &I
) -> Result<(), Error>

impl<'a, EM, I, S, T, Z> HasExecHooks<EM, I, S, Z> for VariableMapObserver<'a, T> where
    T: Default + Copy + 'static + Serialize + DeserializeOwned, 

fn pre_exec(
    &mut self,
    _fuzzer: &mut Z,
    _state: &mut S,
    _mgr: &mut EM,
    _input: &I
) -> Result<(), Error>

impl<A, B, EM, I, S, Z> HasExecHooks<EM, I, S, Z> for CombinedExecutor<A, B, I> where
    A: Executor<I> + HasExecHooks<EM, I, S, Z>,
    B: Executor<I>,
    I: Input, 

fn pre_exec(
    &mut self,
    fuzzer: &mut Z,
    state: &mut S,
    mgr: &mut EM,
    input: &I
) -> Result<(), Error>

fn post_exec(
    &mut self,
    fuzzer: &mut Z,
    state: &mut S,
    mgr: &mut EM,
    input: &I
) -> Result<(), Error>

impl<E, EM, I, S, Z> HasExecHooks<EM, I, S, Z> for TimeoutExecutor<E, I> where
    E: Executor<I> + HasExecHooks<EM, I, S, Z>,
    I: Input, 

fn pre_exec(
    &mut self,
    fuzzer: &mut Z,
    state: &mut S,
    mgr: &mut EM,
    input: &I
) -> Result<(), Error>

fn post_exec(
    &mut self,
    fuzzer: &mut Z,
    state: &mut S,
    mgr: &mut EM,
    input: &I
) -> Result<(), Error>

impl<EM, I, S, M, Z> HasExecHooks<EM, I, S, Z> for HitcountsMapObserver<M> where
    M: MapObserver<u8> + HasExecHooks<EM, I, S, Z>, 

fn pre_exec(
    &mut self,
    fuzzer: &mut Z,
    state: &mut S,
    mgr: &mut EM,
    input: &I
) -> Result<(), Error>

fn post_exec(
    &mut self,
    fuzzer: &mut Z,
    state: &mut S,
    mgr: &mut EM,
    input: &I
) -> Result<(), Error>

impl<EM, I, S, Z> HasExecHooks<EM, I, S, Z> for TimeObserver

fn pre_exec(
    &mut self,
    _fuzzer: &mut Z,
    _state: &mut S,
    _mgr: &mut EM,
    _input: &I
) -> Result<(), Error>

fn post_exec(
    &mut self,
    _fuzzer: &mut Z,
    _state: &mut S,
    _mgr: &mut EM,
    _input: &I
) -> Result<(), Error>