1 //! The encoder and decoder of the ZLIB format.
2 //!
3 //! The ZLIB format is defined in [RFC-1950](https://tools.ietf.org/html/rfc1950).
4 //!
5 //! # Examples
6 //! ```
7 //! use std::io::{self, Read};
8 //! use libflate::zlib::Encoder;
9 //! use libflate::non_blocking::zlib::Decoder;
10 //!
11 //! // Encoding
12 //! let mut encoder = Encoder::new(Vec::new()).unwrap();
13 //! io::copy(&mut &b"Hello World!"[..], &mut encoder).unwrap();
14 //! let encoded_data = encoder.finish().into_result().unwrap();
15 //!
16 //! // Decoding
17 //! let mut decoder = Decoder::new(&encoded_data[..]);
18 //! let mut decoded_data = Vec::new();
19 //! decoder.read_to_end(&mut decoded_data).unwrap();
20 //!
21 //! assert_eq!(decoded_data, b"Hello World!");
22 //! ```
23 use crate::checksum;
24 use crate::non_blocking::deflate;
25 use crate::zlib::Header;
26 use std::io::{self, Read};
27 
28 /// ZLIB decoder which supports non-blocking I/O.
29 #[derive(Debug)]
30 pub struct Decoder<R> {
31     header: Option<Header>,
32     reader: deflate::Decoder<R>,
33     adler32: checksum::Adler32,
34     eos: bool,
35 }
36 impl<R: Read> Decoder<R> {
37     /// Makes a new decoder instance.
38     ///
39     /// `inner` is to be decoded ZLIB stream.
40     ///
41     /// # Examples
42     /// ```
43     /// use std::io::Read;
44     /// use libflate::non_blocking::zlib::Decoder;
45     ///
46     /// let encoded_data = [120, 156, 243, 72, 205, 201, 201, 87, 8, 207, 47,
47     ///                     202, 73, 81, 4, 0, 28, 73, 4, 62];
48     ///
49     /// let mut decoder = Decoder::new(&encoded_data[..]);
50     /// let mut buf = Vec::new();
51     /// decoder.read_to_end(&mut buf).unwrap();
52     ///
53     /// assert_eq!(buf, b"Hello World!");
54     /// ```
new(inner: R) -> Self55     pub fn new(inner: R) -> Self {
56         Decoder {
57             header: None,
58             reader: deflate::Decoder::new(inner),
59             adler32: checksum::Adler32::new(),
60             eos: false,
61         }
62     }
63 
64     /// Returns the header of the ZLIB stream.
65     ///
66     /// # Examples
67     /// ```
68     /// use libflate::zlib::CompressionLevel;
69     /// use libflate::non_blocking::zlib::Decoder;
70     ///
71     /// let encoded_data = [120, 156, 243, 72, 205, 201, 201, 87, 8, 207, 47,
72     ///                     202, 73, 81, 4, 0, 28, 73, 4, 62];
73     ///
74     /// let mut decoder = Decoder::new(&encoded_data[..]);
75     /// assert_eq!(decoder.header().unwrap().compression_level(),
76     ///            CompressionLevel::Default);
77     /// ```
header(&mut self) -> io::Result<&Header>78     pub fn header(&mut self) -> io::Result<&Header> {
79         if let Some(ref header) = self.header {
80             Ok(header)
81         } else {
82             let header = self
83                 .reader
84                 .bit_reader_mut()
85                 .transaction(|r| Header::read_from(r.as_inner_mut()))?;
86             self.header = Some(header);
87             self.header()
88         }
89     }
90 
91     /// Returns the immutable reference to the inner stream.
as_inner_ref(&self) -> &R92     pub fn as_inner_ref(&self) -> &R {
93         self.reader.as_inner_ref()
94     }
95 
96     /// Returns the mutable reference to the inner stream.
as_inner_mut(&mut self) -> &mut R97     pub fn as_inner_mut(&mut self) -> &mut R {
98         self.reader.as_inner_mut()
99     }
100 
101     /// Unwraps this `Decoder`, returning the underlying reader.
102     ///
103     /// # Examples
104     /// ```
105     /// use std::io::Cursor;
106     /// use libflate::non_blocking::zlib::Decoder;
107     ///
108     /// let encoded_data = [120, 156, 243, 72, 205, 201, 201, 87, 8, 207, 47,
109     ///                     202, 73, 81, 4, 0, 28, 73, 4, 62];
110     ///
111     /// let decoder = Decoder::new(Cursor::new(&encoded_data));
112     /// assert_eq!(decoder.into_inner().into_inner(), &encoded_data);
113     /// ```
into_inner(self) -> R114     pub fn into_inner(self) -> R {
115         self.reader.into_inner()
116     }
117 }
118 impl<R: Read> Read for Decoder<R> {
read(&mut self, buf: &mut [u8]) -> io::Result<usize>119     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
120         if self.header.is_none() {
121             self.header()?;
122         }
123         if self.eos {
124             Ok(0)
125         } else {
126             let read_size = self.reader.read(buf)?;
127             if read_size == 0 {
128                 let adler32 = self.reader.bit_reader_mut().transaction(|r| {
129                     let mut buf = [0; 4];
130                     r.as_inner_mut()
131                         .read_exact(&mut buf)
132                         .and(Ok(u32::from_be_bytes(buf)))
133                 })?;
134                 self.eos = true;
135                 // checksum verification is skipped during fuzzing
136                 // so that random data from fuzzer can reach actually interesting code
137                 // Compilation flag 'fuzzing' is automatically set by all 3 Rust fuzzers.
138                 if cfg!(not(fuzzing)) && adler32 != self.adler32.value() {
139                     Err(invalid_data_error!(
140                         "Adler32 checksum mismatched: value={}, expected={}",
141                         self.adler32.value(),
142                         adler32
143                     ))
144                 } else {
145                     Ok(0)
146                 }
147             } else {
148                 self.adler32.update(&buf[..read_size]);
149                 Ok(read_size)
150             }
151         }
152     }
153 }
154 
155 #[cfg(test)]
156 mod tests {
157     use super::*;
158     use crate::util::{nb_read_to_end, WouldBlockReader};
159     use crate::zlib::{EncodeOptions, Encoder};
160     use std::io;
161 
decode_all(buf: &[u8]) -> io::Result<Vec<u8>>162     fn decode_all(buf: &[u8]) -> io::Result<Vec<u8>> {
163         let decoder = Decoder::new(WouldBlockReader::new(buf));
164         nb_read_to_end(decoder)
165     }
default_encode(buf: &[u8]) -> io::Result<Vec<u8>>166     fn default_encode(buf: &[u8]) -> io::Result<Vec<u8>> {
167         let mut encoder = Encoder::new(Vec::new()).unwrap();
168         io::copy(&mut &buf[..], &mut encoder).unwrap();
169         encoder.finish().into_result()
170     }
171     macro_rules! assert_encode_decode {
172         ($input:expr) => {{
173             let encoded = default_encode(&$input[..]).unwrap();
174             assert_eq!(decode_all(&encoded).unwrap(), &$input[..]);
175         }};
176     }
177 
178     const DECODE_WORKS_TESTDATA: [u8; 20] = [
179         120, 156, 243, 72, 205, 201, 201, 87, 8, 207, 47, 202, 73, 81, 4, 0, 28, 73, 4, 62,
180     ];
181     #[test]
decode_works()182     fn decode_works() {
183         let encoded = DECODE_WORKS_TESTDATA;
184         let buf = decode_all(&encoded[..]).unwrap();
185         let expected = b"Hello World!";
186         assert_eq!(buf, expected);
187     }
188 
189     #[test]
default_encode_works()190     fn default_encode_works() {
191         let plain = b"Hello World! Hello ZLIB!!";
192         let mut encoder = Encoder::new(Vec::new()).unwrap();
193         io::copy(&mut &plain[..], &mut encoder).unwrap();
194         let encoded = encoder.finish().into_result().unwrap();
195         assert_eq!(decode_all(&encoded).unwrap(), plain);
196     }
197 
198     #[test]
best_speed_encode_works()199     fn best_speed_encode_works() {
200         let plain = b"Hello World! Hello ZLIB!!";
201         let mut encoder =
202             Encoder::with_options(Vec::new(), EncodeOptions::default().fixed_huffman_codes())
203                 .unwrap();
204         io::copy(&mut &plain[..], &mut encoder).unwrap();
205         let encoded = encoder.finish().into_result().unwrap();
206         assert_eq!(decode_all(&encoded).unwrap(), plain);
207     }
208 
209     const RAW_ENCODE_WORKS_EXPECTED: [u8; 23] = [
210         120, 1, 1, 12, 0, 243, 255, 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 28, 73,
211         4, 62,
212     ];
213     #[test]
raw_encode_works()214     fn raw_encode_works() {
215         let plain = b"Hello World!";
216         let mut encoder =
217             Encoder::with_options(Vec::new(), EncodeOptions::new().no_compression()).unwrap();
218         io::copy(&mut &plain[..], &mut encoder).unwrap();
219         let encoded = encoder.finish().into_result().unwrap();
220         let expected = RAW_ENCODE_WORKS_EXPECTED;
221         assert_eq!(encoded, expected);
222         assert_eq!(decode_all(&encoded).unwrap(), plain);
223     }
224 
225     #[test]
test_issue_2()226     fn test_issue_2() {
227         // See: https://github.com/sile/libflate/issues/2
228         assert_encode_decode!([
229             163, 181, 167, 40, 62, 239, 41, 125, 189, 217, 61, 122, 20, 136, 160, 178, 119, 217,
230             217, 41, 125, 189, 97, 195, 101, 47, 170,
231         ]);
232         assert_encode_decode!([
233             162, 58, 99, 211, 7, 64, 96, 36, 57, 155, 53, 166, 76, 14, 238, 66, 66, 148, 154, 124,
234             162, 58, 99, 188, 138, 131, 171, 189, 54, 229, 192, 38, 29, 240, 122, 28,
235         ]);
236         assert_encode_decode!([
237             239, 238, 212, 42, 5, 46, 186, 67, 122, 247, 30, 61, 219, 62, 228, 202, 164, 205, 139,
238             109, 99, 181, 99, 181, 99, 122, 30, 12, 62, 46, 27, 145, 241, 183, 137,
239         ]);
240         assert_encode_decode!([
241             88, 202, 64, 12, 125, 108, 153, 49, 164, 250, 71, 19, 4, 108, 111, 108, 237, 205, 208,
242             77, 217, 100, 118, 49, 10, 64, 12, 125, 51, 202, 69, 67, 181, 146, 86,
243         ]);
244     }
245 }
246