Gracefully handle type confusion of inflate_state and tdefl_compressor in mz_stream in C API

src/lib.rs

@@ -155,7 +155,10 @@ macro_rules! oxidize {
                     // Make sure we catch a potential panic, as
                     // this is called from C.
                     match catch_unwind(AssertUnwindSafe(|| {
-                        let mut stream_oxide = StreamOxide::new(&mut *stream);
+                        let mut stream_oxide = match StreamOxide::new(&mut *stream) {
+                            Ok(stream_oxide) => stream_oxide,
+                            Err(e) => return e as c_int
+                        };
                         let status = $mz_func_oxide(&mut stream_oxide, $($arg_name),*);
                         *stream = stream_oxide.into_mz_stream();
                         as_c_return_code(status)
@@ -234,7 +237,11 @@ pub unsafe extern "C" fn mz_compress2(
                 ..Default::default()
             };
 
-            let mut stream_oxide = StreamOxide::new(&mut stream);
+            let mut stream_oxide = match StreamOxide::new(&mut stream) {
+                Ok(stream_oxide) => stream_oxide,
+                Err(e) => return e as c_int
+            };
+
             as_c_return_code(mz_compress2_oxide(&mut stream_oxide, level, dest_len))
         },
     )
@@ -272,7 +279,11 @@ pub unsafe extern "C" fn mz_uncompress(
                 ..Default::default()
             };
 
-            let mut stream_oxide = StreamOxide::new(&mut stream);
+            let mut stream_oxide = match StreamOxide::new(&mut stream) {
+                Ok(stream_oxide) => stream_oxide,
+                Err(e) => return e as c_int
+            };
+
             as_c_return_code(mz_uncompress2_oxide(&mut stream_oxide, dest_len))
         },
     )

src/lib_oxide.rs

@@ -139,14 +139,23 @@ pub unsafe extern "C" fn def_free_func(_opaque: *mut c_void, address: *mut c_voi
 /// Trait used for states that can be carried by BoxedState.
 pub trait StateType {
     fn drop_state(&mut self);
+    fn get_stream_type() -> StreamType;
 }
 impl StateType for tdefl_compressor {
     fn drop_state(&mut self) {
         self.drop_inner();
     }
+
+    fn get_stream_type() -> StreamType {
+        StreamType::Deflate
+    }
 }
 impl StateType for inflate_state {
     fn drop_state(&mut self) {}
+
+    fn get_stream_type() -> StreamType {
+        StreamType::Inflate
+    }
 }
 
 /// Wrapper for a heap-allocated compressor/decompressor that frees the stucture on drop.
@@ -221,7 +230,13 @@ pub struct StreamOxide<'io, ST: StateType> {
 
 
 impl<'io, ST: StateType> StreamOxide<'io, ST> {
-    pub unsafe fn new(stream: &mut mz_stream) -> Self {
+    pub unsafe fn new(stream: &mut mz_stream) -> Result<Self, MZError> {
+        if !stream.state.is_null() {
+            let stream_type_slice: StreamType = ptr::read(stream.state as *const StreamType);
+            if stream_type_slice != ST::get_stream_type() {
+                return Err(MZError::Stream);
+            }
+        }
         let in_slice = stream.next_in.as_ref().map(|ptr| {
             slice::from_raw_parts(ptr, stream.avail_in as usize)
         });
@@ -230,14 +245,14 @@ impl<'io, ST: StateType> StreamOxide<'io, ST> {
             slice::from_raw_parts_mut(ptr, stream.avail_out as usize)
         });
 
-        StreamOxide {
+        Ok(StreamOxide {
             next_in: in_slice,
             total_in: stream.total_in,
             next_out: out_slice,
             total_out: stream.total_out,
             state: BoxedState::new(stream),
             adler: stream.adler,
-        }
+        })
     }
 
     pub fn into_mz_stream(mut self) -> mz_stream {
@@ -460,11 +475,17 @@ pub fn mz_deflate_reset_oxide(stream_oxide: &mut StreamOxide<tdefl_compressor>)
     Ok(MZStatus::Ok)
 }
 
-
+#[allow(bad_style)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum StreamType {
+    Inflate,
+    Deflate
+}
 
 #[repr(C)]
 #[allow(bad_style)]
 pub struct inflate_state {
+    pub stream_type: StreamType,
     pub m_decomp: DecompressorOxide,
 
     pub m_dict_ofs: c_uint,
@@ -495,6 +516,7 @@ pub fn mz_inflate_init2_oxide(
 
     stream_oxide.state.alloc_state::<inflate_state>()?;
     let state = stream_oxide.state.as_mut().ok_or(MZError::Mem)?;
+    state.stream_type = StreamType::Inflate;
     state.m_decomp.init();
     state.m_dict_ofs = 0;
     state.m_dict_avail = 0;

src/tdef.rs

@@ -4,6 +4,7 @@ use std::panic::{catch_unwind, AssertUnwindSafe};
 
 use miniz_oxide::deflate::core::{compress, compress_to_output, create_comp_flags_from_zip_params,
                                  CompressorOxide, TDEFLFlush, TDEFLStatus};
+use lib_oxide::StreamType;
 
 /// Compression callback function type.
 pub type PutBufFuncPtrNotNull = unsafe extern "C" fn(
@@ -44,20 +45,23 @@ pub mod strategy {
 #[repr(C)]
 #[allow(bad_style)]
 pub struct tdefl_compressor {
+    pub stream_type: StreamType,
     pub inner: Option<CompressorOxide>,
     pub callback: Option<CallbackFunc>,
 }
 
 impl tdefl_compressor {
     pub(crate) fn new(flags: u32) -> Self {
         tdefl_compressor {
+            stream_type: StreamType::Deflate,
             inner: Some(CompressorOxide::new(flags)),
             callback: None,
         }
     }
 
     pub(crate) fn new_with_callback(flags: u32, func: CallbackFunc) -> Self {
         tdefl_compressor {
+            stream_type: StreamType::Deflate,
             inner: Some(CompressorOxide::new(flags)),
             callback: Some(func),
         }
@@ -178,6 +182,7 @@ pub unsafe extern "C" fn tdefl_compress_buffer(
 pub unsafe extern "C" fn tdefl_allocate() -> *mut tdefl_compressor {
     Box::into_raw(Box::<tdefl_compressor>::new(
         tdefl_compressor {
+            stream_type: StreamType::Deflate,
             inner: None,
             callback: None,
         }