capture-stdio 0.1.1

Capture stdin/out/err of the current process
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

//! Intercept stdio via `pipe`-then-`dup` method
//!
use os_pipe::{PipeReader, PipeWriter};
use std::{
    io::Error,
    os::{unix::io::RawFd, unix::prelude::AsRawFd},
};

pub mod stderr;
pub mod stdin;
pub mod stdout;

pub use stderr::PipedStderr;
pub use stdin::PipedStdin;
pub use stdout::PipedStdout;

struct PipedFd {
    reader: PipeReader,
    writer: PipeWriter,
    original: RawFd,
    target: RawFd,
    restored: bool,
}

impl PipedFd {
    fn capture(target: RawFd, is_stdin: bool) -> Result<Self, Error> {
        let (reader, writer) = os_pipe::pipe()?;
        let original = if is_stdin {
            swap_fd(reader.as_raw_fd(), target)
        } else {
            swap_fd(writer.as_raw_fd(), target)
        };

        Ok(Self {
            reader,
            writer,
            original,
            target,
            restored: false,
        })
    }

    fn restore(&mut self) {
        assert!(!self.restored, "You can't restore it twice");

        let fd = swap_fd(self.original, self.target);
        unsafe {
            libc::close(fd);
        }

        self.restored = true;
    }
}

impl Drop for PipedFd {
    fn drop(&mut self) {
        if !self.restored {
            self.restore();
        }
    }
}

fn swap_fd(fd: RawFd, target: RawFd) -> RawFd {
    unsafe {
        let orig_stdin = libc::dup(target as i32);
        libc::close(target as i32);
        libc::dup2(fd as i32, target as i32);
        orig_stdin as RawFd
    }
}