Removing padding as input of Base64SimdWrapper

This should remove the dependency we have in knowing whether the final
message has padding or not. This is the first step to not have a
ahead-of-time loading of the entire message to encode/decode, and allow
for streaming.

Signed-off-by: Andrea Calabrese <andrea.calabrese@amarulasolutions.com>

Author: Andrea Calabrese

src/uu/base32/src/base_common.rs

@@ -264,17 +264,10 @@ pub fn get_supports_fast_decode_and_encode(
             b"0123456789ABCDEFGHIJKLMNOPQRSTUV=",
         )),
         Format::Base64 => {
-            let alphabet: &[u8] = if has_padding {
-                &b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/="[..]
-            } else {
-                &b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/"[..]
-            };
-            let use_padding = !decode || has_padding;
             Box::from(Base64SimdWrapper::new(
-                use_padding,
                 BASE64_VALID_DECODING_MULTIPLE,
                 BASE64_UNPADDED_MULTIPLE,
-                alphabet,
+                b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=",
             ))
         }
         Format::Base64Url => Box::from(EncodingWrapper::new(

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

@@ -15,14 +15,12 @@ use std::collections::VecDeque;
 // SIMD base64 wrapper
 pub struct Base64SimdWrapper {
     pub alphabet: &'static [u8],
-    pub use_padding: bool,
     pub unpadded_multiple: usize,
     pub valid_decoding_multiple: usize,
 }
 
 impl Base64SimdWrapper {
     pub fn new(
-        use_padding: bool,
         valid_decoding_multiple: usize,
         unpadded_multiple: usize,
         alphabet: &'static [u8],
@@ -33,7 +31,6 @@ impl Base64SimdWrapper {
 
         Self {
             alphabet,
-            use_padding,
             unpadded_multiple,
             valid_decoding_multiple,
         }
@@ -46,31 +43,35 @@ impl SupportsFastDecodeAndEncode for Base64SimdWrapper {
     }
 
     fn decode_into_vec(&self, input: &[u8], output: &mut Vec<u8>) -> UResult<()> {
-        let decoded = if self.use_padding {
-            base64_simd::STANDARD.decode_to_vec(input)
-        } else {
-            base64_simd::STANDARD_NO_PAD.decode_to_vec(input)
-        };
+        // Padding always comes at the end, so at most once. No_PAD should be
+        // called most of the times
+        let decoded = base64_simd::STANDARD_NO_PAD.decode_to_vec(input);
 
         match decoded {
             Ok(decoded_bytes) => {
                 output.extend_from_slice(&decoded_bytes);
                 Ok(())
             }
             Err(_) => {
-                // Restore original length on error
-                output.truncate(output.len());
-                Err(USimpleError::new(1, "error: invalid input".to_owned()))
+                // Check if the padding works
+                let decoded_2 = base64_simd::STANDARD.decode_to_vec(input);
+                match decoded_2 {
+                    Ok(decoded_bytes_2) => {
+                        output.extend_from_slice(&decoded_bytes_2);
+                        Ok(())
+                    }
+                    Err(_) => {
+                        // Restore original length on error
+                        output.truncate(output.len());
+                        Err(USimpleError::new(1, "error: invalid input".to_owned()))
+                    }
+                }
             }
         }
     }
 
     fn encode_to_vec_deque(&self, input: &[u8], output: &mut VecDeque<u8>) -> UResult<()> {
-        let encoded = if self.use_padding {
-            base64_simd::STANDARD.encode_to_string(input)
-        } else {
-            base64_simd::STANDARD_NO_PAD.encode_to_string(input)
-        };
+        let encoded = base64_simd::STANDARD.encode_to_string(input);
 
         output.extend(encoded.as_bytes());