stable api v0

Author: Folkert de Vries

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

@@ -2703,3 +2703,94 @@ fn test_gzip_deflate_config() {
         Some(dest)
     });
 }
+
+mod stable_api {
+    use zlib_rs::{
+        inflate::{uncompress_slice, InflateConfig},
+        DeflateFlush, ReturnCode, Status,
+    };
+
+    #[test]
+    #[should_panic = "StreamError"]
+    fn invalid_config() {
+        zlib_rs::Deflate::new(9000, true, 15);
+    }
+
+    fn with_window_bits(window_bits: i32) {
+        let input = "Hello World!";
+
+        let mut deflate =
+            zlib_rs::Deflate::new(9, window_bits >= 0, window_bits.unsigned_abs() as u8);
+        let mut compressed = [0u8; 64];
+        let ret = deflate.compress(input.as_bytes(), &mut compressed, DeflateFlush::Finish);
+        assert_eq!(ret, Ok(Status::StreamEnd));
+
+        assert_eq!(deflate.total_in() as usize, input.len());
+
+        let compressed = &compressed[..deflate.total_out() as usize];
+        let mut decompressed = [0u8; 64];
+        let (decompressed, ret) =
+            uncompress_slice(&mut decompressed, compressed, InflateConfig { window_bits });
+        assert_eq!(ret, ReturnCode::Ok);
+
+        assert_eq!(decompressed, input.as_bytes());
+    }
+
+    #[test]
+    fn raw() {
+        with_window_bits(-15);
+    }
+
+    #[test]
+    fn zlib_header() {
+        with_window_bits(15);
+    }
+
+    #[test]
+    fn gz_header() {
+        with_window_bits(16 + 15);
+    }
+
+    #[test]
+    fn reset_reuse_stream() {
+        let input1 = "Hello World!";
+        let input2 = "Goodbye World!";
+
+        let mut deflate = zlib_rs::Deflate::new(9, true, 15);
+
+        let mut compressed1 = [0u8; 64];
+        let ret = deflate.compress(input1.as_bytes(), &mut compressed1, DeflateFlush::Finish);
+        assert_eq!(ret, Ok(Status::StreamEnd));
+        assert_eq!(deflate.total_in() as usize, input1.len());
+
+        let compressed1 = &compressed1[..deflate.total_out() as usize];
+
+        deflate.reset();
+
+        let mut compressed2 = [0u8; 64];
+        let ret = deflate.compress(input2.as_bytes(), &mut compressed2, DeflateFlush::Finish);
+        assert_eq!(ret, Ok(Status::StreamEnd));
+        // After reset, total_in should reflect only the second input
+        assert_eq!(deflate.total_in() as usize, input2.len());
+
+        let compressed2 = &compressed2[..deflate.total_out() as usize];
+
+        let mut decompressed1 = [0u8; 64];
+        let (decompressed1, ret) = uncompress_slice(
+            &mut decompressed1,
+            compressed1,
+            InflateConfig { window_bits: 15 },
+        );
+        assert_eq!(ret, ReturnCode::Ok);
+        assert_eq!(decompressed1, input1.as_bytes());
+
+        let mut decompressed2 = [0u8; 64];
+        let (decompressed2, ret) = uncompress_slice(
+            &mut decompressed2,
+            compressed2,
+            InflateConfig { window_bits: 15 },
+        );
+        assert_eq!(ret, ReturnCode::Ok);
+        assert_eq!(decompressed2, input2.as_bytes());
+    }
+}

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

@@ -2404,3 +2404,148 @@ fn test_dict_inflate() {
         assert_eq!(uncompr[..hello.len()], hello);
     });
 }
+
+mod stable_api {
+    use zlib_rs::{
+        deflate::{compress_slice, DeflateConfig},
+        InflateError, ReturnCode,
+    };
+
+    fn with_window_bits(n: i32) {
+        let config = DeflateConfig {
+            window_bits: n,
+            ..DeflateConfig::default()
+        };
+
+        let mut output = [0u8; 64];
+        let input = "Hello World!";
+        let (compressed, ret) = compress_slice(&mut output, input.as_bytes(), config);
+        assert_eq!(ret, ReturnCode::Ok);
+
+        let mut decompressed = [0u8; 64];
+        let mut inflate = zlib_rs::Inflate::new(n >= 0, n.unsigned_abs() as u8);
+        inflate
+            .decompress(compressed, &mut decompressed, zlib_rs::InflateFlush::Finish)
+            .unwrap();
+
+        assert_eq!(inflate.total_in() as usize, compressed.len());
+
+        assert_eq!(
+            &decompressed[..inflate.total_out() as usize],
+            input.as_bytes()
+        );
+    }
+
+    #[test]
+    fn raw() {
+        with_window_bits(-15);
+    }
+
+    #[test]
+    fn zlib_header() {
+        with_window_bits(15);
+    }
+
+    #[test]
+    fn gz_header() {
+        with_window_bits(16 + 15);
+    }
+
+    #[test]
+    #[should_panic = "StreamError"]
+    fn invalid_config() {
+        zlib_rs::Inflate::new(true, 123);
+    }
+
+    #[test]
+    fn invalid_data() {
+        let mut inflate = zlib_rs::Inflate::new(true, 15);
+
+        // Clearly invalid input.
+        let compressed = [0xAA; 64];
+        let mut decompressed = [0u8; 64];
+
+        let ret = inflate.decompress(
+            &compressed,
+            &mut decompressed,
+            zlib_rs::InflateFlush::Finish,
+        );
+
+        assert_eq!(ret, Err(InflateError::DataError));
+    }
+
+    #[test]
+    fn need_dict() {
+        let mut inflate = zlib_rs::Inflate::new(true, 15);
+
+        let compressed = [0x08, 0xb8, 0x0, 0x0, 0x0, 0x1];
+        let mut decompressed = [0u8; 64];
+
+        let ret = inflate.decompress(
+            &compressed,
+            &mut decompressed,
+            zlib_rs::InflateFlush::Finish,
+        );
+
+        assert_eq!(ret, Err(InflateError::NeedDict { dict_id: 1 }));
+    }
+
+    #[test]
+    fn reset_reuse() {
+        let input1 = "Hello World!";
+        let input2 = "Goodbye World!";
+
+        let mut output1 = [0u8; 64];
+        let config1 = DeflateConfig {
+            window_bits: 15,
+            ..DeflateConfig::default()
+        };
+        let (compressed1, ret) = compress_slice(&mut output1, input1.as_bytes(), config1);
+        assert_eq!(ret, ReturnCode::Ok);
+
+        let mut output2 = [0u8; 64];
+        let config2 = DeflateConfig {
+            window_bits: -15,
+            ..DeflateConfig::default()
+        };
+        let (compressed2, ret) = compress_slice(&mut output2, input2.as_bytes(), config2);
+        assert_eq!(ret, ReturnCode::Ok);
+
+        // Start with header enabled.
+        let zlib_header_first = true;
+        let mut inflate = zlib_rs::Inflate::new(zlib_header_first, 15);
+
+        let mut decompressed1 = [0u8; 64];
+        inflate
+            .decompress(
+                compressed1,
+                &mut decompressed1,
+                zlib_rs::InflateFlush::Finish,
+            )
+            .unwrap();
+
+        assert_eq!(inflate.total_in() as usize, compressed1.len());
+        assert_eq!(
+            &decompressed1[..inflate.total_out() as usize],
+            input1.as_bytes()
+        );
+
+        // Reset for a *raw* stream: swap the zlib_header flag.
+        inflate.reset(!zlib_header_first);
+
+        let mut decompressed2 = [0u8; 64];
+        inflate
+            .decompress(
+                compressed2,
+                &mut decompressed2,
+                zlib_rs::InflateFlush::Finish,
+            )
+            .unwrap();
+
+        assert_eq!(inflate.total_in() as usize, compressed2.len());
+        assert_eq!(
+            &decompressed2[..inflate.total_out() as usize],
+            input2.as_bytes()
+        );
+    }
+}

zlib-rs/src/deflate.rs

@@ -121,6 +121,27 @@ impl<'a> DeflateStream<'a> {
             self.state.bit_writer.bits_used,
         )
     }
+
+    pub fn new(level: i32, zlib_header: bool, window_bits: u8) -> Self {
+        let mut inner = crate::c_api::z_stream::default();
+
+        let config = DeflateConfig {
+            window_bits: if zlib_header {
+                i32::from(window_bits)
+            } else {
+                -i32::from(window_bits)
+            },
+            level,
+            method: Method::Deflated,
+            mem_level: DEF_MEM_LEVEL,
+            strategy: Strategy::Default,
+        };
+
+        let ret = crate::deflate::init(&mut inner, config);
+        assert_eq!(ret, ReturnCode::Ok);
+
+        unsafe { core::mem::transmute(inner) }
+    }
 }
 
 /// number of elements in hash table

zlib-rs/src/inflate.rs

@@ -126,6 +126,23 @@ impl<'a> InflateStream<'a> {
         // safety: a valid &mut InflateStream is also a valid &mut z_stream
         unsafe { &mut *(self as *mut _ as *mut z_stream) }
     }
+
+    pub fn new(zlib_header: bool, window_bits: u8) -> Self {
+        let mut inner = crate::c_api::z_stream::default();
+
+        let config = InflateConfig {
+            window_bits: if zlib_header {
+                i32::from(window_bits)
+            } else {
+                -i32::from(window_bits)
+            },
+        };
+
+        let ret = crate::inflate::init(&mut inner, config);
+        assert_eq!(ret, ReturnCode::Ok);
+
+        unsafe { core::mem::transmute(inner) }
+    }
 }
 
 const MAX_BITS: u8 = 15; // maximum number of bits in a code
@@ -2616,7 +2633,7 @@ pub fn set_dictionary(stream: &mut InflateStream, dictionary: &[u8]) -> ReturnCo
     ReturnCode::Ok
 }
 
-pub fn end<'a>(stream: &'a mut InflateStream<'a>) -> &'a mut z_stream {
+pub fn end<'a>(stream: &'a mut InflateStream<'_>) -> &'a mut z_stream {
     let alloc = stream.alloc;
 
     let mut window = Window::empty();

zlib-rs/src/lib.rs

@@ -4,15 +4,19 @@
 #[cfg(any(feature = "rust-allocator", feature = "c-allocator"))]
 extern crate alloc;
 
-mod adler32;
 pub mod allocate;
 pub mod c_api;
-mod cpu_features;
 pub mod crc32;
 pub mod deflate;
 pub mod inflate;
+
+mod adler32;
+mod cpu_features;
+mod stable;
 mod weak_slice;
 
+pub use stable::{Deflate, DeflateError, Inflate, InflateError, Status};
+
 pub use adler32::{adler32, adler32_combine};
 pub use crc32::{crc32, crc32_combine, get_crc_table};
 
@@ -188,7 +192,11 @@ impl From<i32> for ReturnCode {
 }
 
 impl ReturnCode {
-    const fn error_message_str(self) -> &'static str {
+    fn error_message_str(self) -> &'static str {
+        self.error_message_str_with_null().trim_end_matches('\0')
+    }
+
+    const fn error_message_str_with_null(self) -> &'static str {
         match self {
             ReturnCode::Ok => "\0",
             ReturnCode::StreamEnd => "stream end\0",
@@ -203,7 +211,7 @@ impl ReturnCode {
     }
 
     pub const fn error_message(self) -> *const core::ffi::c_char {
-        let msg = self.error_message_str();
+        let msg = self.error_message_str_with_null();
         msg.as_ptr().cast::<core::ffi::c_char>()
     }