codex/codex-rs/utils/pty/src/macos_descriptor_tests.rs

//! Native descriptor isolation, socket stdio, and launch errors.

use super::*;
use pretty_assertions::assert_eq;
use std::fs;
use std::io::Seek;
use std::os::fd::AsRawFd;
use std::os::fd::FromRawFd;
use std::os::fd::OwnedFd;
use std::os::unix::net::UnixStream;
use tokio::io::AsyncReadExt;
use tokio::io::AsyncWriteExt;

#[tokio::test]
async fn explicit_stdio_excludes_inheritable_descriptors_without_changing_parent()
-> anyhow::Result<()> {
    let file = fs::File::open("/dev/null")?;
    // SAFETY: Duplicate a live descriptor without CLOEXEC so the control inherits it.
    let raw = unsafe { libc::fcntl(file.as_raw_fd(), libc::F_DUPFD, 200) };
    assert!(raw >= 200);
    // SAFETY: fcntl returned a new descriptor owned by this test.
    let sentinel = unsafe { OwnedFd::from_raw_fd(raw) };
    // SAFETY: The test owns this descriptor throughout both launches.
    let flags = unsafe { libc::fcntl(raw, libc::F_GETFD) };
    let script = format!("if [ -e /dev/fd/{raw} ]; then printf open; else printf closed; fi");
    let mut control = Command::new("/bin/sh");
    control.args(["-c", &script]);
    let control = control.spawn()?.wait_with_output().await?;
    assert_eq!(
        (control.status.success(), control.stdout),
        (true, b"open".to_vec())
    );

    let mut command = Command::new("/bin/sh");
    command
        .args(["-c", &script])
        .descriptor_policy(DescriptorPolicy::Explicit);
    let output = command.spawn()?.wait_with_output().await?;
    assert_eq!(
        (output.status.success(), output.stdout, output.stderr),
        (true, b"closed".to_vec(), vec![])
    );
    // SAFETY: Spawning must not mutate the parent's descriptor flags.
    assert_eq!(
        unsafe { libc::fcntl(sentinel.as_raw_fd(), libc::F_GETFD) },
        flags
    );
    Ok(())
}

#[tokio::test]
async fn socket_stdin_preserves_bidirectional_io_and_custom_argv0() -> anyhow::Result<()> {
    let (parent, socket) = UnixStream::pair()?;
    parent.set_nonblocking(true)?;
    let mut parent = tokio::net::UnixStream::from_std(parent)?;
    let mut command = Command::new("/bin/sh");
    command
        .args(["--norc", "-c", "IFS= read -r line; printf 'reply:%s\\n' \"$line\" >&0; printf '%s:%s:%s' \"$0\" \"$FS_TEST\" \"${HOME-unset}\"; printf diagnostic >&2; exit 19"])
        .arg0("helper")
        .env("FS_TEST", "literal ; $value")
        .stdin(ChildStdin::File(socket.into()))
        .descriptor_policy(DescriptorPolicy::Explicit)
        .fallback(SpawnFallback::ReturnError);
    let child = command.spawn()?;
    assert!(child.stdin.is_none());
    parent.write_all(b"socket\n").await?;
    parent.shutdown().await?;
    let mut reply = Vec::new();
    parent.read_to_end(&mut reply).await?;
    let output = child.wait_with_output().await?;
    assert_eq!(reply, b"reply:socket\n");
    assert_eq!(
        (output.status.code(), output.stdout, output.stderr),
        (
            Some(19),
            b"helper:literal ; $value:unset".to_vec(),
            b"diagnostic".to_vec()
        )
    );
    Ok(())
}

#[tokio::test]
async fn native_launch_can_reject_executable_text_without_shell_fallback() -> anyhow::Result<()> {
    let directory = tempfile::tempdir()?;
    let script = directory.path().join("no-shebang");
    codex_utils_cargo_bin::write_executable(&script, "printf unexpected-fallback\n")?;
    let mut command = Command::new(script);
    command.fallback(SpawnFallback::ReturnError);
    let error = command.spawn().err().expect("executable text must fail");
    assert_eq!(error.raw_os_error(), Some(libc::ENOEXEC));
    Ok(())
}

#[tokio::test]
async fn inherited_descriptors_survive_native_and_executable_text_spawns() -> anyhow::Result<()> {
    let directory = tempfile::tempdir()?;
    let data = directory.path().join("data");
    fs::write(&data, "captured descriptor")?;
    let mut file = fs::File::open(&data)?;
    for native in [true, false] {
        file.rewind()?;
        // SAFETY: Duplicate this live file into a new inheritable descriptor.
        let raw = unsafe { libc::fcntl(file.as_raw_fd(), libc::F_DUPFD, 100) };
        assert!(raw >= 100);
        // SAFETY: fcntl returned a newly owned descriptor.
        let _original = unsafe { OwnedFd::from_raw_fd(raw) };
        let descriptor = format!("/dev/fd/{raw}");
        let mut command = if native {
            let mut command = Command::new("/bin/cat");
            command.arg(&descriptor);
            command
        } else {
            let script = directory.path().join("executable-text");
            codex_utils_cargo_bin::write_executable(&script, &format!("/bin/cat {descriptor}\n"))?;
            Command::new(script)
        };
        command
            .descriptor_policy(DescriptorPolicy::Explicit)
            .preserve_fds(&[raw]);
        let child = command.spawn()?;
        assert_eq!(
            matches!(child.inner, crate::child::ChildKind::Native(_)),
            native
        );
        let output = child.wait_with_output().await?;
        assert_eq!(
            (output.status.code(), output.stdout, output.stderr),
            (Some(0), b"captured descriptor".to_vec(), vec![])
        );
    }
    Ok(())
}

#[tokio::test]
async fn high_stdio_descriptors_use_compatible_fallback() -> anyhow::Result<()> {
    if std::env::var_os("CODEX_TEST_HIGH_STDIO_FDS").is_none() {
        let output = std::process::Command::new(std::env::current_exe()?)
            .args([
                "--exact",
                "child_command::descriptor_tests::high_stdio_descriptors_use_compatible_fallback",
                "--nocapture",
            ])
            .env("CODEX_TEST_HIGH_STDIO_FDS", "1")
            .output()?;
        assert!(output.status.success(), "{output:?}");
        return Ok(());
    }

    let mut limit = std::mem::MaybeUninit::<libc::rlimit>::uninit();
    // SAFETY: getrlimit initializes writable storage. Only this isolated test
    // subprocess raises its soft limit; the test runner and host are unchanged.
    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.max(16_384);
    assert_eq!(unsafe { libc::setrlimit(libc::RLIMIT_NOFILE, &limit) }, 0);

    let file = fs::File::open("/dev/null")?;
    // SAFETY: Create a new inheritable descriptor to check fallback isolation.
    let raw = unsafe { libc::fcntl(file.as_raw_fd(), libc::F_DUPFD, 3) };
    anyhow::ensure!(raw >= 3, "{}", io::Error::last_os_error());
    let sentinel = unsafe { OwnedFd::from_raw_fd(raw) };
    let mut occupied = Vec::new();
    loop {
        let descriptor = file.try_clone()?;
        let raw = descriptor.as_raw_fd();
        occupied.push(descriptor);
        // Darwin's spawn file actions reject valid descriptors >= OPEN_MAX
        // (10240), even when RLIMIT_NOFILE allows the descriptor to be opened.
        if raw >= 10_240 {
            break;
        }
    }

    let mut strict = Command::new("/usr/bin/true");
    strict.fallback(SpawnFallback::ReturnError);
    let error = strict
        .spawn()
        .err()
        .expect("native high-fd action must fail");
    assert_eq!(error.raw_os_error(), Some(libc::EBADF));

    for mode in [ProcessMode::NewGroup, ProcessMode::NewSession] {
        let mut command = Command::new("/bin/sh");
        command
            .args(["-c", &format!(
                "test ! -e /dev/fd/{} || exit 99; IFS= read -r line; printf '%s' \"$line\"; printf diagnostic >&2; exit 23",
                sentinel.as_raw_fd()
            )])
            .descriptor_policy(DescriptorPolicy::Explicit)
            .process_mode(mode);
        let mut child = command.spawn()?;
        assert!(matches!(child.inner, ChildKind::Tokio(_)));
        let pid = child.id().expect("live child") as libc::pid_t;
        // SAFETY: The child waits for input and still owns this PID.
        assert_eq!(unsafe { libc::getpgid(pid) }, pid);
        child
            .stdin
            .take()
            .expect("piped stdin")
            .write_all(b"round trip\n")
            .await?;
        let output = child.wait_with_output().await?;
        assert_eq!(
            (output.status.code(), output.stdout, output.stderr),
            (Some(23), b"round trip".to_vec(), b"diagnostic".to_vec())
        );
    }
    // SAFETY: Child setup must not close or change the parent's descriptor.
    assert_eq!(
        unsafe { libc::fcntl(sentinel.as_raw_fd(), libc::F_GETFD) },
        0
    );
    Ok(())
}