libdeflate_sys/
lib.rs

1#![allow(non_upper_case_globals)]
2#![allow(non_camel_case_types)]
3#![allow(non_snake_case)]
4#![allow(dead_code)]
5#![allow(bad_style)]
6
7#[repr(C)]
8pub struct libdeflate_compressor { _unused : [ u8 ; 0 ] , }
9#[repr(C)]
10pub struct libdeflate_decompressor { _unused : [ u8 ; 0 ] , }
11
12#[repr(C)]
13pub struct libdeflate_options {
14    pub sizeof_options: usize,
15    pub malloc_func: Option<unsafe extern "C" fn(arg1: usize) -> *mut ::std::os::raw::c_void>,
16    pub free_func: Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
17}
18
19pub const libdeflate_result_LIBDEFLATE_SUCCESS: libdeflate_result = 0;
20pub const libdeflate_result_LIBDEFLATE_BAD_DATA: libdeflate_result = 1;
21pub const libdeflate_result_LIBDEFLATE_SHORT_OUTPUT: libdeflate_result = 2;
22pub const libdeflate_result_LIBDEFLATE_INSUFFICIENT_SPACE: libdeflate_result = 3;
23pub type libdeflate_result = ::std::os::raw::c_uint;
24
25extern "C" {
26    pub fn libdeflate_alloc_decompressor() -> *mut libdeflate_decompressor;
27    pub fn libdeflate_alloc_decompressor_ex(options: *const libdeflate_options) -> *mut libdeflate_decompressor;
28    pub fn libdeflate_free_decompressor(decompressor: *mut libdeflate_decompressor);
29
30    pub fn libdeflate_gzip_decompress(decompressor: *mut libdeflate_decompressor,
31                                      in_: *const ::std::os::raw::c_void,
32                                      in_nbytes: usize ,
33                                      out: *mut ::std::os::raw::c_void,
34                                      out_nbytes_avail: usize,
35                                      actual_out_nbytes_ret: *mut usize) -> libdeflate_result;
36
37    pub fn libdeflate_gzip_decompress_ex(decompressor: *mut libdeflate_decompressor,
38                                         in_: *const ::std::os::raw::c_void,
39                                         in_nbytes: usize,
40                                         out: *mut ::std::os::raw::c_void,
41                                         out_nbytes_avail: usize,
42                                         actual_in_nbytes_ret: *mut usize,
43                                         actual_out_nbytes_ret: *mut usize) -> libdeflate_result;
44
45    pub fn libdeflate_zlib_decompress(decompressor: *mut libdeflate_decompressor,
46                                      in_: *const ::std::os::raw::c_void,
47                                      in_nbytes: usize,
48                                      out: *mut ::std::os::raw::c_void,
49                                      out_nbytes_avail: usize,
50                                      actual_out_nbytes_ret: *mut usize) -> libdeflate_result;
51
52    pub fn libdeflate_zlib_decompress_ex(decompressor: *mut libdeflate_decompressor,
53                                         in_: *const ::std::os::raw::c_void,
54                                         in_nbytes: usize,
55                                         out: *mut ::std::os::raw::c_void,
56                                         out_nbytes_avail: usize,
57                                         actual_in_nbytes_ret: *mut usize,
58                                         actual_out_nbytes_ret: *mut usize) -> libdeflate_result;
59
60    pub fn libdeflate_deflate_decompress(decompressor: *mut libdeflate_decompressor,
61                                         in_: *const ::std::os::raw::c_void,
62                                         in_nbytes: usize,
63                                         out: *mut ::std::os::raw::c_void,
64                                         out_nbytes_avail: usize,
65                                         actual_out_nbytes_ret: *mut usize) -> libdeflate_result;
66    
67    pub fn libdeflate_deflate_decompress_ex(decompressor: *mut libdeflate_decompressor, 
68                                            in_: *const ::std::os::raw::c_void,
69                                            in_nbytes: usize,
70                                            out: *mut ::std::os::raw::c_void,
71                                            out_nbytes_avail: usize,
72                                            actual_in_nbytes_ret: *mut usize,
73                                            actual_out_nbytes_ret: *mut usize) -> libdeflate_result;
74
75    pub fn libdeflate_alloc_compressor(compression_level: ::std::os::raw::c_int) -> *mut libdeflate_compressor;
76    
77    pub fn libdeflate_alloc_compressor_ex(compression_level: ::std::ffi::c_int,
78                                          options: *const libdeflate_options) -> *mut libdeflate_compressor;
79
80    pub fn libdeflate_deflate_compress_bound(compressor: *mut libdeflate_compressor,
81                                             in_nbytes: usize) -> usize;
82
83
84    pub fn libdeflate_deflate_compress(compressor: *mut libdeflate_compressor,
85                                       in_: *const ::std::os::raw::c_void,
86                                       in_nbytes: usize,
87                                       out: *mut ::std::os::raw::c_void,
88                                       out_nbytes_avail: usize) -> usize;
89
90    pub fn libdeflate_zlib_compress_bound(compressor: *mut libdeflate_compressor,
91                                          in_nbytes: usize) -> usize;
92
93    pub fn libdeflate_zlib_compress(compressor: *mut libdeflate_compressor,
94                                    in_: *const ::std::os::raw::c_void,
95                                    in_nbytes: usize,
96                                    out: *mut ::std::os::raw::c_void,
97                                    out_nbytes_avail: usize) -> usize;
98
99    pub fn libdeflate_gzip_compress_bound(compressor: *mut libdeflate_compressor,
100                                          in_nbytes: usize) -> usize;
101
102    pub fn libdeflate_gzip_compress(compressor: *mut libdeflate_compressor,
103                                    in_: *const ::std::os::raw::c_void,
104                                    in_nbytes: usize,
105                                    out: *mut ::std::os::raw::c_void,
106                                    out_nbytes_avail: usize ) -> usize;
107
108    pub fn libdeflate_free_compressor (compressor : * mut libdeflate_compressor);
109
110    pub fn libdeflate_crc32(crc32: u32,
111                            buffer: *const ::std::os::raw::c_void,
112                            len: usize) -> u32;
113
114    pub fn libdeflate_adler32(adler32: u32,
115                              buffer: *const ::std::os::raw::c_void,
116                              len: usize) -> u32;
117
118    pub fn libdeflate_set_memory_allocator(malloc_func: unsafe extern "C" fn(size: usize) -> *mut ::std::os::raw::c_void,
119                                           free_func: unsafe extern "C" fn(ptr: *mut ::std::os::raw::c_void));
120}
121
122// Basic tests for Rust-to-C bindings. These tests are just for quick
123// internal checks to make sure that the bindgen build script built
124// something sane-looking. User-facing tests are in `tests/`
125#[cfg(test)]
126mod tests {
127    use super::*;
128
129    const MIN_COMP_LVL: i32 = 0;
130    const MAX_COMP_LVL: i32 = 12;
131
132    #[test]
133    fn can_make_decompressor_at_each_compression_lvl() {
134        unsafe {
135            for lvl in MIN_COMP_LVL..MAX_COMP_LVL+1 {
136                let ptr = libdeflate_alloc_compressor(lvl);
137
138                assert!(!ptr.is_null());
139
140                libdeflate_free_compressor(ptr);
141            }
142        }
143    }
144
145    #[test]
146    fn can_make_decompressor_with_null_malloc_free() {
147        unsafe {
148            let options = libdeflate_options {
149                sizeof_options: std::mem::size_of::<libdeflate_options>(),
150                malloc_func: None,
151                free_func: None,
152            };
153            let ptr = libdeflate_alloc_decompressor_ex(&options);
154
155            assert!(!ptr.is_null());
156
157            libdeflate_free_decompressor(ptr);
158        }
159    }
160
161    #[test]
162    fn making_compressor_with_negative_compression_lvl_fails() {
163        unsafe {
164            let ptr = libdeflate_alloc_compressor(-1);
165            assert!(ptr.is_null());
166        }
167    }
168
169    #[test]
170    fn making_compressor_with_too_large_compression_lvl_fails() {
171        unsafe {
172            let ptr = libdeflate_alloc_compressor(MAX_COMP_LVL+1);
173
174            assert!(ptr.is_null());
175        }
176    }
177
178    #[test]
179    fn can_use_compressor_to_compress_trivially_compressable_data() {
180        unsafe {
181            let in_data: [u8; 1<<16] = [0; 1<<16];
182            let mut out_data: [u8; 1<<16] = [0; 1<<16];
183            let compressor = libdeflate_alloc_compressor(MAX_COMP_LVL);
184            let sz = libdeflate_deflate_compress(compressor,
185                                                 in_data.as_ptr() as *const core::ffi::c_void,
186                                                 in_data.len(),
187                                                 out_data.as_mut_ptr() as *mut core::ffi::c_void,
188                                                 out_data.len());
189            assert_ne!(sz, 0);
190            assert!(sz < 100);
191        }
192    }
193
194    #[test]
195    fn can_call_crc32() {
196        let init = 0;
197        let buf: [u8; 4] = [0x31, 0x33, 0x33, 0x37];
198
199        unsafe {
200            let ret = libdeflate_crc32(init,
201                                       buf.as_ptr() as *const core::ffi::c_void,
202                                       buf.len());
203
204            assert_ne!(ret, init);
205        }
206    }
207
208    #[test]
209    fn can_call_adler32() {
210        let init = 0;
211        let buf: [u8; 4] = [0x31, 0x33, 0x33, 0x37];
212
213        unsafe {
214            let ret = libdeflate_adler32(init,
215                                         buf.as_ptr() as *const core::ffi::c_void,
216                                         buf.len());
217
218            assert_ne!(ret, init);
219        }
220    }
221}
libdeflate_sys/lib.rs

libdeflate_sys/
lib.rs
