os_pipe/
windows.rs

1use crate::PipeReader;
2use crate::PipeWriter;
3use std::fs::File;
4use std::io;
5use std::os::windows::prelude::*;
6use std::ptr;
7use windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE;
8use windows_sys::Win32::System::Pipes::CreatePipe;
9
10pub(crate) fn pipe() -> io::Result<(PipeReader, PipeWriter)> {
11    let mut read_pipe = INVALID_HANDLE_VALUE;
12    let mut write_pipe = INVALID_HANDLE_VALUE;
13
14    let ret = unsafe {
15        // NOTE: These pipes do not support IOCP. We might want to emulate
16        // anonymous pipes with CreateNamedPipe, as Rust's stdlib does.
17        CreatePipe(&mut read_pipe, &mut write_pipe, ptr::null_mut(), 0)
18    };
19
20    if ret == 0 {
21        Err(io::Error::last_os_error())
22    } else {
23        unsafe {
24            Ok((
25                PipeReader::from_raw_handle(read_pipe as _),
26                PipeWriter::from_raw_handle(write_pipe as _),
27            ))
28        }
29    }
30}
31
32pub(crate) fn dup(handle: impl AsHandle) -> io::Result<OwnedHandle> {
33    handle.as_handle().try_clone_to_owned()
34}
35
36impl IntoRawHandle for PipeReader {
37    fn into_raw_handle(self) -> RawHandle {
38        self.0.into_raw_handle()
39    }
40}
41
42impl AsRawHandle for PipeReader {
43    fn as_raw_handle(&self) -> RawHandle {
44        self.0.as_raw_handle()
45    }
46}
47
48impl FromRawHandle for PipeReader {
49    unsafe fn from_raw_handle(handle: RawHandle) -> PipeReader {
50        unsafe { PipeReader(File::from_raw_handle(handle)) }
51    }
52}
53
54impl From<PipeReader> for OwnedHandle {
55    fn from(reader: PipeReader) -> Self {
56        reader.0.into()
57    }
58}
59
60impl AsHandle for PipeReader {
61    fn as_handle(&self) -> BorrowedHandle<'_> {
62        self.0.as_handle()
63    }
64}
65
66impl From<OwnedHandle> for PipeReader {
67    fn from(handle: OwnedHandle) -> Self {
68        PipeReader(handle.into())
69    }
70}
71
72impl IntoRawHandle for PipeWriter {
73    fn into_raw_handle(self) -> RawHandle {
74        self.0.into_raw_handle()
75    }
76}
77
78impl AsRawHandle for PipeWriter {
79    fn as_raw_handle(&self) -> RawHandle {
80        self.0.as_raw_handle()
81    }
82}
83
84impl FromRawHandle for PipeWriter {
85    unsafe fn from_raw_handle(handle: RawHandle) -> PipeWriter {
86        unsafe { PipeWriter(File::from_raw_handle(handle)) }
87    }
88}
89
90impl From<PipeWriter> for OwnedHandle {
91    fn from(writer: PipeWriter) -> Self {
92        writer.0.into()
93    }
94}
95
96impl AsHandle for PipeWriter {
97    fn as_handle(&self) -> BorrowedHandle<'_> {
98        self.0.as_handle()
99    }
100}
101
102impl From<OwnedHandle> for PipeWriter {
103    fn from(handle: OwnedHandle) -> Self {
104        PipeWriter(handle.into())
105    }
106}