Struct libafl::events::llmp::LlmpEventManager

pub struct LlmpEventManager<I, OT, S, SP> where
    I: Input,
    OT: ObserversTuple<I, S>,
    SP: ShMemProvider + 'static,  { /* fields omitted */ }

An EventManager that forwards all events to other attached fuzzers on shared maps or via tcp, using low-level message passing, crate::bolts::llmp.

Implementations

impl<I, OT, S, SP> LlmpEventManager<I, OT, S, SP> where
    I: Input,
    OT: ObserversTuple<I, S>,
    SP: ShMemProvider + 'static, 

pub fn new(llmp: LlmpClient<SP>, configuration: String) -> Result<Self, Error>

Create a manager from a raw llmp client

pub fn new_on_port(
    shmem_provider: SP,
    port: u16,
    configuration: String
) -> Result<Self, Error>

Create llmp on a port If the port is not yet bound, it will act as broker Else, it will act as client.

pub fn existing_client_from_env(
    shmem_provider: SP,
    env_name: &str,
    configuration: String
) -> Result<Self, Error>

If a client respawns, it may reuse the existing connection, previously stored by LlmpClient::to_env().

pub fn describe(&self) -> Result<LlmpClientDescription, Error>

Describe the client event mgr’s llmp parts in a restorable fashion

pub fn existing_client_from_description(
    shmem_provider: SP,
    description: &LlmpClientDescription,
    configuration: String
) -> Result<Self, Error>

Create an existing client from description

pub fn to_env(&self, env_name: &str)

Write the config for a client EventManager to env vars, a new client can reattach using LlmpEventManager::existing_client_from_env().

Trait Implementations

impl<I: Debug, OT: Debug, S: Debug, SP: Debug> Debug for LlmpEventManager<I, OT, S, SP> where
    I: Input,
    OT: ObserversTuple<I, S>,
    SP: ShMemProvider + 'static, 

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

Formats the value using the given formatter.

impl<I, OT, S, SP> Drop for LlmpEventManager<I, OT, S, SP> where
    I: Input,
    OT: ObserversTuple<I, S>,
    SP: ShMemProvider + 'static, 

fn drop(&mut self)

LLMP clients will have to wait until their pages are mapped by somebody.

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

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

Send off an Event to the broker

fn configuration(&self) -> &str

Get the configuration

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

impl<E, I, OT, S, SP, Z> EventProcessor<E, I, S, Z> for LlmpEventManager<I, OT, S, SP> where
    SP: ShMemProvider,
    E: Executor<Self, I, S, Z> + HasObservers<I, OT, S>,
    I: Input,
    OT: ObserversTuple<I, S> + DeserializeOwned,
    Z: ExecutionProcessor<I, OT, S> + EvaluatorObservers<I, OT, S>, 

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<I, OT, S, SP> EventRestarter<S> for LlmpEventManager<I, OT, S, SP> where
    I: Input,
    OT: ObserversTuple<I, S>,
    SP: ShMemProvider, 

fn await_restart_safe(&mut self)

The llmp client needs to wait until a broker mapped all pages, before shutting down. Otherwise, the OS may already have removed the shared maps,

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

For restarting event managers, implement a way to forward state to their next peers.

impl<I, OT, S, SP> HasEventManagerId for LlmpEventManager<I, OT, S, SP> where
    I: Input,
    OT: ObserversTuple<I, S> + DeserializeOwned,
    SP: ShMemProvider, 

fn mgr_id(&self) -> EventManagerId

Gets the id assigned to this staterestorer.

impl<E, I, OT, S, SP, Z> EventManager<E, I, S, Z> for LlmpEventManager<I, OT, S, SP> where
    E: Executor<Self, I, S, Z> + HasObservers<I, OT, S>,
    I: Input,
    OT: ObserversTuple<I, S> + DeserializeOwned,
    SP: ShMemProvider,
    Z: ExecutionProcessor<I, OT, S> + EvaluatorObservers<I, OT, S>,