Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Route pipe processes through the shared child launcher (#47605)

Charlie Marsh50fc133d05bc
diff --git a/codex-rs/utils/pty/src/child_command.rs b/codex-rs/utils/pty/src/child_command.rs
index 0f549c3719..7207351314 100644
--- a/codex-rs/utils/pty/src/child_command.rs
+++ b/codex-rs/utils/pty/src/child_command.rs
@@ -4,6 +4,7 @@
//! change settings that the native backend cannot inspect. Children receive only
//! explicitly supplied environment variables and default to kill-on-drop. Stdio,
//! descriptor inheritance, and compatibility fallbacks are configured independently.
+//! Original Unix inputs retain their NUL validation even when std replaces them.
use std::ffi::OsStr;
#[cfg(unix)]
@@ -53,10 +54,6 @@ pub(crate) enum ChildDropPolicy {
/// Kill the direct child, then reap it. This is the default.
KillAndReap,
/// Reap the child when it exits, leaving termination to the caller.
- #[allow(
- dead_code,
- reason = "Used by the pipe adapter in the next stacked change."
- )]
ReapOnly,
}
@@ -71,6 +68,8 @@ pub enum ChildStdin {
/// A local command whose complete launch contract is known to both backends.
pub struct Command {
pub(crate) inner: tokio::process::Command,
+ #[cfg(unix)]
+ saw_nul: bool,
pub(crate) process_mode: ProcessMode,
pub(crate) descriptor_policy: DescriptorPolicy,
pub(crate) fallback: SpawnFallback,
@@ -86,6 +85,7 @@ pub struct Command {
impl Command {
pub fn new(program: impl AsRef<OsStr>) -> Self {
+ let program = program.as_ref();
let mut inner = tokio::process::Command::new(program);
inner
.env_clear()
@@ -95,6 +95,8 @@ impl Command {
.stderr(TokioStdio::piped());
Self {
inner,
+ #[cfg(unix)]
+ saw_nul: program.as_encoded_bytes().contains(&0),
process_mode: ProcessMode::Inherit,
descriptor_policy: DescriptorPolicy::Inherit,
fallback: SpawnFallback::Compatible,
@@ -110,12 +112,19 @@ impl Command {
}
pub fn arg(&mut self, arg: impl AsRef<OsStr>) -> &mut Self {
+ let arg = arg.as_ref();
+ #[cfg(unix)]
+ {
+ self.saw_nul |= arg.as_encoded_bytes().contains(&0);
+ }
self.inner.arg(arg);
self
}
pub fn args(&mut self, args: impl IntoIterator<Item = impl AsRef<OsStr>>) -> &mut Self {
- self.inner.args(args);
+ for arg in args {
+ self.arg(arg);
+ }
self
}
@@ -134,6 +143,11 @@ impl Command {
}
pub fn current_dir(&mut self, cwd: impl AsRef<Path>) -> &mut Self {
+ let cwd = cwd.as_ref();
+ #[cfg(unix)]
+ {
+ self.saw_nul |= cwd.as_os_str().as_encoded_bytes().contains(&0);
+ }
self.inner.current_dir(cwd);
self
}
@@ -144,10 +158,6 @@ impl Command {
}
/// Choose who owns termination when the child handle is dropped.
- #[allow(
- dead_code,
- reason = "Used by the pipe adapter in the next stacked change."
- )]
pub(crate) fn drop_policy(&mut self, policy: ChildDropPolicy) -> &mut Self {
self.drop_policy = policy;
self.inner.kill_on_drop(match policy {
@@ -200,6 +210,7 @@ impl Command {
#[cfg(unix)]
pub fn arg0(&mut self, arg0: impl AsRef<OsStr>) -> &mut Self {
+ self.saw_nul |= arg0.as_ref().as_encoded_bytes().contains(&0);
self.inner.arg0(arg0.as_ref());
self.arg0 = Some(arg0.as_ref().to_owned());
self
@@ -211,8 +222,22 @@ impl Command {
job.prepare_suspended_spawn(&mut self.inner);
}
+ /// Reject original inputs that std replaced with a NUL-free placeholder.
+ #[cfg(unix)]
+ pub(crate) fn validate(&self) -> io::Result<()> {
+ if self.saw_nul {
+ return Err(io::Error::new(
+ io::ErrorKind::InvalidInput,
+ "nul byte found in provided data",
+ ));
+ }
+ Ok(())
+ }
+
/// Launch with native macOS path handling and the existing compatibility fallback.
pub fn spawn(mut self) -> io::Result<Child> {
+ #[cfg(unix)]
+ self.validate()?;
#[cfg(unix)]
if let ProcessMode::NewGroup = self.process_mode {
self.inner.process_group(/*pgroup*/ 0);
@@ -295,6 +320,10 @@ impl Command {
}
}
+#[cfg(all(test, unix))]
+#[path = "command_validation_tests.rs"]
+mod validation_tests;
+
#[cfg(all(test, target_os = "macos"))]
#[path = "macos_child_tests.rs"]
mod tests;
diff --git a/codex-rs/utils/pty/src/command_validation_tests.rs b/codex-rs/utils/pty/src/command_validation_tests.rs
new file mode 100644
index 0000000000..39b86d6f28
--- /dev/null
+++ b/codex-rs/utils/pty/src/command_validation_tests.rs
@@ -0,0 +1,126 @@
+//! Invalid command inputs must fail before a child can run on either backend.
+
+use std::io;
+
+use pretty_assertions::assert_eq;
+
+use crate::Command;
+use crate::ProcessMode;
+
+enum Input {
+ Program,
+ Arg,
+ Args,
+ Cwd,
+ Arg0,
+ EnvKey,
+ EnvValue,
+}
+
+#[tokio::test]
+async fn embedded_nul_is_rejected_before_spawning() -> anyhow::Result<()> {
+ for mode in [ProcessMode::Inherit, ProcessMode::NewSession] {
+ for input in [
+ Input::Program,
+ Input::Arg,
+ Input::Args,
+ Input::Cwd,
+ Input::Arg0,
+ Input::EnvKey,
+ Input::EnvValue,
+ ] {
+ let root = tempfile::tempdir()?;
+ let marker = root.path().join("ran");
+ let mut command = Command::new(match input {
+ Input::Program => "/bin/sh\0",
+ Input::Arg
+ | Input::Args
+ | Input::Cwd
+ | Input::Arg0
+ | Input::EnvKey
+ | Input::EnvValue => "/bin/sh",
+ });
+ command
+ .process_mode(mode)
+ .args(["-c", "printf ran > \"$1\"", "sh"])
+ .arg(&marker);
+ match input {
+ Input::Program => {}
+ Input::Arg => {
+ command.arg("bad\0arg");
+ }
+ Input::Args => {
+ command.args(["bad\0arg"]);
+ }
+ Input::Cwd => {
+ command.current_dir("bad\0cwd").current_dir(root.path());
+ }
+ Input::Arg0 => {
+ command.arg0("bad\0arg0").arg0("sh");
+ }
+ Input::EnvKey => {
+ command.env("bad\0key", "value");
+ }
+ Input::EnvValue => {
+ command.env("key", "bad\0value");
+ }
+ }
+ let error = match command.spawn() {
+ Err(error) => error,
+ Ok(child) => {
+ let output = child.wait_with_output().await?;
+ anyhow::bail!(
+ "invalid command ran: {output:?}, marker={}",
+ marker.exists()
+ );
+ }
+ };
+ assert_eq!(error.kind(), io::ErrorKind::InvalidInput);
+ assert!(!marker.exists());
+ }
+ }
+ Ok(())
+}
+
+#[tokio::test]
+async fn literal_nul_placeholder_is_a_valid_argument() -> anyhow::Result<()> {
+ let mut command = Command::new("/bin/echo");
+ command
+ .process_mode(ProcessMode::NewSession)
+ .arg("<string-with-nul>");
+ let output = command.spawn()?.wait_with_output().await?;
+ assert!(output.status.success());
+ assert_eq!(output.stdout, b"<string-with-nul>\n");
+ Ok(())
+}
+
+#[tokio::test]
+async fn pipe_rejects_nul_arguments_without_side_effects() -> anyhow::Result<()> {
+ let root = tempfile::tempdir()?;
+ let marker = root.path().join("ran");
+ let result = crate::spawn_pipe_process(
+ "/usr/bin/touch",
+ &[
+ marker.to_string_lossy().into_owned(),
+ "bad\0arg".to_string(),
+ ],
+ root.path(),
+ &std::collections::HashMap::new(),
+ /*arg0*/ &None,
+ &[],
+ )
+ .await;
+ let error = match result {
+ Err(error) => error,
+ Ok(child) => {
+ let _ = child.exit_rx.await;
+ anyhow::bail!("invalid pipe command ran, marker={}", marker.exists());
+ }
+ };
+ assert_eq!(
+ error.downcast_ref::<io::Error>().map(io::Error::kind),
+ Some(io::ErrorKind::InvalidInput)
+ );
+ assert!(!marker.exists());
+ Ok(())
+}
diff --git a/codex-rs/utils/pty/src/pipe.rs b/codex-rs/utils/pty/src/pipe.rs
index 867d246452..abf88d0a79 100644
--- a/codex-rs/utils/pty/src/pipe.rs
+++ b/codex-rs/utils/pty/src/pipe.rs
@@ -1,19 +1,26 @@
+//! Pipe I/O and process-tree ownership on top of the shared local child launcher.
+
use std::collections::HashMap;
use std::ffi::OsStr;
use std::io;
use std::io::ErrorKind;
use std::path::Path;
-use std::process::Stdio;
use std::sync::Arc;
use std::sync::Mutex as StdMutex;
use std::sync::atomic::AtomicBool;
+use crate::ChildStdin;
+use crate::Command;
+#[cfg(unix)]
+use crate::DescriptorPolicy;
+#[cfg(unix)]
+use crate::ProcessMode;
+use crate::child_command::ChildDropPolicy;
use anyhow::Result;
use tokio::io::AsyncRead;
use tokio::io::AsyncReadExt;
use tokio::io::AsyncWriteExt;
use tokio::io::BufReader;
-use tokio::process::Command;
use tokio::sync::mpsc;
use tokio::sync::oneshot;
use tokio::task::JoinHandle;
@@ -24,9 +31,6 @@ use crate::process::ProcessSignal;
use crate::process::SpawnedProcess;
use crate::process::exit_code_from_status;
-#[cfg(target_os = "linux")]
-use libc;
-
#[cfg(windows)]
enum WindowsChildTerminator {
Job(Arc<crate::win::JobObject>),
@@ -147,40 +151,24 @@ async fn spawn_process_with_stdin_mode(
if let Some(arg0) = arg0 {
command.arg0(arg0);
}
- #[cfg(target_os = "linux")]
- let parent_pid = unsafe { libc::getpid() };
- #[cfg(unix)]
- let inherited_fds = inherited_fds.to_vec();
#[cfg(unix)]
- unsafe {
- command.pre_exec(move || {
- crate::process_group::detach_from_tty()?;
- #[cfg(target_os = "linux")]
- crate::process_group::set_parent_death_signal(parent_pid)?;
- crate::pty::close_inherited_fds_except(&inherited_fds);
- Ok(())
- });
- }
+ command
+ .process_mode(ProcessMode::NewSession)
+ .descriptor_policy(DescriptorPolicy::Explicit)
+ .preserve_fds(inherited_fds);
+ #[cfg(target_os = "linux")]
+ command.terminate_on_parent_death();
#[cfg(not(unix))]
let _ = arg0;
- command.current_dir(cwd);
- command.env_clear();
- for (key, value) in env {
- command.env(key, value);
- }
- for arg in args {
- command.arg(arg);
- }
- match stdin_mode {
- PipeStdinMode::Piped => {
- command.stdin(Stdio::piped());
- }
- PipeStdinMode::Null => {
- command.stdin(Stdio::null());
- }
- }
- command.stdout(Stdio::piped());
- command.stderr(Stdio::piped());
+ command
+ .current_dir(cwd)
+ .envs(env)
+ .args(args)
+ .drop_policy(ChildDropPolicy::ReapOnly)
+ .stdin(match stdin_mode {
+ PipeStdinMode::Piped => ChildStdin::Piped,
+ PipeStdinMode::Null => ChildStdin::Null,
+ });
#[cfg(windows)]
let job = crate::win::JobObject::create().map(Arc::new);
@@ -193,6 +181,7 @@ async fn spawn_process_with_stdin_mode(
.id()
.ok_or_else(|| io::Error::other("missing child pid"))?;
let assigned_job = job.and_then(|job| {
+ let crate::child::ChildKind::Tokio(child) = &child.inner;
let process_handle = child
.raw_handle()
.ok_or_else(|| io::Error::other("missing child process handle"))?;
@@ -368,3 +357,7 @@ pub async fn spawn_process_no_stdin(
#[cfg(all(test, windows))]
#[path = "pipe_tests.rs"]
mod tests;
+
+#[cfg(all(test, unix))]
+#[path = "pipe_unix_tests.rs"]
+mod unix_tests;
diff --git a/codex-rs/utils/pty/src/pipe_tests.rs b/codex-rs/utils/pty/src/pipe_tests.rs
index afed3e933c..fdf8a1352d 100644
--- a/codex-rs/utils/pty/src/pipe_tests.rs
+++ b/codex-rs/utils/pty/src/pipe_tests.rs
@@ -1,4 +1,5 @@
use super::*;
+use std::process::Stdio;
#[test]
fn process_fallback_interrupt_terminates_root() -> anyhow::Result<()> {
diff --git a/codex-rs/utils/pty/src/pipe_unix_tests.rs b/codex-rs/utils/pty/src/pipe_unix_tests.rs
new file mode 100644
index 0000000000..37303e2c8e
--- /dev/null
+++ b/codex-rs/utils/pty/src/pipe_unix_tests.rs
@@ -0,0 +1,137 @@
+//! Pipe and PTY compatibility under inherited-descriptor pressure.
+
+use std::collections::HashMap;
+use std::io;
+use std::io::Seek;
+use std::os::fd::AsRawFd;
+use std::os::fd::FromRawFd;
+use std::os::fd::OwnedFd;
+use std::path::Path;
+
+use pretty_assertions::assert_eq;
+
+#[tokio::test]
+async fn descriptor_capture_pressure_falls_back_to_direct_spawn() -> anyhow::Result<()> {
+ if std::env::var_os("CODEX_TEST_PIPE_FD_PRESSURE").is_none() {
+ let output = std::process::Command::new(std::env::current_exe()?)
+ .args([
+ "--exact",
+ "pipe::unix_tests::descriptor_capture_pressure_falls_back_to_direct_spawn",
+ "--nocapture",
+ ])
+ .env("CODEX_TEST_PIPE_FD_PRESSURE", "1")
+ .output()?;
+ assert!(output.status.success(), "{output:?}");
+ return Ok(());
+ }
+ let root = tempfile::tempdir()?;
+ let path = root.path().join("input");
+ std::fs::write(&path, "preserved")?;
+ let mut source = std::fs::File::open(path)?;
+ let descriptors = (0..17)
+ .map(|_| {
+ // SAFETY: fcntl duplicates a live source into a newly owned slot.
+ let fd = unsafe { libc::fcntl(source.as_raw_fd(), libc::F_DUPFD, 3) };
+ anyhow::ensure!(fd >= 3, "{}", io::Error::last_os_error());
+ Ok(unsafe { OwnedFd::from_raw_fd(fd) })
+ })
+ .collect::<anyhow::Result<Vec<_>>>()?;
+ let targets = descriptors[..16]
+ .iter()
+ .map(AsRawFd::as_raw_fd)
+ .collect::<Vec<_>>();
+ let excluded = descriptors[16].as_raw_fd();
+ let script = format!(
+ "for fd in \"$@\"; do test -e /dev/fd/$fd || exit 10; done; \
+ test ! -e /dev/fd/{excluded} || exit 11; /bin/cat /dev/fd/$1"
+ );
+ let mut args = vec!["-c".to_owned(), script, "sh".to_owned()];
+ args.extend(targets.iter().map(ToString::to_string));
+ let mut limit = std::mem::MaybeUninit::<libc::rlimit>::uninit();
+ // SAFETY: getrlimit initializes writable storage.
+ assert_eq!(
+ unsafe { libc::getrlimit(libc::RLIMIT_NOFILE, limit.as_mut_ptr()) },
+ 0
+ );
+ let mut limit = unsafe { limit.assume_init() };
+ limit.rlim_cur = limit.rlim_cur.min(128);
+ // SAFETY: Only this isolated subprocess's soft descriptor limit changes.
+ assert_eq!(unsafe { libc::setrlimit(libc::RLIMIT_NOFILE, &limit) }, 0);
+ enum Transport {
+ Pipe(super::PipeStdinMode),
+ Pty,
+ }
+ for (spare_slots, transport) in [
+ (12, Transport::Pipe(super::PipeStdinMode::Piped)),
+ (12, Transport::Pipe(super::PipeStdinMode::Null)),
+ (12, Transport::Pty),
+ (20, Transport::Pipe(super::PipeStdinMode::Piped)),
+ (20, Transport::Pipe(super::PipeStdinMode::Null)),
+ (20, Transport::Pty),
+ ] {
+ source.rewind()?;
+ let mut occupied = Vec::new();
+ loop {
+ let fd = unsafe { libc::fcntl(source.as_raw_fd(), libc::F_DUPFD_CLOEXEC, 3) };
+ if fd == -1 {
+ assert_eq!(
+ io::Error::last_os_error().raw_os_error(),
+ Some(libc::EMFILE)
+ );
+ break;
+ }
+ occupied.push(unsafe { OwnedFd::from_raw_fd(fd) });
+ }
+ // Twelve slots reject capture itself; twenty allow all sixteen copies
+ // but leave too little room for stdio. Both must preserve the old launch.
+ anyhow::ensure!(
+ occupied.len() >= spare_slots,
+ "not enough descriptors to reserve"
+ );
+ occupied.truncate(occupied.len() - spare_slots);
+ let mut spawned = match transport {
+ Transport::Pipe(stdin) => {
+ super::spawn_process_with_stdin_mode(
+ std::ffi::OsStr::new("/bin/sh"),
+ &args,
+ Path::new("."),
+ &HashMap::new(),
+ &None,
+ stdin,
+ &targets,
+ )
+ .await?
+ }
+ Transport::Pty => {
+ crate::spawn_pty_process(
+ "/bin/sh",
+ &args,
+ Path::new("."),
+ &HashMap::new(),
+ &None,
+ crate::TerminalSize::default(),
+ &targets,
+ )
+ .await?
+ }
+ };
+ drop(occupied);
+ spawned.session.close_stdin();
+ let mut stdout = Vec::new();
+ while let Some(bytes) = spawned.stdout_rx.recv().await {
+ stdout.extend(bytes);
+ }
+ let mut stderr = Vec::new();
+ while let Some(bytes) = spawned.stderr_rx.recv().await {
+ stderr.extend(bytes);
+ }
+ assert_eq!(
+ (spawned.exit_rx.await?, stdout, stderr),
+ (0, b"preserved".to_vec(), vec![])
+ );
+ for fd in &descriptors {
+ assert_eq!(unsafe { libc::fcntl(fd.as_raw_fd(), libc::F_GETFD) }, 0);
+ }
+ }
+ Ok(())
+}
diff --git a/codex-rs/utils/pty/tests/macos_pipe_spawn.rs b/codex-rs/utils/pty/tests/macos_pipe_spawn.rs
new file mode 100644
index 0000000000..3a8498d1eb
--- /dev/null
+++ b/codex-rs/utils/pty/tests/macos_pipe_spawn.rs
@@ -0,0 +1,166 @@
+//! Exercise the public pipe adapter with native spawning and explicit inheritance.
+//! This binary isolates atfork registration from the rest of the test suite.
+
+#![cfg(target_os = "macos")]
+
+use std::collections::HashMap;
+use std::io::Read;
+use std::io::Seek;
+use std::os::fd::AsRawFd;
+use std::os::fd::FromRawFd;
+use std::os::fd::OwnedFd;
+use std::os::unix::fs::symlink;
+use std::os::unix::process::CommandExt;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
+use std::time::Duration;
+
+use codex_utils_pty::spawn_pipe_process;
+use codex_utils_pty::spawn_pipe_process_no_stdin;
+use pretty_assertions::assert_eq;
+
+static PARENT_FORKS: AtomicUsize = AtomicUsize::new(0);
+
+extern "C" fn record_parent_fork() {
+ PARENT_FORKS.fetch_add(1, Ordering::Relaxed);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn pipe_commands_avoid_fork() -> anyhow::Result<()> {
+ let directory = tempfile::tempdir()?;
+ let cwd = directory.path().canonicalize()?;
+ let executable = std::env::current_exe()?;
+ symlink(&executable, cwd.join("probe"))?;
+ let mut file = std::fs::File::create(cwd.join("preserved"))?;
+ let preserved = inheritable_fd(&file, /*minimum*/ 100)?;
+ let excluded = inheritable_fd(&file, /*minimum*/ 200)?;
+ let args = ["--exact", "pipe_child", "--ignored", "--nocapture"].map(str::to_owned);
+ let mut env = HashMap::from([
+ ("PATH".to_string(), ".".to_string()),
+ ("PRESERVED".to_string(), preserved.as_raw_fd().to_string()),
+ ("EXCLUDED".to_string(), excluded.as_raw_fd().to_string()),
+ (
+ "EXPECTED_CWD".to_string(),
+ cwd.to_string_lossy().into_owned(),
+ ),
+ ]);
+ // SAFETY: This is the binary's only active test; the permanent parent hook
+ // only updates a lock-free atomic and remains valid until process exit.
+ assert_eq!(
+ unsafe {
+ libc::pthread_atfork(
+ /*prepare*/ None,
+ Some(record_parent_fork),
+ /*child*/ None,
+ )
+ },
+ 0
+ );
+ let mut control = std::process::Command::new("/usr/bin/true");
+ // SAFETY: A no-op pre-exec hook forces fork for the positive control.
+ unsafe {
+ control.pre_exec(|| Ok(()));
+ }
+ assert!(control.status()?.success());
+ assert_eq!(PARENT_FORKS.load(Ordering::Relaxed), 1);
+
+ for program in [executable.as_os_str(), "./probe".as_ref(), "probe".as_ref()] {
+ for input in ["hello", ""] {
+ env.insert("EXPECTED_INPUT".to_string(), input.to_string());
+ file.set_len(0)?;
+ file.rewind()?;
+ let inherited = [preserved.as_raw_fd()];
+ let arg0 = Some("pipe-probe".to_string());
+ let mut child = if input.is_empty() {
+ spawn_pipe_process_no_stdin(program, &args, &cwd, &env, &arg0, &inherited).await?
+ } else {
+ spawn_pipe_process(program, &args, &cwd, &env, &arg0, &inherited).await?
+ };
+ if !input.is_empty() {
+ child
+ .session
+ .writer_sender()
+ .send(input.as_bytes().to_vec())
+ .await?;
+ }
+ child.session.close_stdin();
+ let (status, stdout, stderr) = tokio::time::timeout(Duration::from_secs(10), async {
+ let stdout = async {
+ let mut output = Vec::new();
+ while let Some(bytes) = child.stdout_rx.recv().await {
+ output.extend(bytes);
+ }
+ output
+ };
+ let stderr = async {
+ let mut output = Vec::new();
+ while let Some(bytes) = child.stderr_rx.recv().await {
+ output.extend(bytes);
+ }
+ output
+ };
+ tokio::join!(child.exit_rx, stdout, stderr)
+ })
+ .await?;
+ assert_eq!(
+ status?,
+ 0,
+ "{}\n{}",
+ String::from_utf8_lossy(&stdout),
+ String::from_utf8_lossy(&stderr)
+ );
+ assert!(String::from_utf8_lossy(&stdout).contains("pipe child assertions completed"));
+ assert!(String::from_utf8_lossy(&stderr).contains("pipe diagnostic"));
+ assert_eq!(std::fs::read(cwd.join("preserved"))?, b"fd");
+ assert_eq!(PARENT_FORKS.load(Ordering::Relaxed), 1);
+ }
+ }
+ Ok(())
+}
+
+#[test]
+#[ignore = "child process for pipe_commands_avoid_fork"]
+fn pipe_child() -> anyhow::Result<()> {
+ assert_eq!(std::env::args().next().as_deref(), Some("pipe-probe"));
+ assert_eq!(
+ std::env::current_dir()?,
+ std::path::PathBuf::from(std::env::var("EXPECTED_CWD")?)
+ );
+ assert!(std::env::var_os("HOME").is_none());
+ // SAFETY: These calls inspect the current process's group and session.
+ assert_eq!(
+ unsafe {
+ (libc::getpgrp(), libc::getsid(/*pid*/ 0))
+ },
+ unsafe { (libc::getpid(), libc::getpid()) }
+ );
+ let preserved = std::env::var("PRESERVED")?.parse::<i32>()?;
+ let excluded = std::env::var("EXCLUDED")?.parse::<i32>()?;
+ // SAFETY: The buffer is valid; the syscall reports an error if the fd was not inherited.
+ assert_eq!(
+ unsafe { libc::write(preserved, b"fd".as_ptr().cast(), 2) },
+ 2
+ );
+ // SAFETY: fcntl safely probes whether the unrelated descriptor survived exec.
+ assert_eq!(unsafe { libc::fcntl(excluded, libc::F_GETFD) }, -1);
+ assert_eq!(
+ std::io::Error::last_os_error().raw_os_error(),
+ Some(libc::EBADF)
+ );
+ let mut input = String::new();
+ std::io::stdin().read_to_string(&mut input)?;
+ assert_eq!(input, std::env::var("EXPECTED_INPUT")?);
+ eprintln!("pipe diagnostic");
+ println!("pipe child assertions completed");
+ Ok(())
+}
+
+fn inheritable_fd(file: &std::fs::File, minimum: i32) -> anyhow::Result<OwnedFd> {
+ // SAFETY: The live file is duplicated into a new descriptor without CLOEXEC.
+ let raw = unsafe { libc::fcntl(file.as_raw_fd(), libc::F_DUPFD, minimum) };
+ if raw == -1 {
+ return Err(std::io::Error::last_os_error().into());
+ }
+ // SAFETY: fcntl returned a new owned descriptor.
+ Ok(unsafe { OwnedFd::from_raw_fd(raw) })
+}