Struct ResolvedInputs 

#[non_exhaustive]
pub struct ResolvedInputs {
    pub root: ResolvedRoot,
    pub env: Vec<(OsString, OsString)>,
    pub mounts: Vec<ResolvedMount>,
    pub identity: ResolvedIdentity,
    pub network: Network,
    pub streams: ResolvedStreams,
    pub rlimits: Vec<ResolvedRlimit>,
    pub hardening: ResolvedHardening,
}

The root, environment, mounts, and posture a built sandbox will apply.

Obtained from Cage::resolved_inputs.

Stability

This type’s shape follows the compatibility promise like any other public item. Its contents do not: they report the defaults in force, and those are explicitly outside the promise — the mount profile and the base environment may both change in a patch release. That is the reason to record the value rather than assume it, and a consumer that needs the contents themselves to be stable should set managed_mounts(false) and base_env(false) and declare its own.

Example

let cage = ferroday_cage::Cage::builder()
    .rootfs("/srv/rootfs/alpine")
    .command("/usr/bin/make")
    .build()?;

let inputs = cage.resolved_inputs();
for (name, value) in &inputs.env {
    println!("{}={}", name.to_string_lossy(), value.to_string_lossy());
}
for mount in &inputs.mounts {
    println!("{}", mount.get_target().display());
}

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

root: ResolvedRoot

What the command’s root filesystem is.

Its own field rather than a mount: the root is not something the profile lays over the sandbox, it is what the profile is laid over.

env: Vec<(OsString, OsString)>

The command’s complete environment, sorted by variable name.

The caller’s variables composed over the library’s base, or the caller’s alone where base_env(false) is set.

mounts: Vec<ResolvedMount>

Every mount the sandbox establishes over its root, in the order it establishes them: the managed profile, then the caller’s own, and last the resolv.conf bind that Network::Host adds.

Empty for a restriction, which mounts nothing.

identity: ResolvedIdentity

The identity the command holds inside the sandbox.

network: Network

The network the command can reach.

A NetStack is not visible here: a stack attaches to a pending launch after the cage is built, so what this reports is the namespace the sandbox creates, not what may later be plugged into it.

streams: ResolvedStreams

Where the command’s three standard streams are wired.

rlimits: Vec<ResolvedRlimit>

The resource limits applied to the command process, in the order they are applied.

hardening: ResolvedHardening

The hardening controls the command runs under.

Present whether or not the hardening feature is compiled in, reporting Unavailable when it is not. A record that simply omitted the key could not be told apart from one written before the key existed, and a provenance record has to be readable without knowing which build wrote it.

Trait Implementations

impl Clone for ResolvedInputs

fn clone(&self) -> ResolvedInputs

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResolvedInputs

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

Formats the value using the given formatter.

impl Eq for ResolvedInputs

impl PartialEq for ResolvedInputs

fn eq(&self, other: &ResolvedInputs) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ResolvedInputs

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ResolvedInputs