uucore: return utility-specific exit code when --help/--version write fails

Author: sylvestre

src/uucore/src/lib/mods/clap_localization.rs

@@ -11,7 +11,7 @@
 //! instead of parsing error strings, providing a more robust solution.
 //!
 
-use crate::error::{UResult, USimpleError};
+use crate::error::{UClapError, UResult, USimpleError};
 use crate::locale::translate;
 
 use clap::error::{ContextKind, ErrorKind};
@@ -442,7 +442,10 @@ where
 {
     cmd.try_get_matches_from(itr).map_err(|e| {
         if e.exit_code() == 0 {
-            e.into() // Preserve help/version
+            // For help/version display, use exit_code as the write failure code so that
+            // if stdout is full (e.g., /dev/full), the program exits with the utility's
+            // expected error code rather than the default 1.
+            e.with_exit_code(exit_code).into()
         } else {
             let formatter = ErrorFormatter::new(crate::util_name());
             let code = formatter.print_error(&e, exit_code);
@@ -451,6 +454,38 @@ where
     })
 }
 
+/// Like [`handle_clap_result_with_exit_code`], but allows specifying separate exit codes for
+/// argument parse errors and for write failures when printing help/version output.
+///
+/// This is useful for utilities that use different exit codes for I/O errors vs. argument
+/// parse errors (e.g., `tty` exits 3 on write errors but 2 on argument parse errors).
+pub fn handle_clap_result_with_exit_codes<I, T>(
+    cmd: Command,
+    itr: I,
+    parse_error_code: i32,
+    write_failure_code: i32,
+) -> UResult<ArgMatches>
+where
+    I: IntoIterator<Item = T>,
+    T: Into<OsString> + Clone,
+{
+    cmd.try_get_matches_from(itr).map_err(|e| {
+        if e.exit_code() == 0 {
+            // For DisplayHelp/DisplayVersion, ClapErrorWrapper::code() ignores the `code` field
+            // and returns either 0 (success) or `write_failure_code` (on stdout write failure).
+            // We pass `parse_error_code` to `with_exit_code` only to satisfy the constructor;
+            // the actual success/failure distinction is driven by `write_failure_code`.
+            e.with_exit_code(parse_error_code)
+                .with_write_failure_code(write_failure_code)
+                .into()
+        } else {
+            let formatter = ErrorFormatter::new(crate::util_name());
+            let code = formatter.print_error(&e, parse_error_code);
+            USimpleError::new(code, "")
+        }
+    })
+}
+
 /// Handles a clap error directly with a custom exit code.
 ///
 /// This function processes a clap error and exits the program with the specified

src/uucore/src/lib/mods/error.rs

@@ -701,10 +701,22 @@ impl From<i32> for Box<dyn UError> {
 #[derive(Debug)]
 pub struct ClapErrorWrapper {
     code: i32,
+    write_failure_code: i32,
     error: clap::Error,
     print_failed: Cell<bool>,
 }
 
+impl ClapErrorWrapper {
+    /// Override the exit code to use when writing help/version output fails (e.g., /dev/full).
+    ///
+    /// By default this matches `code`, but some utilities use different exit codes for I/O errors
+    /// vs. argument parse errors (e.g., `tty` exits 3 on write errors, 2 on parse errors).
+    pub fn with_write_failure_code(mut self, code: i32) -> Self {
+        self.write_failure_code = code;
+        self
+    }
+}
+
 /// Extension trait for `clap::Error` to adjust the exit code.
 pub trait UClapError<T> {
     /// Set the exit code for the program if `uumain` returns `Ok(())`.
@@ -715,6 +727,7 @@ impl From<clap::Error> for Box<dyn UError> {
     fn from(e: clap::Error) -> Self {
         Box::new(ClapErrorWrapper {
             code: 1,
+            write_failure_code: 1,
             error: e,
             print_failed: Cell::new(false),
         })
@@ -725,6 +738,7 @@ impl UClapError<ClapErrorWrapper> for clap::Error {
     fn with_exit_code(self, code: i32) -> ClapErrorWrapper {
         ClapErrorWrapper {
             code,
+            write_failure_code: code,
             error: self,
             print_failed: Cell::new(false),
         }
@@ -742,11 +756,16 @@ impl UClapError<Result<clap::ArgMatches, ClapErrorWrapper>>
 impl UError for ClapErrorWrapper {
     fn code(&self) -> i32 {
         // If the error is a DisplayHelp or DisplayVersion variant,
-        // check if printing failed. If it did, return 1, otherwise 0.
+        // check if printing failed. If it did, return the utility-specific write failure code,
+        // otherwise 0 (success).
         if let clap::error::ErrorKind::DisplayHelp | clap::error::ErrorKind::DisplayVersion =
             self.error.kind()
         {
-            i32::from(self.print_failed.get())
+            if self.print_failed.get() {
+                self.write_failure_code
+            } else {
+                0
+            }
         } else {
             self.code
         }
@@ -767,9 +786,6 @@ impl Display for ClapErrorWrapper {
             // Try to display this error to stderr, but ignore if that fails too
             // since we're already in an error state.
             let _ = writeln!(std::io::stderr(), "{}: {print_fail}", crate::util_name());
-            // Mirror GNU behavior: when failing to print help or version, exit with error code.
-            // This avoids silent failures when stdout is full or closed.
-            set_exit_code(1);
         }
         // Always return Ok(()) to satisfy Display's contract and prevent panic
         Ok(())