Struct libafl::executors::command::CommandExecutor

pub struct CommandExecutor<EM, I, OT, S, T, Z> where
    T: Debug,
    OT: Debug, { /* private fields */ }

A CommandExecutor is a wrapper around std::process::Command to execute a target as a child process. Construct a CommandExecutor by implementing CommandConfigurator for a type of your choice and calling CommandConfigurator::into_executor on it. Instead, you can use CommandExecutor::builder() to construct a CommandExecutor backed by a StdCommandConfigurator.

Implementations

impl CommandExecutor<(), (), (), (), (), ()>

pub fn builder() -> CommandExecutorBuilder

Creates a builder for a new CommandExecutor, backed by a StdCommandConfigurator This is usually the easiest way to construct a CommandExecutor.

It mimics the api of Command, specifically, you will use arg, args, env, and so on.

By default, input is read from stdin, unless you specify a different location using

• arg_input_arg for input delivered as an command line argument
• arg_input_file for input via a file of a specific name
• arg_input_file_std for a file with default name (at the right location in the arguments)

impl<EM, I, OT, S, T, Z> CommandExecutor<EM, I, OT, S, T, Z> where
    T: Debug,
    OT: Debug, 

pub fn inner(&mut self) -> &mut T

Accesses the inner value

impl<EM, I, OT, S, Z> CommandExecutor<EM, I, OT, S, StdCommandConfigurator, Z> where
    OT: MatchName + Debug, 

pub fn from_cmd_with_file<P>(
    cmd: &Command,
    debug_child: bool,
    observers: OT,
    path: P
) -> Result<Self, Error> where
    P: AsRef<Path>, 

Creates a new CommandExecutor. Instead of parsing the Command for @@, it will

pub fn parse_afl_cmdline<IT, O>(
    args: IT,
    observers: OT,
    debug_child: bool
) -> Result<Self, Error> where
    IT: IntoIterator<Item = O>,
    O: AsRef<OsStr>, 

Parses an AFL-like comandline, replacing @@ with the input file. If no @@ was found, will use stdin for input. The arg 0 is the program.

Trait Implementations

impl<EM, I, OT, S, T, Z> Debug for CommandExecutor<EM, I, OT, S, T, Z> where
    T: Debug,
    OT: Debug, 

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

Formats the value using the given formatter.

impl<EM, I, OT, S, T, Z> Executor<EM, I, S, Z> for CommandExecutor<EM, I, OT, S, T, Z> where
    I: Input + HasTargetBytes,
    T: CommandConfigurator,
    OT: Debug + MatchName,
    T: Debug, 

fn run_target(
    &mut self,
    _fuzzer: &mut Z,
    _state: &mut S,
    _mgr: &mut EM,
    input: &I
) -> Result<ExitKind, Error>

Instruct the target about the input and run

fn with_observers<OT>(self, observers: OT) -> WithObservers<Self, OT> where
    Self: Sized,
    OT: ObserversTuple<I, S>, 

Wraps this Executor with the given ObserversTuple to implement HasObservers.

fn post_run_reset(&mut self)

Custom Reset Handler, e.g., to reset timers

impl<EM, I, OT: ObserversTuple<I, S>, S, T: Debug, Z> HasObservers<I, OT, S> for CommandExecutor<EM, I, OT, S, T, Z>

fn observers(&self) -> &OT

Get the linked observers

fn observers_mut(&mut self) -> &mut OT

Get the linked observers (mutable)