uucore: centralize SIGPIPE handling in main macro

ChrisDryden · ChrisDryden · commit 4c6a71150812 · 2026-01-19T14:33:27.000Z
diff --git a/src/uu/cat/src/cat.rs b/src/uu/cat/src/cat.rs
@@ -218,13 +218,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"))]
-    let _ = uucore::signals::enable_pipe_errors();
-
     let matches = uucore::clap_localization::handle_clap_result(uu_app(), args)?;
 
     let number_mode = if matches.get_flag(options::NUMBER_NONBLANK) {
diff --git a/src/uu/env/src/env.rs b/src/uu/env/src/env.rs
@@ -1095,10 +1095,6 @@ fn list_signal_handling(log: &SignalActionLog) {
 
 #[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)]
-    let _ = uucore::signals::enable_pipe_errors();
     EnvAppData::default().run_env(args)
 }
 
diff --git a/src/uu/seq/src/seq.rs b/src/uu/seq/src/seq.rs
@@ -92,22 +92,8 @@ fn select_precision(
     }
 }
 
-// Initialize SIGPIPE state capture at process startup (Unix only)
-#[cfg(unix)]
-uucore::init_sigpipe_capture!();
-
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
-    // Restore SIGPIPE to default if it wasn't explicitly ignored by parent.
-    // The Rust runtime ignores SIGPIPE, but we need to respect the parent's
-    // signal disposition for proper pipeline behavior (GNU compatibility).
-    #[cfg(unix)]
-    if !signals::sigpipe_was_ignored() {
-        // Ignore the return value: if setting signal handler fails, we continue anyway.
-        // The worst case is we don't get proper SIGPIPE behavior, but seq will still work.
-        let _ = signals::enable_pipe_errors();
-    }
-
     let matches =
         uucore::clap_localization::handle_clap_result(uu_app(), split_short_args_with_value(args))?;
 
diff --git a/src/uu/split/src/split.rs b/src/uu/split/src/split.rs
@@ -54,7 +54,16 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uucore::clap_localization::handle_clap_result(uu_app(), args)?;
 
     match Settings::from(&matches, obs_lines.as_deref()) {
-        Ok(settings) => split(&settings),
+        Ok(settings) => {
+            // When using --filter, we write to a child process's stdin which may
+            // close early. Disable SIGPIPE so we get EPIPE errors instead of
+            // being terminated, allowing graceful handling of broken pipes.
+            #[cfg(unix)]
+            if settings.filter.is_some() {
+                let _ = uucore::signals::disable_pipe_errors();
+            }
+            split(&settings)
+        }
         Err(e) if e.requires_usage() => Err(UUsageError::new(1, format!("{e}"))),
         Err(e) => Err(USimpleError::new(1, format!("{e}"))),
     }
diff --git a/src/uu/tail/src/tail.rs b/src/uu/tail/src/tail.rs
@@ -40,13 +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"))]
-    let _ = uucore::signals::enable_pipe_errors();
-
     let settings = parse_args(args)?;
 
     settings.check_warnings();
diff --git a/src/uu/tee/src/tee.rs b/src/uu/tee/src/tee.rs
@@ -19,7 +19,7 @@ use uucore::{format_usage, show_error};
 #[cfg(target_os = "linux")]
 use uucore::signals::ensure_stdout_not_broken;
 #[cfg(unix)]
-use uucore::signals::{enable_pipe_errors, ignore_interrupts};
+use uucore::signals::{disable_pipe_errors, ignore_interrupts};
 
 mod options {
     pub const APPEND: &str = "append";
@@ -163,8 +163,8 @@ fn tee(options: &Options) -> Result<()> {
         if options.ignore_interrupts {
             ignore_interrupts().map_err(|_| Error::from(ErrorKind::Other))?;
         }
-        if options.output_error.is_none() {
-            enable_pipe_errors().map_err(|_| Error::from(ErrorKind::Other))?;
+        if options.output_error.is_some() {
+            disable_pipe_errors().map_err(|_| Error::from(ErrorKind::Other))?;
         }
     }
     let mut writers: Vec<NamedWriter> = options
diff --git a/src/uu/timeout/src/timeout.rs b/src/uu/timeout/src/timeout.rs
@@ -19,9 +19,6 @@ use uucore::parser::parse_time;
 use uucore::process::ChildExt;
 use uucore::translate;
 
-#[cfg(unix)]
-use uucore::signals::enable_pipe_errors;
-
 use uucore::{
     format_usage, show_error,
     signals::{signal_by_name_or_value, signal_name_by_value},
@@ -331,8 +328,6 @@ fn timeout(
     if !foreground {
         let _ = setpgid(Pid::from_raw(0), Pid::from_raw(0));
     }
-    #[cfg(unix)]
-    enable_pipe_errors()?;
 
     let process = &mut process::Command::new(&cmd[0])
         .args(&cmd[1..])
diff --git a/src/uu/tr/src/tr.rs b/src/uu/tr/src/tr.rs
@@ -31,13 +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"))]
-    let _ = uucore::signals::enable_pipe_errors();
-
     let matches = uucore::clap_localization::handle_clap_result(uu_app(), args)?;
 
     let delete_flag = matches.get_flag(options::DELETE);
diff --git a/src/uu/yes/src/yes.rs b/src/uu/yes/src/yes.rs
@@ -11,8 +11,6 @@ use std::ffi::OsString;
 use std::io::{self, Write};
 use uucore::error::{UResult, USimpleError};
 use uucore::format_usage;
-#[cfg(unix)]
-use uucore::signals::enable_pipe_errors;
 use uucore::translate;
 
 // it's possible that using a smaller or larger buffer might provide better performance on some
@@ -113,8 +111,6 @@ fn prepare_buffer(buf: &mut Vec<u8>) {
 pub fn exec(bytes: &[u8]) -> io::Result<()> {
     let stdout = io::stdout();
     let mut stdout = stdout.lock();
-    #[cfg(unix)]
-    enable_pipe_errors()?;
 
     loop {
         stdout.write_all(bytes)?;
diff --git a/src/uucore/Cargo.toml b/src/uucore/Cargo.toml
@@ -119,7 +119,7 @@ windows-sys = { workspace = true, optional = true, default-features = false, fea
 utmp-classic = { workspace = true, optional = true }
 
 [features]
-default = []
+default = ["signals"]
 # * non-default features
 backup-control = []
 colors = []
diff --git a/src/uucore/src/lib/features/signals.rs b/src/uucore/src/lib/features/signals.rs
@@ -410,14 +410,23 @@ pub fn signal_name_by_value(signal_value: usize) -> Option<&'static str> {
     ALL_SIGNALS.get(signal_value).copied()
 }
 
-/// Returns the default signal value.
+/// Restores SIGPIPE to default behavior (process terminates on broken pipe).
 #[cfg(unix)]
 pub fn enable_pipe_errors() -> Result<(), Errno> {
     // We pass the error as is, the return value would just be Ok(SigDfl), so we can safely ignore it.
     // SAFETY: this function is safe as long as we do not use a custom SigHandler -- we use the default one.
     unsafe { signal(SIGPIPE, SigDfl) }.map(|_| ())
 }
 
+/// Ignores SIGPIPE signal (broken pipe errors are returned instead of terminating).
+/// Use this to override the default SIGPIPE handling when you need to handle
+/// broken pipe errors gracefully (e.g., tee with --output-error).
+#[cfg(unix)]
+pub fn disable_pipe_errors() -> Result<(), Errno> {
+    // SAFETY: this function is safe as long as we do not use a custom SigHandler -- we use the default one.
+    unsafe { signal(SIGPIPE, SigIgn) }.map(|_| ())
+}
+
 /// Ignores the SIGINT signal.
 #[cfg(unix)]
 pub fn ignore_interrupts() -> Result<(), Errno> {
diff --git a/src/uucore_procs/src/lib.rs b/src/uucore_procs/src/lib.rs
@@ -16,14 +16,34 @@ use quote::quote;
 //* ref: [path construction from LitStr](https://oschwald.github.io/maxminddb-rust/syn/struct.LitStr.html) @@ <http://archive.is/8YDua>
 
 /// A procedural macro to define the main function of a uutils binary.
+///
+/// This macro handles:
+/// - SIGPIPE state capture at process startup (before Rust runtime overrides it)
+/// - SIGPIPE restoration to default if parent didn't explicitly ignore it
+/// - Disabling Rust signal handlers for proper core dumps
+/// - Error handling and exit code management
 #[proc_macro_attribute]
 pub fn main(_args: TokenStream, stream: TokenStream) -> TokenStream {
     let stream = proc_macro2::TokenStream::from(stream);
 
     let new = quote!(
+        // Initialize SIGPIPE state capture at process startup (Unix only).
+        // This must be at module level to set up the .init_array static that runs
+        // before main() to capture whether SIGPIPE was ignored by the parent process.
+        #[cfg(unix)]
+        uucore::init_sigpipe_capture!();
+
         pub fn uumain(args: impl uucore::Args) -> i32 {
             #stream
 
+            // Restore SIGPIPE to default if it wasn't explicitly ignored by parent.
+            // The Rust runtime ignores SIGPIPE, but we need to respect the parent's
+            // signal disposition for proper pipeline behavior (GNU compatibility).
+            #[cfg(unix)]
+            if !uucore::signals::sigpipe_was_ignored() {
+                let _ = uucore::signals::enable_pipe_errors();
+            }
+
             // disable rust signal handlers (otherwise processes don't dump core after e.g. one SIGSEGV)
             #[cfg(unix)]
             uucore::disable_rust_signal_handlers().expect("Disabling rust signal handlers failed");

Original file line number	Diff line number	Diff line change
`@@ -1095,10 +1095,6 @@ fn list_signal_handling(log: &SignalActionLog) {`
`1095`	`1095`
`1096`	`1096`	`#[uucore::main]`
`1097`	`1097`	`pub fn uumain(args: impl uucore::Args) -> UResult<()> {`
`1098`		`- // Rust ignores SIGPIPE (see https://github.com/rust-lang/rust/issues/62569).`
`1099`		`- // We restore its default action here.`
`1100`		`- #[cfg(unix)]`
`1101`		`- let _ = uucore::signals::enable_pipe_errors();`
`1102`	`1098`	`EnvAppData::default().run_env(args)`
`1103`	`1099`	`}`
`1104`	`1100`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ use uucore::{format_usage, show_error};`
`19`	`19`	`#[cfg(target_os = "linux")]`
`20`	`20`	`use uucore::signals::ensure_stdout_not_broken;`
`21`	`21`	`#[cfg(unix)]`
`22`		`-use uucore::signals::{enable_pipe_errors, ignore_interrupts};`
	`22`	`+use uucore::signals::{disable_pipe_errors, ignore_interrupts};`
`23`	`23`
`24`	`24`	`mod options {`
`25`	`25`	`pub const APPEND: &str = "append";`
`@@ -163,8 +163,8 @@ fn tee(options: &Options) -> Result<()> {`
`163`	`163`	`if options.ignore_interrupts {`
`164`	`164`	`ignore_interrupts().map_err(\|_\| Error::from(ErrorKind::Other))?;`
`165`	`165`	`}`
`166`		`- if options.output_error.is_none() {`
`167`		`- enable_pipe_errors().map_err(\|_\| Error::from(ErrorKind::Other))?;`
	`166`	`+ if options.output_error.is_some() {`
	`167`	`+ disable_pipe_errors().map_err(\|_\| Error::from(ErrorKind::Other))?;`
`168`	`168`	`}`
`169`	`169`	`}`
`170`	`170`	`let mut writers: Vec<NamedWriter> = options`