Copy chunks as MaybeUninit<u8>

test-libz-rs-sys/src/lib.rs

@@ -1,14 +1,14 @@
 #[cfg(test)]
 mod deflate;
 pub mod end_to_end;
+#[cfg(test)]
+#[cfg(feature = "gz")]
+mod gz;
 mod helpers;
 #[cfg(test)]
 mod inflate;
 #[cfg(test)]
 mod zlib_ng_cve;
-#[cfg(test)]
-#[cfg(feature = "gz")]
-mod gz;
 
 #[cfg(test)]
 #[macro_export]
@@ -98,8 +98,11 @@ fn flags() {
 
 #[cfg(test)]
 mod null {
+    use core::ffi::{c_char, c_int};
     use core::mem::MaybeUninit;
 
+    use zlib_rs::{inflate::InflateConfig, InflateFlush, ReturnCode};
+
     #[test]
     fn adler() {
         assert_eq_rs_ng!({ adler32(0, core::ptr::null(), 0) });
@@ -1132,6 +1135,46 @@ mod null {
             assert_eq!(err, Z_OK);
         }
     }
+
+    #[test]
+    fn inflate_with_uninitialized_output_buffer() {
+        let input = include_bytes!("test-data/issue-109.gz");
+
+        let config = InflateConfig::default();
+
+        assert_eq_rs_ng!({
+            let mut stream = MaybeUninit::<z_stream>::zeroed();
+
+            const VERSION: *const c_char = libz_rs_sys::zlibVersion();
+            const STREAM_SIZE: c_int = core::mem::size_of::<z_stream>() as c_int;
+
+            let err = unsafe {
+                inflateInit2_(
+                    stream.as_mut_ptr(),
+                    16 + config.window_bits,
+                    VERSION,
+                    STREAM_SIZE,
+                )
+            };
+            assert_eq!(err, 0);
+
+            let stream = unsafe { stream.assume_init_mut() };
+
+            let mut output = [MaybeUninit::<u8>::uninit(); 256];
+            stream.next_out = output.as_mut_ptr().cast();
+            stream.avail_out = output.len() as _;
+
+            let chunk = &input[..128];
+            stream.next_in = chunk.as_ptr().cast_mut();
+            stream.avail_in = chunk.len() as _;
+
+            let err = unsafe { inflate(stream, InflateFlush::NoFlush as _) };
+            assert_eq!(err, ReturnCode::Ok as i32);
+
+            let err = unsafe { inflateEnd(stream) };
+            assert_eq!(err, ReturnCode::Ok as i32);
+        });
+    }
 }
 
 #[cfg(test)]

zlib-rs/src/inflate/writer.rs

@@ -295,15 +295,15 @@ impl<'a> Writer<'a> {
 ///
 /// Must be valid to read a `[u8; N]` value from `from` with an unaligned read.
 #[inline(always)]
-unsafe fn load_chunk<const N: usize>(from: *const MaybeUninit<u8>) -> [u8; N] {
-    core::ptr::read_unaligned(from.cast::<[u8; N]>())
+unsafe fn load_chunk<const N: usize>(from: *const MaybeUninit<u8>) -> [MaybeUninit<u8>; N] {
+    core::ptr::read_unaligned(from.cast::<[MaybeUninit<u8>; N]>())
 }
 
 /// # Safety
 ///
 /// Must be valid to write a `[u8; N]` value to `out` with an unaligned write.
 #[inline(always)]
-unsafe fn store_chunk<const N: usize>(out: *mut MaybeUninit<u8>, chunk: [u8; N]) {
+unsafe fn store_chunk<const N: usize>(out: *mut MaybeUninit<u8>, chunk: [MaybeUninit<u8>; N]) {
     core::ptr::write_unaligned(out.cast(), chunk)
 }