libflate/non_blocking/
zlib.rs

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 no_std_io2::io::{Read, Write};
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//! encoder.write_all(b"Hello World!".as_ref()).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//! ```
23use crate::checksum;
24use crate::non_blocking::deflate;
25use crate::zlib::Header;
26use no_std_io2::io::{self, Read};
27
28/// ZLIB decoder which supports non-blocking I/O.
29#[derive(Debug)]
30pub struct Decoder<R> {
31    header: Option<Header>,
32    reader: deflate::Decoder<R>,
33    adler32: checksum::Adler32,
34    eos: bool,
35}
36impl<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 no_std_io2::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    /// ```
55    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    /// ```
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.
92    pub fn as_inner_ref(&self) -> &R {
93        self.reader.as_inner_ref()
94    }
95
96    /// Returns the mutable reference to the inner stream.
97    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 no_std_io2::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    /// ```
114    pub fn into_inner(self) -> R {
115        self.reader.into_inner()
116    }
117}
118impl<R: Read> Read for Decoder<R> {
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)]
156mod tests {
157    use super::*;
158    use crate::util::{WouldBlockReader, nb_read_to_end};
159    use crate::zlib::{EncodeOptions, Encoder};
160    use alloc::vec::Vec;
161    use no_std_io2::io::Write;
162
163    fn decode_all(buf: &[u8]) -> io::Result<Vec<u8>> {
164        let decoder = Decoder::new(WouldBlockReader::new(buf));
165        nb_read_to_end(decoder)
166    }
167    #[cfg(feature = "std")]
168    fn default_encode(buf: &[u8]) -> io::Result<Vec<u8>> {
169        let mut encoder = Encoder::new(Vec::new()).unwrap();
170        encoder.write_all(buf.as_ref()).unwrap();
171        encoder.finish().into_result()
172    }
173    #[cfg(feature = "std")]
174    macro_rules! assert_encode_decode {
175        ($input:expr) => {{
176            let encoded = default_encode(&$input[..]).unwrap();
177            assert_eq!(decode_all(&encoded).unwrap(), &$input[..]);
178        }};
179    }
180
181    const DECODE_WORKS_TESTDATA: [u8; 20] = [
182        120, 156, 243, 72, 205, 201, 201, 87, 8, 207, 47, 202, 73, 81, 4, 0, 28, 73, 4, 62,
183    ];
184    #[test]
185    fn decode_works() {
186        let encoded = DECODE_WORKS_TESTDATA;
187        let buf = decode_all(&encoded[..]).unwrap();
188        let expected = b"Hello World!";
189        assert_eq!(buf, expected);
190    }
191
192    #[test]
193    #[cfg(feature = "std")]
194    fn default_encode_works() {
195        let plain = b"Hello World! Hello ZLIB!!";
196        let mut encoder = Encoder::new(Vec::new()).unwrap();
197        io::copy(&mut &plain[..], &mut encoder).unwrap();
198        let encoded = encoder.finish().into_result().unwrap();
199        assert_eq!(decode_all(&encoded).unwrap(), plain);
200    }
201
202    #[test]
203    #[cfg(feature = "std")]
204    fn best_speed_encode_works() {
205        let plain = b"Hello World! Hello ZLIB!!";
206        let mut encoder =
207            Encoder::with_options(Vec::new(), EncodeOptions::default().fixed_huffman_codes())
208                .unwrap();
209        io::copy(&mut &plain[..], &mut encoder).unwrap();
210        let encoded = encoder.finish().into_result().unwrap();
211        assert_eq!(decode_all(&encoded).unwrap(), plain);
212    }
213
214    const RAW_ENCODE_WORKS_EXPECTED: [u8; 23] = [
215        120, 1, 1, 12, 0, 243, 255, 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 28, 73,
216        4, 62,
217    ];
218    #[test]
219    fn raw_encode_works() {
220        let plain = b"Hello World!";
221        let mut encoder =
222            Encoder::with_options(Vec::new(), EncodeOptions::new().no_compression()).unwrap();
223        encoder.write_all(plain.as_ref()).unwrap();
224        let encoded = encoder.finish().into_result().unwrap();
225        let expected = RAW_ENCODE_WORKS_EXPECTED;
226        assert_eq!(encoded, expected);
227        assert_eq!(decode_all(&encoded).unwrap(), plain);
228    }
229
230    #[test]
231    #[cfg(feature = "std")]
232    fn test_issue_2() {
233        // See: https://github.com/sile/libflate/issues/2
234        assert_encode_decode!([
235            163, 181, 167, 40, 62, 239, 41, 125, 189, 217, 61, 122, 20, 136, 160, 178, 119, 217,
236            217, 41, 125, 189, 97, 195, 101, 47, 170,
237        ]);
238        assert_encode_decode!([
239            162, 58, 99, 211, 7, 64, 96, 36, 57, 155, 53, 166, 76, 14, 238, 66, 66, 148, 154, 124,
240            162, 58, 99, 188, 138, 131, 171, 189, 54, 229, 192, 38, 29, 240, 122, 28,
241        ]);
242        assert_encode_decode!([
243            239, 238, 212, 42, 5, 46, 186, 67, 122, 247, 30, 61, 219, 62, 228, 202, 164, 205, 139,
244            109, 99, 181, 99, 181, 99, 122, 30, 12, 62, 46, 27, 145, 241, 183, 137,
245        ]);
246        assert_encode_decode!([
247            88, 202, 64, 12, 125, 108, 153, 49, 164, 250, 71, 19, 4, 108, 111, 108, 237, 205, 208,
248            77, 217, 100, 118, 49, 10, 64, 12, 125, 51, 202, 69, 67, 181, 146, 86,
249        ]);
250    }
251}
libflate/non_blocking/zlib.rs

libflate/non_blocking/
zlib.rs
