Trait libafl::events::EventFirer

pub trait EventFirer<I, S> where
    I: Input, {
    fn fire(&mut self, state: &mut S, event: Event<I>) -> Result<(), Error>;

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

EventFirer fire an event.

Required methods

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

Send off an Event to the broker

For multi-processed managers, such as llmp::LlmpEventManager, this serializes the Event and commits it to the llmp page. In this case, if you fire faster than the broker can consume (for example for each Input, on multiple cores) the llmp shared map may fill up and the client will eventually OOM or panic. This should not happen for a normal use-cases.

Provided methods

fn serialize_observers<OT>(&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) -> &str

Get the configuration

Implementors

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

impl<I, OT, S, SP> EventFirer<I, S> for LlmpEventManager<I, OT, S, SP> where
    I: Input,
    OT: ObserversTuple<I, S>,
    SP: ShMemProvider, 

impl<I, OT, S, SP> EventFirer<I, S> for LlmpRestartingEventManager<I, OT, S, SP> where
    I: Input,
    OT: ObserversTuple<I, S>,
    S: Serialize,
    SP: ShMemProvider, 

impl<I, S> EventFirer<I, S> for NopEventManager where
    I: Input, 

impl<I, S, ST> EventFirer<I, S> for SimpleEventManager<I, ST> where
    I: Input,
    ST: Stats,