Fix handling of empty data (#24)

* Add fmt::Debug to InflateState

* Add failing empty_data variant

* All fixed except empty_data rountrip into

* Fix compress_into test when empty data

* Bump version -> 0.5.2

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "isal-rs"
-version = "0.5.1+496255c"
+version = "0.5.2+496255c"
 edition = "2021"
 description = "isa-l Rust bindings"
 readme = "README.md"
@@ -28,7 +28,7 @@ use-system-isal = ["isal-sys/use-system-isal"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
-isal-sys = { path = "isal-sys", version = "0.5.1+496255c" }
+isal-sys = { path = "isal-sys", version = "0.5.2+496255c" }
 
 [dev-dependencies]
 criterion = { version = "0.5", features = ["html_reports"] }

isal-sys/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "isal-sys"
-version = "0.5.1+496255c"
+version = "0.5.2+496255c"
 edition = "2021"
 description = "isa-l sys crate"
 license = "MIT AND BSD-3-Clause"

src/lib.rs

@@ -308,6 +308,17 @@ impl ZStream {
 
 pub(crate) struct InflateState {
     state: isal::inflate_state,
+    no_change_count: usize,
+}
+
+impl std::fmt::Debug for InflateState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("InflateState")
+            .field("block_state", &self.state.block_state)
+            .field("avail_in", &self.state.avail_in)
+            .field("avail_out", &self.state.avail_out)
+            .finish()
+    }
 }
 
 impl InflateState {
@@ -316,7 +327,10 @@ impl InflateState {
         unsafe { isal::isal_inflate_init(uninit.as_mut_ptr()) };
         let mut state = unsafe { uninit.assume_init() };
         state.crc_flag = codec as _;
-        Self { state }
+        Self {
+            state,
+            no_change_count: 0,
+        }
     }
 
     pub fn block_state(&self) -> u32 {
@@ -325,6 +339,7 @@ impl InflateState {
 
     pub fn reset(&mut self) {
         unsafe { isal::isal_inflate_reset(&mut self.state) }
+        self.no_change_count = 0;
     }
 
     pub fn step_inflate(&mut self) -> Result<()> {
@@ -341,10 +356,13 @@ impl InflateState {
         // ISA-L doesn't catch some bad data in the header and will loop endlessly
         // unless we check if anything was written to the output
         if self.state.avail_out == avail_out {
-            return Err(Error::Other((
-                None,
-                "Corrupt data, appears the compressed input is invalid".to_string(),
-            )));
+            self.no_change_count += 1;
+            if self.no_change_count >= 2 {
+                return Err(Error::Other((
+                    None,
+                    "Corrupt data, appears the compressed input is invalid".to_string(),
+                )));
+            }
         }
         Ok(())
     }
@@ -395,6 +413,9 @@ pub mod tests {
     pub fn small_data() -> Vec<u8> {
         b"foobar".to_vec()
     }
+    pub fn empty_data() -> Vec<u8> {
+        vec![]
+    }
 
     pub fn same_same(a: &[u8], b: &[u8]) -> bool {
         md5::compute(a) == md5::compute(b)
@@ -470,7 +491,8 @@ pub mod tests {
                                             let compressed_len = compress(data.as_slice(), $lvl, $codec).unwrap().len();
                                             let decompressed_len = data.len();
 
-                                            let mut compressed = vec![0; compressed_len * 2];
+                                            // cmp is special case when data to be compressed is empty, we at least need room for the header
+                                            let mut compressed = vec![0; std::cmp::max(compressed_len * 2, 8)];
                                             let mut decompressed = vec![0; decompressed_len * 2];
 
                                             // compress_into
@@ -657,6 +679,7 @@ pub mod tests {
                                     }
                                 }
                             }
+                            test_data_size!(empty_data);
                             test_data_size!(small_data);
                             test_data_size!(large_data);
                         }

src/write.rs

@@ -184,6 +184,8 @@ pub struct Decoder<W: io::Write> {
     inner: W,
     zst: InflateState,
     out_buf: Vec<u8>,
+    total_out: usize,
+    total_in: usize,
     #[allow(dead_code)]
     codec: Codec,
 }
@@ -196,6 +198,8 @@ impl<W: io::Write> Decoder<W> {
             inner: writer,
             zst,
             out_buf: Vec::with_capacity(BUF_SIZE),
+            total_out: 0,
+            total_in: 0,
             codec,
         }
     }
@@ -216,8 +220,10 @@ impl<W: io::Write> io::Write for Decoder<W> {
         self.zst.state.avail_in = buf.len() as _;
         self.zst.state.next_in = buf.as_ptr() as *mut _;
 
+        self.total_in += buf.len();
+
         let mut n_bytes = 0;
-        while self.zst.state.avail_in > 0 {
+        loop {
             loop {
                 self.out_buf.resize(n_bytes + BUF_SIZE, 0);
 
@@ -227,6 +233,7 @@ impl<W: io::Write> io::Write for Decoder<W> {
                 self.zst.step_inflate()?;
 
                 n_bytes += BUF_SIZE - self.zst.state.avail_out as usize;
+                self.total_out += n_bytes;
 
                 if self.zst.block_state() == isal::isal_block_state_ISAL_BLOCK_FINISH {
                     break;
@@ -235,13 +242,23 @@ impl<W: io::Write> io::Write for Decoder<W> {
             if self.zst.block_state() == isal::isal_block_state_ISAL_BLOCK_FINISH {
                 self.zst.reset();
             }
+
+            if self.zst.state.avail_in == 0 {
+                break;
+            }
         }
         self.inner.write_all(&self.out_buf[..n_bytes])?;
 
         let nbytes = buf.len() - self.zst.state.avail_in as usize;
         Ok(nbytes)
     }
     fn flush(&mut self) -> io::Result<()> {
+        if self.total_out == 0 && self.total_in == 0 {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                Error::DecompressionError(DecompCode::EndInput),
+            ));
+        }
         self.inner.flush()
     }
 }