Initial implementation of annoymous_pipe

Signed-off-by: Jiahao XU <[email protected]>

Author: NobodyXu

library/std/src/io/mod.rs

@@ -338,6 +338,8 @@ pub(crate) mod copy;
 mod cursor;
 mod error;
 mod impls;
+#[unstable(feature = "annoymous_pipe", issue = "")]
+pub mod pipe;
 pub mod prelude;
 mod stdio;
 mod util;

library/std/src/io/pipe/mod.rs

@@ -0,0 +1,238 @@
+use crate::{io, process::Stdio, sys::pipe::AnonPipe};
+
+/// Create annoymous pipe that is close-on-exec and blocking.
+#[inline]
+pub fn pipe() -> io::Result<(PipeReader, PipeWriter)> {
+    cfg_if::cfg_if! {
+        if #[cfg(unix)] {
+            unix::pipe()
+        } else {
+            windows::pipe()
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct PipeReader(AnonPipe);
+
+#[derive(Debug)]
+pub struct PipeWriter(AnonPipe);
+
+pub struct NotAPipeError;
+
+impl PipeReader {
+    /// Create a new [`PipeReader`] instance that shares the same underlying file description.
+    pub fn try_clone(&self) -> io::Result<Self> {
+        self.0.try_clone().map(Self)
+    }
+}
+
+impl PipeWriter {
+    /// Create a new [`PipeWriter`] instance that shares the same underlying file description.
+    pub fn try_clone(&self) -> io::Result<Self> {
+        self.0.try_clone().map(Self)
+    }
+}
+
+macro_rules! forward_io_read_traits {
+    ($name:ty) => {
+        impl io::Read for $name {
+            fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+                self.0.read(buf)
+            }
+            fn read_vectored(&mut self, bufs: &mut [io::IoSliceMut<'_>]) -> io::Result<usize> {
+                self.0.read_vectored(bufs)
+            }
+            fn is_read_vectored(&self) -> bool {
+                self.0.is_read_vectored()
+            }
+            fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+                self.0.read_to_end(buf)
+            }
+            fn read_buf(&mut self, buf: io::BorrowedCursor<'_>) -> io::Result<()> {
+                self.0.read_buf(buf)
+            }
+        }
+    };
+}
+forward_io_read_traits!(PipeReader);
+forward_io_read_traits!(&PipeReader);
+
+macro_rules! forward_io_write_traits {
+    ($name:ty) => {
+        impl io::Write for $name {
+            fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+                self.0.write(buf)
+            }
+            fn flush(&mut self) -> io::Result<()> {
+                Ok(())
+            }
+
+            fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result<usize> {
+                self.0.write_vectored(bufs)
+            }
+            fn is_write_vectored(&self) -> bool {
+                self.0.is_write_vectored()
+            }
+        }
+    };
+}
+forward_io_write_traits!(PipeWriter);
+forward_io_write_traits!(&PipeWriter);
+
+#[cfg(unix)]
+mod unix {
+    use super::*;
+
+    use crate::{
+        os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd},
+        sys::{
+            fd::FileDesc,
+            pipe::{anon_pipe, AnonPipe},
+        },
+        sys_common::{FromInner, IntoInner},
+    };
+
+    #[inline]
+    pub(super) fn pipe() -> io::Result<(PipeReader, PipeWriter)> {
+        anon_pipe().map(|(rx, tx)| (PipeReader(rx), PipeWriter(tx)))
+    }
+
+    macro_rules! impl_traits {
+        ($name:ty) => {
+            impl AsFd for $name {
+                fn as_fd(&self) -> BorrowedFd<'_> {
+                    self.0.as_fd()
+                }
+            }
+            impl AsRawFd for $name {
+                fn as_raw_fd(&self) -> RawFd {
+                    self.0.as_raw_fd()
+                }
+            }
+            impl From<$name> for OwnedFd {
+                fn from(pipe: $name) -> Self {
+                    FileDesc::into_inner(AnonPipe::into_inner(pipe.0))
+                }
+            }
+            impl FromRawFd for $name {
+                unsafe fn from_raw_fd(raw_fd: RawFd) -> Self {
+                    Self(AnonPipe::from_raw_fd(raw_fd))
+                }
+            }
+            impl IntoRawFd for $name {
+                fn into_raw_fd(self) -> RawFd {
+                    self.0.into_raw_fd()
+                }
+            }
+            impl From<$name> for Stdio {
+                fn from(pipe: $name) -> Self {
+                    Self::from(OwnedFd::from(pipe))
+                }
+            }
+        };
+    }
+    impl_traits!(PipeReader);
+    impl_traits!(PipeWriter);
+
+    fn owned_fd_to_anon_pipe(owned_fd: OwnedFd) -> AnonPipe {
+        AnonPipe::from_inner(FileDesc::from_inner(owned_fd))
+    }
+
+    impl TryFrom<OwnedFd> for PipeReader {
+        type Error = NotAPipeError;
+
+        fn try_from(owned_fd: OwnedFd) -> Result<Self, Self::Error> {
+            Ok(Self(owned_fd_to_anon_pipe(owned_fd)))
+        }
+    }
+
+    impl TryFrom<OwnedFd> for PipeWriter {
+        type Error = NotAPipeError;
+
+        fn try_from(owned_fd: OwnedFd) -> Result<Self, Self::Error> {
+            Ok(Self(owned_fd_to_anon_pipe(owned_fd)))
+        }
+    }
+}
+
+#[cfg(windows)]
+mod windows {
+    use super::*;
+
+    use crate::{
+        os::windows::io::{
+            AsHandle, AsRawHandle, BorrowedHandle, FromRawHandle, IntoRawHandle, OwnedHandle,
+            RawHandle,
+        },
+        sys::{
+            handle::Handle,
+            pipe::{anon_pipe, AnonPipe, Pipes},
+        },
+        sys_common::{FromInner, IntoInner},
+    };
+
+    #[inline]
+    pub(super) fn pipe() -> io::Result<(PipeReader, PipeWriter)> {
+        anon_pipe(true, false).map(|Pipes { ours, their }| (PipeReader(ours), PipeWrite(theirs)))
+    }
+
+    macro_rules! impl_traits {
+        ($name:ty) => {
+            impl AsHandle for $name {
+                fn as_handle(&self) -> BorrowedHandle<'_> {
+                    self.0.handle().as_handle()
+                }
+            }
+            impl AsRawHandle for $name {
+                fn as_raw_handle(&self) -> RawHandle {
+                    self.0.handle().as_raw_handle()
+                }
+            }
+
+            impl FromRawHandle for $name {
+                unsafe fn from_raw_handle(raw_handle: RawHandle) -> Self {
+                    Self(AnonPipe::from_inner(Handle::from_raw_handle(raw_handle)))
+                }
+            }
+            impl IntoRawHandle for $name {
+                fn into_raw_handle(self) -> RawHandle {
+                    self.0.into_handle().into_raw_handle()
+                }
+            }
+
+            impl From<$name> for OwnedHandle {
+                fn from(pipe: $name) -> Self {
+                    Handle::into_inner(AnonPipe::into_inner(pipe.0))
+                }
+            }
+            impl From<$name> for Stdio {
+                fn from(pipe: $name) -> Self {
+                    Self::from(OwnedHandle::from(pipe))
+                }
+            }
+        };
+    }
+    impl_traits!(PipeReader);
+    impl_traits!(PipeWriter);
+
+    fn owned_handle_to_anon_pipe(owned_handle: OwnedHandle) -> AnonPipe {
+        AnonPipe::from_inner(Handle::from_inner(owned_handle))
+    }
+
+    impl TryFrom<OwnedHandle> for PipeReader {
+        type Error = NotAPipeError;
+
+        fn try_from(owned_handle: OwnedHandle) -> Result<Self, Self::Error> {
+            Ok(Self(owned_handle_to_anon_pipe(owned_handle)))
+        }
+    }
+
+    impl TryFrom<OwnedHandle> for PipeWriter {
+        type Error = NotAPipeError;
+
+        fn try_from(owned_handle: OwnedHandle) -> Result<Self, Self::Error> {
+            Ok(Self(owned_handle_to_anon_pipe(owned_handle)))
+        }
+    }
+}

library/std/src/sys/pal/unix/pipe.rs

@@ -9,6 +9,7 @@ use crate::sys_common::{FromInner, IntoInner};
 // Anonymous pipes
 ////////////////////////////////////////////////////////////////////////////////
 
+#[derive(Debug)]
 pub struct AnonPipe(FileDesc);
 
 pub fn anon_pipe() -> io::Result<(AnonPipe, AnonPipe)> {
@@ -46,6 +47,10 @@ pub fn anon_pipe() -> io::Result<(AnonPipe, AnonPipe)> {
 }
 
 impl AnonPipe {
+    pub fn try_clone(&self) -> io::Result<Self> {
+        self.0.duplicate().map(Self)
+    }
+
     pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
         self.0.read(buf)
     }

library/std/src/sys/pal/windows/handle.rs

@@ -17,6 +17,7 @@ use crate::sys_common::{AsInner, FromInner, IntoInner};
 /// An owned container for `HANDLE` object, closing them on Drop.
 ///
 /// All methods are inherited through a `Deref` impl to `RawHandle`
+#[derive(Debug)]
 pub struct Handle(OwnedHandle);
 
 impl Handle {

library/std/src/sys/pal/windows/pipe.rs

@@ -19,6 +19,7 @@ use crate::sys_common::{FromInner, IntoInner};
 // Anonymous pipes
 ////////////////////////////////////////////////////////////////////////////////
 
+#[derive(Debug)]
 pub struct AnonPipe {
     inner: Handle,
 }
@@ -182,7 +183,7 @@ pub fn spawn_pipe_relay(
     their_handle_inheritable: bool,
 ) -> io::Result<AnonPipe> {
     // We need this handle to live for the lifetime of the thread spawned below.
-    let source = source.duplicate()?;
+    let source = source.try_clone()?;
 
     // create a new pair of anon pipes.
     let Pipes { theirs, ours } = anon_pipe(ours_readable, their_handle_inheritable)?;
@@ -238,7 +239,8 @@ impl AnonPipe {
     pub fn into_handle(self) -> Handle {
         self.inner
     }
-    fn duplicate(&self) -> io::Result<Self> {
+
+    pub fn try_clone(&self) -> io::Result<Self> {
         self.inner.duplicate(0, false, c::DUPLICATE_SAME_ACCESS).map(|inner| AnonPipe { inner })
     }