Merging upstream version 1.74.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

2 files changed, 114 insertions, 57 deletions

diff --git a/vendor/base64/src/engine/mod.rs b/vendor/base64/src/engine/mod.rs
index aa41dffec..e10d66bb2 100644
--- a/vendor/base64/src/engine/mod.rs
+++ b/vendor/base64/src/engine/mod.rs
@@ -114,14 +114,23 @@ pub trait Engine: Send + Sync {
     ///
     /// let b64_url = CUSTOM_ENGINE.encode(b"hello internet~");
     #[cfg(any(feature = "alloc", feature = "std", test))]
+    #[inline]
     fn encode<T: AsRef<[u8]>>(&self, input: T) -> String {
-        let encoded_size = encoded_len(input.as_ref().len(), self.config().encode_padding())
-            .expect("integer overflow when calculating buffer size");
-        let mut buf = vec![0; encoded_size];
+        fn inner<E>(engine: &E, input_bytes: &[u8]) -> String
+        where
+            E: Engine + ?Sized,
+        {
+            let encoded_size = encoded_len(input_bytes.len(), engine.config().encode_padding())
+                .expect("integer overflow when calculating buffer size");
+
+            let mut buf = vec![0; encoded_size];
+
+            encode_with_padding(input_bytes, &mut buf[..], engine, encoded_size);
 
-        encode_with_padding(input.as_ref(), &mut buf[..], self, encoded_size);
+            String::from_utf8(buf).expect("Invalid UTF8")
+        }
 
-        String::from_utf8(buf).expect("Invalid UTF8")
+        inner(self, input.as_ref())
     }
 
     /// Encode arbitrary octets as base64 into a supplied `String`.
@@ -145,16 +154,20 @@ pub trait Engine: Send + Sync {
     /// }
     /// ```
     #[cfg(any(feature = "alloc", feature = "std", test))]
+    #[inline]
     fn encode_string<T: AsRef<[u8]>>(&self, input: T, output_buf: &mut String) {
-        let input_bytes = input.as_ref();
-
+        fn inner<E>(engine: &E, input_bytes: &[u8], output_buf: &mut String)
+        where
+            E: Engine + ?Sized,
         {
             let mut sink = chunked_encoder::StringSink::new(output_buf);
 
-            chunked_encoder::ChunkedEncoder::new(self)
+            chunked_encoder::ChunkedEncoder::new(engine)
                 .encode(input_bytes, &mut sink)
                 .expect("Writing to a String shouldn't fail");
         }
+
+        inner(self, input.as_ref(), output_buf)
     }
 
     /// Encode arbitrary octets as base64 into a supplied slice.
@@ -179,25 +192,35 @@ pub trait Engine: Send + Sync {
     ///
     /// assert_eq!(s, general_purpose::STANDARD.decode(&buf).unwrap().as_slice());
     /// ```
+    #[inline]
     fn encode_slice<T: AsRef<[u8]>>(
         &self,
         input: T,
         output_buf: &mut [u8],
     ) -> Result<usize, EncodeSliceError> {
-        let input_bytes = input.as_ref();
+        fn inner<E>(
+            engine: &E,
+            input_bytes: &[u8],
+            output_buf: &mut [u8],
+        ) -> Result<usize, EncodeSliceError>
+        where
+            E: Engine + ?Sized,
+        {
+            let encoded_size = encoded_len(input_bytes.len(), engine.config().encode_padding())
+                .expect("usize overflow when calculating buffer size");
 
-        let encoded_size = encoded_len(input_bytes.len(), self.config().encode_padding())
-            .expect("usize overflow when calculating buffer size");
+            if output_buf.len() < encoded_size {
+                return Err(EncodeSliceError::OutputSliceTooSmall);
+            }
 
-        if output_buf.len() < encoded_size {
-            return Err(EncodeSliceError::OutputSliceTooSmall);
-        }
+            let b64_output = &mut output_buf[0..encoded_size];
 
-        let b64_output = &mut output_buf[0..encoded_size];
+            encode_with_padding(input_bytes, b64_output, engine, encoded_size);
 
-        encode_with_padding(input_bytes, b64_output, self, encoded_size);
+            Ok(encoded_size)
+        }
 
-        Ok(encoded_size)
+        inner(self, input.as_ref(), output_buf)
     }
 
     /// Decode the input into a new `Vec`.
@@ -219,18 +242,25 @@ pub trait Engine: Send + Sync {
     /// println!("{:?}", bytes_url);
     /// ```
     #[cfg(any(feature = "alloc", feature = "std", test))]
+    #[inline]
     fn decode<T: AsRef<[u8]>>(&self, input: T) -> Result<Vec<u8>, DecodeError> {
-        let input_bytes = input.as_ref();
+        fn inner<E>(engine: &E, input_bytes: &[u8]) -> Result<Vec<u8>, DecodeError>
+        where
+            E: Engine + ?Sized,
+        {
+            let estimate = engine.internal_decoded_len_estimate(input_bytes.len());
+            let mut buffer = vec![0; estimate.decoded_len_estimate()];
 
-        let estimate = self.internal_decoded_len_estimate(input_bytes.len());
-        let mut buffer = vec![0; estimate.decoded_len_estimate()];
+            let bytes_written = engine
+                .internal_decode(input_bytes, &mut buffer, estimate)?
+                .decoded_len;
 
-        let bytes_written = self
-            .internal_decode(input_bytes, &mut buffer, estimate)?
-            .decoded_len;
-        buffer.truncate(bytes_written);
+            buffer.truncate(bytes_written);
 
-        Ok(buffer)
+            Ok(buffer)
+        }
+
+        inner(self, input.as_ref())
     }
 
     /// Decode the `input` into the supplied `buffer`.
@@ -264,30 +294,38 @@ pub trait Engine: Send + Sync {
     /// }
     /// ```
     #[cfg(any(feature = "alloc", feature = "std", test))]
+    #[inline]
     fn decode_vec<T: AsRef<[u8]>>(
         &self,
         input: T,
         buffer: &mut Vec<u8>,
     ) -> Result<(), DecodeError> {
-        let input_bytes = input.as_ref();
+        fn inner<E>(engine: &E, input_bytes: &[u8], buffer: &mut Vec<u8>) -> Result<(), DecodeError>
+        where
+            E: Engine + ?Sized,
+        {
+            let starting_output_len = buffer.len();
+            let estimate = engine.internal_decoded_len_estimate(input_bytes.len());
+
+            let total_len_estimate = estimate
+                .decoded_len_estimate()
+                .checked_add(starting_output_len)
+                .expect("Overflow when calculating output buffer length");
 
-        let starting_output_len = buffer.len();
+            buffer.resize(total_len_estimate, 0);
 
-        let estimate = self.internal_decoded_len_estimate(input_bytes.len());
-        let total_len_estimate = estimate
-            .decoded_len_estimate()
-            .checked_add(starting_output_len)
-            .expect("Overflow when calculating output buffer length");
-        buffer.resize(total_len_estimate, 0);
+            let buffer_slice = &mut buffer.as_mut_slice()[starting_output_len..];
 
-        let buffer_slice = &mut buffer.as_mut_slice()[starting_output_len..];
-        let bytes_written = self
-            .internal_decode(input_bytes, buffer_slice, estimate)?
-            .decoded_len;
+            let bytes_written = engine
+                .internal_decode(input_bytes, buffer_slice, estimate)?
+                .decoded_len;
 
-        buffer.truncate(starting_output_len + bytes_written);
+            buffer.truncate(starting_output_len + bytes_written);
+
+            Ok(())
+        }
 
-        Ok(())
+        inner(self, input.as_ref(), buffer)
     }
 
     /// Decode the input into the provided output slice.
@@ -301,21 +339,33 @@ pub trait Engine: Send + Sync {
     ///
     /// See [Engine::decode_slice_unchecked] for a version that panics instead of returning an error
     /// if the output buffer is too small.
+    #[inline]
     fn decode_slice<T: AsRef<[u8]>>(
         &self,
         input: T,
         output: &mut [u8],
     ) -> Result<usize, DecodeSliceError> {
-        let input_bytes = input.as_ref();
+        fn inner<E>(
+            engine: &E,
+            input_bytes: &[u8],
+            output: &mut [u8],
+        ) -> Result<usize, DecodeSliceError>
+        where
+            E: Engine + ?Sized,
+        {
+            let estimate = engine.internal_decoded_len_estimate(input_bytes.len());
+
+            if output.len() < estimate.decoded_len_estimate() {
+                return Err(DecodeSliceError::OutputSliceTooSmall);
+            }
 
-        let estimate = self.internal_decoded_len_estimate(input_bytes.len());
-        if output.len() < estimate.decoded_len_estimate() {
-            return Err(DecodeSliceError::OutputSliceTooSmall);
+            engine
+                .internal_decode(input_bytes, output, estimate)
+                .map_err(|e| e.into())
+                .map(|dm| dm.decoded_len)
         }
 
-        self.internal_decode(input_bytes, output, estimate)
-            .map_err(|e| e.into())
-            .map(|dm| dm.decoded_len)
+        inner(self, input.as_ref(), output)
     }
 
     /// Decode the input into the provided output slice.
@@ -332,19 +382,26 @@ pub trait Engine: Send + Sync {
     /// # Panics
     ///
     /// Panics if the provided output buffer is too small for the decoded data.
+    #[inline]
     fn decode_slice_unchecked<T: AsRef<[u8]>>(
         &self,
         input: T,
         output: &mut [u8],
     ) -> Result<usize, DecodeError> {
-        let input_bytes = input.as_ref();
-
-        self.internal_decode(
-            input_bytes,
-            output,
-            self.internal_decoded_len_estimate(input_bytes.len()),
-        )
-        .map(|dm| dm.decoded_len)
+        fn inner<E>(engine: &E, input_bytes: &[u8], output: &mut [u8]) -> Result<usize, DecodeError>
+        where
+            E: Engine + ?Sized,
+        {
+            engine
+                .internal_decode(
+                    input_bytes,
+                    output,
+                    engine.internal_decoded_len_estimate(input_bytes.len()),
+                )
+                .map(|dm| dm.decoded_len)
+        }
+
+        inner(self, input.as_ref(), output)
     }
 }
 
diff --git a/vendor/base64/src/engine/tests.rs b/vendor/base64/src/engine/tests.rs
index 6430b35a9..b04800552 100644
--- a/vendor/base64/src/engine/tests.rs
+++ b/vendor/base64/src/engine/tests.rs
@@ -623,7 +623,7 @@ fn decode_padding_before_final_non_padding_char_error_invalid_byte<E: EngineWrap
     let mut rng = seeded_rng();
 
     // the different amounts of proper padding, w/ offset from end for the last non-padding char
-    let suffixes = vec![("/w==", 2), ("iYu=", 1), ("zzzz", 0)];
+    let suffixes = [("/w==", 2), ("iYu=", 1), ("zzzz", 0)];
 
     let prefix_quads_range = distributions::Uniform::from(0..=256);
 
@@ -869,7 +869,7 @@ fn decode_pad_mode_requires_canonical_accepts_canonical<E: EngineWrapper>(engine
 fn decode_pad_mode_requires_canonical_rejects_non_canonical<E: EngineWrapper>(engine_wrapper: E) {
     let engine = E::standard_with_pad_mode(true, DecodePaddingMode::RequireCanonical);
 
-    let suffixes = vec!["/w", "/w=", "iYU"];
+    let suffixes = ["/w", "/w=", "iYU"];
     for num_prefix_quads in 0..256 {
         for &suffix in suffixes.iter() {
             let mut encoded = "AAAA".repeat(num_prefix_quads);
@@ -896,7 +896,7 @@ fn decode_pad_mode_requires_no_padding_accepts_no_padding<E: EngineWrapper>(engi
 fn decode_pad_mode_requires_no_padding_rejects_any_padding<E: EngineWrapper>(engine_wrapper: E) {
     let engine = E::standard_with_pad_mode(true, DecodePaddingMode::RequireNone);
 
-    let suffixes = vec!["/w=", "/w==", "iYU="];
+    let suffixes = ["/w=", "/w==", "iYU="];
     for num_prefix_quads in 0..256 {
         for &suffix in suffixes.iter() {
             let mut encoded = "AAAA".repeat(num_prefix_quads);