expose uncompress2

Author: folkertdev

libz-rs-sys/src/lib.rs

@@ -478,25 +478,71 @@ pub unsafe extern "C-unwind" fn uncompress(
     dest: *mut u8,
     destLen: *mut c_ulong,
     source: *const u8,
-    sourceLen: c_ulong,
+    mut sourceLen: c_ulong,
+) -> c_int {
+    uncompress2(dest, destLen, source, &mut sourceLen)
+}
+
+/// Inflates `source` into `dest` like [`uncompress`], and writes the final inflated size into `destLen` and the number
+/// of source bytes consumed into `sourceLen`.
+///
+/// Upon entry, `destLen` is the total size of the destination buffer, which must be large enough to hold the entire
+/// uncompressed data. (The size of the uncompressed data must have been saved previously by the compressor and
+/// transmitted to the decompressor by some mechanism outside the scope of this compression library.)
+/// Upon exit, `destLen` is the actual size of the uncompressed data.
+///
+/// # Returns
+///
+/// * [`Z_OK`] if success
+/// * [`Z_MEM_ERROR`] if there was not enough memory
+/// * [`Z_BUF_ERROR`] if there was not enough room in the output buffer
+/// * [`Z_DATA_ERROR`] if the input data was corrupted or incomplete
+///
+/// In the case where there is not enough room, [`uncompress2`] will fill the output buffer with the uncompressed data up to that point.
+///
+/// # Safety
+///
+/// The caller must guarantee that
+///
+/// * Either
+///     - `destLen` is `NULL`
+///     - `destLen` satisfies the requirements of `&mut *destLen`
+/// * Either
+///     - `dest` is `NULL`
+///     - `dest` and `*destLen` satisfy the requirements of [`core::slice::from_raw_parts_mut::<MaybeUninit<u8>>`]
+/// * Either
+///     - `source` is `NULL`
+///     - `source` and `sourceLen` satisfy the requirements of [`core::slice::from_raw_parts::<u8>`]
+/// * `sourceLen` satisfies the requirements of `&mut *sourceLen`
+#[cfg_attr(feature = "export-symbols", export_name = prefix!(uncompress2))]
+pub unsafe extern "C" fn uncompress2(
+    dest: *mut u8,
+    destLen: *mut c_ulong,
+    source: *const u8,
+    sourceLen: *mut c_ulong,
 ) -> c_int {
     // stock zlib will just dereference a NULL pointer: that's UB.
     // Hence us returning an error value is compatible
     let Some(destLen) = (unsafe { destLen.as_mut() }) else {
         return ReturnCode::StreamError as _;
     };
 
+    let Some(sourceLen) = (unsafe { sourceLen.as_mut() }) else {
+        return ReturnCode::StreamError as _;
+    };
+
     let Some(output) = (unsafe { slice_from_raw_parts_uninit_mut(dest, *destLen as usize) }) else {
         return ReturnCode::StreamError as _;
     };
 
-    let Some(input) = (unsafe { slice_from_raw_parts(source, sourceLen as usize) }) else {
+    let Some(input) = (unsafe { slice_from_raw_parts(source, *sourceLen as usize) }) else {
         return ReturnCode::StreamError as _;
     };
 
     let config = InflateConfig::default();
-    let (output, err) = zlib_rs::inflate::uncompress(output, input, config);
+    let (consumed, output, err) = zlib_rs::inflate::uncompress2(output, input, config);
 
+    *sourceLen -= consumed as c_ulong;
     *destLen = output.len() as c_ulong;
 
     err as c_int

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

@@ -1069,23 +1069,27 @@ fn hello_world_uncompressed() {
 fn copy_direct_from_next_in_to_next_out() {
     assert_eq_rs_ng!({
         let input = [120, 1, 1, 2, 0, 253, 255, 6, 10, 0, 24, 0, 17];
+        let output = [6u8, 10];
         let mut dest_vec = vec![0u8; 1 << 16];
 
         let mut dest_len = dest_vec.len() as c_ulong;
         let dest = dest_vec.as_mut_ptr();
 
         let source = input.as_ptr();
-        let source_len = input.len() as _;
+        let mut source_len = input.len() as c_ulong;
 
-        let err = unsafe { uncompress(dest, &mut dest_len, source, source_len) };
+        let err = unsafe { uncompress2(dest, &mut dest_len, source, &mut source_len) };
 
         if err != 0 {
             panic!("error {:?}", ReturnCode::from(err));
         }
 
+        assert_eq!(dest_len as usize, output.len());
+        assert_eq!(source_len as usize, input.len());
+
         dest_vec.truncate(dest_len as usize);
 
-        assert_eq!(String::from_utf8(dest_vec).unwrap(), "\u{6}\n");
+        assert_eq!(dest_vec, output);
     });
 }
 

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

@@ -45,6 +45,14 @@ macro_rules! assert_eq_rs_ng {
                     dictLength: *mut core::ffi::c_uint,
                 ) -> core::ffi::c_int;
 
+                #[allow(unused)]
+                fn uncompress2(
+                    dest: *mut u8,
+                    destLen: *mut core::ffi::c_ulong,
+                    source: *const u8,
+                    sourceLen: *mut core::ffi::c_ulong,
+                ) -> core::ffi::c_int;
+
                 #[allow(unused)]
                 fn crc32_z(
                     crc: core::ffi::c_ulong,

zlib-rs/src/inflate.rs

@@ -172,6 +172,15 @@ pub fn uncompress<'a>(
     input: &[u8],
     config: InflateConfig,
 ) -> (&'a mut [u8], ReturnCode) {
+    let (_consumed, output, ret) = uncompress2(output, input, config);
+    (output, ret)
+}
+
+pub fn uncompress2<'a>(
+    output: &'a mut [MaybeUninit<u8>],
+    input: &[u8],
+    config: InflateConfig,
+) -> (u64, &'a mut [u8], ReturnCode) {
     let mut dest_len_ptr = output.len() as z_checksum;
 
     // for detection of incomplete stream when *destLen == 0
@@ -204,14 +213,14 @@ pub fn uncompress<'a>(
 
     let err = init(&mut stream, config);
     if err != ReturnCode::Ok {
-        return (&mut [], err);
+        return (0, &mut [], err);
     }
 
     stream.next_out = dest;
     stream.avail_out = 0;
 
     let Some(stream) = (unsafe { InflateStream::from_stream_mut(&mut stream) }) else {
-        return (&mut [], ReturnCode::StreamError);
+        return (0, &mut [], ReturnCode::StreamError);
     };
 
     let err = loop {
@@ -232,6 +241,7 @@ pub fn uncompress<'a>(
         }
     };
 
+    let consumed = len + u64::from(stream.avail_in);
     if !output.is_empty() {
         dest_len_ptr = stream.total_out;
     } else if stream.total_out != 0 && err == ReturnCode::BufError {
@@ -254,7 +264,7 @@ pub fn uncompress<'a>(
         core::slice::from_raw_parts_mut(output.as_mut_ptr() as *mut u8, dest_len_ptr as usize)
     };
 
-    (output_slice, ret)
+    (consumed, output_slice, ret)
 }
 
 #[derive(Debug, Clone, Copy)]