Struct libafl::events::simple::SimpleRestartingEventManager

pub struct SimpleRestartingEventManager<'a, C, I, MT, S, SC, SP> where
    C: Corpus<I>,
    I: Input,
    S: Serialize,
    SP: ShMemProvider,
    MT: Monitor,  { /* fields omitted */ }

Provides a builder which can be used to build a SimpleRestartingEventManager, which is a combination of a restarter and runner, that can be used on systems both with and without fork support. The restarter will start a new process each time the child crashes or times out.

Implementations

impl<'a, C, I, MT, S, SC, SP> SimpleRestartingEventManager<'a, C, I, MT, S, SC, SP> where
    C: Corpus<I>,
    I: Input,
    S: DeserializeOwned + Serialize + HasCorpus<C, I> + HasSolutions<SC, I>,
    SC: Corpus<I>,
    SP: ShMemProvider,
    MT: Monitor, 

pub fn launch(
    monitor: MT,
    shmem_provider: &mut SP
) -> Result<(Option<S>, Self), Error>

Launch the simple restarting manager. This EventManager is simple and single threaded, but can still used shared maps to recover from crashes and timeouts.

Trait Implementations

impl<'a, C, I, MT, S, SC, SP> EventFirer<I> for SimpleRestartingEventManager<'a, C, I, MT, S, SC, SP> where
    C: Corpus<I>,
    I: Input,
    S: Serialize,
    SP: ShMemProvider,
    MT: Monitor, 

fn fire<S2>(&mut self, _state: &mut S2, event: Event<I>) -> Result<(), Error>

Send off an Event to the broker

fn log<S>(
    &mut self,
    state: &mut S,
    severity_level: LogSeverity,
    message: String
) -> Result<(), Error>

Send off an Event::Log event to the broker This is a shortcut for EventFirer::fire with Event::Log as argument.

fn serialize_observers<OT, S>(
    &mut self,
    observers: &OT
) -> Result<Vec<u8>, Error> where
    OT: ObserversTuple<I, S> + Serialize, 

Serialize all observers for this type and manager

fn configuration(&self) -> EventConfig

Get the configuration

impl<'a, C, E, I, S, SC, SP, MT, Z> EventProcessor<E, I, S, Z> for SimpleRestartingEventManager<'a, C, I, MT, S, SC, SP> where
    C: Corpus<I>,
    I: Input,
    S: Serialize,
    SP: ShMemProvider,
    MT: Monitor, 

fn process(
    &mut self,
    fuzzer: &mut Z,
    state: &mut S,
    executor: &mut E
) -> Result<usize, Error>

Lookup for incoming events and process them. Return the number of processes events or an error

fn deserialize_observers<OT>(
    &mut self,
    observers_buf: &[u8]
) -> Result<OT, Error> where
    OT: ObserversTuple<I, S> + DeserializeOwned, 

Deserialize all observers for this type and manager

impl<'a, C, I, MT, S, SC, SP> EventRestarter<S> for SimpleRestartingEventManager<'a, C, I, MT, S, SC, SP> where
    C: Corpus<I>,
    I: Input,
    S: Serialize,
    SP: ShMemProvider,
    MT: Monitor, 

fn on_restart(&mut self, state: &mut S) -> Result<(), Error>

Reset the single page (we reuse it over and over from pos 0), then send the current state to the next runner.

fn await_restart_safe(&mut self)

Block until we are safe to exit.

impl<'a, C, I, MT, S, SC, SP> HasEventManagerId for SimpleRestartingEventManager<'a, C, I, MT, S, SC, SP> where
    C: Corpus<I>,
    I: Input,
    S: Serialize,
    SP: ShMemProvider,
    MT: Monitor, 

fn mgr_id(&self) -> EventManagerId

The id of this manager. For Multiprocessed EventManagers, each client sholud have a unique ids.

impl<'a, C, I, MT, S, SC, SP> ProgressReporter<I> for SimpleRestartingEventManager<'a, C, I, MT, S, SC, SP> where
    I: Input,
    C: Corpus<I>,
    S: Serialize,
    SP: ShMemProvider,
    MT: Monitor, 

fn maybe_report_progress<S>(
    &mut self,
    state: &mut S,
    last_report_time: Duration,
    monitor_timeout: Duration
) -> Result<Duration, Error> where
    S: HasExecutions + HasClientPerfMonitor, 

Given the last time, if monitor_timeout seconds passed, send off an info/monitor/heartbeat message to the broker. Returns the new last time (so the old one, unless monitor_timeout time has passed and monitor have been sent) Will return an crate::Error, if the stats could not be sent.

impl<'a, C, E, I, S, SC, SP, MT, Z> EventManager<E, I, S, Z> for SimpleRestartingEventManager<'a, C, I, MT, S, SC, SP> where
    C: Corpus<I>,
    I: Input,
    S: Serialize,
    SP: ShMemProvider,
    MT: Monitor,