Vendor dependency os_pipe

Cargo.toml

@@ -19,7 +19,12 @@ edition = "2018"
 
 [dependencies]
 jobserver = { version = "0.1.16", optional = true }
-os_pipe = "1"
+
+[target.'cfg(unix)'.dependencies]
+libc = "0.2.62"
+
+[target.'cfg(windows)'.dependencies]
+windows-sys = { version = "0.48.0", features = ["Win32_Foundation", "Win32_System_Pipes", "Win32_Security"] }
 
 [features]
 parallel = ["jobserver"]

src/lib.rs

@@ -61,14 +61,16 @@ use std::collections::{hash_map, HashMap};
 use std::env;
 use std::ffi::{OsStr, OsString};
 use std::fmt::{self, Display, Formatter};
-use std::fs;
+use std::fs::{self, File};
 use std::hash::Hasher;
 use std::io::{self, BufRead, BufReader, Read, Write};
 use std::path::{Component, Path, PathBuf};
 use std::process::{Child, Command, Stdio};
 use std::sync::{Arc, Mutex};
 use std::thread::{self, JoinHandle};
 
+mod os_pipe;
+
 // These modules are all glue to support reading the MSVC version from
 // the registry and from COM interfaces
 #[cfg(windows)]
@@ -3494,11 +3496,7 @@ fn wait_on_child(cmd: &Command, program: &str, child: &mut Child) -> Result<(),
  }
 }
 
-fn run_inner(
- cmd: &mut Command,
- program: &str,
- pipe_writer: os_pipe::PipeWriter,
-) -> Result<(), Error> {
+fn run_inner(cmd: &mut Command, program: &str, pipe_writer: File) -> Result<(), Error> {
  let mut child = spawn(cmd, program, pipe_writer)?;
  wait_on_child(cmd, program, &mut child)
 }
@@ -3529,11 +3527,7 @@ fn run_output(cmd: &mut Command, program: &str) -> Result<Vec<u8>, Error> {
  Ok(stdout)
 }
 
-fn spawn(
- cmd: &mut Command,
- program: &str,
- pipe_writer: os_pipe::PipeWriter,
-) -> Result<Child, Error> {
+fn spawn(cmd: &mut Command, program: &str, pipe_writer: File) -> Result<Child, Error> {
  struct ResetStderr<'cmd>(&'cmd mut Command);
 
  impl Drop for ResetStderr<'_> {
@@ -3773,7 +3767,7 @@ impl AsmFileExt {
 
 struct PrintThread {
  handle: Option<JoinHandle<()>>,
- pipe_writer: Option<os_pipe::PipeWriter>,
+ pipe_writer: Option<File>,
 }
 
 impl PrintThread {
@@ -3804,14 +3798,14 @@ impl PrintThread {
  })
  }
 
- fn pipe_writer(&mut self) -> &mut Option<os_pipe::PipeWriter> {
+ fn pipe_writer(&mut self) -> &mut Option<File> {
  &mut self.pipe_writer
  }
 
- fn pipe_writer_cloned(&self) -> Result<Option<os_pipe::PipeWriter>, Error> {
+ fn pipe_writer_cloned(&self) -> Result<Option<File>, Error> {
  self.pipe_writer
  .as_ref()
- .map(os_pipe::PipeWriter::try_clone)
+ .map(File::try_clone)
  .transpose()
  .map_err(From::from)
  }

src/os_pipe.rs

@@ -0,0 +1,28 @@
+//! Adapted from:
+//! - https://doc.rust-lang.org/src/std/sys/unix/pipe.rs.html
+//! - https://doc.rust-lang.org/src/std/sys/unix/fd.rs.html#385
+//! - https:/rust-lang/rust/blob/master/library/std/src/sys/mod.rs#L57
+//! - https:/oconnor663/os_pipe.rs
+use std::fs::File;
+
+/// Open a new pipe and return a pair of [`File`] objects for the reader and writer.
+///
+/// This corresponds to the `pipe2` library call on Posix and the
+/// `CreatePipe` library call on Windows (though these implementation
+/// details might change). These pipes are non-inheritable, so new child
+/// processes won't receive a copy of them unless they're explicitly
+/// passed as stdin/stdout/stderr.
+pub fn pipe() -> std::io::Result<(File, File)> {
+ sys::pipe()
+}
+
+#[cfg(unix)]
+#[path = "os_pipe/unix.rs"]
+mod sys;
+
+#[cfg(windows)]
+#[path = "os_pipe/windows.rs"]
+mod sys;
+
+#[cfg(all(not(unix), not(windows)))]
+compile_error!("Only unix and windows support os_pipe!");

src/os_pipe/unix.rs

@@ -0,0 +1,121 @@
+use std::{
+ fs::File,
+ io,
+ os::{raw::c_int, unix::io::FromRawFd},
+};
+
+pub(super) fn pipe() -> io::Result<(File, File)> {
+ let mut fds = [0; 2];
+
+ // The only known way right now to create atomically set the CLOEXEC flag is
+ // to use the `pipe2` syscall. This was added to Linux in 2.6.27, glibc 2.9
+ // and musl 0.9.3, and some other targets also have it.
+ #[cfg(any(
+ target_os = "dragonfly",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ target_os = "redox"
+ ))]
+ {
+ unsafe {
+ cvt(libc::pipe2(fds.as_mut_ptr(), libc::O_CLOEXEC))?;
+ }
+ }
+
+ #[cfg(not(any(
+ target_os = "dragonfly",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ target_os = "redox"
+ )))]
+ {
+ unsafe {
+ cvt(libc::pipe(fds.as_mut_ptr()))?;
+ }
+
+ cloexec::set_cloexec(fds[0])?;
+ cloexec::set_cloexec(fds[1])?;
+ }
+
+ unsafe { Ok((File::from_raw_fd(fds[0]), File::from_raw_fd(fds[1]))) }
+}
+
+fn cvt(t: c_int) -> io::Result<c_int> {
+ if t == -1 {
+ Err(io::Error::last_os_error())
+ } else {
+ Ok(t)
+ }
+}
+
+#[cfg(not(any(
+ target_os = "dragonfly",
+ target_os = "freebsd",
+ target_os = "linux",
+ target_os = "netbsd",
+ target_os = "openbsd",
+ target_os = "redox"
+)))]
+mod cloexec {
+ use super::{c_int, cvt, io};
+
+ #[cfg(not(any(
+ target_env = "newlib",
+ target_os = "solaris",
+ target_os = "illumos",
+ target_os = "emscripten",
+ target_os = "fuchsia",
+ target_os = "l4re",
+ target_os = "linux",
+ target_os = "haiku",
+ target_os = "redox",
+ target_os = "vxworks",
+ target_os = "nto",
+ )))]
+ pub(super) fn set_cloexec(fd: c_int) -> io::Result<()> {
+ unsafe {
+ cvt(libc::ioctl(fd, libc::FIOCLEX))?;
+ }
+
+ Ok(())
+ }
+
+ #[cfg(any(
+ all(
+ target_env = "newlib",
+ not(any(target_os = "espidf", target_os = "horizon"))
+ ),
+ target_os = "solaris",
+ target_os = "illumos",
+ target_os = "emscripten",
+ target_os = "fuchsia",
+ target_os = "l4re",
+ target_os = "linux",
+ target_os = "haiku",
+ target_os = "redox",
+ target_os = "vxworks",
+ target_os = "nto",
+ ))]
+ pub(super) fn set_cloexec(fd: c_int) -> io::Result<()> {
+ unsafe {
+ let previous = cvt(libc::fcntl(fd, libc::F_GETFD))?;
+ let new = previous | libc::FD_CLOEXEC;
+ if new != previous {
+ cvt(libc::fcntl(fd, libc::F_SETFD, new))?;
+ }
+ }
+
+ Ok(())
+ }
+
+ // FD_CLOEXEC is not supported in ESP-IDF and Horizon OS but there's no need to,
+ // because neither supports spawning processes.
+ #[cfg(any(target_os = "espidf", target_os = "horizon"))]
+ pub(super) fn set_cloexec(_fd: c_int) -> io::Result<()> {
+ Ok(())
+ }
+}

src/os_pipe/windows.rs

@@ -0,0 +1,24 @@
+use std::{fs::File, io, os::windows::prelude::*, ptr};
+use windows_sys::Win32::{Foundation::INVALID_HANDLE_VALUE, System::Pipes::CreatePipe};
+
+/// NOTE: These pipes do not support IOCP.
+///
+/// If IOCP is needed, then you might want to emulate
+/// anonymous pipes with CreateNamedPipe, as Rust's stdlib does.
+pub(super) fn pipe() -> io::Result<(File, File)> {
+ let mut read_pipe = INVALID_HANDLE_VALUE;
+ let mut write_pipe = INVALID_HANDLE_VALUE;
+
+ let ret = unsafe { CreatePipe(&mut read_pipe, &mut write_pipe, ptr::null_mut(), 0) };
+
+ if ret == 0 {
+ Err(io::Error::last_os_error())
+ } else {
+ unsafe {
+ Ok((
+ File::from_raw_handle(read_pipe as RawHandle),
+ File::from_raw_handle(write_pipe as RawHandle),
+ ))
+ }
+ }
+}