Allow base32 decoder to auto-pad truncated blocks

Introduce PadResult, trim/pad incomplete base32 chunks, emit decoded
prefixes, and still return error: invalid input in line with GNU basenc.

Author: karanabe

src/uu/base32/src/base_common.rs

@@ -8,7 +8,7 @@
 use clap::{Arg, ArgAction, Command};
 use std::ffi::OsString;
 use std::fs::File;
-use std::io::{self, ErrorKind, Read, Seek};
+use std::io::{self, ErrorKind, Read, Seek, Write};
 use std::path::{Path, PathBuf};
 use uucore::display::Quotable;
 use uucore::encoding::{
@@ -193,7 +193,7 @@ pub fn handle_input<R: Read + Seek>(input: &mut R, format: Format, config: Confi
 
     let supports_fast_decode_and_encode_ref = supports_fast_decode_and_encode.as_ref();
     let mut stdout_lock = io::stdout().lock();
-    if config.decode {
+    let result = if config.decode {
         fast_decode::fast_decode(
             read,
             &mut stdout_lock,
@@ -207,6 +207,14 @@ pub fn handle_input<R: Read + Seek>(input: &mut R, format: Format, config: Confi
             supports_fast_decode_and_encode_ref,
             config.wrap_cols,
         )
+    };
+
+    // Ensure any pending stdout buffer is flushed even if decoding failed; GNU basenc
+    // keeps already-decoded bytes visible before reporting the error.
+    match (result, stdout_lock.flush()) {
+        (res, Ok(())) => res,
+        (Ok(_), Err(err)) => Err(err.into()),
+        (Err(original), Err(_)) => Err(original),
     }
 }
 
@@ -531,6 +539,7 @@ pub mod fast_decode {
     fn write_to_output(decoded_buffer: &mut Vec<u8>, output: &mut dyn Write) -> io::Result<()> {
         // Write all data in `decoded_buffer` to `output`
         output.write_all(decoded_buffer.as_slice())?;
+        output.flush()?;
 
         decoded_buffer.clear();
 
@@ -584,16 +593,6 @@ pub mod fast_decode {
         assert!(decode_in_chunks_of_size > 0);
         assert!(valid_multiple > 0);
 
-        if !ignore_garbage {
-            // Match GNU basenc: fail fast when any non alphabet/non newline slips through without -i.
-            if input
-                .iter()
-                .any(|&byte| byte != b'\n' && byte != b'\r' && !alphabet_table[usize::from(byte)])
-            {
-                return Err(USimpleError::new(1, "error: invalid input".to_owned()));
-            }
-        }
-
         // Start of buffers
 
         // Decoded data that needs to be written to `output`
@@ -650,11 +649,22 @@ pub mod fast_decode {
         }
 
         if !buffer.is_empty() {
-            let padded = supports_fast_decode_and_encode.pad_remainder(&buffer);
-            let final_chunk = padded.as_deref().unwrap_or(&buffer);
+            let mut owned_chunk: Option<Vec<u8>> = None;
+            let mut had_invalid_tail = false;
+
+            if let Some(pad_result) = supports_fast_decode_and_encode.pad_remainder(&buffer) {
+                had_invalid_tail = pad_result.had_invalid_tail;
+                owned_chunk = Some(pad_result.chunk);
+            }
+
+            let final_chunk = owned_chunk.as_deref().unwrap_or(&buffer);
 
             supports_fast_decode_and_encode.decode_into_vec(final_chunk, &mut decoded_buffer)?;
             write_to_output(&mut decoded_buffer, output)?;
+
+            if had_invalid_tail {
+                return Err(USimpleError::new(1, "error: invalid input".to_owned()));
+            }
         }
 
         Ok(())

src/uucore/src/lib/features/encoding.rs

@@ -214,6 +214,11 @@ impl EncodingWrapper {
     }
 }
 
+pub struct PadResult {
+    pub chunk: Vec<u8>,
+    pub had_invalid_tail: bool,
+}
+
 pub trait SupportsFastDecodeAndEncode {
     /// Returns the list of characters used by this encoding
     fn alphabet(&self) -> &'static [u8];
@@ -255,7 +260,7 @@ pub trait SupportsFastDecodeAndEncode {
 
     /// Gives encoding-specific logic a chance to pad a trailing, non-empty remainder
     /// before the final decode attempt. The default implementation opts out.
-    fn pad_remainder(&self, _remainder: &[u8]) -> Option<Vec<u8>> {
+    fn pad_remainder(&self, _remainder: &[u8]) -> Option<PadResult> {
         None
     }
 }
@@ -561,21 +566,33 @@ impl SupportsFastDecodeAndEncode for Base32Wrapper {
         self.inner.valid_decoding_multiple()
     }
 
-    fn pad_remainder(&self, remainder: &[u8]) -> Option<Vec<u8>> {
+    fn pad_remainder(&self, remainder: &[u8]) -> Option<PadResult> {
         if remainder.is_empty() || remainder.contains(&b'=') {
             return None;
         }
 
         const VALID_REMAINDERS: [usize; 4] = [2, 4, 5, 7];
 
-        if !VALID_REMAINDERS.contains(&remainder.len()) {
+        let mut len = remainder.len();
+        let mut trimmed = false;
+
+        while len > 0 && !VALID_REMAINDERS.contains(&len) {
+            len -= 1;
+            trimmed = true;
+        }
+
+        if len == 0 {
             return None;
         }
 
-        let mut padded = remainder.to_vec();
-        let missing = self.valid_decoding_multiple() - remainder.len();
+        let mut padded = remainder[..len].to_vec();
+        let missing = self.valid_decoding_multiple() - padded.len();
         padded.extend(std::iter::repeat_n(b'=', missing));
-        Some(padded)
+
+        Some(PadResult {
+            chunk: padded,
+            had_invalid_tail: trimmed,
+        })
     }
 
     fn supports_partial_decode(&self) -> bool {