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