Stop consuming input on errors in codecs. (#451)

Closes #450.

Author: orium

crates/compression-codecs/src/brotli/decoder.rs

@@ -42,7 +42,7 @@ impl BrotliDecoder {
         let mut input_len = 0;
         let mut output_len = 0;
 
-        let result = match BrotliDecompressStream(
+        let status = match BrotliDecompressStream(
             &mut in_buf.len(),
             &mut input_len,
             in_buf,
@@ -52,14 +52,14 @@ impl BrotliDecoder {
             &mut 0,
             &mut self.state,
         ) {
-            BrotliResult::ResultFailure => Err(io::Error::other("brotli error")),
-            status => Ok(status),
+            BrotliResult::ResultFailure => return Err(io::Error::other("brotli error")),
+            status => status,
         };
 
         input.advance(input_len);
         output.advance(output_len);
 
-        result
+        Ok(status)
     }
 }
 

crates/compression-codecs/src/brotli/encoder.rs

@@ -31,7 +31,7 @@ impl BrotliEncoder {
         let mut input_len = 0;
         let mut output_len = 0;
 
-        let result = if !self.state.compress_stream(
+        if !self.state.compress_stream(
             op,
             &mut in_buf.len(),
             in_buf,
@@ -42,15 +42,13 @@ impl BrotliEncoder {
             &mut None,
             &mut |_, _, _, _| (),
         ) {
-            Err(io::Error::other("brotli error"))
-        } else {
-            Ok(())
-        };
+            return Err(io::Error::other("brotli error"));
+        }
 
         input.advance(input_len);
         output.advance(output_len);
 
-        result
+        Ok(())
     }
 }
 

crates/compression-codecs/src/bzip2/decoder.rs

@@ -41,11 +41,11 @@ impl BzDecoder {
         let prior_in = self.decompress.total_in();
         let prior_out = self.decompress.total_out();
 
-        let result = self
+        let status = self
             .decompress
             // Safety: We **trust** bzip2 to only write initialized data to it
             .decompress_uninit(input.unwritten(), unsafe { output.unwritten_mut() })
-            .map_err(io::Error::other);
+            .map_err(io::Error::other)?;
 
         input.advance((self.decompress.total_in() - prior_in) as usize);
         // Safety: We **trust** bzip2 to write bytes properly
@@ -54,11 +54,11 @@ impl BzDecoder {
         };
 
         // Track when stream has properly ended
-        if matches!(result, Ok(Status::StreamEnd)) {
+        if status == Status::StreamEnd {
             self.stream_ended = true;
         }
 
-        result
+        Ok(status)
     }
 }
 

crates/compression-codecs/src/bzip2/encoder.rs

@@ -55,17 +55,17 @@ impl BzEncoder {
         let prior_in = self.compress.total_in();
         let prior_out = self.compress.total_out();
 
-        let result = self
+        let status = self
             .compress
             // Safety: We **trust** bzip2 to only write initialized bytes into it
             .compress_uninit(input.unwritten(), unsafe { output.unwritten_mut() }, action)
-            .map_err(io::Error::other);
+            .map_err(io::Error::other)?;
 
         input.advance((self.compress.total_in() - prior_in) as usize);
         // Safety: We **trust** bzip2 to properly write bytes into it
         unsafe { output.assume_init_and_advance((self.compress.total_out() - prior_out) as usize) };
 
-        result
+        Ok(status)
     }
 }
 

crates/compression-codecs/src/deflate64/decoder.rs

@@ -31,13 +31,13 @@ impl Deflate64Decoder {
             // Safety: We **trust** deflate64 to not write uninitialized bytes
             .inflate_uninit(input.unwritten(), unsafe { output.unwritten_mut() });
 
-        input.advance(result.bytes_consumed);
-        // Safety: We **trust** deflate64 to properly write bytes into buffer
-        unsafe { output.assume_init_and_advance(result.bytes_written) };
-
         if result.data_error {
             Err(Error::new(ErrorKind::InvalidData, "invalid data"))
         } else {
+            input.advance(result.bytes_consumed);
+            // Safety: We **trust** deflate64 to properly write bytes into buffer
+            unsafe { output.assume_init_and_advance(result.bytes_written) };
+
             Ok(self.inflater.finished() && self.inflater.available_output() == 0)
         }
     }

crates/compression-codecs/src/flate/decoder.rs

@@ -26,18 +26,18 @@ impl FlateDecoder {
         let prior_in = self.decompress.total_in();
         let prior_out = self.decompress.total_out();
 
-        let result = self
+        let status = self
             .decompress
             // Safety: We **trust** flate2 to not write uninitialized bytes into buffer
-            .decompress_uninit(input.unwritten(), unsafe { output.unwritten_mut() }, flush);
+            .decompress_uninit(input.unwritten(), unsafe { output.unwritten_mut() }, flush)?;
 
         input.advance((self.decompress.total_in() - prior_in) as usize);
         // Safety: We **trust** flate2 to write bytes into buffer properly
         unsafe {
             output.assume_init_and_advance((self.decompress.total_out() - prior_out) as usize)
         };
 
-        Ok(result?)
+        Ok(status)
     }
 }
 

crates/compression-codecs/src/flate/encoder.rs

@@ -31,16 +31,16 @@ impl FlateEncoder {
         let prior_in = self.compress.total_in();
         let prior_out = self.compress.total_out();
 
-        let result = self
+        let status = self
             .compress
             // Safety: We **trust** flate2 to not write uninitialized bytes into buffer
-            .compress_uninit(input.unwritten(), unsafe { output.unwritten_mut() }, flush);
+            .compress_uninit(input.unwritten(), unsafe { output.unwritten_mut() }, flush)?;
 
         input.advance((self.compress.total_in() - prior_in) as usize);
         // Safety: We **trust** flate2 to write bytes properly into buffer
         unsafe { output.assume_init_and_advance((self.compress.total_out() - prior_out) as usize) };
 
-        Ok(result?)
+        Ok(status)
     }
 }
 

crates/compression-codecs/src/lz4/decoder.rs

@@ -77,14 +77,14 @@ impl DecodeV2 for Lz4Decoder {
                 input.unwritten().as_ptr(),
                 &mut input_size,
                 core::ptr::null(),
-            ));
+            ))?;
             output.assume_init_and_advance(output_size);
 
             result
         };
         input.advance(input_size);
 
-        let finished = result? == 0;
+        let finished = result == 0;
         if finished {
             self.stream_ended = true;
         }

crates/compression-codecs/src/xz2/mod.rs

@@ -24,13 +24,14 @@ fn process_stream(
     let previous_out = stream.total_out() as usize;
 
     // Safety: We **trust** liblzma to not write uninitialized bytes into the buffer
-    let res = stream.process_uninit(input.unwritten(), unsafe { output.unwritten_mut() }, action);
+    let status =
+        stream.process_uninit(input.unwritten(), unsafe { output.unwritten_mut() }, action)?;
 
     input.advance(stream.total_in() as usize - previous_in);
     // Safety: We **trust** liblzma to write bytes into the buffer properly
     unsafe { output.assume_init_and_advance(stream.total_out() as usize - previous_out) };
 
-    match res? {
+    match status {
         Status::Ok => Ok(false),
         Status::StreamEnd => Ok(true),
         Status::GetCheck => Err(io::Error::other("Unexpected lzma integrity check")),