fix: accept an empty gzip as a valid input

src/codec/gzip/decoder.rs

@@ -5,9 +5,9 @@ use crate::{
     },
     util::PartialBuffer,
 };
-use std::io::{Error, ErrorKind, Result};
-
 use flate2::Crc;
+use std::io::{Error, ErrorKind, Read, Result};
+use std::ops::Deref;
 
 #[derive(Debug)]
 enum State {
@@ -163,16 +163,16 @@ impl Decode for GzipDecoder {
 
     fn finish(
         &mut self,
-        _output: &mut PartialBuffer<impl AsRef<[u8]> + AsMut<[u8]>>,
+        output: &mut PartialBuffer<impl AsRef<[u8]> + AsMut<[u8]>>,
     ) -> Result<bool> {
-        // Because of the footer we have to have already flushed all the data out before we get here
-        if let State::Done = self.state {
-            Ok(true)
-        } else {
-            Err(Error::new(
+        match &mut self.state {
+            State::Done => Ok(true),
+            // In this case, the input was an empty gzip. Exit successfully with an empty gzip.
+            State::Header(parser) if parser.has_no_content() => Ok(true),
+            _ => Err(Error::new(
                 ErrorKind::UnexpectedEof,
                 "unexpected end of file",
-            ))
+            )),
         }
     }
 }

src/codec/gzip/header.rs

@@ -161,4 +161,8 @@ impl Parser {
             };
         }
     }
+
+    pub(super) fn has_no_content(&self) -> bool {
+        matches!(&self.state, State::Fixed(data) if data.buffer().iter().all(|&b| b == 0))
+    }
 }

src/util.rs

@@ -20,6 +20,10 @@ impl<B: AsRef<[u8]>> PartialBuffer<B> {
         &self.buffer.as_ref()[self.index..]
     }
 
+    pub(crate) fn buffer(&self) -> &[u8] {
+        self.buffer.as_ref()
+    }
+
     pub(crate) fn advance(&mut self, amount: usize) {
         self.index += amount;
     }

tests/gzip.rs

@@ -6,6 +6,9 @@ test_cases!(gzip);
 #[allow(unused)]
 use utils::{algos::gzip::sync, InputStream};
 
+#[allow(unused)]
+use ntest::assert_true;
+
 #[cfg(feature = "futures-io")]
 use utils::algos::gzip::futures::bufread;
 
@@ -51,3 +54,28 @@ fn gzip_bufread_chunks_decompress_with_extra_header() {
 
     assert_eq!(output, &[1, 2, 3, 4, 5, 6][..]);
 }
+
+#[test]
+#[ntest::timeout(1000)]
+#[cfg(feature = "futures-io")]
+fn gzip_empty() {
+    let bytes = Vec::new();
+
+    let input = InputStream::from(bytes.chunks(2));
+    let output = bufread::decompress(bufread::from(&input));
+
+    assert_eq!(output, &[][..]);
+}
+
+#[test]
+#[ntest::timeout(1000)]
+#[cfg(feature = "futures-io")]
+fn invalid_gzip() {
+    let bytes = [0, 0, 0, 1, 0, 0];
+
+    let input = InputStream::from(bytes.chunks(2));
+
+    let result = std::panic::catch_unwind(|| bufread::decompress(bufread::from(&input)));
+
+    assert_true!(result.is_err());
+}