1 use super::symbol;
2 use crate::bit;
3 use crate::lz77;
4 use std::io;
5 use std::io::Read;
6 
7 /// DEFLATE decoder.
8 #[derive(Debug)]
9 pub struct Decoder<R> {
10     bit_reader: bit::BitReader<R>,
11     lz77_decoder: lz77::Lz77Decoder,
12     eos: bool,
13 }
14 impl<R> Decoder<R>
15 where
16     R: Read,
17 {
18     /// Makes a new decoder instance.
19     ///
20     /// `inner` is to be decoded DEFLATE stream.
21     ///
22     /// # Examples
23     /// ```
24     /// use std::io::{Cursor, Read};
25     /// use libflate::deflate::Decoder;
26     ///
27     /// let encoded_data = [243, 72, 205, 201, 201, 87, 8, 207, 47, 202, 73, 81, 4, 0];
28     /// let mut decoder = Decoder::new(&encoded_data[..]);
29     /// let mut buf = Vec::new();
30     /// decoder.read_to_end(&mut buf).unwrap();
31     ///
32     /// assert_eq!(buf, b"Hello World!");
33     /// ```
34     pub fn new(inner: R) -> Self {
35         Decoder {
36             bit_reader: bit::BitReader::new(inner),
37             lz77_decoder: lz77::Lz77Decoder::new(),
38             eos: false,
39         }
40     }
41 
42     /// Returns the immutable reference to the inner stream.
43     pub fn as_inner_ref(&self) -> &R {
44         self.bit_reader.as_inner_ref()
45     }
46 
47     /// Returns the mutable reference to the inner stream.
48     pub fn as_inner_mut(&mut self) -> &mut R {
49         self.bit_reader.as_inner_mut()
50     }
51 
52     /// Unwraps this `Decoder`, returning the underlying reader.
53     ///
54     /// # Examples
55     /// ```
56     /// use std::io::Cursor;
57     /// use libflate::deflate::Decoder;
58     ///
59     /// let encoded_data = [243, 72, 205, 201, 201, 87, 8, 207, 47, 202, 73, 81, 4, 0];
60     /// let decoder = Decoder::new(Cursor::new(&encoded_data));
61     /// assert_eq!(decoder.into_inner().into_inner(), &encoded_data);
62     /// ```
63     pub fn into_inner(self) -> R {
64         self.bit_reader.into_inner()
65     }
66 
67     pub(crate) fn reset(&mut self) {
68         self.bit_reader.reset();
69         self.lz77_decoder.clear();
70         self.eos = false
71     }
72 
73     fn read_non_compressed_block(&mut self) -> io::Result<()> {
74         self.bit_reader.reset();
75         let mut buf = [0; 2];
76         self.bit_reader.as_inner_mut().read_exact(&mut buf)?;
77         let len = u16::from_le_bytes(buf);
78         self.bit_reader.as_inner_mut().read_exact(&mut buf)?;
79         let nlen = u16::from_le_bytes(buf);
80         if !len != nlen {
81             Err(invalid_data_error!(
82                 "LEN={} is not the one's complement of NLEN={}",
83                 len,
84                 nlen
85             ))
86         } else {
87             self.lz77_decoder
88                 .extend_from_reader(self.bit_reader.as_inner_mut().take(len.into()))
89                 .and_then(|used| {
90                     if used != len.into() {
91                         Err(io::Error::new(
92                             io::ErrorKind::UnexpectedEof,
93                             format!(
94                                 "The reader has incorrect length: expected {}, read {}",
95                                 len, used
96                             ),
97                         ))
98                     } else {
99                         Ok(())
100                     }
101                 })
102         }
103     }
104     fn read_compressed_block<H>(&mut self, huffman: &H) -> io::Result<()>
105     where
106         H: symbol::HuffmanCodec,
107     {
108         let symbol_decoder = huffman.load(&mut self.bit_reader)?;
109         loop {
110             let s = symbol_decoder.decode_unchecked(&mut self.bit_reader);
111             self.bit_reader.check_last_error()?;
112             match s {
113                 symbol::Symbol::Code(code) => {
114                     self.lz77_decoder.decode(code)?;
115                 }
116                 symbol::Symbol::EndOfBlock => {
117                     break;
118                 }
119             }
120         }
121         Ok(())
122     }
123 }
124 impl<R> Read for Decoder<R>
125 where
126     R: Read,
127 {
128     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
129         if !self.lz77_decoder.buffer().is_empty() {
130             self.lz77_decoder.read(buf)
131         } else if self.eos {
132             Ok(0)
133         } else {
134             let bfinal = self.bit_reader.read_bit()?;
135             let btype = self.bit_reader.read_bits(2)?;
136             self.eos = bfinal;
137             match btype {
138                 0b00 => {
139                     self.read_non_compressed_block()?;
140                     self.read(buf)
141                 }
142                 0b01 => {
143                     self.read_compressed_block(&symbol::FixedHuffmanCodec)?;
144                     self.read(buf)
145                 }
146                 0b10 => {
147                     self.read_compressed_block(&symbol::DynamicHuffmanCodec)?;
148                     self.read(buf)
149                 }
150                 0b11 => Err(invalid_data_error!(
151                     "btype 0x11 of DEFLATE is reserved(error) value"
152                 )),
153                 _ => unreachable!(),
154             }
155         }
156     }
157 }
158 
159 #[cfg(test)]
160 mod tests {
161     use super::*;
162     use crate::deflate::symbol::{DynamicHuffmanCodec, HuffmanCodec};
163     use std::io;
164 
165     #[test]
166     fn test_issues_3() {
167         // see: https://github.com/sile/libflate/issues/3
168         let input = [
169             180, 253, 73, 143, 28, 201, 150, 46, 8, 254, 150, 184, 139, 75, 18, 69, 247, 32, 157,
170             51, 27, 141, 132, 207, 78, 210, 167, 116, 243, 160, 223, 136, 141, 66, 205, 76, 221,
171             76, 195, 213, 84, 236, 234, 224, 78, 227, 34, 145, 221, 139, 126, 232, 69, 173, 170,
172             208, 192, 219, 245, 67, 3, 15, 149, 120, 171, 70, 53, 106, 213, 175, 23, 21, 153, 139,
173             254, 27, 249, 75, 234, 124, 71, 116, 56, 71, 68, 212, 204, 121, 115, 64, 222, 160, 203,
174             119, 142, 170, 169, 138, 202, 112, 228, 140, 38,
175         ];
176         let mut bit_reader = crate::bit::BitReader::new(&input[..]);
177         assert_eq!(bit_reader.read_bit().unwrap(), false); // not final block
178         assert_eq!(bit_reader.read_bits(2).unwrap(), 0b10); // DynamicHuffmanCodec
179         DynamicHuffmanCodec.load(&mut bit_reader).unwrap();
180     }
181 
182     #[test]
183     fn it_works() {
184         let input = [
185             180, 253, 73, 143, 28, 201, 150, 46, 8, 254, 150, 184, 139, 75, 18, 69, 247, 32, 157,
186             51, 27, 141, 132, 207, 78, 210, 167, 116, 243, 160, 223, 136, 141, 66, 205, 76, 221,
187             76, 195, 213, 84, 236, 234, 224, 78, 227, 34, 145, 221, 139, 126, 232, 69, 173, 170,
188             208, 192, 219, 245, 67, 3, 15, 149, 120, 171, 70, 53, 106, 213, 175, 23, 21, 153, 139,
189             254, 27, 249, 75, 234, 124, 71, 116, 56, 71, 68, 212, 204, 121, 115, 64, 222, 160, 203,
190             119, 142, 170, 169, 138, 202, 112, 228, 140, 38, 171, 162, 88, 212, 235, 56, 136, 231,
191             233, 239, 113, 249, 163, 252, 16, 42, 138, 49, 226, 108, 73, 28, 153,
192         ];
193         let mut decoder = Decoder::new(&input[..]);
194 
195         let result = io::copy(&mut decoder, &mut io::sink());
196         assert!(result.is_err());
197 
198         let error = result.err().unwrap();
199         assert_eq!(error.kind(), io::ErrorKind::InvalidData);
200         assert!(error.to_string().starts_with("Too long backword reference"));
201     }
202 }
203