From b2ee991c96698043f922b2b2d2dea77436db7549 Mon Sep 17 00:00:00 2001
From: Justus Winter <justus@sequoia-pgp.org>
Date: Mon, 18 Jun 2018 19:18:56 +0200
Subject: openpgp, buffered-reader: Make compression an optional feature.

  - This helps to reduce the trusted computing base if compression is
    not needed.

  - This makes it easier to fuzz Sequoia, previously the fuzzer was
    doing a great job creating compression bombs that triggered the
    fuzzers timeout.

  - Currently, the cargo workspace feature does not propagate
    --no-default-features, but it is possible to depend on the openpgp
    crate with `default-features = false`.

  - Unfortunately, a lot of test cases include compressed packages.
    This change conditionally disables these tests.
---
 buffered-reader/Cargo.toml                |  12 +-
 buffered-reader/src/decompress.rs         | 411 ------------------------------
 buffered-reader/src/decompress_bzip2.rs   | 118 +++++++++
 buffered-reader/src/decompress_deflate.rs | 299 ++++++++++++++++++++++
 buffered-reader/src/lib.rs                |  16 +-
 5 files changed, 439 insertions(+), 417 deletions(-)
 delete mode 100644 buffered-reader/src/decompress.rs
 create mode 100644 buffered-reader/src/decompress_bzip2.rs
 create mode 100644 buffered-reader/src/decompress_deflate.rs

(limited to 'buffered-reader')

diff --git a/buffered-reader/Cargo.toml b/buffered-reader/Cargo.toml
index 68f4c60d..1702ac97 100644
--- a/buffered-reader/Cargo.toml
+++ b/buffered-reader/Cargo.toml
@@ -4,5 +4,13 @@ version = "0.1.0"
 authors = ["Neal H. Walfield <neal@gnu.org>"]
 
 [dependencies]
-bzip2 = "0.3.2"
-flate2 = "1.0.1"
+bzip2 = { version = "0.3.2", optional = true }
+flate2 = { version = "1.0.1", optional = true }
+
+[features]
+default = ["compression"]
+
+# The compression algorithms.
+compression = ["compression-deflate", "compression-bzip2"]
+compression-deflate = ["flate2"]
+compression-bzip2 = ["bzip2"]
diff --git a/buffered-reader/src/decompress.rs b/buffered-reader/src/decompress.rs
deleted file mode 100644
index 376edd06..00000000
--- a/buffered-reader/src/decompress.rs
+++ /dev/null
@@ -1,411 +0,0 @@
-use std::io;
-use std::fmt;
-
-use flate2::read::DeflateDecoder;
-use flate2::read::ZlibDecoder;
-use bzip2::read::BzDecoder;
-
-use super::*;
-
-pub struct BufferedReaderDeflate<R: BufferedReader<C>, C> {
-    reader: BufferedReaderGeneric<DeflateDecoder<R>, C>,
-}
-
-impl <R: BufferedReader<()>> BufferedReaderDeflate<R, ()> {
-    /// Instantiate a new deflate decompression reader.  `reader` is
-    /// the source to wrap.
-    pub fn new(reader: R) -> Self {
-        Self::with_cookie(reader, ())
-    }
-}
-
-impl <R: BufferedReader<C>, C> BufferedReaderDeflate<R, C> {
-    /// Like `new()`, but sets a cookie, which can be retrieved using
-    /// the `cookie_ref` and `cookie_mut` methods, and set using
-    /// the `cookie_set` method.
-    pub fn with_cookie(reader: R, cookie: C) -> Self {
-        BufferedReaderDeflate {
-            reader: BufferedReaderGeneric::with_cookie(
-                DeflateDecoder::new(reader), None, cookie),
-        }
-    }
-}
-
-impl<R: BufferedReader<C>, C> io::Read for BufferedReaderDeflate<R, C> {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
-        self.reader.read(buf)
-    }
-}
-
-impl <R: BufferedReader<C>, C> fmt::Debug for BufferedReaderDeflate<R, C> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("BufferedReaderDeflate")
-            .field("reader", &self.get_ref().unwrap())
-            .finish()
-    }
-}
-
-impl<R: BufferedReader<C>, C> BufferedReader<C>
-        for BufferedReaderDeflate<R, C> {
-    fn buffer(&self) -> &[u8] {
-        return self.reader.buffer();
-    }
-
-    fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.reader.data(amount);
-    }
-
-    fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.reader.data_hard(amount);
-    }
-
-    fn data_eof(&mut self) -> Result<&[u8], io::Error> {
-        return self.reader.data_eof();
-    }
-
-    fn consume(&mut self, amount: usize) -> &[u8] {
-        return self.reader.consume(amount);
-    }
-
-    fn data_consume(&mut self, amount: usize)
-                    -> Result<&[u8], io::Error> {
-        return self.reader.data_consume(amount);
-    }
-
-    fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.reader.data_consume_hard(amount);
-    }
-
-    fn read_be_u16(&mut self) -> Result<u16, io::Error> {
-        return self.reader.read_be_u16();
-    }
-
-    fn read_be_u32(&mut self) -> Result<u32, io::Error> {
-        return self.reader.read_be_u32();
-    }
-
-    fn steal(&mut self, amount: usize) -> Result<Vec<u8>, io::Error> {
-        return self.reader.steal(amount);
-    }
-
-    fn steal_eof(&mut self) -> Result<Vec<u8>, io::Error> {
-        return self.reader.steal_eof();
-    }
-
-    fn get_mut(&mut self) -> Option<&mut BufferedReader<C>> {
-        Some(self.reader.reader.get_mut())
-    }
-
-    fn get_ref(&self) -> Option<&BufferedReader<C>> {
-        Some(self.reader.reader.get_ref())
-    }
-
-    fn into_inner<'b>(self: Box<Self>)
-            -> Option<Box<BufferedReader<C> + 'b>> where Self: 'b {
-        // Strip the outer box.
-        Some(Box::new(self.reader.reader.into_inner()))
-    }
-
-    fn cookie_set(&mut self, cookie: C) -> C {
-        self.reader.cookie_set(cookie)
-    }
-
-    fn cookie_ref(&self) -> &C {
-        self.reader.cookie_ref()
-    }
-
-    fn cookie_mut(&mut self) -> &mut C {
-        self.reader.cookie_mut()
-    }
-}
-
-pub struct BufferedReaderZlib<R: BufferedReader<C>, C> {
-    reader: BufferedReaderGeneric<ZlibDecoder<R>, C>,
-}
-
-impl <R: BufferedReader<()>> BufferedReaderZlib<R, ()> {
-    /// Instantiate a new zlib decompression reader.  `reader` is
-    /// the source to wrap.
-    pub fn new(reader: R) -> Self {
-        Self::with_cookie(reader, ())
-    }
-}
-
-impl <R: BufferedReader<C>, C> BufferedReaderZlib<R, C> {
-    /// Like `new()`, but sets a cookie, which can be retrieved using
-    /// the `cookie_ref` and `cookie_mut` methods, and set using
-    /// the `cookie_set` method.
-    pub fn with_cookie(reader: R, cookie: C) -> Self {
-        BufferedReaderZlib {
-            reader: BufferedReaderGeneric::with_cookie(
-                ZlibDecoder::new(reader), None, cookie),
-        }
-    }
-}
-
-impl<R: BufferedReader<C>, C> io::Read for BufferedReaderZlib<R, C> {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
-        self.reader.read(buf)
-    }
-}
-
-impl <R: BufferedReader<C>, C> fmt::Debug for BufferedReaderZlib<R, C> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("BufferedReaderZlib")
-            .field("reader", &self.get_ref().unwrap())
-            .finish()
-    }
-}
-
-impl<R: BufferedReader<C>, C> BufferedReader<C>
-        for BufferedReaderZlib<R, C> {
-    fn buffer(&self) -> &[u8] {
-        return self.reader.buffer();
-    }
-
-    fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.reader.data(amount);
-    }
-
-    fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.reader.data_hard(amount);
-    }
-
-    fn data_eof(&mut self) -> Result<&[u8], io::Error> {
-        return self.reader.data_eof();
-    }
-
-    fn consume(&mut self, amount: usize) -> &[u8] {
-        return self.reader.consume(amount);
-    }
-
-    fn data_consume(&mut self, amount: usize)
-                    -> Result<&[u8], io::Error> {
-        return self.reader.data_consume(amount);
-    }
-
-    fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.reader.data_consume_hard(amount);
-    }
-
-    fn read_be_u16(&mut self) -> Result<u16, io::Error> {
-        return self.reader.read_be_u16();
-    }
-
-    fn read_be_u32(&mut self) -> Result<u32, io::Error> {
-        return self.reader.read_be_u32();
-    }
-
-    fn steal(&mut self, amount: usize) -> Result<Vec<u8>, io::Error> {
-        return self.reader.steal(amount);
-    }
-
-    fn steal_eof(&mut self) -> Result<Vec<u8>, io::Error> {
-        return self.reader.steal_eof();
-    }
-
-    fn get_mut(&mut self) -> Option<&mut BufferedReader<C>> {
-        Some(self.reader.reader.get_mut())
-    }
-
-    fn get_ref(&self) -> Option<&BufferedReader<C>> {
-        Some(self.reader.reader.get_ref())
-    }
-
-    fn into_inner<'b>(self: Box<Self>)
-            -> Option<Box<BufferedReader<C> + 'b>> where Self: 'b {
-        // Strip the outer box.
-        Some(Box::new(self.reader.reader.into_inner()))
-    }
-
-    fn cookie_set(&mut self, cookie: C) -> C {
-        self.reader.cookie_set(cookie)
-    }
-
-    fn cookie_ref(&self) -> &C {
-        self.reader.cookie_ref()
-    }
-
-    fn cookie_mut(&mut self) -> &mut C {
-        self.reader.cookie_mut()
-    }
-}
-
-pub struct BufferedReaderBzip<R: BufferedReader<C>, C> {
-    reader: BufferedReaderGeneric<BzDecoder<R>, C>,
-}
-
-impl <R: BufferedReader<()>> BufferedReaderBzip<R, ()> {
-    /// Instantiate a new bzip decompression reader.  `reader` is
-    /// the source to wrap.
-    pub fn new(reader: R) -> Self {
-        Self::with_cookie(reader, ())
-    }
-}
-
-impl <R: BufferedReader<C>, C> BufferedReaderBzip<R, C> {
-    /// Like `new()`, but sets a cookie, which can be retrieved using
-    /// the `cookie_ref` and `cookie_mut` methods, and set using
-    /// the `cookie_set` method.
-    pub fn with_cookie(reader: R, cookie: C) -> Self {
-        BufferedReaderBzip {
-            reader: BufferedReaderGeneric::with_cookie(
-                BzDecoder::new(reader), None, cookie),
-        }
-    }
-}
-
-impl<R: BufferedReader<C>, C> io::Read for BufferedReaderBzip<R, C> {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
-        self.reader.read(buf)
-    }
-}
-
-impl <R: BufferedReader<C>, C> fmt::Debug for BufferedReaderBzip<R, C> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("BufferedReaderBzip")
-            .field("reader", &self.get_ref().unwrap())
-            .finish()
-    }
-}
-
-impl<R: BufferedReader<C>, C> BufferedReader<C> for BufferedReaderBzip<R, C> {
-    fn buffer(&self) -> &[u8] {
-        return self.reader.buffer();
-    }
-
-    fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.reader.data(amount);
-    }
-
-    fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.reader.data_hard(amount);
-    }
-
-    fn data_eof(&mut self) -> Result<&[u8], io::Error> {
-        return self.reader.data_eof();
-    }
-
-    fn consume(&mut self, amount: usize) -> &[u8] {
-        return self.reader.consume(amount);
-    }
-
-    fn data_consume(&mut self, amount: usize)
-                    -> Result<&[u8], io::Error> {
-        return self.reader.data_consume(amount);
-    }
-
-    fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
-        return self.reader.data_consume_hard(amount);
-    }
-
-    fn read_be_u16(&mut self) -> Result<u16, io::Error> {
-        return self.reader.read_be_u16();
-    }
-
-    fn read_be_u32(&mut self) -> Result<u32, io::Error> {
-        return self.reader.read_be_u32();
-    }
-
-    fn steal(&mut self, amount: usize) -> Result<Vec<u8>, io::Error> {
-        return self.reader.steal(amount);
-    }
-
-    fn steal_eof(&mut self) -> Result<Vec<u8>, io::Error> {
-        return self.reader.steal_eof();
-    }
-
-    fn get_mut(&mut self) -> Option<&mut BufferedReader<C>> {
-        Some(self.reader.reader.get_mut())
-    }
-
-    fn get_ref(&self) -> Option<&BufferedReader<C>> {
-        Some(self.reader.reader.get_ref())
-    }
-
-    fn into_inner<'b>(self: Box<Self>)
-            -> Option<Box<BufferedReader<C> + 'b>> where Self: 'b {
-        // Strip the outer box.
-        Some(Box::new(self.reader.reader.into_inner()))
-    }
-
-    fn cookie_set(&mut self, cookie: C) -> C {
-        self.reader.cookie_set(cookie)
-    }
-
-    fn cookie_ref(&self) -> &C {
-        self.reader.cookie_ref()
-    }
-
-    fn cookie_mut(&mut self) -> &mut C {
-        self.reader.cookie_mut()
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    // Test that buffer() returns the same data as data().
-    #[test]
-    fn buffer_test() {
-        use flate2::write::DeflateEncoder;
-        use flate2::Compression;
-        use std::io::prelude::*;
-
-        // Test vector.
-        let size = 10 * DEFAULT_BUF_SIZE;
-        let mut input_raw = Vec::with_capacity(size);
-        let mut v = 0u8;
-        for _ in 0..size {
-            input_raw.push(v);
-            if v == std::u8::MAX {
-                v = 0;
-            } else {
-                v += 1;
-            }
-        }
-
-        // Compress the raw input.
-        let mut input = Vec::new();
-        {
-            let mut encoder =
-                DeflateEncoder::new(&mut input, Compression::default());
-            encoder.write(&input_raw[..]).unwrap();
-            encoder.try_finish().unwrap();
-        }
-
-        let mut reader = BufferedReaderDeflate::new(
-            BufferedReaderGeneric::new(&input[..], None));
-
-        // Gather some stats to make it easier to figure out whether
-        // this test is working.
-        let stats_count =  2 * DEFAULT_BUF_SIZE;
-        let mut stats = vec![0usize; stats_count];
-
-        for i in 0..input_raw.len() {
-            let data = reader.data(DEFAULT_BUF_SIZE + 1).unwrap().to_vec();
-            assert!(data.len() > 0);
-            assert_eq!(data, reader.buffer());
-            // And, we may as well check to make sure we read the
-            // right data.
-            assert_eq!(data, &input_raw[i..i+data.len()]);
-
-            stats[cmp::min(data.len(), stats_count - 1)] += 1;
-
-            // Consume one byte and see what happens.
-            reader.consume(1);
-        }
-
-        if false {
-            for i in 0..stats.len() {
-                if stats[i] > 0 {
-                    if i == stats.len() - 1 {
-                        eprint!(">=");
-                    }
-                    eprintln!("{}: {}", i, stats[i]);
-                }
-            }
-        }
-    }
-}
diff --git a/buffered-reader/src/decompress_bzip2.rs b/buffered-reader/src/decompress_bzip2.rs
new file mode 100644
index 00000000..41fba37a
--- /dev/null
+++ b/buffered-reader/src/decompress_bzip2.rs
@@ -0,0 +1,118 @@
+use std::io;
+use std::fmt;
+
+use bzip2::read::BzDecoder;
+
+use super::*;
+
+
+pub struct BufferedReaderBzip<R: BufferedReader<C>, C> {
+    reader: BufferedReaderGeneric<BzDecoder<R>, C>,
+}
+
+impl <R: BufferedReader<()>> BufferedReaderBzip<R, ()> {
+    /// Instantiate a new bzip decompression reader.  `reader` is
+    /// the source to wrap.
+    pub fn new(reader: R) -> Self {
+        Self::with_cookie(reader, ())
+    }
+}
+
+impl <R: BufferedReader<C>, C> BufferedReaderBzip<R, C> {
+    /// Like `new()`, but sets a cookie, which can be retrieved using
+    /// the `cookie_ref` and `cookie_mut` methods, and set using
+    /// the `cookie_set` method.
+    pub fn with_cookie(reader: R, cookie: C) -> Self {
+        BufferedReaderBzip {
+            reader: BufferedReaderGeneric::with_cookie(
+                BzDecoder::new(reader), None, cookie),
+        }
+    }
+}
+
+impl<R: BufferedReader<C>, C> io::Read for BufferedReaderBzip<R, C> {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
+        self.reader.read(buf)
+    }
+}
+
+impl <R: BufferedReader<C>, C> fmt::Debug for BufferedReaderBzip<R, C> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("BufferedReaderBzip")
+            .field("reader", &self.get_ref().unwrap())
+            .finish()
+    }
+}
+
+impl<R: BufferedReader<C>, C> BufferedReader<C> for BufferedReaderBzip<R, C> {
+    fn buffer(&self) -> &[u8] {
+        return self.reader.buffer();
+    }
+
+    fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> {
+        return self.reader.data(amount);
+    }
+
+    fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
+        return self.reader.data_hard(amount);
+    }
+
+    fn data_eof(&mut self) -> Result<&[u8], io::Error> {
+        return self.reader.data_eof();
+    }
+
+    fn consume(&mut self, amount: usize) -> &[u8] {
+        return self.reader.consume(amount);
+    }
+
+    fn data_consume(&mut self, amount: usize)
+                    -> Result<&[u8], io::Error> {
+        return self.reader.data_consume(amount);
+    }
+
+    fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
+        return self.reader.data_consume_hard(amount);
+    }
+
+    fn read_be_u16(&mut self) -> Result<u16, io::Error> {
+        return self.reader.read_be_u16();
+    }
+
+    fn read_be_u32(&mut self) -> Result<u32, io::Error> {
+        return self.reader.read_be_u32();
+    }
+
+    fn steal(&mut self, amount: usize) -> Result<Vec<u8>, io::Error> {
+        return self.reader.steal(amount);
+    }
+
+    fn steal_eof(&mut self) -> Result<Vec<u8>, io::Error> {
+        return self.reader.steal_eof();
+    }
+
+    fn get_mut(&mut self) -> Option<&mut BufferedReader<C>> {
+        Some(self.reader.reader.get_mut())
+    }
+
+    fn get_ref(&self) -> Option<&BufferedReader<C>> {
+        Some(self.reader.reader.get_ref())
+    }
+
+    fn into_inner<'b>(self: Box<Self>)
+            -> Option<Box<BufferedReader<C> + 'b>> where Self: 'b {
+        // Strip the outer box.
+        Some(Box::new(self.reader.reader.into_inner()))
+    }
+
+    fn cookie_set(&mut self, cookie: C) -> C {
+        self.reader.cookie_set(cookie)
+    }
+
+    fn cookie_ref(&self) -> &C {
+        self.reader.cookie_ref()
+    }
+
+    fn cookie_mut(&mut self) -> &mut C {
+        self.reader.cookie_mut()
+    }
+}
diff --git a/buffered-reader/src/decompress_deflate.rs b/buffered-reader/src/decompress_deflate.rs
new file mode 100644
index 00000000..c46b9eea
--- /dev/null
+++ b/buffered-reader/src/decompress_deflate.rs
@@ -0,0 +1,299 @@
+use std::io;
+use std::fmt;
+
+use flate2::read::DeflateDecoder;
+use flate2::read::ZlibDecoder;
+
+use super::*;
+
+pub struct BufferedReaderDeflate<R: BufferedReader<C>, C> {
+    reader: BufferedReaderGeneric<DeflateDecoder<R>, C>,
+}
+
+impl <R: BufferedReader<()>> BufferedReaderDeflate<R, ()> {
+    /// Instantiate a new deflate decompression reader.  `reader` is
+    /// the source to wrap.
+    pub fn new(reader: R) -> Self {
+        Self::with_cookie(reader, ())
+    }
+}
+
+impl <R: BufferedReader<C>, C> BufferedReaderDeflate<R, C> {
+    /// Like `new()`, but sets a cookie, which can be retrieved using
+    /// the `cookie_ref` and `cookie_mut` methods, and set using
+    /// the `cookie_set` method.
+    pub fn with_cookie(reader: R, cookie: C) -> Self {
+        BufferedReaderDeflate {
+            reader: BufferedReaderGeneric::with_cookie(
+                DeflateDecoder::new(reader), None, cookie),
+        }
+    }
+}
+
+impl<R: BufferedReader<C>, C> io::Read for BufferedReaderDeflate<R, C> {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
+        self.reader.read(buf)
+    }
+}
+
+impl <R: BufferedReader<C>, C> fmt::Debug for BufferedReaderDeflate<R, C> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("BufferedReaderDeflate")
+            .field("reader", &self.get_ref().unwrap())
+            .finish()
+    }
+}
+
+impl<R: BufferedReader<C>, C> BufferedReader<C>
+        for BufferedReaderDeflate<R, C> {
+    fn buffer(&self) -> &[u8] {
+        return self.reader.buffer();
+    }
+
+    fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> {
+        return self.reader.data(amount);
+    }
+
+    fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
+        return self.reader.data_hard(amount);
+    }
+
+    fn data_eof(&mut self) -> Result<&[u8], io::Error> {
+        return self.reader.data_eof();
+    }
+
+    fn consume(&mut self, amount: usize) -> &[u8] {
+        return self.reader.consume(amount);
+    }
+
+    fn data_consume(&mut self, amount: usize)
+                    -> Result<&[u8], io::Error> {
+        return self.reader.data_consume(amount);
+    }
+
+    fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
+        return self.reader.data_consume_hard(amount);
+    }
+
+    fn read_be_u16(&mut self) -> Result<u16, io::Error> {
+        return self.reader.read_be_u16();
+    }
+
+    fn read_be_u32(&mut self) -> Result<u32, io::Error> {
+        return self.reader.read_be_u32();
+    }
+
+    fn steal(&mut self, amount: usize) -> Result<Vec<u8>, io::Error> {
+        return self.reader.steal(amount);
+    }
+
+    fn steal_eof(&mut self) -> Result<Vec<u8>, io::Error> {
+        return self.reader.steal_eof();
+    }
+
+    fn get_mut(&mut self) -> Option<&mut BufferedReader<C>> {
+        Some(self.reader.reader.get_mut())
+    }
+
+    fn get_ref(&self) -> Option<&BufferedReader<C>> {
+        Some(self.reader.reader.get_ref())
+    }
+
+    fn into_inner<'b>(self: Box<Self>)
+            -> Option<Box<BufferedReader<C> + 'b>> where Self: 'b {
+        // Strip the outer box.
+        Some(Box::new(self.reader.reader.into_inner()))
+    }
+
+    fn cookie_set(&mut self, cookie: C) -> C {
+        self.reader.cookie_set(cookie)
+    }
+
+    fn cookie_ref(&self) -> &C {
+        self.reader.cookie_ref()
+    }
+
+    fn cookie_mut(&mut self) -> &mut C {
+        self.reader.cookie_mut()
+    }
+}
+
+pub struct BufferedReaderZlib<R: BufferedReader<C>, C> {
+    reader: BufferedReaderGeneric<ZlibDecoder<R>, C>,
+}
+
+impl <R: BufferedReader<()>> BufferedReaderZlib<R, ()> {
+    /// Instantiate a new zlib decompression reader.  `reader` is
+    /// the source to wrap.
+    pub fn new(reader: R) -> Self {
+        Self::with_cookie(reader, ())
+    }
+}
+
+impl <R: BufferedReader<C>, C> BufferedReaderZlib<R, C> {
+    /// Like `new()`, but sets a cookie, which can be retrieved using
+    /// the `cookie_ref` and `cookie_mut` methods, and set using
+    /// the `cookie_set` method.
+    pub fn with_cookie(reader: R, cookie: C) -> Self {
+        BufferedReaderZlib {
+            reader: BufferedReaderGeneric::with_cookie(
+                ZlibDecoder::new(reader), None, cookie),
+        }
+    }
+}
+
+impl<R: BufferedReader<C>, C> io::Read for BufferedReaderZlib<R, C> {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
+        self.reader.read(buf)
+    }
+}
+
+impl <R: BufferedReader<C>, C> fmt::Debug for BufferedReaderZlib<R, C> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("BufferedReaderZlib")
+            .field("reader", &self.get_ref().unwrap())
+            .finish()
+    }
+}
+
+impl<R: BufferedReader<C>, C> BufferedReader<C>
+        for BufferedReaderZlib<R, C> {
+    fn buffer(&self) -> &[u8] {
+        return self.reader.buffer();
+    }
+
+    fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> {
+        return self.reader.data(amount);
+    }
+
+    fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
+        return self.reader.data_hard(amount);
+    }
+
+    fn data_eof(&mut self) -> Result<&[u8], io::Error> {
+        return self.reader.data_eof();
+    }
+
+    fn consume(&mut self, amount: usize) -> &[u8] {
+        return self.reader.consume(amount);
+    }
+
+    fn data_consume(&mut self, amount: usize)
+                    -> Result<&[u8], io::Error> {
+        return self.reader.data_consume(amount);
+    }
+
+    fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> {
+        return self.reader.data_consume_hard(amount);
+    }
+
+    fn read_be_u16(&mut self) -> Result<u16, io::Error> {
+        return self.reader.read_be_u16();
+    }
+
+    fn read_be_u32(&mut self) -> Result<u32, io::Error> {
+        return self.reader.read_be_u32();
+    }
+
+    fn steal(&mut self, amount: usize) -> Result<Vec<u8>, io::Error> {
+        return self.reader.steal(amount);
+    }
+
+    fn steal_eof(&mut self) -> Result<Vec<u8>, io::Error> {
+        return self.reader.steal_eof();
+    }
+
+    fn get_mut(&mut self) -> Option<&mut BufferedReader<C>> {
+        Some(self.reader.reader.get_mut())
+    }
+
+    fn get_ref(&self) -> Option<&BufferedReader<C>> {
+        Some(self.reader.reader.get_ref())
+    }
+
+    fn into_inner<'b>(self: Box<Self>)
+            -> Option<Box<BufferedReader<C> + 'b>> where Self: 'b {
+        // Strip the outer box.
+        Some(Box::new(self.reader.reader.into_inner()))
+    }
+
+    fn cookie_set(&mut self, cookie: C) -> C {
+        self.reader.cookie_set(cookie)
+    }
+
+    fn cookie_ref(&self) -> &C {
+        self.reader.cookie_ref()
+    }
+
+    fn cookie_mut(&mut self) -> &mut C {
+        self.reader.cookie_mut()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    // Test that buffer() returns the same data as data().
+    #[test]
+    fn buffer_test() {
+        use flate2::write::DeflateEncoder;
+        use flate2::Compression;
+        use std::io::prelude::*;
+
+        // Test vector.
+        let size = 10 * DEFAULT_BUF_SIZE;
+        let mut input_raw = Vec::with_capacity(size);
+        let mut v = 0u8;
+        for _ in 0..size {
+            input_raw.push(v);
+            if v == std::u8::MAX {
+                v = 0;
+            } else {
+                v += 1;
+            }
+        }
+
+        // Compress the raw input.
+        let mut input = Vec::new();
+        {
+            let mut encoder =
+                DeflateEncoder::new(&mut input, Compression::default());
+            encoder.write(&input_raw[..]).unwrap();
+            encoder.try_finish().unwrap();
+        }
+
+        let mut reader = BufferedReaderDeflate::new(
+            BufferedReaderGeneric::new(&input[..], None));
+
+        // Gather some stats to make it easier to figure out whether
+        // this test is working.
+        let stats_count =  2 * DEFAULT_BUF_SIZE;
+        let mut stats = vec![0usize; stats_count];
+
+        for i in 0..input_raw.len() {
+            let data = reader.data(DEFAULT_BUF_SIZE + 1).unwrap().to_vec();
+            assert!(data.len() > 0);
+            assert_eq!(data, reader.buffer());
+            // And, we may as well check to make sure we read the
+            // right data.
+            assert_eq!(data, &input_raw[i..i+data.len()]);
+
+            stats[cmp::min(data.len(), stats_count - 1)] += 1;
+
+            // Consume one byte and see what happens.
+            reader.consume(1);
+        }
+
+        if false {
+            for i in 0..stats.len() {
+                if stats[i] > 0 {
+                    if i == stats.len() - 1 {
+                        eprint!(">=");
+                    }
+                    eprintln!("{}: {}", i, stats[i]);
+                }
+            }
+        }
+    }
+}
diff --git a/buffered-reader/src/lib.rs b/buffered-reader/src/lib.rs
index ab19fa37..9619e0de 100644
--- a/buffered-reader/src/lib.rs
+++ b/buffered-reader/src/lib.rs
@@ -1,6 +1,8 @@
 //! An improved `BufRead` interface.
 
+#[cfg(feature = "compression-deflate")]
 extern crate flate2;
+#[cfg(feature = "compression-bzip2")]
 extern crate bzip2;
 
 use std::io;
@@ -13,16 +15,22 @@ mod memory;
 mod limitor;
 mod dup;
 mod eof;
-mod decompress;
+#[cfg(feature = "compression-deflate")]
+mod decompress_deflate;
+#[cfg(feature = "compression-bzip2")]
+mod decompress_bzip2;
 
 pub use self::generic::BufferedReaderGeneric;
 pub use self::memory::BufferedReaderMemory;
 pub use self::limitor::BufferedReaderLimitor;
 pub use self::dup::BufferedReaderDup;
 pub use self::eof::BufferedReaderEOF;
-pub use self::decompress::BufferedReaderDeflate;
-pub use self::decompress::BufferedReaderZlib;
-pub use self::decompress::BufferedReaderBzip;
+#[cfg(feature = "compression-deflate")]
+pub use self::decompress_deflate::BufferedReaderDeflate;
+#[cfg(feature = "compression-deflate")]
+pub use self::decompress_deflate::BufferedReaderZlib;
+#[cfg(feature = "compression-bzip2")]
+pub use self::decompress_bzip2::BufferedReaderBzip;
 
 // The default buffer size.
 const DEFAULT_BUF_SIZE: usize = 8 * 1024;
-- 
cgit v1.2.3