diff --git a/src/bufread.rs b/src/bufread.rs
index 770cd6b4..8d4ea727 100644
--- a/src/bufread.rs
+++ b/src/bufread.rs
@@ -28,6 +28,7 @@ pub struct BzDecoder<R> {
     obj: R,
     data: Decompress,
     done: bool,
+    multi: bool,
 }
 
 impl<R: BufRead> BzEncoder<R> {
@@ -147,8 +148,14 @@ impl<R: BufRead> BzDecoder<R> {
             obj: r,
             data: Decompress::new(false),
             done: false,
+            multi: false,
         }
     }
+
+    fn multi(mut self, flag: bool) -> BzDecoder<R> {
+        self.multi = flag;
+        self
+    }
 }
 
 impl<R> BzDecoder<R> {
@@ -187,7 +194,7 @@ impl<R> BzDecoder<R> {
 impl<R: BufRead> Read for BzDecoder<R> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         if self.done {
-            return Ok(0)
+            return Ok(0);
         }
         loop {
             let (read, consumed, eof, ret);
@@ -206,7 +213,12 @@ impl<R: BufRead> Read for BzDecoder<R> {
                 io::Error::new(io::ErrorKind::InvalidInput, e)
             }));
             if ret == Status::StreamEnd {
-                self.done = true;
+                if !eof && self.multi {
+                    self.data = Decompress::new(false);
+                } else {
+                    self.done = true;
+                }
+
                 return Ok(read)
             }
             if read > 0 || eof || buf.len() == 0 {
@@ -236,3 +248,62 @@ impl<R: AsyncWrite> AsyncWrite for BzDecoder<R> {
         self.get_mut().shutdown()
     }
 }
+
+/// A bzip2 streaming decoder that decodes all members of a multistream
+///
+/// Wikipedia, particularly, uses bzip2 multistream for their dumps.
+pub struct MultiBzDecoder<R>(BzDecoder<R>);
+
+impl<R: BufRead> MultiBzDecoder<R> {
+    /// Creates a new decoder from the given reader. If the bzip2 stream contains multiple members
+    /// all will be decoded.
+    pub fn new(r: R) -> MultiBzDecoder<R> {
+        MultiBzDecoder(BzDecoder::new(r).multi(true))
+    }
+}
+
+impl<R> MultiBzDecoder<R> {
+    /// Acquires a reference to the underlying reader.
+    pub fn get_ref(&self) -> &R {
+        self.0.get_ref()
+    }
+
+    /// Acquires a mutable reference to the underlying stream.
+    ///
+    /// Note that mutation of the stream may result in surprising results if
+    /// this encoder is continued to be used.
+    pub fn get_mut(&mut self) -> &mut R {
+        self.0.get_mut()
+    }
+
+    /// Consumes this decoder, returning the underlying reader.
+    pub fn into_inner(self) -> R {
+        self.0.into_inner()
+    }
+}
+
+impl<R: BufRead> Read for MultiBzDecoder<R> {
+    fn read(&mut self, into: &mut [u8]) -> io::Result<usize> {
+        self.0.read(into)
+    }
+}
+
+#[cfg(feature = "tokio")]
+impl<R: AsyncRead + BufRead> AsyncRead for MultiBzDecoder<R> {}
+
+impl<R: BufRead + Write> Write for MultiBzDecoder<R> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.get_mut().write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.get_mut().flush()
+    }
+}
+
+#[cfg(feature = "tokio")]
+impl<R: AsyncWrite + BufRead> AsyncWrite for MultiBzDecoder<R> {
+    fn shutdown(&mut self) -> Poll<(), io::Error> {
+        self.get_mut().shutdown()
+    }
+}
diff --git a/src/read.rs b/src/read.rs
index d9c298ff..36b2d31e 100644
--- a/src/read.rs
+++ b/src/read.rs
@@ -77,8 +77,7 @@ impl<R: Read> Read for BzEncoder<R> {
 }
 
 #[cfg(feature = "tokio")]
-impl<R: AsyncRead> AsyncRead for BzEncoder<R> {
-}
+impl<R: AsyncRead> AsyncRead for BzEncoder<R> {}
 
 impl<W: Write + Read> Write for BzEncoder<W> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
@@ -149,8 +148,7 @@ impl<R: Read> Read for BzDecoder<R> {
 }
 
 #[cfg(feature = "tokio")]
-impl<R: AsyncRead + Read> AsyncRead for BzDecoder<R> {
-}
+impl<R: AsyncRead + Read> AsyncRead for BzDecoder<R> {}
 
 impl<W: Write + Read> Write for BzDecoder<W> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
@@ -169,10 +167,74 @@ impl<R: AsyncWrite + Read> AsyncWrite for BzDecoder<R> {
     }
 }
 
+/// A bzip2 streaming decoder that decodes all members of a multistream
+///
+/// Wikipedia, particularly, uses bzip2 multistream for their dumps.
+pub struct MultiBzDecoder<R> {
+    inner: bufread::MultiBzDecoder<BufReader<R>>,
+}
+
+impl<R: Read> MultiBzDecoder<R> {
+    /// Creates a new decoder from the given reader, immediately parsing the
+    /// (first) gzip header. If the gzip stream contains multiple members all will
+    /// be decoded.
+    pub fn new(r: R) -> MultiBzDecoder<R> {
+        MultiBzDecoder {
+            inner: bufread::MultiBzDecoder::new(BufReader::new(r)),
+        }
+    }
+}
+
+impl<R> MultiBzDecoder<R> {
+    /// Acquires a reference to the underlying reader.
+    pub fn get_ref(&self) -> &R {
+        self.inner.get_ref().get_ref()
+    }
+
+    /// Acquires a mutable reference to the underlying stream.
+    ///
+    /// Note that mutation of the stream may result in surprising results if
+    /// this encoder is continued to be used.
+    pub fn get_mut(&mut self) -> &mut R {
+        self.inner.get_mut().get_mut()
+    }
+
+    /// Consumes this decoder, returning the underlying reader.
+    pub fn into_inner(self) -> R {
+        self.inner.into_inner().into_inner()
+    }
+}
+
+impl<R: Read> Read for MultiBzDecoder<R> {
+    fn read(&mut self, into: &mut [u8]) -> io::Result<usize> {
+        self.inner.read(into)
+    }
+}
+
+#[cfg(feature = "tokio")]
+impl<R: AsyncRead> AsyncRead for MultiBzDecoder<R> {}
+
+impl<R: Read + Write> Write for MultiBzDecoder<R> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.get_mut().write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.get_mut().flush()
+    }
+}
+
+#[cfg(feature = "tokio")]
+impl<R: AsyncWrite + AsyncRead> AsyncWrite for MultiBzDecoder<R> {
+    fn shutdown(&mut self) -> Poll<(), io::Error> {
+        self.get_mut().shutdown()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::io::prelude::*;
-    use read::{BzEncoder, BzDecoder};
+    use read::{BzEncoder, BzDecoder, MultiBzDecoder};
     use Compression;
     use rand::{thread_rng, Rng};
     use rand::distributions::Standard;
@@ -256,6 +318,25 @@ mod tests {
         assert!(d.read(&mut data).unwrap() == 0);
     }
 
+    #[test]
+    fn multistream_read_till_eof() {
+        let m = vec![3u8; 128 * 1024 + 1];
+        let repeat = 3;
+        let mut result = Vec::new();
+
+        for _i in 0..repeat {
+            let mut c = BzEncoder::new(&m[..], Compression::default());
+            c.read_to_end(&mut result).unwrap();
+        }
+
+        let mut d = MultiBzDecoder::new(&result[..]);
+        let mut data = Vec::new();
+
+        let a = d.read_to_end(&mut data).unwrap();
+        let b = m.len() * repeat;
+        assert!(a == b, "{} {}", a, b);
+    }
+
     #[test]
     fn empty() {
         let r = BzEncoder::new(&[][..], Compression::default());