Struct StackLayoutBuilder

pub struct StackLayoutBuilder<'a> { /* private fields */ }

Builder to create a stack layout as described by the StackLayoutRef type.

Implementations

impl<'a> StackLayoutBuilder<'a>

pub const fn new() -> Self

Creates a mew bioöder-

Examples found in repository

examples/minimal_builder.rs (line 28)

fn main() {
    let builder = StackLayoutBuilder::new()
        // can contain terminating zero; not mandatory in the builder
        .add_argv("foo")
        .add_argv("hello")
        .add_envv("PATH=/bin")
        .add_auxv(AuxVar::ExecFn("/usr/bin/foo".into()));

    let layout = builder.build(None /* we create the layout in our address space */);
    let layout = StackLayoutRef::new(layout.as_ref(), None);

    // SAFETY: This is safe as all pointers point into our address space.
    for (i, arg) in unsafe { layout.argv_iter() }.enumerate() {
        println!("  [{i}] {}", arg.to_str().unwrap());
    }
}

pub fn add_argv(self, arg: impl Into<String>) -> Self

Adds an argument to the builder.

Adding a terminating NUL byte is not necessary. Interim NUL bytes are prohibited.

Examples found in repository

examples/minimal_builder.rs (line 30)

fn main() {
    let builder = StackLayoutBuilder::new()
        // can contain terminating zero; not mandatory in the builder
        .add_argv("foo")
        .add_argv("hello")
        .add_envv("PATH=/bin")
        .add_auxv(AuxVar::ExecFn("/usr/bin/foo".into()));

    let layout = builder.build(None /* we create the layout in our address space */);
    let layout = StackLayoutRef::new(layout.as_ref(), None);

    // SAFETY: This is safe as all pointers point into our address space.
    for (i, arg) in unsafe { layout.argv_iter() }.enumerate() {
        println!("  [{i}] {}", arg.to_str().unwrap());
    }
}

pub fn add_envv(self, env: impl Into<String>) -> Self

Adds an environment-variable to the builder.

Adding a terminating NUL byte is not necessary. Interim NUL bytes are prohibited.

The value must follow the key=value syntax, where value may be empty.

Examples found in repository

examples/minimal_builder.rs (line 32)

fn main() {
    let builder = StackLayoutBuilder::new()
        // can contain terminating zero; not mandatory in the builder
        .add_argv("foo")
        .add_argv("hello")
        .add_envv("PATH=/bin")
        .add_auxv(AuxVar::ExecFn("/usr/bin/foo".into()));

    let layout = builder.build(None /* we create the layout in our address space */);
    let layout = StackLayoutRef::new(layout.as_ref(), None);

    // SAFETY: This is safe as all pointers point into our address space.
    for (i, arg) in unsafe { layout.argv_iter() }.enumerate() {
        println!("  [{i}] {}", arg.to_str().unwrap());
    }
}

pub fn add_auxv(self, aux: AuxVar<'a>) -> Self

Adds an AuxVar to the builder.

Examples found in repository

examples/minimal_builder.rs (line 33)

fn main() {
    let builder = StackLayoutBuilder::new()
        // can contain terminating zero; not mandatory in the builder
        .add_argv("foo")
        .add_argv("hello")
        .add_envv("PATH=/bin")
        .add_auxv(AuxVar::ExecFn("/usr/bin/foo".into()));

    let layout = builder.build(None /* we create the layout in our address space */);
    let layout = StackLayoutRef::new(layout.as_ref(), None);

    // SAFETY: This is safe as all pointers point into our address space.
    for (i, arg) in unsafe { layout.argv_iter() }.enumerate() {
        println!("  [{i}] {}", arg.to_str().unwrap());
    }
}

pub fn build(self, target_addr: Option<usize>) -> ABox<[u8]>

Builds the layout with heap-allocated memory.

Arguments

• target_addr: The address the stack layout in the target address space. This may be a user-space address of another process. If this is None then the address of the buffer will be used.

Examples found in repository

examples/minimal_builder.rs (line 35)

fn main() {
    let builder = StackLayoutBuilder::new()
        // can contain terminating zero; not mandatory in the builder
        .add_argv("foo")
        .add_argv("hello")
        .add_envv("PATH=/bin")
        .add_auxv(AuxVar::ExecFn("/usr/bin/foo".into()));

    let layout = builder.build(None /* we create the layout in our address space */);
    let layout = StackLayoutRef::new(layout.as_ref(), None);

    // SAFETY: This is safe as all pointers point into our address space.
    for (i, arg) in unsafe { layout.argv_iter() }.enumerate() {
        println!("  [{i}] {}", arg.to_str().unwrap());
    }
}

Trait Implementations

impl<'a> Clone for StackLayoutBuilder<'a>

fn clone(&self) -> StackLayoutBuilder<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for StackLayoutBuilder<'a>

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

Formats the value using the given formatter.

impl<'a> Default for StackLayoutBuilder<'a>

fn default() -> StackLayoutBuilder<'a>

Returns the “default value” for a type.

impl<'a> PartialEq for StackLayoutBuilder<'a>

fn eq(&self, other: &StackLayoutBuilder<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for StackLayoutBuilder<'a>

impl<'a> StructuralPartialEq for StackLayoutBuilder<'a>