refactor(tac): replace nix with uucore signals for stdin closed detection

Remove dependency on nix crate and use uucore's new signals feature to detect
if stdin was closed before Rust reopens it as /dev/null. This centralizes stdio
state handling and improves consistency across utilities. Add libc dependency
for signal functions. Update error handling to set exit code properly on
stdin closure.

Author: mattsu2020

Cargo.lock

@@ -24,13 +24,11 @@ memchr = { workspace = true }
 memmap2 = { workspace = true }
 regex = { workspace = true }
 clap = { workspace = true }
-uucore = { workspace = true }
+libc = { workspace = true }
+uucore = { workspace = true, features = ["signals"] }
 thiserror = { workspace = true }
 fluent = { workspace = true }
 
-[target.'cfg(unix)'.dependencies]
-nix = { workspace = true, features = ["fs"] }
-
 [[bin]]
 name = "tac"
 path = "src/main.rs"

src/uu/tac/Cargo.toml

@@ -4,26 +4,23 @@
 // file that was distributed with this source code.
 
 // spell-checker:ignore (ToDO) sbytes slen dlen memmem memmap Mmap mmap SIGBUS
+#[cfg(unix)]
+uucore::init_stdio_state_capture!();
+
 mod error;
 
 use clap::{Arg, ArgAction, Command};
 use memchr::memmem;
 use memmap2::Mmap;
-#[cfg(unix)]
-use nix::{
-    errno::Errno,
-    fcntl::{FcntlArg, fcntl},
-};
 use std::ffi::OsString;
 use std::io::{BufWriter, Read, Write, stdin, stdout};
-#[cfg(unix)]
-use std::os::fd::{AsRawFd, BorrowedFd};
 use std::{
     fs::{File, read},
     path::Path,
 };
-use uucore::error::UError;
-use uucore::error::UResult;
+#[cfg(unix)]
+use uucore::error::set_exit_code;
+use uucore::error::{UError, UResult};
 use uucore::{format_usage, show};
 
 use crate::error::TacError;
@@ -244,19 +241,24 @@ fn tac(filenames: &[OsString], before: bool, regex: bool, separator: &str) -> UR
         let buf;
 
         let data: &[u8] = if filename == "-" {
-            if let Err(e) = ensure_stdin_open() {
-                let e: Box<dyn UError> = TacError::ReadError(OsString::from("stdin"), e).into();
+            #[cfg(unix)]
+            if uucore::signals::stdin_was_closed() {
+                let e: Box<dyn UError> = TacError::ReadError(
+                    OsString::from("-"),
+                    std::io::Error::from_raw_os_error(libc::EBADF),
+                )
+                .into();
                 show!(e);
+                set_exit_code(1);
                 continue;
             }
-
             if let Some(mmap1) = try_mmap_stdin() {
                 mmap = mmap1;
                 &mmap
             } else {
                 let mut buf1 = Vec::new();
                 if let Err(e) = stdin().read_to_end(&mut buf1) {
-                    let e: Box<dyn UError> = TacError::ReadError(OsString::from("stdin"), e).into();
+                    let e: Box<dyn UError> = TacError::ReadError(OsString::from("-"), e).into();
                     show!(e);
                     continue;
                 }
@@ -336,27 +338,3 @@ fn try_mmap_path(path: &Path) -> Option<Mmap> {
 
     Some(mmap)
 }
-
-#[cfg(unix)]
-fn stdin_closed() -> std::io::Result<bool> {
-    let stdin_fd = unsafe { BorrowedFd::borrow_raw(stdin().as_raw_fd()) };
-    match fcntl(stdin_fd, FcntlArg::F_GETFL) {
-        Ok(_) => Ok(false),
-        Err(_) => Ok(true),
-    }
-}
-
-fn ensure_stdin_open() -> std::io::Result<()> {
-    #[cfg(unix)]
-    {
-        if stdin_closed()? {
-            return Err(nix_error_to_io(Errno::EBADF));
-        }
-    }
-    Ok(())
-}
-
-#[cfg(unix)]
-fn nix_error_to_io(errno: Errno) -> std::io::Error {
-    std::io::Error::from_raw_os_error(errno as i32)
-}

src/uu/tac/src/tac.rs

@@ -426,6 +426,90 @@ pub fn ignore_interrupts() -> Result<(), Errno> {
     unsafe { signal(SIGINT, SigIgn) }.map(|_| ())
 }
 
+// Detect closed stdin/stdout/stderr before Rust reopens them as /dev/null (see issue #2873)
+#[cfg(unix)]
+use std::sync::atomic::{AtomicBool, Ordering};
+
+#[cfg(unix)]
+static STDIN_WAS_CLOSED: AtomicBool = AtomicBool::new(false);
+#[cfg(unix)]
+static STDOUT_WAS_CLOSED: AtomicBool = AtomicBool::new(false);
+#[cfg(unix)]
+static STDERR_WAS_CLOSED: AtomicBool = AtomicBool::new(false);
+
+#[cfg(unix)]
+#[allow(clippy::missing_safety_doc)]
+pub unsafe extern "C" fn capture_stdio_state() {
+    use nix::libc;
+
+    unsafe {
+        STDIN_WAS_CLOSED.store(
+            libc::fcntl(libc::STDIN_FILENO, libc::F_GETFD) == -1,
+            Ordering::Relaxed,
+        );
+        STDOUT_WAS_CLOSED.store(
+            libc::fcntl(libc::STDOUT_FILENO, libc::F_GETFD) == -1,
+            Ordering::Relaxed,
+        );
+        STDERR_WAS_CLOSED.store(
+            libc::fcntl(libc::STDERR_FILENO, libc::F_GETFD) == -1,
+            Ordering::Relaxed,
+        );
+    }
+}
+
+#[macro_export]
+#[cfg(unix)]
+macro_rules! init_stdio_state_capture {
+    () => {
+        #[cfg(not(target_os = "macos"))]
+        #[used]
+        #[unsafe(link_section = ".init_array")]
+        static CAPTURE_STDIO_STATE: unsafe extern "C" fn() = $crate::signals::capture_stdio_state;
+
+        #[cfg(target_os = "macos")]
+        #[used]
+        #[unsafe(link_section = "__DATA,__mod_init_func")]
+        static CAPTURE_STDIO_STATE: unsafe extern "C" fn() = $crate::signals::capture_stdio_state;
+    };
+}
+
+#[macro_export]
+#[cfg(not(unix))]
+macro_rules! init_stdio_state_capture {
+    () => {};
+}
+
+#[cfg(unix)]
+pub fn stdin_was_closed() -> bool {
+    STDIN_WAS_CLOSED.load(Ordering::Relaxed)
+}
+
+#[cfg(not(unix))]
+pub const fn stdin_was_closed() -> bool {
+    false
+}
+
+#[cfg(unix)]
+pub fn stdout_was_closed() -> bool {
+    STDOUT_WAS_CLOSED.load(Ordering::Relaxed)
+}
+
+#[cfg(not(unix))]
+pub const fn stdout_was_closed() -> bool {
+    false
+}
+
+#[cfg(unix)]
+pub fn stderr_was_closed() -> bool {
+    STDERR_WAS_CLOSED.load(Ordering::Relaxed)
+}
+
+#[cfg(not(unix))]
+pub const fn stderr_was_closed() -> bool {
+    false
+}
+
 #[test]
 fn signal_by_value() {
     assert_eq!(signal_by_name_or_value("0"), Some(0));

src/uucore/src/lib/features/signals.rs

@@ -377,3 +377,23 @@ fn test_stdin_dev_null_rdwr_is_supported() {
         .no_stderr()
         .stdout_is("");
 }
+
+#[test]
+#[cfg(unix)]
+fn test_stdin_closed_with_dash_args_fails() {
+    use std::os::unix::process::CommandExt;
+
+    let ts = TestScenario::new(util_name!());
+    let mut cmd = std::process::Command::new(&ts.bin_path);
+    cmd.arg("tac").args(["-", "-"]);
+
+    unsafe {
+        cmd.pre_exec(|| {
+            libc::close(libc::STDIN_FILENO);
+            Ok(())
+        });
+    }
+
+    let output = cmd.output().unwrap();
+    assert_eq!(output.status.code(), Some(1));
+}