Trait libafl::state::UsesState

pub trait UsesState: UsesInput<Input = <Self::State as UsesInput>::Input> {
    type State: State;
}

Structs which implement this trait are aware of the state. This is used for type enforcement.

Required Associated Types

type State: State

The state known by this type.

Implementors

impl<'a, CS, O> UsesState for CoverageAccountingScheduler<'a, CS, O>

where CS: UsesState, CS::State: Debug,

type State = <CS as UsesState>::State

impl<'a, H, HT, OT, S, SP, EM, Z> UsesState for GenericInProcessForkExecutor<'a, H, HT, OT, S, SP, EM, Z>

where H: FnMut(&S::Input) -> ExitKind + ?Sized, OT: ObserversTuple<S>, S: State, SP: ShMemProvider, HT: ExecutorHooksTuple<S>, EM: UsesState<State = S>, Z: UsesState<State = S>,

type State = S

impl<'a, H, HT, OT, S, SP, ES, EM, Z> UsesState for StatefulGenericInProcessForkExecutor<'a, H, HT, OT, S, SP, ES, EM, Z>

where H: FnMut(&S::Input, &mut ES) -> ExitKind + ?Sized, OT: ObserversTuple<S>, S: State, SP: ShMemProvider, HT: ExecutorHooksTuple<S>, EM: UsesState<State = S>, Z: UsesState<State = S>,

type State = S

impl<A, B> UsesState for CombinedExecutor<A, B>

where A: UsesState,

type State = <A as UsesState>::State

impl<A, B, DOT, OTA, OTB> UsesState for DiffExecutor<A, B, DOT, OTA, OTB>

where A: UsesState, B: UsesState<State = A::State>,

type State = <A as UsesState>::State

impl<C, E, EM, O, Z> UsesState for ColorizationStage<C, E, EM, O, Z>

where E: UsesState,

type State = <E as UsesState>::State

impl<C, EM, O, OT, Z> UsesState for GeneralizationStage<C, EM, O, OT, Z>

where EM: UsesState, EM::State: UsesInput<Input = BytesInput>,

type State = <EM as UsesState>::State

impl<C, F, O, S> UsesState for WeightedScheduler<C, F, O, S>

where S: State,

type State = S

impl<C, O, OT, S> UsesState for CalibrationStage<C, O, OT, S>

where S: State,

type State = S

impl<C, O, S> UsesState for PowerQueueScheduler<C, O, S>

where S: State,

type State = S

impl<CB, E, EM, ST1, ST2, Z> UsesState for IfElseStage<CB, E, EM, ST1, ST2, Z>

where CB: FnMut(&mut Z, &mut E, &mut E::State, &mut EM) -> Result<bool, Error>, E: UsesState, EM: UsesState<State = E::State>, ST1: StagesTuple<E, EM, E::State, Z>, ST2: StagesTuple<E, EM, E::State, Z>, Z: UsesState<State = E::State>,

type State = <E as UsesState>::State

impl<CB, E, EM, ST, Z> UsesState for IfStage<CB, E, EM, ST, Z>

where CB: FnMut(&mut Z, &mut E, &mut E::State, &mut EM) -> Result<bool, Error>, E: UsesState, EM: UsesState<State = E::State>, ST: StagesTuple<E, EM, E::State, Z>, Z: UsesState<State = E::State>,

type State = <E as UsesState>::State

impl<CB, E, EM, ST, Z> UsesState for WhileStage<CB, E, EM, ST, Z>

where CB: FnMut(&mut Z, &mut E, &mut E::State, &mut EM) -> Result<bool, Error>, E: UsesState, EM: UsesState<State = E::State>, ST: StagesTuple<E, EM, E::State, Z>, Z: UsesState<State = E::State>,

type State = <E as UsesState>::State

impl<CB, E, EM, Z> UsesState for ClosureStage<CB, E, EM, Z>

where CB: FnMut(&mut Z, &mut E, &mut E::State, &mut EM) -> Result<(), Error>, E: UsesState,

type State = <E as UsesState>::State

impl<CB, E, EM, Z> UsesState for SyncFromDiskStage<CB, E, EM, Z>

where E: UsesState,

type State = <E as UsesState>::State

impl<CB, EM, Z> UsesState for DumpToDiskStage<CB, EM, Z>

where EM: UsesState,

type State = <EM as UsesState>::State

impl<CS, E, EM, F1, F2, FF, I, IP, M, OT, Z> UsesState for StdTMinMutationalStage<CS, E, EM, F1, F2, FF, I, IP, M, OT, Z>

where CS: Scheduler, M: Mutator<I, CS::State>, Z: ExecutionProcessor<OT, State = CS::State>, CS::State: HasCorpus, IP: MutatedTransformPost<CS::State> + Clone, I: MutatedTransform<CS::Input, CS::State, Post = IP> + Clone,

type State = <CS as UsesState>::State

impl<CS, EM, OT, PS, Z> UsesState for PushStageAdapter<CS, EM, OT, PS, Z>

where CS: UsesState,

type State = <CS as UsesState>::State

impl<CS, F, M, O> UsesState for MinimizerScheduler<CS, F, M, O>

where CS: UsesState,

type State = <CS as UsesState>::State

impl<CS, F, OF, OT> UsesState for StdFuzzer<CS, F, OF, OT>

where CS: Scheduler, F: Feedback<CS::State>, OF: Feedback<CS::State>, CS::State: HasCorpus,

type State = <CS as UsesState>::State

impl<DI, IC, ICB, S, SP> UsesState for LlmpEventConverter<DI, IC, ICB, S, SP>

where S: State, SP: ShMemProvider, IC: InputConverter<From = S::Input, To = DI>, ICB: InputConverter<From = DI, To = S::Input>, DI: Input,

type State = S

impl<DI, IC, ICB, S, SP> UsesState for SyncFromBrokerStage<DI, IC, ICB, S, SP>

where SP: ShMemProvider + 'static, S: State, IC: InputConverter<From = S::Input, To = DI>, ICB: InputConverter<From = DI, To = S::Input>, DI: Input,

type State = S

impl<E, EM, I, M, Z> UsesState for MultiMutationalStage<E, EM, I, M, Z>

where E: UsesState<State = Z::State>, EM: UsesState<State = Z::State>, M: MultiMutator<I, Z::State>, Z: Evaluator<E, EM>, Z::State: HasCorpus + HasRand,

type State = <Z as UsesState>::State

impl<E, EM, I, M, Z> UsesState for StdMutationalStage<E, EM, I, M, Z>

where E: UsesState<State = Z::State>, EM: UsesState<State = Z::State>, M: Mutator<I, Z::State>, Z: Evaluator<E, EM>, Z::State: HasCorpus + HasRand,

type State = <Z as UsesState>::State

impl<E, EM, I, M, Z> UsesState for TuneableMutationalStage<E, EM, I, M, Z>

where E: UsesState<State = Z::State>, EM: UsesState<State = Z::State>, M: Mutator<I, Z::State>, Z: Evaluator<E, EM>, Z::State: HasCorpus + HasRand + HasExecutions, I: MutatedTransform<Z::Input, Z::State> + Clone,

type State = <Z as UsesState>::State

impl<E, EM, SOT, Z> UsesState for ShadowTracingStage<E, EM, SOT, Z>

where E: UsesState,

type State = <E as UsesState>::State

impl<E, EM, ST, Z> UsesState for OptionalStage<E, EM, ST, Z>

where E: UsesState, EM: UsesState<State = E::State>, ST: StagesTuple<E, EM, E::State, Z>, Z: UsesState<State = E::State>,

type State = <E as UsesState>::State

impl<E, EM, Z> UsesState for AflStatsStage<E, EM, Z>

where E: UsesState, EM: EventFirer<State = E::State>, Z: UsesState<State = E::State>,

type State = <E as UsesState>::State

impl<E, F, EM, I, M, Z> UsesState for PowerMutationalStage<E, F, EM, I, M, Z>

where E: UsesState,

type State = <E as UsesState>::State

impl<E, OT> UsesState for WithObservers<E, OT>

where E: UsesState,

type State = <E as UsesState>::State

impl<E, SOT> UsesState for ShadowExecutor<E, SOT>

where E: UsesState,

type State = <E as UsesState>::State

impl<EM, M> UsesState for MonitorTypedEventManager<EM, M>

where EM: UsesState,

type State = <EM as UsesState>::State

impl<EM, SP> UsesState for CentralizedEventManager<EM, SP>

where EM: UsesState, SP: ShMemProvider + 'static,

type State = <EM as UsesState>::State

impl<EM, TE, Z> UsesState for ConcolicTracingStage<EM, TE, Z>

where TE: UsesState,

type State = <TE as UsesState>::State

impl<EM, TE, Z> UsesState for TracingStage<EM, TE, Z>

where TE: UsesState,

type State = <TE as UsesState>::State

impl<EMH, S> UsesState for TcpEventManager<EMH, S>

where EMH: EventManagerHooksTuple<S>, S: State,

type State = S

impl<EMH, S, SP> UsesState for LlmpEventManager<EMH, S, SP>

where S: State, SP: ShMemProvider,

type State = S

impl<EMH, S, SP> UsesState for LlmpRestartingEventManager<EMH, S, SP>

where S: State, SP: ShMemProvider + 'static,

type State = S

impl<EMH, S, SP> UsesState for TcpRestartingEventManager<EMH, S, SP>

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

type State = S

impl<F, S> UsesState for ProbabilitySamplingScheduler<F, S>

where S: State + HasTestcase,

type State = S

impl<H, HB, HT, OT, S> UsesState for GenericInProcessExecutor<H, HB, HT, OT, S>

where H: FnMut(&S::Input) -> ExitKind + ?Sized, HB: BorrowMut<H>, HT: ExecutorHooksTuple<S>, OT: ObserversTuple<S>, S: State,

type State = S

impl<H, HB, HT, OT, S, ES> UsesState for StatefulGenericInProcessExecutor<H, HB, HT, OT, S, ES>

where H: FnMut(&S::Input, &mut ES) -> ExitKind + ?Sized, HB: BorrowMut<H>, HT: ExecutorHooksTuple<S>, OT: ObserversTuple<S>, S: State,

type State = S

impl<HT, OT, S> UsesState for GenericInProcessExecutorInner<HT, OT, S>

where HT: ExecutorHooksTuple<S>, OT: ObserversTuple<S>, S: State,

type State = S

impl<HT, OT, S, SP, EM, Z> UsesState for GenericInProcessForkExecutorInner<HT, OT, S, SP, EM, Z>

where OT: ObserversTuple<S>, S: State, SP: ShMemProvider, HT: ExecutorHooksTuple<S>, EM: UsesState<State = S>, Z: UsesState<State = S>,

type State = S

impl<MT, S> UsesState for SimpleEventManager<MT, S>

where S: State,

type State = S

impl<MT, S, SP> UsesState for SimpleRestartingEventManager<MT, S, SP>

where S: State, SP: ShMemProvider,

type State = S

impl<OT, S, SP> UsesState for ForkserverExecutor<OT, S, SP>

where S: State, SP: ShMemProvider,

type State = S

impl<OT, S, T> UsesState for CommandExecutor<OT, S, T>

where S: State,

type State = S

impl<S> UsesState for NopEventManager<S>

where S: State,

type State = S

impl<S> UsesState for QueueScheduler<S>

where S: State,

type State = S

impl<S> UsesState for RandScheduler<S>

where S: State + HasTestcase,

type State = S

impl<S> UsesState for TuneableScheduler<S>

where S: State,

type State = S

impl<S> UsesState for StringIdentificationStage<S>

where S: State,

type State = S

impl<Z> UsesState for SimpleConcolicMutationalStage<Z>

where Z: UsesState,

type State = <Z as UsesState>::State