Struct libafl::executors::inprocess::InProcessExecutor

pub struct InProcessExecutor<'a, H, I, OT, S> where
    H: FnMut(&I) -> ExitKind,
    I: Input,
    OT: ObserversTuple<I, S>,  { /* fields omitted */ }

The inmem executor simply calls a target function, then returns afterwards.

Implementations

impl<'a, H, I, OT, S> InProcessExecutor<'a, H, I, OT, S> where
    H: FnMut(&I) -> ExitKind,
    I: Input,
    OT: ObserversTuple<I, S>, 

pub fn new<EM, OC, OF, Z>(
    harness_fn: &'a mut H,
    observers: OT,
    _fuzzer: &mut Z,
    _state: &mut S,
    _event_mgr: &mut EM
) -> Result<Self, Error> where
    EM: EventFirer<I> + EventRestarter<S>,
    OC: Corpus<I>,
    OF: Feedback<I, S>,
    S: HasSolutions<OC, I> + HasClientPerfMonitor,
    Z: HasObjective<I, OF, S>, 

Create a new in mem executor. Caution: crash and restart in one of them will lead to odd behavior if multiple are used, depending on different corpus or state.

• harness_fn - the harness, executiong the function
• observers - the observers observing the target during execution This may return an error on unix, if signal handler setup fails

pub fn harness(&self) -> &H

Retrieve the harness function.

pub fn harness_mut(&mut self) -> &mut H

Retrieve the harness function for a mutable reference.

Trait Implementations

impl<'a, H: Debug, I: Debug, OT: Debug, S: Debug> Debug for InProcessExecutor<'a, H, I, OT, S> where
    H: FnMut(&I) -> ExitKind,
    I: Input,
    OT: ObserversTuple<I, S>, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, EM, H, I, OT, S, Z> Executor<EM, I, S, Z> for InProcessExecutor<'a, H, I, OT, S> where
    H: FnMut(&I) -> ExitKind,
    I: Input,
    OT: ObserversTuple<I, S>, 

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

Instruct the target about the input and run

fn with_observers<OT>(self, observers: OT) -> WithObservers<Self, OT> where
    Self: Sized,
    OT: ObserversTuple<I, S>, 

Wraps this Executor with the given ObserversTuple to implement HasObservers.

impl<'a, H, I, OT, S> HasObservers<I, OT, S> for InProcessExecutor<'a, H, I, OT, S> where
    H: FnMut(&I) -> ExitKind,
    I: Input,
    OT: ObserversTuple<I, S>, 

fn observers(&self) -> &OT

Get the linked observers

fn observers_mut(&mut self) -> &mut OT

Get the linked observers