Struct libafl :: events :: llmp :: LlmpEventManager Copy item path

impl<S, SP> LlmpEventManager<(), S, SP>
where S: State, SP: ShMemProvider + 'static,

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

Create a manager from a raw LLMP client

pub fn on_port( shmem_provider: SP, port: u16, configuration: EventConfig ) -> Result<LlmpEventManager<(), S, SP>, Error>

Create an LLMP event manager on a port

If the port is not yet bound, it will act as a broker; otherwise, it will act as a client.

pub fn existing_client_from_env( shmem_provider: SP, env_name: &str, configuration: EventConfig ) -> Result<LlmpEventManager<(), S, SP>, Error>

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

pub fn existing_client_from_description( shmem_provider: SP, description: &LlmpClientDescription, configuration: EventConfig ) -> Result<LlmpEventManager<(), S, SP>, Error>

Create an existing client from description

impl<EMH, S, SP> LlmpEventManager<EMH, S, SP>
where S: State, SP: ShMemProvider + 'static,

pub fn detach_from_broker(&self, broker_port: u16) -> Result<(), Error>

Calling this function will tell the llmp broker that this client is exiting This should be called from the restarter not from the actual fuzzer client This function serves the same roll as the LlmpClient.send_exiting() However, from the the event restarter process it is forbidden to call send_exiting() (You can call it and it compiles but you should never do so) send_exiting() is exclusive to the fuzzer client.

pub fn with_hooks( llmp: LlmpClient<SP>, configuration: EventConfig, hooks: EMH ) -> Result<Self, Error>

Create a manager from a raw LLMP client with hooks

pub fn on_port_with_hooks( shmem_provider: SP, port: u16, configuration: EventConfig, hooks: EMH ) -> Result<Self, Error>

Create an LLMP event manager on a port with hook

If the port is not yet bound, it will act as a broker; otherwise, it will act as a client. This will make a new connection to the broker so will return its new ClientId, too

pub fn existing_client_from_env_with_hooks( shmem_provider: SP, env_name: &str, configuration: EventConfig, hooks: EMH ) -> Result<Self, Error>

If a client respawns, it may reuse the existing connection, previously stored by LlmpClient::to_env(). create a event manager from env with hooks

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

Describe the client event manager’s LLMP parts in a restorable fashion

pub fn existing_client_from_description_with_hooks( shmem_provider: SP, description: &LlmpClientDescription, configuration: EventConfig, hooks: EMH ) -> 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().

impl<EMH, S: State, SP: ShMemProvider> LlmpEventManager<EMH, S, SP>

pub fn send_exiting(&mut self) -> Result<(), Error>

Send information that this client is exiting. The other side may free up all allocated memory. We are no longer allowed to send anything afterwards.

Trait Implementations§

impl<EMH, S, SP> AdaptiveSerializer for LlmpEventManager<EMH, S, SP>
where SP: ShMemProvider + 'static, S: State,

fn serialization_time(&self) -> Duration

Expose the collected observers serialization time

fn deserialization_time(&self) -> Duration

Expose the collected observers deserialization time

fn serializations_cnt(&self) -> usize

How many times observers were serialized

fn should_serialize_cnt(&self) -> usize

How many times shoukd have been serialized an observer

fn serialization_time_mut(&mut self) -> &mut Duration

Expose the collected observers serialization time (mut)

fn deserialization_time_mut(&mut self) -> &mut Duration

Expose the collected observers deserialization time (mut)

fn serializations_cnt_mut(&mut self) -> &mut usize

How many times observers were serialized (mut)

fn should_serialize_cnt_mut(&mut self) -> &mut usize

How many times shoukd have been serialized an observer (mut)

fn serialize_observers_adaptive<S, OT>( &mut self, observers: &OT, time_factor: u32, percentage_threshold: usize ) -> Result<Option<Vec<u8>>, Error>
where OT: ObserversTuple<S> + Serialize, S: UsesInput,

Serialize the observer using the time_factor and percentage_threshold. These parameters are unique to each of the different types of EventManager

impl<EMH, S, SP> Debug for LlmpEventManager<EMH, S, SP>
where SP: ShMemProvider + 'static, S: State,

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

Formats the value using the given formatter. Read more

impl<EMH, S, SP> Drop for LlmpEventManager<EMH, S, SP>
where SP: ShMemProvider + 'static, S: State,

fn drop(&mut self)

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

impl<EMH, S, SP> EventFirer for LlmpEventManager<EMH, S, SP>
where S: State, SP: ShMemProvider,

fn fire( &mut self, _state: &mut Self::State, event: Event<<Self::State as UsesInput>::Input> ) -> Result<(), Error>

Send off an Event to the broker Read more

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

Serialize all observers for this type and manager

fn configuration(&self) -> EventConfig

Get the configuration

fn log( &mut self, state: &mut Self::State, 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.

impl<E, EMH, S, SP, Z> EventProcessor<E, Z> for LlmpEventManager<EMH, S, SP>
where EMH: EventManagerHooksTuple<S>, S: State + HasExecutions + HasMetadata, SP: ShMemProvider, E: HasObservers<State = S> + Executor<Self, Z>, for<'a> E::Observers: Deserialize<'a>, Z: EvaluatorObservers<E::Observers, State = S> + ExecutionProcessor<E::Observers, State = S>,

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

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

impl<EMH, S, SP> EventRestarter for LlmpEventManager<EMH, S, SP>
where S: State, SP: ShMemProvider,

fn await_restart_safe(&mut self)

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

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

For restarting event managers, implement a way to forward state to their next peers. You must ensure that HasCurrentStage::on_restart will be invoked in this method, by you or an internal EventRestarter, before the state is saved for recovery.

fn send_exiting(&mut self) -> Result<(), Error>

Send information that this client is exiting. No need to restart us any longer, and no need to print an error, either.

impl<EMH, S, SP> HasCustomBufHandlers for LlmpEventManager<EMH, S, SP>
where S: State, SP: ShMemProvider,

fn add_custom_buf_handler( &mut self, handler: Box<dyn FnMut(&mut S, &str, &[u8]) -> Result<CustomBufEventResult, Error>> )

Adds a custom buffer handler that will run for each incoming CustomBuf event.

impl<EMH, S, SP> HasEventManagerId for LlmpEventManager<EMH, S, SP>
where S: State, SP: ShMemProvider,

fn mgr_id(&self) -> EventManagerId

Gets the id assigned to this staterestorer.

impl<EMH, S, SP> ProgressReporter for LlmpEventManager<EMH, S, SP>
where S: State + HasExecutions + HasMetadata + HasLastReportTime, SP: ShMemProvider,

fn maybe_report_progress( &mut self, state: &mut Self::State, monitor_timeout: Duration ) -> Result<(), Error>

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.

fn report_progress(&mut self, state: &mut Self::State) -> Result<(), Error>

Send off an info/monitor/heartbeat message to the broker. Will return an crate::Error, if the stats could not be sent.

impl<EMH, S, SP> UsesState for LlmpEventManager<EMH, S, SP>
where S: State, SP: ShMemProvider,

type State = S

The state known by this type.

impl<E, EMH, S, SP, Z> EventManager<E, Z> for LlmpEventManager<EMH, S, SP>
where E: HasObservers<State = S> + Executor<Self, Z>, for<'a> E::Observers: Deserialize<'a>, EMH: EventManagerHooksTuple<S>, S: State + HasExecutions + HasMetadata + HasLastReportTime, SP: ShMemProvider, Z: EvaluatorObservers<E::Observers, State = S> + ExecutionProcessor<E::Observers, State = S>,

Auto Trait Implementations§

impl<EMH, S, SP> Freeze for LlmpEventManager<EMH, S, SP>
where EMH: Freeze, SP: Freeze, <SP as ShMemProvider>::ShMem: Freeze,

impl<EMH, S, SP> Unpin for LlmpEventManager<EMH, S, SP>
where EMH: Unpin, S: Unpin, SP: Unpin, <SP as ShMemProvider>::ShMem: Unpin,

impl<EMH, S, SP> !UnwindSafe for LlmpEventManager<EMH, S, SP>

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> Conv for T

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, W> HasTypeWitness<W> for T
where W: MakeTypeWitness<Arg = T>, T: ?Sized,

const WITNESS: W = W::MAKE

A constant of the type witness

impl<T> Identity for T
where T: ?Sized,

type Type = T

The same type as Self, used to emulate type equality bounds (T == U) with associated type equality constraints (T: Identity<Type = U>).

const TYPE_EQ: TypeEq<T, <T as Identity>::Type> = TypeEq::NEW

Proof that Self is the same type as Self::Type, provides methods for casting between Self and Self::Type.

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> Pipe for T
where T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R
where Self: BorrowMut, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.

impl<Tail, T> Prepend<T> for Tail

type PreprendResult = Tail

The Resulting TupleList, of an Prepend::prepend() call, including the prepended entry.

fn prepend(self, value: T) -> (T, <Tail as Prepend<T>>::PreprendResult)

Prepend a value to this tuple, returning a new tuple with prepended value.

impl<T> Same for T

type Output = T

Should always be Self

impl<T> Tap for T

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more

fn tap_borrow(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow, B: ?Sized,

Immutable access to the Borrow of a value. Read more

fn tap_borrow_mut(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut, B: ?Sized,

Mutable access to the BorrowMut of a value. Read more

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.

fn tap_borrow_dbg(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.

fn tap_borrow_mut_dbg(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.

impl<T> TryConv for T

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for T
where U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<KS> UsesInput for KS
where KS: UsesState,

type Input = <<KS as UsesState>::State as UsesInput>::Input

Type which will be used throughout this state.

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more