Struct pam_client::env_list::EnvList

pub struct EnvList(_);

A PAM environment list

The PAM environment represents the contents of the regular environment variables of the authenticated user when service is granted and can be used to prepare the environment of child processes run as the authenticated user.

See Context::envlist().

Examples

// Print the PAM environment
for item in &context.envlist() {
    println!("VAR: {}", item);
}

The environment can be passed to std::process::Command by using EnvList::iter_tuples():

use std::process::Command;

// Spawn a process in the PAM environment
let command = Command::new("/usr/bin/some_program")
                      .env_clear()
                      .envs(context.envlist().iter_tuples());

The environment can be passed to NIX’s execve by using EnvList::as_ref():

use nix::unistd::execve;

// Replace this process with another program in the PAM environment
execve(
    &CString::new("/usr/bin/some_program").unwrap(),
    &[CString::new("some_program").unwrap()],
    context.envlist().as_ref()
).expect("replacing the current process failed");

Implementations

impl EnvList

pub fn get<T: AsRef<OsStr>>(&self, name: T) -> Option<&OsStr>

Returns a reference to the value of the named environment variable.

Returns None if the variable doesn’t exist in this list.

pub fn iter(&self) -> Iter<'_>

Returns an iterator over all contained variables as EnvItems.

The iteration happens in deterministic, but unspecified order.

pub fn len(&self) -> usize

Returns the count of environment variables in the list.

pub fn is_empty(&self) -> bool

Returns true if the environment list is empty.

pub fn iter_tuples(&self) -> TupleIter<'_>

Returns an iterator over all contained variables as (key: &OsStr, value: &OsStr) tuples.

The iteration happens in deterministic, but unspecified order.

Provides compatibility with std::process::Command::envs().

Trait Implementations

impl AsRef<[EnvItem]> for EnvList

Provide compatibility with the 3rd parameter of nix::unistd::execve.

fn as_ref(&self) -> &[EnvItem]

Converts this type into a shared reference of the (usually inferred) input type.

impl Debug for EnvList

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

Formats the value using the given formatter.

impl Display for EnvList

Display and string conversion of the environment list.

Also causes .to_string() to be implemented.

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

Formats the environment list as a multi-line string

impl<'a, S> From<&'a EnvList> for HashMap<&'a OsStr, &'a OsStr, S> where
    S: BuildHasher + Default, 

Reference conversion to a referencing hash map

fn from(list: &'a EnvList) -> Self

Converts to this type from the input type.

impl<'a> From<&'a EnvList> for Vec<&'a CStr>

Reference conversion to a vector of “key=value” &CStrs.

fn from(list: &'a EnvList) -> Self

Converts to this type from the input type.

impl<'a> From<&'a EnvList> for Vec<(&'a OsStr, &'a OsStr)>

Reference conversion to a vector of (&key, &value) tuples.

fn from(list: &'a EnvList) -> Self

Converts to this type from the input type.

impl<S> From<EnvList> for HashMap<OsString, OsString, S> where
    S: BuildHasher + Default, 

Conversion to a hash map

fn from(list: EnvList) -> Self

Converts to this type from the input type.

impl From<EnvList> for Vec<(OsString, OsString)>

Conversion to a vector of (key, value) tuples.

fn from(list: EnvList) -> Self

Converts to this type from the input type.

impl From<EnvList> for Vec<CString>

Conversion to a vector of “key=value” CStrings.

fn from(list: EnvList) -> Self

Converts to this type from the input type.

impl<T: AsRef<OsStr>> Index<T> for EnvList

Indexing with list[key]

fn index(&self, name: T) -> &Self::Output

Returns a reference to the value of the named environment variable.

Panics

Panics if the environment variable is not present in the EnvList.

type Output = OsStr

The returned type after indexing.

impl<'a> IntoIterator for &'a EnvList

Provide direct for-loop support.

See EnvList::iter().

type Item = &'a EnvItem

The type of the elements being iterated over.

type IntoIter = Iter<'a, EnvItem>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.