add std::os::unix::process::CommandExt::fd

Author: Qelxiros

library/std/src/os/unix/process.rs

@@ -4,10 +4,13 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
+use libc::{F_GETFD, F_SETFD, FD_CLOEXEC};
+
 use crate::ffi::OsStr;
 use crate::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
 use crate::path::Path;
 use crate::sealed::Sealed;
+use crate::sys::{cvt, cvt_r};
 use crate::sys_common::{AsInner, AsInnerMut, FromInner, IntoInner};
 use crate::{io, process, sys};
 
@@ -213,6 +216,84 @@ pub trait CommandExt: Sealed {
 
     #[unstable(feature = "process_setsid", issue = "105376")]
     fn setsid(&mut self, setsid: bool) -> &mut process::Command;
+
+    /// Pass a file descriptor to a child process.
+    ///
+    /// Getting this right is tricky. It is recommended to provide further information to the child
+    /// process by some other mechanism. This could be an argument confirming file descriptors that
+    /// the child can use, device/inode numbers to allow for sanity checks, or something similar.
+    ///
+    /// If `new_fd` is an open file descriptor and closing it would produce one or more errors,
+    /// those errors will be lost when this function is called. See
+    /// [`man 2 dup`](https://www.man7.org/linux/man-pages/man2/dup.2.html#NOTES) for more information.
+    ///
+    /// If this method is called multiple times with the same `new_fd`, all but one file descriptor
+    /// will be lost.
+    ///
+    /// ```
+    /// #![feature(command_pass_fds)]
+    ///
+    /// use std::process::{Command, Stdio};
+    /// use std::os::fd::process::CommandExt;
+    /// use std::io::{self, Write};
+    ///
+    /// fn main() -> io::Result<()> {
+    ///     let (pipe_reader, mut pipe_writer) = io::pipe()?;
+    ///
+    ///     let fd_num = 123;
+    ///
+    ///     let mut cmd = Command::new("cat");
+    ///     cmd.arg(format!("/dev/fd/{fd_num}")).stdout(Stdio::piped()).fd(fd_num, pipe_reader);
+    ///
+    ///     let mut child = cmd.spawn()?;
+    ///     let mut stdout = child.stdout.take().unwrap();
+    ///
+    ///     pipe_writer.write_all(b"Hello, world!")?;
+    ///     drop(pipe_writer);
+    ///
+    ///     child.wait()?;
+    ///     assert_eq!(io::read_to_string(&mut stdout)?, "Hello, world!");
+    ///
+    ///     Ok(())
+    /// }
+    /// ```
+    ///
+    /// ```
+    /// #![feature(command_pass_fds)]
+    ///
+    /// use std::process::{Command, Stdio};
+    /// use std::os::fd::process::CommandExt;
+    /// use std::io::{self, Write};
+    ///
+    /// fn main() -> io::Result<()> {
+    ///     let (pipe_reader1, mut pipe_writer1) = io::pipe()?;
+    ///     let (pipe_reader2, mut pipe_writer2) = io::pipe()?;
+    ///
+    ///     let fd_num = 123;
+    ///
+    ///     let mut cmd = Command::new("cat");
+    ///     cmd.arg(format!("/dev/fd/{fd_num}"))
+    ///         .stdout(Stdio::piped())
+    ///         .fd(fd_num, pipe_reader1)
+    ///         .fd(fd_num, pipe_reader2);
+    ///
+    ///     let mut child = cmd.spawn()?;
+    ///     let mut stdout = child.stdout.take().unwrap();
+    ///
+    ///     pipe_writer1.write_all(b"Hello from pipe 1!")?;
+    ///     drop(pipe_writer1);
+    ///
+    ///     pipe_writer2.write_all(b"Hello from pipe 2!")?;
+    ///     drop(pipe_writer2);
+    ///
+    ///     child.wait()?;
+    ///     assert_eq!(io::read_to_string(&mut stdout)?, "Hello from pipe 2!");
+    ///
+    ///     Ok(())
+    /// }
+    /// ```
+    #[unstable(feature = "command_pass_fds", issue = "144989")]
+    fn fd(&mut self, new_fd: RawFd, old_fd: impl Into<OwnedFd>) -> &mut Self;
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -268,6 +349,21 @@ impl CommandExt for process::Command {
         self.as_inner_mut().setsid(setsid);
         self
     }
+
+    fn fd(&mut self, new_fd: RawFd, old_fd: impl Into<OwnedFd>) -> &mut Self {
+        let old = old_fd.into();
+        unsafe {
+            self.as_inner_mut().pre_exec(Box::new(move || {
+                cvt_r(|| libc::dup2(old.as_raw_fd(), new_fd))?;
+                let flags = cvt(libc::fcntl(new_fd, F_GETFD))?;
+                cvt(libc::fcntl(new_fd, F_SETFD, flags & !FD_CLOEXEC))?;
+                cvt_r(|| libc::close(old.as_raw_fd()))?;
+                Ok(())
+            }))
+        }
+
+        self
+    }
 }
 
 /// Unix-specific extensions to [`process::ExitStatus`] and

library/std/tests/fd_passing.rs

@@ -0,0 +1,79 @@
+#![feature(command_pass_fds)]
+#![cfg(unix)]
+
+use std::io::{self, Write};
+use std::os::unix::io::AsRawFd;
+use std::os::unix::process::CommandExt;
+use std::process::{Command, Stdio};
+
+use libc::{F_GETFD, fcntl};
+
+#[test]
+fn fd_test_stdin() {
+    let (pipe_reader, mut pipe_writer) = io::pipe().unwrap();
+
+    let fd_num = 0;
+
+    let mut cmd = Command::new("cat");
+    cmd.stdout(Stdio::piped()).fd(fd_num, pipe_reader);
+
+    let mut child = cmd.spawn().unwrap();
+    let mut stdout = child.stdout.take().unwrap();
+
+    pipe_writer.write_all(b"Hello, world!").unwrap();
+    drop(pipe_writer);
+
+    child.wait().unwrap();
+    assert_eq!(io::read_to_string(&mut stdout).unwrap(), "Hello, world!");
+}
+
+#[test]
+fn fd_test_swap() {
+    let (pipe_reader1, mut pipe_writer1) = io::pipe().unwrap();
+    let (pipe_reader2, mut pipe_writer2) = io::pipe().unwrap();
+
+    let num1 = pipe_reader1.as_raw_fd();
+    let num2 = pipe_reader2.as_raw_fd();
+
+    let mut cmd = Command::new("cat");
+    cmd.arg(format!("/dev/fd/{}", num1))
+        .stdout(Stdio::piped())
+        .fd(num2, pipe_reader1)
+        .fd(num1, pipe_reader2);
+
+    let mut child = cmd.spawn().unwrap();
+    let mut stdout = child.stdout.take().unwrap();
+
+    pipe_writer1.write_all(b"Hello from pipe 1!").unwrap();
+    drop(pipe_writer1);
+
+    pipe_writer2.write_all(b"Hello from pipe 2!").unwrap();
+    drop(pipe_writer2);
+
+    child.wait().unwrap();
+    assert_eq!(io::read_to_string(&mut stdout).unwrap(), "Hello from pipe 1!");
+}
+
+#[test]
+fn fd_test_close_time() {
+    let (pipe_reader, mut pipe_writer) = io::pipe().unwrap();
+
+    let fd_num = 123;
+
+    let original = pipe_reader.as_raw_fd();
+
+    let mut cmd = Command::new("cat");
+    cmd.arg(format!("/dev/fd/{fd_num}")).stdout(Stdio::piped()).fd(fd_num, pipe_reader);
+
+    assert_ne!(unsafe { fcntl(original, F_GETFD) }, -1);
+
+    let mut child = cmd.spawn().unwrap();
+    let mut stdout = child.stdout.take().unwrap();
+
+    pipe_writer.write_all(b"Hello, world!").unwrap();
+    drop(pipe_writer);
+
+    child.wait().unwrap();
+    assert_eq!(io::read_to_string(&mut stdout).unwrap(), "Hello, world!");
+    assert_eq!(unsafe { fcntl(original, F_GETFD) }, -1);
+}