px-userland-execve 0.2.1

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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

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

use crate::loader::{Executable, Interpreter};



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.clone(), options.interpreter);
    let path = match options.executable {
        Executable::Path(path) => path,
        Executable::Bytes { data: _, fake_path } => fake_path,
    };
    let path = path_to_c_string(&path);
    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::from_path(path);
    options.args(args);
    options.env_pairs(env);

    exec_with_options(options)
}

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

impl ExecOptions {
    pub fn from_path(executable_path: impl AsRef<Path>) -> Self {
        Self {
            executable: Executable::Path(executable_path.as_ref().to_path_buf()),
            args: vec![],
            env: vec![],
            interpreter: Interpreter::FromHeader,
        }
    }

    pub fn from_bytes(executable_bytes: Vec<u8>, fake_path: impl AsRef<Path>) -> Self {
        Self {
            executable: Executable::Bytes {
                data: executable_bytes,
                fake_path: fake_path.as_ref().to_path_buf(),
            },
            args: vec![],
            env: vec![],
            interpreter: 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) => Interpreter::Path(path.as_ref().to_owned()),
            None => Interpreter::None,
        };
        self
    }
}