mxsh 0.2.0

Embeddable POSIX-style shell parser and runtime
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

use std::io;

use crate::status::normalize_exit_status;

/// Wait behavior for runtime-managed processes.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum WaitMode {
    Poll,
    Block,
}

/// Structured process lifecycle events surfaced by a runtime.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ProcessEvent {
    Running,
    Continued,
    Stopped(i32),
    Exited(i32),
    Signaled(i32),
}

#[cfg(feature = "unix-runtime")]
pub(crate) fn wait_process(pid: libc::pid_t, mode: WaitMode) -> Result<ProcessEvent, io::Error> {
    let options = match mode {
        WaitMode::Poll => libc::WNOHANG | libc::WUNTRACED | libc::WCONTINUED,
        WaitMode::Block => libc::WUNTRACED | libc::WCONTINUED,
    };
    loop {
        let mut wstatus: i32 = 0;
        let waited = unsafe { libc::waitpid(pid, &mut wstatus, options) };
        if waited == 0 {
            return Ok(ProcessEvent::Running);
        }
        if waited == pid {
            return Ok(wait_status_to_event(wstatus));
        }
        if waited < 0 {
            let err = io::Error::last_os_error();
            if err.raw_os_error() == Some(libc::EINTR) {
                continue;
            }
            return Err(err);
        }
    }
}

pub(crate) fn wait_child_status(
    mut wait_once: impl FnMut() -> Result<ProcessEvent, io::Error>,
) -> i32 {
    loop {
        match wait_once() {
            Ok(ProcessEvent::Running | ProcessEvent::Continued) => continue,
            Ok(ProcessEvent::Stopped(sig)) => return normalize_exit_status(128 + i64::from(sig)),
            Ok(ProcessEvent::Exited(code)) => return normalize_exit_status(code),
            Ok(ProcessEvent::Signaled(sig)) => return normalize_exit_status(128 + i64::from(sig)),
            Err(_) => return 128,
        }
    }
}

#[cfg(feature = "unix-runtime")]
fn wait_status_to_event(wstatus: i32) -> ProcessEvent {
    if libc::WIFCONTINUED(wstatus) {
        ProcessEvent::Continued
    } else if libc::WIFSTOPPED(wstatus) {
        ProcessEvent::Stopped(libc::WSTOPSIG(wstatus))
    } else if libc::WIFEXITED(wstatus) {
        ProcessEvent::Exited(libc::WEXITSTATUS(wstatus))
    } else if libc::WIFSIGNALED(wstatus) {
        ProcessEvent::Signaled(libc::WTERMSIG(wstatus))
    } else {
        ProcessEvent::Exited(128)
    }
}