make decompression able to handle larger inputs

Author: folkertdev

fuzz/fuzz_targets/compress.rs

@@ -14,18 +14,14 @@ fuzz_target!(|data: String| {
 
     assert_eq!(error, BZ_OK);
 
-    let mut output = [0u8; 1 << 10];
-    let mut output_len = output.len() as _;
-    let error = unsafe {
-        test_libbz2_rs_sys::decompress_rs(
-            output.as_mut_ptr(),
-            &mut output_len,
+    let (error, output) = unsafe {
+        test_libbz2_rs_sys::decompress_rs_with_capacity(
+            1 << 10,
             deflated.as_ptr(),
             deflated.len() as _,
         )
     };
     assert_eq!(error, BZ_OK);
-    let output = &output[..output_len as usize];
 
     if output != data.as_bytes() {
         let path = std::env::temp_dir().join("compressed.txt");

fuzz/fuzz_targets/decompress_random_input.rs

@@ -3,36 +3,17 @@ use libbz2_rs_sys::BZ_OK;
 use libfuzzer_sys::fuzz_target;
 
 fuzz_target!(|source: Vec<u8>| {
-    let mut dest_c = vec![0u8; 1 << 16];
-    let mut dest_rs = vec![0u8; 1 << 16];
-
-    let mut dest_len_c = dest_c.len() as _;
-    let mut dest_len_rs = dest_rs.len() as _;
-
-    let err_c = unsafe {
-        test_libbz2_rs_sys::decompress_c(
-            dest_c.as_mut_ptr(),
-            &mut dest_len_c,
-            source.as_ptr(),
-            source.len() as _,
-        )
+    let (err_c, dest_c) = unsafe {
+        test_libbz2_rs_sys::decompress_c_with_capacity(1 << 16, source.as_ptr(), source.len() as _)
     };
 
-    let err_rs = unsafe {
-        test_libbz2_rs_sys::decompress_rs(
-            dest_rs.as_mut_ptr(),
-            &mut dest_len_rs,
-            source.as_ptr(),
-            source.len() as _,
-        )
+    let (err_rs, dest_rs) = unsafe {
+        test_libbz2_rs_sys::decompress_rs_with_capacity(1 << 16, source.as_ptr(), source.len() as _)
     };
 
     assert_eq!(err_c, err_rs);
 
     if err_c == BZ_OK {
-        dest_c.truncate(dest_len_c as usize);
-        dest_rs.truncate(dest_len_rs as usize);
-
         assert_eq!(dest_c, dest_rs);
     }
 });

fuzz/fuzz_targets/end_to_end.rs

@@ -3,22 +3,16 @@ use libbz2_rs_sys::BZ_OK;
 use libfuzzer_sys::fuzz_target;
 
 fn decompress_help(input: &[u8]) -> Vec<u8> {
-    let mut dest_vec = vec![0u8; 1 << 16];
-
-    let mut dest_len = dest_vec.len() as _;
-    let dest = dest_vec.as_mut_ptr();
-
     let source = input.as_ptr();
     let source_len = input.len() as _;
 
-    let err = unsafe { test_libbz2_rs_sys::decompress_rs(dest, &mut dest_len, source, source_len) };
+    let (err, dest_vec) =
+        unsafe { test_libbz2_rs_sys::decompress_rs_with_capacity(1 << 16, source, source_len) };
 
     if err != BZ_OK {
         panic!("error {:?}", err);
     }
 
-    dest_vec.truncate(dest_len as usize);
-
     dest_vec
 }
 

test-libbz2-rs-sys/examples/decompress.rs

@@ -1,6 +1,4 @@
-use core::ffi::c_uint;
-
-use test_libbz2_rs_sys::{decompress_c, decompress_rs};
+use test_libbz2_rs_sys::{decompress_c_with_capacity, decompress_rs_with_capacity};
 
 fn main() {
     let mut it = std::env::args();
@@ -12,44 +10,32 @@ fn main() {
             let path = it.next().unwrap();
             let input = std::fs::read(&path).unwrap();
 
-            let mut dest_vec = vec![0u8; 1 << 28];
-
-            let mut dest_len = dest_vec.len() as c_uint;
-            let dest = dest_vec.as_mut_ptr();
-
             let source = input.as_ptr();
             let source_len = input.len() as _;
 
-            let err = unsafe { decompress_c(dest, &mut dest_len, source, source_len) };
+            let (err, dest_vec) =
+                unsafe { decompress_c_with_capacity(1 << 28, source, source_len) };
 
             if err != 0 {
                 panic!("error {err}");
             }
 
-            dest_vec.truncate(dest_len as usize);
-
             drop(dest_vec)
         }
         "rs" => {
             let path = it.next().unwrap();
             let input = std::fs::read(&path).unwrap();
 
-            let mut dest_vec = vec![0u8; 1 << 28];
-
-            let mut dest_len = dest_vec.len() as std::ffi::c_uint;
-            let dest = dest_vec.as_mut_ptr();
-
             let source = input.as_ptr();
             let source_len = input.len() as _;
 
-            let err = unsafe { decompress_rs(dest, &mut dest_len, source, source_len) };
+            let (err, dest_vec) =
+                unsafe { decompress_rs_with_capacity(1 << 28, source, source_len) };
 
             if err != 0 {
                 panic!("error {err}");
             }
 
-            dest_vec.truncate(dest_len as usize);
-
             drop(dest_vec)
         }
         other => panic!("invalid option '{other}', expected one of 'c' or 'rs'"),

test-libbz2-rs-sys/src/chunked.rs

@@ -1,4 +1,4 @@
-use crate::{compress_c, decompress_c, SAMPLE1_BZ2, SAMPLE1_REF};
+use crate::{compress_c, decompress_c, decompress_c_with_capacity, SAMPLE1_BZ2, SAMPLE1_REF};
 
 fn decompress_rs_chunked_input<'a>(
     dest: &'a mut [u8],
@@ -55,18 +55,10 @@ fn decompress_chunked_input() {
     let chunked = decompress_rs_chunked_input(&mut dest_chunked, SAMPLE1_BZ2, 1).unwrap();
 
     if !cfg!(miri) {
-        let mut dest = vec![0; 1 << 18];
-        let mut dest_len = dest.len() as _;
-        let err = unsafe {
-            decompress_c(
-                dest.as_mut_ptr(),
-                &mut dest_len,
-                SAMPLE1_BZ2.as_ptr(),
-                SAMPLE1_BZ2.len() as _,
-            )
+        let (err, dest) = unsafe {
+            decompress_c_with_capacity(1 << 18, SAMPLE1_BZ2.as_ptr(), SAMPLE1_BZ2.len() as _)
         };
         assert_eq!(err, 0);
-        dest.truncate(dest_len as usize);
 
         assert_eq!(chunked.len(), dest.len());
         assert_eq!(chunked, dest);
@@ -201,18 +193,8 @@ fn decompress_rs_chunked_output<'a>(
 
 #[test]
 fn decompress_chunked_output() {
-    let mut dest = vec![0; 1 << 18];
-    let mut dest_len = dest.len() as _;
-    let err = unsafe {
-        decompress_c(
-            dest.as_mut_ptr(),
-            &mut dest_len,
-            SAMPLE1_BZ2.as_ptr(),
-            SAMPLE1_BZ2.len() as _,
-        )
-    };
+    let (err, dest) = unsafe { decompress_c(SAMPLE1_BZ2.as_ptr(), SAMPLE1_BZ2.len() as _) };
     assert_eq!(err, 0);
-    dest.truncate(dest_len as usize);
 
     let mut dest_chunked = vec![0; 1 << 18];
     let chunked = decompress_rs_chunked_input(&mut dest_chunked, SAMPLE1_BZ2, 1).unwrap();