shh 1.0.1

Silence stderr and stdout, optionally rerouting it.
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
134
135
136
137
138

use super::*;

use std::io;
use std::os::windows::io::{AsRawHandle, FromRawHandle};
use winapi;
use winapi::ctypes::c_void;
use winapi::shared::{
    minwindef::{DWORD, LPDWORD},
    ntdef::NULL,
};
use winapi::um::{
    handleapi::INVALID_HANDLE_VALUE,
    minwinbase::{OVERLAPPED, SECURITY_ATTRIBUTES},
    winbase::{STD_ERROR_HANDLE, STD_OUTPUT_HANDLE},
    winnt::HANDLE,
};

pub struct Impl;

impl Create for Impl {
    fn create_files() -> io::Result<(File, File)> {
        let mut read_handle: HANDLE = NULL;
        let mut write_handle: HANDLE = NULL;

        let create_pipe_result = unsafe {
            winapi::um::namedpipeapi::CreatePipe(
                &mut read_handle,
                &mut write_handle,
                NULL as *mut SECURITY_ATTRIBUTES,
                0, // default buffer size
            )
        };

        match create_pipe_result {
            0 => Err(io::Error::last_os_error()),
            _ => Ok((
                unsafe { File::from_raw_handle(read_handle as Fdandle) },
                unsafe { File::from_raw_handle(write_handle as Fdandle) },
            )),
        }
    }
}

impl Divert<io::Stdout> for Impl {
    fn divert_std_stream(write_file: &File) -> io::Result<()> {
        set_std_handle(STD_OUTPUT_HANDLE, write_file.as_raw_handle())
    }

    fn reinstate_std_stream(orignal_handle: Fdandle) -> io::Result<()> {
        set_std_handle(STD_OUTPUT_HANDLE, orignal_handle)
    }
}

impl Divert<io::Stderr> for Impl {
    fn divert_std_stream(write_file: &File) -> io::Result<()> {
        set_std_handle(STD_ERROR_HANDLE, write_file.as_raw_handle())
    }

    fn reinstate_std_stream(orignal_handle: Fdandle) -> io::Result<()> {
        set_std_handle(STD_ERROR_HANDLE, orignal_handle)
    }
}

impl Device for io::Stdout {
    fn obtain_original() -> io::Result<Fdandle> {
        get_std_handle(STD_OUTPUT_HANDLE)
    }
}

impl Device for io::Stderr {
    fn obtain_original() -> io::Result<Fdandle> {
        get_std_handle(STD_ERROR_HANDLE)
    }
}

impl ShhRead for Impl {
    fn shh_read(read_file: &File, buf: &mut [u8]) -> io::Result<usize> {
        let read_handle = read_file.as_raw_handle();

        if !has_bytes(read_handle)? {
            return Ok(0);
        }

        let buf_len: DWORD = buf.len() as DWORD;
        let mut bytes_read: DWORD = 0;

        let read_result = unsafe {
            winapi::um::fileapi::ReadFile(
                read_handle as HANDLE,
                buf.as_mut_ptr() as *mut c_void,
                buf_len,
                &mut bytes_read,
                NULL as *mut OVERLAPPED,
            )
        };

        match read_result {
            0 => Err(io::Error::last_os_error()),
            _ => Ok(bytes_read as usize),
        }
    }
}

fn get_std_handle(device: DWORD) -> io::Result<Fdandle> {
    match unsafe { winapi::um::processenv::GetStdHandle(device) } {
        INVALID_HANDLE_VALUE => Err(io::Error::last_os_error()),
        handle => Ok(handle as Fdandle),
    }
}

fn set_std_handle(device: DWORD, handle: Fdandle) -> io::Result<()> {
    match unsafe { winapi::um::processenv::SetStdHandle(device, handle as HANDLE) } {
        0 => Err(io::Error::last_os_error()),
        _ => Ok(()),
    }
}

/// Uses PeekNamedPipe and checks TotalBytesAvail
fn has_bytes(handle: Fdandle) -> io::Result<bool> {
    let mut bytes_avail: DWORD = 0;

    let result = unsafe {
        winapi::um::namedpipeapi::PeekNamedPipe(
            handle as HANDLE,
            NULL as *mut c_void,
            0,
            NULL as LPDWORD,
            &mut bytes_avail,
            NULL as LPDWORD,
        )
    };

    if result == 0 {
        return Err(io::Error::last_os_error());
    }

    Ok(bytes_avail > 0)
}