Trait libafl::executors::Executor

pub trait Executor<EM, Z>: UsesState
where
    EM: UsesState<State = Self::State>,
    Z: UsesState<State = Self::State>,
{
    // Required method
    fn run_target(
        &mut self,
        fuzzer: &mut Z,
        state: &mut Self::State,
        mgr: &mut EM,
        input: &Self::Input
    ) -> Result<ExitKind, Error>;

    // Provided method
    fn with_observers<OT>(self, observers: OT) -> WithObservers<Self, OT>
       where Self: Sized,
             OT: ObserversTuple<Self::State> { ... }
}

An executor takes the given inputs, and runs the harness/target.

Required Methods

fn run_target( &mut self, fuzzer: &mut Z, state: &mut Self::State, mgr: &mut EM, input: &Self::Input ) -> Result<ExitKind, Error>

Instruct the target about the input and run

Provided Methods

fn with_observers<OT>(self, observers: OT) -> WithObservers<Self, OT>

where Self: Sized, OT: ObserversTuple<Self::State>,

Wraps this Executor with the given ObserversTuple to implement HasObservers.

If the executor already implements HasObservers, then the original implementation will be overshadowed by the implementation of this wrapper.

Implementors

impl<'a, EM, H, HT, OT, S, SP, Z> Executor<EM, Z> for GenericInProcessForkExecutor<'a, H, HT, OT, S, SP, EM, Z>

where H: FnMut(&S::Input) -> ExitKind + ?Sized, OT: ObserversTuple<S> + Debug, S: State + HasExecutions, SP: ShMemProvider, HT: ExecutorHooksTuple<S>, EM: EventFirer<State = S> + EventRestarter<State = S>, Z: UsesState<State = S>,

impl<'a, EM, H, HT, OT, S, SP, Z, ES, OF> Executor<EM, Z> for StatefulGenericInProcessForkExecutor<'a, H, HT, OT, S, SP, ES, EM, Z>

where H: FnMut(&S::Input, &mut ES) -> ExitKind + ?Sized, OT: ObserversTuple<S> + Debug, S: State + HasExecutions, SP: ShMemProvider, HT: ExecutorHooksTuple<S>, EM: EventFirer<State = S> + EventRestarter<State = S>, Z: HasObjective<Objective = OF, State = S>, OF: Feedback<S>,

impl<A, B, DOT, EM, Z> Executor<EM, Z> for DiffExecutor<A, B, DOT, A::Observers, B::Observers>

where A: Executor<EM, Z> + HasObservers, B: Executor<EM, Z, State = A::State> + HasObservers, EM: UsesState<State = A::State>, DOT: DifferentialObserversTuple<A::Observers, B::Observers, A::State>, Z: UsesState<State = A::State>,

impl<A, B, EM, Z> Executor<EM, Z> for CombinedExecutor<A, B>

where A: Executor<EM, Z>, B: Executor<EM, Z, State = A::State>, EM: UsesState<State = A::State>, EM::State: HasExecutions, Z: UsesState<State = A::State>,

impl<E, EM, OT, Z> Executor<EM, Z> for WithObservers<E, OT>

where E: Executor<EM, Z>, EM: UsesState<State = E::State>, Z: UsesState<State = E::State>,

impl<E, EM, SOT, Z> Executor<EM, Z> for ShadowExecutor<E, SOT>

where E: Executor<EM, Z> + HasObservers, SOT: ObserversTuple<E::State>, EM: UsesState<State = E::State>, Z: UsesState<State = E::State>,

impl<EM, H, HB, HT, OT, S, Z> Executor<EM, Z> for GenericInProcessExecutor<H, HB, HT, OT, S>

where EM: UsesState<State = S>, H: FnMut(&S::Input) -> ExitKind + ?Sized, HB: BorrowMut<H>, HT: ExecutorHooksTuple<S>, OT: ObserversTuple<S>, S: State + HasExecutions, Z: UsesState<State = S>,

impl<EM, H, HB, HT, OT, S, Z, ES> Executor<EM, Z> for StatefulGenericInProcessExecutor<H, HB, HT, OT, S, ES>

where EM: UsesState<State = S>, H: FnMut(&S::Input, &mut ES) -> ExitKind + ?Sized, HB: BorrowMut<H>, HT: ExecutorHooksTuple<S>, OT: ObserversTuple<S>, S: State + HasExecutions, Z: UsesState<State = S>,

impl<EM, OT, S, SP, Z> Executor<EM, Z> for ForkserverExecutor<OT, S, SP>

where OT: ObserversTuple<S>, SP: ShMemProvider, S: State + HasExecutions, S::Input: HasTargetBytes, EM: UsesState<State = S>, Z: UsesState<State = S>,

impl<EM, OT, S, T, Z> Executor<EM, Z> for CommandExecutor<OT, S, T>

where EM: UsesState<State = S>, S: State + HasExecutions, S::Input: HasTargetBytes, T: CommandConfigurator, OT: Debug + MatchName + ObserversTuple<S>, Z: UsesState<State = S>,