1 // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! Simple [DEFLATE][def]-based compression. This is a wrapper around the
12 //! [`miniz`][mz] library, which is a one-file pure-C implementation of zlib.
14 //! [def]: https://en.wikipedia.org/wiki/DEFLATE
15 //! [mz]: https://code.google.com/p/miniz/
17 // Do not remove on snapshot creation. Needed for bootstrap. (Issue #22364)
18 #![cfg_attr(stage0, feature(custom_attribute))]
19 #![crate_name = "flate"]
20 #![unstable(feature = "rustc_private", issue = "27812")]
22 #![crate_type = "rlib"]
23 #![crate_type = "dylib"]
24 #![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
25 html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
26 html_root_url = "https://doc.rust-lang.org/nightly/")]
29 #![feature(staged_api)]
31 #![cfg_attr(test, feature(rustc_private, rand, vec_push_all))]
32 #![cfg_attr(stage0, allow(improper_ctypes))]
40 use libc::{c_void, size_t, c_int};
46 #[derive(Clone, Eq, Hash, Ord, PartialEq, PartialOrd)]
57 impl fmt::Debug for Error {
58 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
59 "decompression error".fmt(f)
68 impl Deref for Bytes {
70 fn deref(&self) -> &[u8] {
71 unsafe { slice::from_raw_parts(*self.ptr, self.len) }
78 libc::free(*self.ptr as *mut _);
83 #[link(name = "miniz", kind = "static")]
85 /// Raw miniz compression function.
86 fn tdefl_compress_mem_to_heap(psrc_buf: *const c_void,
88 pout_len: *mut size_t,
92 /// Raw miniz decompression function.
93 fn tinfl_decompress_mem_to_heap(psrc_buf: *const c_void,
95 pout_len: *mut size_t,
100 const LZ_NORM: c_int = 0x80; // LZ with 128 probes, "normal"
101 const TINFL_FLAG_PARSE_ZLIB_HEADER: c_int = 0x1; // parse zlib header and adler32 checksum
102 const TDEFL_WRITE_ZLIB_HEADER: c_int = 0x01000; // write zlib header and adler32 checksum
104 fn deflate_bytes_internal(bytes: &[u8], flags: c_int) -> Bytes {
106 let mut outsz: size_t = 0;
107 let res = tdefl_compress_mem_to_heap(bytes.as_ptr() as *const _,
108 bytes.len() as size_t,
111 assert!(!res.is_null());
113 ptr: Unique::new(res as *mut u8),
119 /// Compress a buffer, without writing any sort of header on the output.
120 pub fn deflate_bytes(bytes: &[u8]) -> Bytes {
121 deflate_bytes_internal(bytes, LZ_NORM)
124 /// Compress a buffer, using a header that zlib can understand.
125 pub fn deflate_bytes_zlib(bytes: &[u8]) -> Bytes {
126 deflate_bytes_internal(bytes, LZ_NORM | TDEFL_WRITE_ZLIB_HEADER)
129 fn inflate_bytes_internal(bytes: &[u8], flags: c_int) -> Result<Bytes, Error> {
131 let mut outsz: size_t = 0;
132 let res = tinfl_decompress_mem_to_heap(bytes.as_ptr() as *const _,
133 bytes.len() as size_t,
138 ptr: Unique::new(res as *mut u8),
147 /// Decompress a buffer, without parsing any sort of header on the input.
148 pub fn inflate_bytes(bytes: &[u8]) -> Result<Bytes, Error> {
149 inflate_bytes_internal(bytes, 0)
152 /// Decompress a buffer that starts with a zlib header.
153 pub fn inflate_bytes_zlib(bytes: &[u8]) -> Result<Bytes, Error> {
154 inflate_bytes_internal(bytes, TINFL_FLAG_PARSE_ZLIB_HEADER)
159 #![allow(deprecated)]
160 use super::{inflate_bytes, deflate_bytes};
161 use std::__rand::{thread_rng, Rng};
164 fn test_flate_round_trip() {
165 let mut r = thread_rng();
166 let mut words = vec![];
168 let range = r.gen_range(1, 10);
169 let v = r.gen_iter::<u8>().take(range).collect::<Vec<u8>>();
173 let mut input = vec![];
175 input.push_all(r.choose(&words).unwrap());
177 debug!("de/inflate of {} bytes of random word-sequences",
179 let cmp = deflate_bytes(&input);
180 let out = inflate_bytes(&cmp).unwrap();
181 debug!("{} bytes deflated to {} ({:.1}% size)",
184 100.0 * ((cmp.len() as f64) / (input.len() as f64)));
185 assert_eq!(&*input, &*out);
190 fn test_zlib_flate() {
191 let bytes = vec![1, 2, 3, 4, 5];
192 let deflated = deflate_bytes(&bytes);
193 let inflated = inflate_bytes(&deflated).unwrap();
194 assert_eq!(&*inflated, &*bytes);