vfork 0.1.0

vfork-rs is used in embedded low memory to run an external program.
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

use std::ffi::{OsStr, OsString};
use std::fs::File;
use std::io::Error as IoError;
use std::io::Result;
use std::os::fd::FromRawFd;
use std::os::unix::ffi::OsStrExt;

use crate::child::Child;

pub struct Command {
    program: OsString,
    argv: Vec<OsString>,
}

impl Command {
    /// Constructs a new Command for launching the program at path program
    pub fn new<S: AsRef<OsStr>>(program: S) -> Self {
        Command {
            program: program.as_ref().to_os_string(),
            argv: Vec::new(),
        }
    }

    /// Adds an argument to pass to the program.
    pub fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut Self {
        self.argv.push(arg.as_ref().to_os_string());
        self
    }

    /// Adds multiple arguments to pass to the program.
    pub fn args<S: AsRef<OsStr>>(&mut self, args: &[S]) -> &mut Self {
        for arg in args {
            self.argv.push(arg.as_ref().to_os_string());
        }
        self
    }

    /// Executes the command as a child process
    pub fn spawn(&self) -> Result<Child> {
        let mut fds = [0; 2];

        let mut items = Vec::with_capacity(self.argv.len() + 1);
        items.push(self.program.clone());
        items.extend(self.argv.iter().cloned());

        let mut argv = items
            .iter()
            .map(|arg| arg.as_bytes().as_ptr() as *const libc::c_char)
            .collect::<Vec<_>>();

        // null pointer at last
        argv.push(std::ptr::null());

        unsafe {
            if libc::pipe(fds.as_mut_ptr()) == -1 {
                return Err(IoError::last_os_error().into());
            }

            #[allow(deprecated)]
            let pid = libc::vfork();
            match pid {
                -1 => Err(IoError::last_os_error().into()),
                0 => {
                    // child
                    libc::close(fds[0]);

                    if libc::dup2(fds[1], libc::STDOUT_FILENO) == -1 {
                        libc::_exit(1);
                    }

                    libc::execv(
                        self.program.as_bytes().as_ptr() as *const libc::c_char,
                        argv.as_ptr() as *const *const libc::c_char,
                    );

                    libc::_exit(1);
                }
                _ => {
                    libc::close(fds[1]);

                    let file = File::from_raw_fd(fds[0]);

                    Ok(Child::new(pid, file))
                }
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_echo_command() {
        let mut cmd = Command::new("/bin/echo")
            .arg("Hello, world!")
            .spawn()
            .expect("failed to execute process");

        let status_code = cmd.wait().expect("failed to wait process");
        assert_eq!(status_code.code(), 0);

        let output = cmd.output().expect("failed to get output");
        assert_eq!(
            String::from_utf8_lossy(&output),
            "Hello, world!\n".to_string()
        );
    }
}