lib.rs: restore default SIGPIPE signal handler

Rust's start-up code sets the SIGPIPE signal handler to ignored. However the
vast majority of the utilities should use the default signal handler for
SIGPIPE.

Instead of restoring the default signaler handler in individual utilities, do it in lib.rs
and add some logic in the utilities which can't use the default SIGPIPE signal handler (cat, env, seq, split, tail, tee, tr, tty).

Signed-off-by: Etienne Cordonnier <[email protected]>

Author: Ecordonnier

src/uu/cat/src/cat.rs

@@ -25,8 +25,6 @@ use std::os::unix::net::UnixStream;
 use thiserror::Error;
 use uucore::display::Quotable;
 use uucore::error::UResult;
-#[cfg(not(target_os = "windows"))]
-use uucore::libc;
 use uucore::translate;
 use uucore::{fast_inc::fast_inc_one, format_usage};
 
@@ -222,15 +220,6 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    // When we receive a SIGPIPE signal, we want to terminate the process so
-    // that we don't print any error messages to stderr. Rust ignores SIGPIPE
-    // (see https://github.com/rust-lang/rust/issues/62569), so we restore it's
-    // default action here.
-    #[cfg(not(target_os = "windows"))]
-    unsafe {
-        libc::signal(libc::SIGPIPE, libc::SIG_DFL);
-    }
-
     let matches = uucore::clap_localization::handle_clap_result(uu_app(), args)?;
 
     let number_mode = if matches.get_flag(options::NUMBER_NONBLANK) {

src/uu/env/src/env.rs

@@ -18,8 +18,6 @@ use native_int_str::{
     Convert, NCvt, NativeIntStr, NativeIntString, NativeStr, from_native_int_representation_owned,
 };
 #[cfg(unix)]
-use nix::libc;
-#[cfg(unix)]
 use nix::sys::signal::{SigHandler::SigIgn, Signal, signal};
 use std::borrow::Cow;
 use std::env;
@@ -845,12 +843,6 @@ fn ignore_signal(sig: Signal) -> UResult<()> {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    // Rust ignores SIGPIPE (see https://github.com/rust-lang/rust/issues/62569).
-    // We restore its default action here.
-    #[cfg(unix)]
-    unsafe {
-        libc::signal(libc::SIGPIPE, libc::SIG_DFL);
-    }
     EnvAppData::default().run_env(args)
 }
 

src/uu/seq/Cargo.toml

@@ -30,6 +30,7 @@ uucore = { workspace = true, features = [
   "format",
   "parser",
   "quoting-style",
+  "signals",
 ] }
 fluent = { workspace = true }
 

src/uu/seq/src/error.rs

@@ -36,6 +36,11 @@ pub enum SeqError {
         translate!("seq-error-format-and-equal-width")
     )]
     FormatAndEqualWidth,
+
+    /// Failed to set signal handler
+    #[cfg(unix)]
+    #[error("failed to set signal handler")]
+    SignalHandler,
 }
 
 fn parse_error_type(e: &ParseNumberError) -> String {

src/uu/seq/src/seq.rs

@@ -17,6 +17,9 @@ use uucore::format::num_format::FloatVariant;
 use uucore::format::{Format, num_format};
 use uucore::{fast_inc::fast_inc, format_usage};
 
+#[cfg(unix)]
+use uucore::signals::ignore_pipe;
+
 mod error;
 
 // public to allow fuzzing
@@ -92,6 +95,13 @@ fn select_precision(
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    #[cfg(unix)]
+    {
+        // Ignore SIGPIPE so that broken pipes return EPIPE errors instead of
+        // killing the process. This allows seq to handle broken pipes gracefully
+        // (printing an error message but exiting with status 0, matching GNU seq behavior).
+        ignore_pipe().map_err(|_| SeqError::SignalHandler)?;
+    }
     let matches =
         uucore::clap_localization::handle_clap_result(uu_app(), split_short_args_with_value(args))?;
 

src/uu/split/Cargo.toml

@@ -20,7 +20,7 @@ path = "src/split.rs"
 [dependencies]
 clap = { workspace = true }
 memchr = { workspace = true }
-uucore = { workspace = true, features = ["fs", "parser-size"] }
+uucore = { workspace = true, features = ["fs", "parser-size", "signals"] }
 thiserror = { workspace = true }
 fluent = { workspace = true }
 

src/uu/split/src/split.rs

@@ -29,6 +29,9 @@ use uucore::parser::parse_size::parse_size_u64;
 use uucore::format_usage;
 use uucore::uio_error;
 
+#[cfg(unix)]
+use uucore::signals::ignore_pipe;
+
 static OPT_BYTES: &str = "bytes";
 static OPT_LINE_BYTES: &str = "line-bytes";
 static OPT_LINES: &str = "lines";
@@ -1530,6 +1533,15 @@ where
 
 #[allow(clippy::cognitive_complexity)]
 fn split(settings: &Settings) -> UResult<()> {
+    #[cfg(unix)]
+    {
+        // When using --filter, ignore SIGPIPE so that closure of one pipe
+        // does not terminate the process, as there may still be other streams
+        // expecting input from us. This matches GNU split behavior.
+        if settings.filter.is_some() {
+            ignore_pipe().map_err(|_| USimpleError::new(1, "failed to set signal handler"))?;
+        }
+    }
     let r_box = if settings.input == "-" {
         Box::new(stdin()) as Box<dyn Read>
     } else {

src/uu/tail/src/tail.rs

@@ -40,15 +40,6 @@ use uucore::{show, show_error};
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    // When we receive a SIGPIPE signal, we want to terminate the process so
-    // that we don't print any error messages to stderr. Rust ignores SIGPIPE
-    // (see https://github.com/rust-lang/rust/issues/62569), so we restore it's
-    // default action here.
-    #[cfg(not(target_os = "windows"))]
-    unsafe {
-        libc::signal(libc::SIGPIPE, libc::SIG_DFL);
-    }
-
     let settings = parse_args(args)?;
 
     settings.check_warnings();

src/uu/tee/src/tee.rs

@@ -19,7 +19,7 @@ use uucore::{format_usage, show_error};
 // spell-checker:ignore nopipe
 
 #[cfg(unix)]
-use uucore::signals::{enable_pipe_errors, ignore_interrupts};
+use uucore::signals::{enable_pipe_errors, ignore_interrupts, ignore_pipe};
 
 mod options {
     pub const APPEND: &str = "append";
@@ -164,6 +164,9 @@ fn tee(options: &Options) -> Result<()> {
         }
         if options.output_error.is_none() {
             enable_pipe_errors().map_err(|_| Error::from(ErrorKind::Other))?;
+        } else {
+            // When --output-error is set, ignore SIGPIPE to handle broken pipes gracefully
+            ignore_pipe().map_err(|_| Error::from(ErrorKind::Other))?;
         }
     }
     let mut writers: Vec<NamedWriter> = options

src/uu/tr/src/tr.rs

@@ -18,8 +18,6 @@ use std::io::{stdin, stdout};
 use uucore::display::Quotable;
 use uucore::error::{UResult, USimpleError, UUsageError};
 use uucore::fs::is_stdin_directory;
-#[cfg(not(target_os = "windows"))]
-use uucore::libc;
 use uucore::translate;
 use uucore::{format_usage, os_str_as_bytes, show};
 
@@ -33,15 +31,6 @@ mod options {
 
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    // When we receive a SIGPIPE signal, we want to terminate the process so
-    // that we don't print any error messages to stderr. Rust ignores SIGPIPE
-    // (see https://github.com/rust-lang/rust/issues/62569), so we restore it's
-    // default action here.
-    #[cfg(not(target_os = "windows"))]
-    unsafe {
-        libc::signal(libc::SIGPIPE, libc::SIG_DFL);
-    }
-
     let matches = uucore::clap_localization::handle_clap_result(uu_app(), args)?;
 
     let delete_flag = matches.get_flag(options::DELETE);