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