@@ -18,56 +18,20 @@ use crate::sys_common::IntoInner;
1818// Anonymous pipes
1919////////////////////////////////////////////////////////////////////////////////
2020
21- // A 64kb pipe capacity is the same as a typical Linux default.
22- const PIPE_BUFFER_CAPACITY: u32 = 64 * 1024;
23-
24- pub enum AnonPipe {
25- Sync(Handle),
26- Async(Handle),
21+ pub struct AnonPipe {
22+ inner: Handle,
2723}
2824
2925impl IntoInner<Handle> for AnonPipe {
3026 fn into_inner(self) -> Handle {
31- match self {
32- Self::Sync(handle) => handle,
33- Self::Async(handle) => handle,
34- }
27+ self.inner
3528 }
3629}
3730
3831pub struct Pipes {
3932 pub ours: AnonPipe,
4033 pub theirs: AnonPipe,
4134}
42- impl Pipes {
43- /// Create a new pair of pipes where both pipes are synchronous.
44- ///
45- /// These must not be used asynchronously.
46- pub fn new_synchronous(
47- ours_readable: bool,
48- their_handle_inheritable: bool,
49- ) -> io::Result<Self> {
50- unsafe {
51- // If `CreatePipe` succeeds, these will be our pipes.
52- let mut read = ptr::null_mut();
53- let mut write = ptr::null_mut();
54-
55- if c::CreatePipe(&mut read, &mut write, ptr::null(), PIPE_BUFFER_CAPACITY) == 0 {
56- Err(io::Error::last_os_error())
57- } else {
58- let (ours, theirs) = if ours_readable { (read, write) } else { (write, read) };
59- let ours = Handle::from_raw_handle(ours);
60- let theirs = Handle::from_raw_handle(theirs);
61-
62- if their_handle_inheritable {
63- theirs.set_inheritable()?;
64- }
65-
66- Ok(Pipes { ours: AnonPipe::Sync(ours), theirs: AnonPipe::Sync(theirs) })
67- }
68- }
69- }
70- }
7135
7236/// Although this looks similar to `anon_pipe` in the Unix module it's actually
7337/// subtly different. Here we'll return two pipes in the `Pipes` return value,
@@ -89,6 +53,9 @@ impl Pipes {
8953/// with `OVERLAPPED` instances, but also works out ok if it's only ever used
9054/// once at a time (which we do indeed guarantee).
9155pub fn anon_pipe(ours_readable: bool, their_handle_inheritable: bool) -> io::Result<Pipes> {
56+ // A 64kb pipe capacity is the same as a typical Linux default.
57+ const PIPE_BUFFER_CAPACITY: u32 = 64 * 1024;
58+
9259 // Note that we specifically do *not* use `CreatePipe` here because
9360 // unfortunately the anonymous pipes returned do not support overlapped
9461 // operations. Instead, we create a "hopefully unique" name and create a
@@ -189,9 +156,12 @@ pub fn anon_pipe(ours_readable: bool, their_handle_inheritable: bool) -> io::Res
189156 };
190157 opts.security_attributes(&mut sa);
191158 let theirs = File::open(Path::new(&name), &opts)?;
192- let theirs = AnonPipe::Sync( theirs.into_inner()) ;
159+ let theirs = AnonPipe { inner: theirs.into_inner() } ;
193160
194- Ok(Pipes { ours: AnonPipe::Async(ours), theirs })
161+ Ok(Pipes {
162+ ours: AnonPipe { inner: ours },
163+ theirs: AnonPipe { inner: theirs.into_inner() },
164+ })
195165 }
196166}
197167
@@ -201,12 +171,12 @@ pub fn anon_pipe(ours_readable: bool, their_handle_inheritable: bool) -> io::Res
201171/// This is achieved by creating a new set of pipes and spawning a thread that
202172/// relays messages between the source and the synchronous pipe.
203173pub fn spawn_pipe_relay(
204- source: &Handle ,
174+ source: &AnonPipe ,
205175 ours_readable: bool,
206176 their_handle_inheritable: bool,
207177) -> io::Result<AnonPipe> {
208178 // We need this handle to live for the lifetime of the thread spawned below.
209- let source = AnonPipe::Async( source.duplicate(0, true, c::DUPLICATE_SAME_ACCESS)?) ;
179+ let source = source.duplicate()? ;
210180
211181 // create a new pair of anon pipes.
212182 let Pipes { theirs, ours } = anon_pipe(ours_readable, their_handle_inheritable)?;
@@ -257,24 +227,19 @@ type AlertableIoFn = unsafe extern "system" fn(
257227
258228impl AnonPipe {
259229 pub fn handle(&self) -> &Handle {
260- match self {
261- Self::Async(ref handle) => handle,
262- Self::Sync(ref handle) => handle,
263- }
230+ &self.inner
264231 }
265232 pub fn into_handle(self) -> Handle {
266- self.into_inner()
233+ self.inner
234+ }
235+ fn duplicate(&self) -> io::Result<Self> {
236+ self.inner.duplicate(0, false, c::DUPLICATE_SAME_ACCESS).map(|inner| AnonPipe { inner })
267237 }
268238
269239 pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
270240 let result = unsafe {
271241 let len = crate::cmp::min(buf.len(), c::DWORD::MAX as usize) as c::DWORD;
272- match self {
273- Self::Sync(ref handle) => handle.read(buf),
274- Self::Async(_) => {
275- self.alertable_io_internal(c::ReadFileEx, buf.as_mut_ptr() as _, len)
276- }
277- }
242+ self.alertable_io_internal(c::ReadFileEx, buf.as_mut_ptr() as _, len)
278243 };
279244
280245 match result {
@@ -288,33 +253,28 @@ impl AnonPipe {
288253 }
289254
290255 pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
291- io::default_read_vectored(|buf| self.read(buf), bufs)
256+ self.inner.read_vectored( bufs)
292257 }
293258
294259 #[inline]
295260 pub fn is_read_vectored(&self) -> bool {
296- false
261+ self.inner.is_read_vectored()
297262 }
298263
299264 pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
300265 unsafe {
301266 let len = crate::cmp::min(buf.len(), c::DWORD::MAX as usize) as c::DWORD;
302- match self {
303- Self::Sync(ref handle) => handle.write(buf),
304- Self::Async(_) => {
305- self.alertable_io_internal(c::WriteFileEx, buf.as_ptr() as _, len)
306- }
307- }
267+ self.alertable_io_internal(c::WriteFileEx, buf.as_ptr() as _, len)
308268 }
309269 }
310270
311271 pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
312- io::default_write_vectored(|buf| self.write(buf), bufs)
272+ self.inner.write_vectored( bufs)
313273 }
314274
315275 #[inline]
316276 pub fn is_write_vectored(&self) -> bool {
317- false
277+ self.inner.is_write_vectored()
318278 }
319279
320280 /// Synchronizes asynchronous reads or writes using our anonymous pipe.
@@ -386,7 +346,7 @@ impl AnonPipe {
386346
387347 // Asynchronous read of the pipe.
388348 // If successful, `callback` will be called once it completes.
389- let result = io(self.handle() .as_handle(), buf, len, &mut overlapped, callback);
349+ let result = io(self.inner .as_handle(), buf, len, &mut overlapped, callback);
390350 if result == c::FALSE {
391351 // We can return here because the call failed.
392352 // After this we must not return until the I/O completes.
0 commit comments