other fuzzers: handle larger inputs

Author: folkertdev

fuzz/fuzz_targets/compress.rs

@@ -3,13 +3,9 @@ use libbz2_rs_sys::BZ_OK;
 use libfuzzer_sys::fuzz_target;
 
 fuzz_target!(|data: String| {
-    let length = 8 * 1024;
-    let mut deflated = vec![0; length as usize];
-    let mut length = length as _;
-    let error = unsafe {
-        test_libbz2_rs_sys::compress_rs(
-            deflated.as_mut_ptr().cast(),
-            &mut length,
+    let (error, deflated) = unsafe {
+        test_libbz2_rs_sys::compress_rs_with_capacity(
+            4096,
             data.as_ptr().cast(),
             data.len() as _,
             9,
@@ -18,8 +14,6 @@ fuzz_target!(|data: String| {
 
     assert_eq!(error, BZ_OK);
 
-    deflated.truncate(length as usize);
-
     let mut output = [0u8; 1 << 10];
     let mut output_len = output.len() as _;
     let error = unsafe {

fuzz/fuzz_targets/decompress_chunked.rs

@@ -35,7 +35,7 @@ fn compress_c(data: &[u8]) -> Vec<u8> {
                 output.resize(output.len() + add_space as usize, 0);
 
                 // If resize() reallocates, it may have moved in memory.
-                stream.next_out = output.as_mut_ptr().cast::<i8>().wrapping_add(used as usize);
+                stream.next_out = output.as_mut_ptr().cast::<i8>().wrapping_add(used);
                 stream.avail_out += add_space;
 
                 continue;

fuzz/fuzz_targets/end_to_end.rs

@@ -23,23 +23,12 @@ fn decompress_help(input: &[u8]) -> Vec<u8> {
 }
 
 fuzz_target!(|data: Vec<u8>| {
-    let mut length = 8 * 1024;
-    let mut deflated = vec![0; length as usize];
-
-    let error = unsafe {
-        test_libbz2_rs_sys::compress_c(
-            deflated.as_mut_ptr().cast(),
-            &mut length,
-            data.as_ptr().cast(),
-            data.len() as _,
-            9,
-        )
+    let (error, deflated) = unsafe {
+        test_libbz2_rs_sys::compress_c_with_capacity(4096, data.as_ptr().cast(), data.len() as _, 9)
     };
 
     assert_eq!(error, BZ_OK);
 
-    deflated.truncate(length as _);
-
     let output = decompress_help(&deflated);
 
     if output != data {

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

@@ -1,6 +1,4 @@
-use core::ffi::c_uint;
-
-use test_libbz2_rs_sys::{compress_c, compress_rs};
+use test_libbz2_rs_sys::{compress_c_with_capacity, compress_rs_with_capacity};
 
 fn main() {
     let mut it = std::env::args();
@@ -14,22 +12,16 @@ 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 { compress_c(dest, &mut dest_len, source, source_len, level) };
+            let (err, dest_vec) =
+                unsafe { compress_c_with_capacity(1 << 18, source, source_len, level) };
 
             if err != 0 {
                 panic!("error {err}");
             }
 
-            dest_vec.truncate(dest_len as usize);
-
             drop(dest_vec)
         }
         "rs" => {
@@ -38,22 +30,16 @@ 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 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 { compress_rs(dest, &mut dest_len, source, source_len, level) };
+            let (err, dest_vec) =
+                unsafe { compress_rs_with_capacity(1 << 18, source, source_len, level) };
 
             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

@@ -141,19 +141,8 @@ fn compress_chunked_input() {
     let chunked = compress_rs_chunked_input(&mut dest_chunked, SAMPLE1_REF, 256).unwrap();
 
     if !cfg!(miri) {
-        let mut dest = vec![0; 1 << 18];
-        let mut dest_len = dest.len() as _;
-        let err = unsafe {
-            compress_c(
-                dest.as_mut_ptr(),
-                &mut dest_len,
-                SAMPLE1_REF.as_ptr(),
-                SAMPLE1_REF.len() as _,
-                9,
-            )
-        };
+        let (err, dest) = unsafe { compress_c(SAMPLE1_REF.as_ptr(), SAMPLE1_REF.len() as _, 9) };
         assert_eq!(err, 0);
-        dest.truncate(dest_len as usize);
 
         assert_eq!(chunked.len(), dest.len());
         assert_eq!(chunked, dest);
@@ -294,19 +283,8 @@ fn compress_chunked_output() {
     let chunked = compress_rs_chunked_input(&mut dest_chunked, SAMPLE1_REF, 256).unwrap();
 
     if !cfg!(miri) {
-        let mut dest = vec![0; 1 << 18];
-        let mut dest_len = dest.len() as _;
-        let err = unsafe {
-            compress_c(
-                dest.as_mut_ptr(),
-                &mut dest_len,
-                SAMPLE1_REF.as_ptr(),
-                SAMPLE1_REF.len() as _,
-                9,
-            )
-        };
+        let (err, dest) = unsafe { compress_c(SAMPLE1_REF.as_ptr(), SAMPLE1_REF.len() as _, 9) };
         assert_eq!(err, 0);
-        dest.truncate(dest_len as usize);
 
         assert_eq!(chunked.len(), dest.len());
         assert_eq!(chunked, dest);
@@ -317,20 +295,9 @@ fn compress_chunked_output() {
 fn fuzzer_short() {
     const INPUT: &[u8] = &[0, 0, 67, 0, 67, 0, 0, 5, 0, 0];
 
-    let mut dest = [0u8; 256];
-    let mut len = dest.len() as u32;
-    unsafe {
-        compress_c(
-            dest.as_mut_ptr(),
-            &mut len,
-            INPUT.as_ptr(),
-            INPUT.len() as u32,
-            1,
-        );
-    }
-
-    let input = &dest[..len as usize];
+    let (err, input) = unsafe { compress_c(INPUT.as_ptr(), INPUT.len() as u32, 1) };
+    assert_eq!(err, 0);
 
     let mut dest_chunked = vec![0; 1 << 18];
-    let _ = decompress_rs_chunked_input(&mut dest_chunked, input, 6).unwrap();
+    let _ = decompress_rs_chunked_input(&mut dest_chunked, &input, 6).unwrap();
 }