Trait libafl::events::EventProcessor[−][src]

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

    fn serialize_observers<OT>(
        &mut self, 
        observers: &OT
    ) -> Result<Vec<u8>, Error>
    where
        OT: ObserversTuple,
    { ... }

    fn deserialize_observers<OT>(
        &mut self, 
        observers_buf: &[u8]
    ) -> Result<OT, Error>
    where
        OT: ObserversTuple,
    { ... }
}
Expand description

EventProcessor process all the incoming messages

Required methods

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

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

Provided methods

fn serialize_observers<OT>(&mut self, observers: &OT) -> Result<Vec<u8>, Error> where
    OT: ObserversTuple, [src]

Serialize all observers for this type and manager

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

Deserialize all observers for this type and manager

Implementors

impl<E, I, OT, S, SP, ST, Z> EventProcessor<E, S, Z> for LlmpEventManager<I, OT, S, SP, ST> where
    SP: ShMemProvider,
    ST: Stats,
    E: Executor<I>,
    I: Input,
    OT: ObserversTuple,
    Z: IfInteresting<I, S> + IsInteresting<I, OT, S>, [src]

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

impl<E, I, OT, S, SP, ST, Z> EventProcessor<E, S, Z> for LlmpRestartingEventManager<I, OT, S, SP, ST> where
    E: Executor<I>,
    I: Input,
    Z: IfInteresting<I, S> + IsInteresting<I, OT, S>,
    OT: ObserversTuple,
    SP: ShMemProvider + 'static,
    ST: Stats, [src]

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

impl<E, I, S, ST, Z> EventProcessor<E, S, Z> for SimpleEventManager<I, ST> where
    I: Input,
    ST: Stats, [src]

fn process(
    &mut self,
    _fuzzer: &mut Z,
    state: &mut S,
    _executor: &mut E
) -> Result<usize, Error>[src]

impl<E, S, Z> EventProcessor<E, S, Z> for NopEventManager[src]

fn process(
    &mut self,
    _fuzzer: &mut Z,
    _state: &mut S,
    _executor: &mut E
) -> Result<usize, Error>[src]