Trait libafl::executors::Executor

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

    fn with_observers<OT>(self, observers: OT) -> WithObservers<Self, OT>
    where
        Self: Sized,
        OT: ObserversTuple<Self::State>,
    { ... }
    fn post_run_reset(&mut self) { ... }
}

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.

fn post_run_reset(&mut self)

Custom Reset Handler, e.g., to reset timers

Implementors

impl<'a, EM, H, OT, S, SP, Z> Executor<EM, Z> for InProcessForkExecutor<'a, H, OT, S, SP>where
    EM: UsesState<State = S>,
    H: FnMut(&S::Input) -> ExitKind + ?Sized,
    OT: ObserversTuple<S>,
    S: UsesInput,
    SP: ShMemProvider,
    Z: UsesState<State = S>,

impl<'a, EM, H, OT, S, SP, Z> Executor<EM, Z> for TimeoutInProcessForkExecutor<'a, H, OT, S, SP>where
    EM: UsesState<State = S>,
    H: FnMut(&S::Input) -> ExitKind + ?Sized,
    OT: ObserversTuple<S>,
    S: UsesInput,
    SP: ShMemProvider,
    Z: UsesState<State = S>,

impl<A, B, EM, DOT, Z> Executor<EM, Z> for DiffExecutor<A, B, A::Observers, B::Observers, DOT>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>,
    Z: UsesState<State = A::State>,

impl<E, EM, OT, Z> Executor<EM, Z> for WithObservers<E, OT>where
    E: Executor<EM, Z> + Debug,
    OT: Debug,
    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<E, EM, Z> Executor<EM, Z> for TimeoutForkserverExecutor<E>where
    E: Executor<EM, Z> + HasForkserver + Debug,
    E::Input: HasTargetBytes,
    EM: UsesState<State = E::State>,
    Z: UsesState<State = E::State>,

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

impl<EM, H, HB, OT, S, Z> Executor<EM, Z> for GenericInProcessExecutor<H, HB, OT, S>where
    H: FnMut(&S::Input) -> ExitKind + ?Sized,
    HB: BorrowMut<H>,
    EM: UsesState<State = S>,
    OT: ObserversTuple<S>,
    S: UsesInput,
    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: UsesInput,
    S::Input: HasTargetBytes,
    EM: UsesState<State = S>,
    Z: UsesState<State = S>,

impl<EM, OT, S, T, Z> Executor<EM, Z> for CommandExecutor<EM, OT, S, T, Z>where
    EM: UsesState<State = S>,
    S: UsesInput,
    S::Input: HasTargetBytes,
    T: CommandConfigurator + Debug,
    OT: Debug + MatchName + ObserversTuple<S>,
    Z: UsesState<State = S>,