userland-execve 0.2.0

An implementation of execve() in user space
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use std::{
    ffi::{CStr, CString},
    iter::once,
    os::unix::prelude::OsStrExt,
    path::{Path, PathBuf},
};

fn path_to_c_string(path: &Path) -> CString {
    CString::from_vec_with_nul(
        path.as_os_str()
            .as_bytes()
            .iter()
            .copied()
            .chain(once(0))
            .collect(),
    )
    .unwrap()
}

pub fn exec_with_options(options: ExecOptions) -> ! {
    let (bin_addr, bin_header, opt_interp) =
        crate::loader::load(&options.executable, options.interpreter);
    let path = path_to_c_string(&options.executable);
    let interp_addr = opt_interp.map(|(addr, _)| addr);
    let sp = crate::stack::make_stack(
        interp_addr,
        bin_addr,
        bin_header,
        &path,
        &options.args,
        &options.env,
    );
    let entry = match opt_interp {
        Some((interp_addr, interp_header)) => {
            let interp_entry: usize = interp_header.e_entry.try_into().unwrap();
            interp_addr + interp_entry
        }
        None => {
            let bin_entry: usize = bin_header.e_entry.try_into().unwrap();
            bin_addr + bin_entry
        }
    };
    unsafe { crate::run::run(sp, entry) }
}

pub fn exec(path: &Path, args: &[impl AsRef<CStr>], env: &[impl AsRef<CStr>]) -> ! {
    let mut options = ExecOptions::new(path);
    options.args(args);
    options.env_pairs(env);

    exec_with_options(options)
}

pub struct ExecOptions {
    pub executable: PathBuf,
    pub args: Vec<CString>,
    pub env: Vec<CString>,
    interpreter: crate::loader::Interpreter,
}

impl ExecOptions {
    pub fn new(executable: impl AsRef<Path>) -> Self {
        Self {
            executable: executable.as_ref().to_owned(),
            args: vec![],
            env: vec![],
            interpreter: crate::loader::Interpreter::FromHeader,
        }
    }

    pub fn arg(&mut self, value: impl AsRef<CStr>) -> &mut Self {
        self.args.push(value.as_ref().to_owned());
        self
    }

    pub fn args(&mut self, values: impl IntoIterator<Item = impl AsRef<CStr>>) -> &mut Self {
        self.args
            .extend(values.into_iter().map(|v| v.as_ref().to_owned()));
        self
    }

    pub fn env(&mut self, key: impl AsRef<CStr>, value: impl AsRef<CStr>) -> &mut Self {
        let mut pair = key.as_ref().to_bytes().to_vec();
        pair.push(b'=');
        pair.extend(value.as_ref().to_bytes());
        self.env.push(CString::new(pair).unwrap());
        self
    }

    pub fn env_pairs(&mut self, pairs: impl IntoIterator<Item = impl AsRef<CStr>>) -> &mut Self {
        self.env
            .extend(pairs.into_iter().map(|v| v.as_ref().to_owned()));
        self
    }

    pub fn envs(
        &mut self,
        pairs: impl IntoIterator<Item = (impl AsRef<CStr>, impl AsRef<CStr>)>,
    ) -> &mut Self {
        for (key, value) in pairs {
            self.env(key, value);
        }
        self
    }

    pub fn override_interpreter(&mut self, interpreter: Option<impl AsRef<Path>>) -> &mut Self {
        self.interpreter = match interpreter {
            Some(path) => crate::loader::Interpreter::Path(path.as_ref().to_owned()),
            None => crate::loader::Interpreter::None,
        };
        self
    }
}