Use the error message from z_stream.msg for [De]CompressError (#270)

* Use the error message from z_stream.msg for [De]CompressError

* Don't make the size of Error types bigger if msg is always going to be None

* Clean up cfg()s for zlib vs any_zlib

* Test error messages on invalid data

Author: coolreader18

src/ffi/c.rs

@@ -12,6 +12,23 @@ pub use libc::{c_int, c_uint, c_void, size_t};
 use super::*;
 use crate::mem::{self, FlushDecompress, Status};
 
+// miniz doesn't provide any error messages, so only enable the field when we use a real zlib
+#[derive(Default)]
+pub struct ErrorMessage(#[cfg(feature = "any_zlib")] Option<&'static str>);
+
+impl ErrorMessage {
+    pub fn get(&self) -> Option<&str> {
+        #[cfg(feature = "any_zlib")]
+        {
+            self.0
+        }
+        #[cfg(not(feature = "any_zlib"))]
+        {
+            None
+        }
+    }
+}
+
 pub struct StreamWrapper {
     pub inner: Box<mz_stream>,
 }
@@ -138,6 +155,25 @@ pub struct Stream<D: Direction> {
     pub _marker: marker::PhantomData<D>,
 }
 
+impl<D: Direction> Stream<D> {
+    pub fn msg(&self) -> ErrorMessage {
+        #[cfg(feature = "any_zlib")]
+        {
+            let msg = self.stream_wrapper.msg;
+            ErrorMessage(if msg.is_null() {
+                None
+            } else {
+                let s = unsafe { std::ffi::CStr::from_ptr(msg) };
+                std::str::from_utf8(s.to_bytes()).ok()
+            })
+        }
+        #[cfg(not(feature = "any_zlib"))]
+        {
+            ErrorMessage()
+        }
+    }
+}
+
 impl<D: Direction> Drop for Stream<D> {
     fn drop(&mut self) {
         unsafe {
@@ -193,6 +229,7 @@ impl InflateBackend for Inflate {
         flush: FlushDecompress,
     ) -> Result<Status, DecompressError> {
         let raw = &mut *self.inner.stream_wrapper;
+        raw.msg = ptr::null_mut();
         raw.next_in = input.as_ptr() as *mut u8;
         raw.avail_in = cmp::min(input.len(), c_uint::max_value() as usize) as c_uint;
         raw.next_out = output.as_mut_ptr();
@@ -206,7 +243,7 @@ impl InflateBackend for Inflate {
         self.inner.total_out += (raw.next_out as usize - output.as_ptr() as usize) as u64;
 
         match rc {
-            MZ_DATA_ERROR | MZ_STREAM_ERROR => mem::decompress_failed(),
+            MZ_DATA_ERROR | MZ_STREAM_ERROR => mem::decompress_failed(self.inner.msg()),
             MZ_OK => Ok(Status::Ok),
             MZ_BUF_ERROR => Ok(Status::BufError),
             MZ_STREAM_END => Ok(Status::StreamEnd),
@@ -286,6 +323,7 @@ impl DeflateBackend for Deflate {
         flush: FlushCompress,
     ) -> Result<Status, CompressError> {
         let raw = &mut *self.inner.stream_wrapper;
+        raw.msg = ptr::null_mut();
         raw.next_in = input.as_ptr() as *mut _;
         raw.avail_in = cmp::min(input.len(), c_uint::max_value() as usize) as c_uint;
         raw.next_out = output.as_mut_ptr();
@@ -302,7 +340,7 @@ impl DeflateBackend for Deflate {
             MZ_OK => Ok(Status::Ok),
             MZ_BUF_ERROR => Ok(Status::BufError),
             MZ_STREAM_END => Ok(Status::StreamEnd),
-            MZ_STREAM_ERROR => Err(CompressError(())),
+            MZ_STREAM_ERROR => mem::compress_failed(self.inner.msg()),
             c => panic!("unknown return code: {}", c),
         }
     }
@@ -336,103 +374,41 @@ mod c_backend {
     pub type AllocSize = libc::size_t;
 }
 
-/// Zlib specific
-#[cfg(any(
-    feature = "zlib-ng-compat",
-    all(feature = "zlib", not(feature = "cloudflare_zlib"))
-))]
-#[allow(bad_style)]
-mod c_backend {
-    use libc::{c_char, c_int};
-    use std::mem;
-
-    pub use libz_sys::deflate as mz_deflate;
-    pub use libz_sys::deflateEnd as mz_deflateEnd;
-    pub use libz_sys::deflateReset as mz_deflateReset;
-    pub use libz_sys::inflate as mz_inflate;
-    pub use libz_sys::inflateEnd as mz_inflateEnd;
-    pub use libz_sys::z_stream as mz_stream;
-    pub use libz_sys::*;
-
-    pub use libz_sys::Z_BLOCK as MZ_BLOCK;
-    pub use libz_sys::Z_BUF_ERROR as MZ_BUF_ERROR;
-    pub use libz_sys::Z_DATA_ERROR as MZ_DATA_ERROR;
-    pub use libz_sys::Z_DEFAULT_STRATEGY as MZ_DEFAULT_STRATEGY;
-    pub use libz_sys::Z_DEFLATED as MZ_DEFLATED;
-    pub use libz_sys::Z_FINISH as MZ_FINISH;
-    pub use libz_sys::Z_FULL_FLUSH as MZ_FULL_FLUSH;
-    pub use libz_sys::Z_NEED_DICT as MZ_NEED_DICT;
-    pub use libz_sys::Z_NO_FLUSH as MZ_NO_FLUSH;
-    pub use libz_sys::Z_OK as MZ_OK;
-    pub use libz_sys::Z_PARTIAL_FLUSH as MZ_PARTIAL_FLUSH;
-    pub use libz_sys::Z_STREAM_END as MZ_STREAM_END;
-    pub use libz_sys::Z_STREAM_ERROR as MZ_STREAM_ERROR;
-    pub use libz_sys::Z_SYNC_FLUSH as MZ_SYNC_FLUSH;
-    pub type AllocSize = libz_sys::uInt;
-
-    pub const MZ_DEFAULT_WINDOW_BITS: c_int = 15;
-
-    const ZLIB_VERSION: &'static str = "1.2.8\0";
-
-    pub unsafe extern "C" fn mz_deflateInit2(
-        stream: *mut mz_stream,
-        level: c_int,
-        method: c_int,
-        window_bits: c_int,
-        mem_level: c_int,
-        strategy: c_int,
-    ) -> c_int {
-        libz_sys::deflateInit2_(
-            stream,
-            level,
-            method,
-            window_bits,
-            mem_level,
-            strategy,
-            ZLIB_VERSION.as_ptr() as *const c_char,
-            mem::size_of::<mz_stream>() as c_int,
-        )
-    }
-    pub unsafe extern "C" fn mz_inflateInit2(stream: *mut mz_stream, window_bits: c_int) -> c_int {
-        libz_sys::inflateInit2_(
-            stream,
-            window_bits,
-            ZLIB_VERSION.as_ptr() as *const c_char,
-            mem::size_of::<mz_stream>() as c_int,
-        )
-    }
-}
-
-/// Cloudflare optimized Zlib specific
-#[cfg(all(feature = "cloudflare_zlib", not(feature = "zlib-ng-compat")))]
+/// Zlib specific - make zlib mimic miniz' API
+#[cfg(feature = "any_zlib")]
 #[allow(bad_style)]
 mod c_backend {
     use libc::{c_char, c_int};
     use std::mem;
 
-    pub use cloudflare_zlib_sys::deflate as mz_deflate;
-    pub use cloudflare_zlib_sys::deflateEnd as mz_deflateEnd;
-    pub use cloudflare_zlib_sys::deflateReset as mz_deflateReset;
-    pub use cloudflare_zlib_sys::inflate as mz_inflate;
-    pub use cloudflare_zlib_sys::inflateEnd as mz_inflateEnd;
-    pub use cloudflare_zlib_sys::z_stream as mz_stream;
-    pub use cloudflare_zlib_sys::*;
-
-    pub use cloudflare_zlib_sys::Z_BLOCK as MZ_BLOCK;
-    pub use cloudflare_zlib_sys::Z_BUF_ERROR as MZ_BUF_ERROR;
-    pub use cloudflare_zlib_sys::Z_DATA_ERROR as MZ_DATA_ERROR;
-    pub use cloudflare_zlib_sys::Z_DEFAULT_STRATEGY as MZ_DEFAULT_STRATEGY;
-    pub use cloudflare_zlib_sys::Z_DEFLATED as MZ_DEFLATED;
-    pub use cloudflare_zlib_sys::Z_FINISH as MZ_FINISH;
-    pub use cloudflare_zlib_sys::Z_FULL_FLUSH as MZ_FULL_FLUSH;
-    pub use cloudflare_zlib_sys::Z_NEED_DICT as MZ_NEED_DICT;
-    pub use cloudflare_zlib_sys::Z_NO_FLUSH as MZ_NO_FLUSH;
-    pub use cloudflare_zlib_sys::Z_OK as MZ_OK;
-    pub use cloudflare_zlib_sys::Z_PARTIAL_FLUSH as MZ_PARTIAL_FLUSH;
-    pub use cloudflare_zlib_sys::Z_STREAM_END as MZ_STREAM_END;
-    pub use cloudflare_zlib_sys::Z_STREAM_ERROR as MZ_STREAM_ERROR;
-    pub use cloudflare_zlib_sys::Z_SYNC_FLUSH as MZ_SYNC_FLUSH;
-    pub type AllocSize = cloudflare_zlib_sys::uInt;
+    #[cfg(feature = "cloudflare_zlib")]
+    use cloudflare_zlib_sys as libz;
+    #[cfg(not(feature = "cloudflare_zlib"))]
+    use libz_sys as libz;
+
+    pub use libz::deflate as mz_deflate;
+    pub use libz::deflateEnd as mz_deflateEnd;
+    pub use libz::deflateReset as mz_deflateReset;
+    pub use libz::inflate as mz_inflate;
+    pub use libz::inflateEnd as mz_inflateEnd;
+    pub use libz::z_stream as mz_stream;
+    pub use libz::*;
+
+    pub use libz::Z_BLOCK as MZ_BLOCK;
+    pub use libz::Z_BUF_ERROR as MZ_BUF_ERROR;
+    pub use libz::Z_DATA_ERROR as MZ_DATA_ERROR;
+    pub use libz::Z_DEFAULT_STRATEGY as MZ_DEFAULT_STRATEGY;
+    pub use libz::Z_DEFLATED as MZ_DEFLATED;
+    pub use libz::Z_FINISH as MZ_FINISH;
+    pub use libz::Z_FULL_FLUSH as MZ_FULL_FLUSH;
+    pub use libz::Z_NEED_DICT as MZ_NEED_DICT;
+    pub use libz::Z_NO_FLUSH as MZ_NO_FLUSH;
+    pub use libz::Z_OK as MZ_OK;
+    pub use libz::Z_PARTIAL_FLUSH as MZ_PARTIAL_FLUSH;
+    pub use libz::Z_STREAM_END as MZ_STREAM_END;
+    pub use libz::Z_STREAM_ERROR as MZ_STREAM_ERROR;
+    pub use libz::Z_SYNC_FLUSH as MZ_SYNC_FLUSH;
+    pub type AllocSize = libz::uInt;
 
     pub const MZ_DEFAULT_WINDOW_BITS: c_int = 15;
 
@@ -446,7 +422,7 @@ mod c_backend {
         mem_level: c_int,
         strategy: c_int,
     ) -> c_int {
-        cloudflare_zlib_sys::deflateInit2_(
+        libz::deflateInit2_(
             stream,
             level,
             method,
@@ -458,7 +434,7 @@ mod c_backend {
         )
     }
     pub unsafe extern "C" fn mz_inflateInit2(stream: *mut mz_stream, window_bits: c_int) -> c_int {
-        cloudflare_zlib_sys::inflateInit2_(
+        libz::inflateInit2_(
             stream,
             window_bits,
             ZLIB_VERSION.as_ptr() as *const c_char,

src/ffi/mod.rs

@@ -44,3 +44,9 @@ cfg_if::cfg_if! {
         pub use self::rust::*;
     }
 }
+
+impl std::fmt::Debug for ErrorMessage {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        self.get().fmt(f)
+    }
+}

src/ffi/rust.rs

@@ -16,6 +16,16 @@ pub const MZ_FINISH: isize = MZFlush::Finish as isize;
 use super::*;
 use crate::mem;
 
+// miniz_oxide doesn't provide any error messages (yet?)
+#[derive(Default)]
+pub struct ErrorMessage;
+
+impl ErrorMessage {
+    pub fn get(&self) -> Option<&str> {
+        None
+    }
+}
+
 fn format_from_bool(zlib_header: bool) -> DataFormat {
     if zlib_header {
         DataFormat::Zlib
@@ -73,7 +83,7 @@ impl InflateBackend for Inflate {
             },
             Err(status) => match status {
                 MZError::Buf => Ok(Status::BufError),
-                _ => mem::decompress_failed(),
+                _ => mem::decompress_failed(ErrorMessage),
             },
         }
     }
@@ -144,11 +154,11 @@ impl DeflateBackend for Deflate {
             Ok(status) => match status {
                 MZStatus::Ok => Ok(Status::Ok),
                 MZStatus::StreamEnd => Ok(Status::StreamEnd),
-                MZStatus::NeedDict => Err(CompressError(())),
+                MZStatus::NeedDict => mem::compress_failed(ErrorMessage),
             },
             Err(status) => match status {
                 MZError::Buf => Ok(Status::BufError),
-                _ => Err(CompressError(())),
+                _ => mem::compress_failed(ErrorMessage),
             },
         }
     }