aboutsummaryrefslogtreecommitdiff
path: root/vendor/flate2/src/gz
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/flate2/src/gz')
-rw-r--r--vendor/flate2/src/gz/bufread.rs483
-rw-r--r--vendor/flate2/src/gz/mod.rs644
-rw-r--r--vendor/flate2/src/gz/read.rs378
-rw-r--r--vendor/flate2/src/gz/write.rs641
4 files changed, 0 insertions, 2146 deletions
diff --git a/vendor/flate2/src/gz/bufread.rs b/vendor/flate2/src/gz/bufread.rs
deleted file mode 100644
index 679b4a7..0000000
--- a/vendor/flate2/src/gz/bufread.rs
+++ /dev/null
@@ -1,483 +0,0 @@
-use std::cmp;
-use std::io;
-use std::io::prelude::*;
-use std::mem;
-
-use super::{corrupt, read_into, GzBuilder, GzHeader, GzHeaderParser};
-use crate::crc::CrcReader;
-use crate::deflate;
-use crate::Compression;
-
-fn copy(into: &mut [u8], from: &[u8], pos: &mut usize) -> usize {
- let min = cmp::min(into.len(), from.len() - *pos);
- for (slot, val) in into.iter_mut().zip(from[*pos..*pos + min].iter()) {
- *slot = *val;
- }
- *pos += min;
- min
-}
-
-/// A gzip streaming encoder
-///
-/// This structure implements a [`Read`] interface. When read from, it reads
-/// uncompressed data from the underlying [`BufRead`] and provides the compressed data.
-///
-/// [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
-/// [`BufRead`]: https://doc.rust-lang.org/std/io/trait.BufRead.html
-///
-/// # Examples
-///
-/// ```
-/// use std::io::prelude::*;
-/// use std::io;
-/// use flate2::Compression;
-/// use flate2::bufread::GzEncoder;
-/// use std::fs::File;
-/// use std::io::BufReader;
-///
-/// // Opens sample file, compresses the contents and returns a Vector or error
-/// // File wrapped in a BufReader implements BufRead
-///
-/// fn open_hello_world() -> io::Result<Vec<u8>> {
-/// let f = File::open("examples/hello_world.txt")?;
-/// let b = BufReader::new(f);
-/// let mut gz = GzEncoder::new(b, Compression::fast());
-/// let mut buffer = Vec::new();
-/// gz.read_to_end(&mut buffer)?;
-/// Ok(buffer)
-/// }
-/// ```
-#[derive(Debug)]
-pub struct GzEncoder<R> {
- inner: deflate::bufread::DeflateEncoder<CrcReader<R>>,
- header: Vec<u8>,
- pos: usize,
- eof: bool,
-}
-
-pub fn gz_encoder<R: BufRead>(header: Vec<u8>, r: R, lvl: Compression) -> GzEncoder<R> {
- let crc = CrcReader::new(r);
- GzEncoder {
- inner: deflate::bufread::DeflateEncoder::new(crc, lvl),
- header,
- pos: 0,
- eof: false,
- }
-}
-
-impl<R: BufRead> GzEncoder<R> {
- /// Creates a new encoder which will use the given compression level.
- ///
- /// The encoder is not configured specially for the emitted header. For
- /// header configuration, see the `GzBuilder` type.
- ///
- /// The data read from the stream `r` will be compressed and available
- /// through the returned reader.
- pub fn new(r: R, level: Compression) -> GzEncoder<R> {
- GzBuilder::new().buf_read(r, level)
- }
-
- fn read_footer(&mut self, into: &mut [u8]) -> io::Result<usize> {
- if self.pos == 8 {
- return Ok(0);
- }
- let crc = self.inner.get_ref().crc();
- let ref arr = [
- (crc.sum() >> 0) as u8,
- (crc.sum() >> 8) as u8,
- (crc.sum() >> 16) as u8,
- (crc.sum() >> 24) as u8,
- (crc.amount() >> 0) as u8,
- (crc.amount() >> 8) as u8,
- (crc.amount() >> 16) as u8,
- (crc.amount() >> 24) as u8,
- ];
- Ok(copy(into, arr, &mut self.pos))
- }
-}
-
-impl<R> GzEncoder<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 reader.
- ///
- /// Note that mutation of the reader 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()
- }
-
- /// Returns the underlying stream, consuming this encoder
- pub fn into_inner(self) -> R {
- self.inner.into_inner().into_inner()
- }
-}
-
-#[inline]
-fn finish(buf: &[u8; 8]) -> (u32, u32) {
- let crc = ((buf[0] as u32) << 0)
- | ((buf[1] as u32) << 8)
- | ((buf[2] as u32) << 16)
- | ((buf[3] as u32) << 24);
- let amt = ((buf[4] as u32) << 0)
- | ((buf[5] as u32) << 8)
- | ((buf[6] as u32) << 16)
- | ((buf[7] as u32) << 24);
- (crc, amt)
-}
-
-impl<R: BufRead> Read for GzEncoder<R> {
- fn read(&mut self, mut into: &mut [u8]) -> io::Result<usize> {
- let mut amt = 0;
- if self.eof {
- return self.read_footer(into);
- } else if self.pos < self.header.len() {
- amt += copy(into, &self.header, &mut self.pos);
- if amt == into.len() {
- return Ok(amt);
- }
- let tmp = into;
- into = &mut tmp[amt..];
- }
- match self.inner.read(into)? {
- 0 => {
- self.eof = true;
- self.pos = 0;
- self.read_footer(into)
- }
- n => Ok(amt + n),
- }
- }
-}
-
-impl<R: BufRead + Write> Write for GzEncoder<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()
- }
-}
-
-/// A decoder for a single member of a [gzip file].
-///
-/// This structure implements a [`Read`] interface. When read from, it reads
-/// compressed data from the underlying [`BufRead`] and provides the uncompressed data.
-///
-/// After reading a single member of the gzip data this reader will return
-/// Ok(0) even if there are more bytes available in the underlying reader.
-/// If you need the following bytes, call `into_inner()` after Ok(0) to
-/// recover the underlying reader.
-///
-/// To handle gzip files that may have multiple members, see [`MultiGzDecoder`]
-/// or read more
-/// [in the introduction](../index.html#about-multi-member-gzip-files).
-///
-/// [gzip file]: https://www.rfc-editor.org/rfc/rfc1952#page-5
-/// [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
-/// [`BufRead`]: https://doc.rust-lang.org/std/io/trait.BufRead.html
-///
-/// # Examples
-///
-/// ```
-/// use std::io::prelude::*;
-/// use std::io;
-/// # use flate2::Compression;
-/// # use flate2::write::GzEncoder;
-/// use flate2::bufread::GzDecoder;
-///
-/// # fn main() {
-/// # let mut e = GzEncoder::new(Vec::new(), Compression::default());
-/// # e.write_all(b"Hello World").unwrap();
-/// # let bytes = e.finish().unwrap();
-/// # println!("{}", decode_reader(bytes).unwrap());
-/// # }
-/// #
-/// // Uncompresses a Gz Encoded vector of bytes and returns a string or error
-/// // Here &[u8] implements BufRead
-///
-/// fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
-/// let mut gz = GzDecoder::new(&bytes[..]);
-/// let mut s = String::new();
-/// gz.read_to_string(&mut s)?;
-/// Ok(s)
-/// }
-/// ```
-#[derive(Debug)]
-pub struct GzDecoder<R> {
- state: GzState,
- reader: CrcReader<deflate::bufread::DeflateDecoder<R>>,
- multi: bool,
-}
-
-#[derive(Debug)]
-enum GzState {
- Header(GzHeaderParser),
- Body(GzHeader),
- Finished(GzHeader, usize, [u8; 8]),
- Err(io::Error),
- End(Option<GzHeader>),
-}
-
-impl<R: BufRead> GzDecoder<R> {
- /// Creates a new decoder from the given reader, immediately parsing the
- /// gzip header.
- pub fn new(mut r: R) -> GzDecoder<R> {
- let mut header_parser = GzHeaderParser::new();
-
- let state = match header_parser.parse(&mut r) {
- Ok(_) => GzState::Body(GzHeader::from(header_parser)),
- Err(ref err) if io::ErrorKind::WouldBlock == err.kind() => {
- GzState::Header(header_parser)
- }
- Err(err) => GzState::Err(err),
- };
-
- GzDecoder {
- state,
- reader: CrcReader::new(deflate::bufread::DeflateDecoder::new(r)),
- multi: false,
- }
- }
-
- fn multi(mut self, flag: bool) -> GzDecoder<R> {
- self.multi = flag;
- self
- }
-}
-
-impl<R> GzDecoder<R> {
- /// Returns the header associated with this stream, if it was valid
- pub fn header(&self) -> Option<&GzHeader> {
- match &self.state {
- GzState::Body(header) | GzState::Finished(header, _, _) => Some(header),
- GzState::End(header) => header.as_ref(),
- _ => None,
- }
- }
-
- /// Acquires a reference to the underlying reader.
- pub fn get_ref(&self) -> &R {
- self.reader.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 decoder is continued to be used.
- pub fn get_mut(&mut self) -> &mut R {
- self.reader.get_mut().get_mut()
- }
-
- /// Consumes this decoder, returning the underlying reader.
- pub fn into_inner(self) -> R {
- self.reader.into_inner().into_inner()
- }
-}
-
-impl<R: BufRead> Read for GzDecoder<R> {
- fn read(&mut self, into: &mut [u8]) -> io::Result<usize> {
- loop {
- match &mut self.state {
- GzState::Header(parser) => {
- parser.parse(self.reader.get_mut().get_mut())?;
- self.state = GzState::Body(GzHeader::from(mem::take(parser)));
- }
- GzState::Body(header) => {
- if into.is_empty() {
- return Ok(0);
- }
- match self.reader.read(into)? {
- 0 => {
- self.state = GzState::Finished(mem::take(header), 0, [0; 8]);
- }
- n => {
- return Ok(n);
- }
- }
- }
- GzState::Finished(header, pos, buf) => {
- if *pos < buf.len() {
- *pos += read_into(self.reader.get_mut().get_mut(), &mut buf[*pos..])?;
- } else {
- let (crc, amt) = finish(&buf);
-
- if crc != self.reader.crc().sum() || amt != self.reader.crc().amount() {
- self.state = GzState::End(Some(mem::take(header)));
- return Err(corrupt());
- } else if self.multi {
- let is_eof = self
- .reader
- .get_mut()
- .get_mut()
- .fill_buf()
- .map(|buf| buf.is_empty())?;
-
- if is_eof {
- self.state = GzState::End(Some(mem::take(header)));
- } else {
- self.reader.reset();
- self.reader.get_mut().reset_data();
- self.state = GzState::Header(GzHeaderParser::new())
- }
- } else {
- self.state = GzState::End(Some(mem::take(header)));
- }
- }
- }
- GzState::Err(err) => {
- let result = Err(mem::replace(err, io::ErrorKind::Other.into()));
- self.state = GzState::End(None);
- return result;
- }
- GzState::End(_) => return Ok(0),
- }
- }
- }
-}
-
-impl<R: BufRead + Write> Write for GzDecoder<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()
- }
-}
-
-/// A gzip streaming decoder that decodes a [gzip file] that may have multiple members.
-///
-/// This structure implements a [`Read`] interface. When read from, it reads
-/// compressed data from the underlying [`BufRead`] and provides the uncompressed data.
-///
-/// A gzip file consists of a series of *members* concatenated one after another.
-/// MultiGzDecoder decodes all members from the data and only returns Ok(0) when the
-/// underlying reader does. For a file, this reads to the end of the file.
-///
-/// To handle members seperately, see [GzDecoder] or read more
-/// [in the introduction](../index.html#about-multi-member-gzip-files).
-///
-/// [gzip file]: https://www.rfc-editor.org/rfc/rfc1952#page-5
-/// [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
-/// [`BufRead`]: https://doc.rust-lang.org/std/io/trait.BufRead.html
-///
-/// # Examples
-///
-/// ```
-/// use std::io::prelude::*;
-/// use std::io;
-/// # use flate2::Compression;
-/// # use flate2::write::GzEncoder;
-/// use flate2::bufread::MultiGzDecoder;
-///
-/// # fn main() {
-/// # let mut e = GzEncoder::new(Vec::new(), Compression::default());
-/// # e.write_all(b"Hello World").unwrap();
-/// # let bytes = e.finish().unwrap();
-/// # println!("{}", decode_reader(bytes).unwrap());
-/// # }
-/// #
-/// // Uncompresses a Gz Encoded vector of bytes and returns a string or error
-/// // Here &[u8] implements BufRead
-///
-/// fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
-/// let mut gz = MultiGzDecoder::new(&bytes[..]);
-/// let mut s = String::new();
-/// gz.read_to_string(&mut s)?;
-/// Ok(s)
-/// }
-/// ```
-#[derive(Debug)]
-pub struct MultiGzDecoder<R>(GzDecoder<R>);
-
-impl<R: BufRead> MultiGzDecoder<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) -> MultiGzDecoder<R> {
- MultiGzDecoder(GzDecoder::new(r).multi(true))
- }
-}
-
-impl<R> MultiGzDecoder<R> {
- /// Returns the current header associated with this stream, if it's valid
- pub fn header(&self) -> Option<&GzHeader> {
- self.0.header()
- }
-
- /// 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 decoder 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 MultiGzDecoder<R> {
- fn read(&mut self, into: &mut [u8]) -> io::Result<usize> {
- self.0.read(into)
- }
-}
-
-#[cfg(test)]
-mod test {
- use crate::bufread::GzDecoder;
- use crate::gz::write;
- use crate::Compression;
- use std::io::{Read, Write};
-
- // GzDecoder consumes one gzip member and then returns 0 for subsequent reads, allowing any
- // additional data to be consumed by the caller.
- #[test]
- fn decode_extra_data() {
- let expected = "Hello World";
-
- let compressed = {
- let mut e = write::GzEncoder::new(Vec::new(), Compression::default());
- e.write(expected.as_ref()).unwrap();
- let mut b = e.finish().unwrap();
- b.push(b'x');
- b
- };
-
- let mut output = Vec::new();
- let mut decoder = GzDecoder::new(compressed.as_slice());
- let decoded_bytes = decoder.read_to_end(&mut output).unwrap();
- assert_eq!(decoded_bytes, output.len());
- let actual = std::str::from_utf8(&output).expect("String parsing error");
- assert_eq!(
- actual, expected,
- "after decompression we obtain the original input"
- );
-
- output.clear();
- assert_eq!(
- decoder.read(&mut output).unwrap(),
- 0,
- "subsequent read of decoder returns 0, but inner reader can return additional data"
- );
- let mut reader = decoder.into_inner();
- assert_eq!(
- reader.read_to_end(&mut output).unwrap(),
- 1,
- "extra data is accessible in underlying buf-read"
- );
- assert_eq!(output, b"x");
- }
-}
diff --git a/vendor/flate2/src/gz/mod.rs b/vendor/flate2/src/gz/mod.rs
deleted file mode 100644
index 31a6961..0000000
--- a/vendor/flate2/src/gz/mod.rs
+++ /dev/null
@@ -1,644 +0,0 @@
-use std::ffi::CString;
-use std::io::{BufRead, Error, ErrorKind, Read, Result, Write};
-use std::time;
-
-use crate::bufreader::BufReader;
-use crate::{Compression, Crc};
-
-pub static FHCRC: u8 = 1 << 1;
-pub static FEXTRA: u8 = 1 << 2;
-pub static FNAME: u8 = 1 << 3;
-pub static FCOMMENT: u8 = 1 << 4;
-pub static FRESERVED: u8 = 1 << 5 | 1 << 6 | 1 << 7;
-
-pub mod bufread;
-pub mod read;
-pub mod write;
-
-// The maximum length of the header filename and comment fields. More than
-// enough for these fields in reasonable use, but prevents possible attacks.
-const MAX_HEADER_BUF: usize = 65535;
-
-/// A structure representing the header of a gzip stream.
-///
-/// The header can contain metadata about the file that was compressed, if
-/// present.
-#[derive(PartialEq, Clone, Debug, Default)]
-pub struct GzHeader {
- extra: Option<Vec<u8>>,
- filename: Option<Vec<u8>>,
- comment: Option<Vec<u8>>,
- operating_system: u8,
- mtime: u32,
-}
-
-impl GzHeader {
- /// Returns the `filename` field of this gzip stream's header, if present.
- pub fn filename(&self) -> Option<&[u8]> {
- self.filename.as_ref().map(|s| &s[..])
- }
-
- /// Returns the `extra` field of this gzip stream's header, if present.
- pub fn extra(&self) -> Option<&[u8]> {
- self.extra.as_ref().map(|s| &s[..])
- }
-
- /// Returns the `comment` field of this gzip stream's header, if present.
- pub fn comment(&self) -> Option<&[u8]> {
- self.comment.as_ref().map(|s| &s[..])
- }
-
- /// Returns the `operating_system` field of this gzip stream's header.
- ///
- /// There are predefined values for various operating systems.
- /// 255 means that the value is unknown.
- pub fn operating_system(&self) -> u8 {
- self.operating_system
- }
-
- /// This gives the most recent modification time of the original file being compressed.
- ///
- /// The time is in Unix format, i.e., seconds since 00:00:00 GMT, Jan. 1, 1970.
- /// (Note that this may cause problems for MS-DOS and other systems that use local
- /// rather than Universal time.) If the compressed data did not come from a file,
- /// `mtime` is set to the time at which compression started.
- /// `mtime` = 0 means no time stamp is available.
- ///
- /// The usage of `mtime` is discouraged because of Year 2038 problem.
- pub fn mtime(&self) -> u32 {
- self.mtime
- }
-
- /// Returns the most recent modification time represented by a date-time type.
- /// Returns `None` if the value of the underlying counter is 0,
- /// indicating no time stamp is available.
- ///
- ///
- /// The time is measured as seconds since 00:00:00 GMT, Jan. 1 1970.
- /// See [`mtime`](#method.mtime) for more detail.
- pub fn mtime_as_datetime(&self) -> Option<time::SystemTime> {
- if self.mtime == 0 {
- None
- } else {
- let duration = time::Duration::new(u64::from(self.mtime), 0);
- let datetime = time::UNIX_EPOCH + duration;
- Some(datetime)
- }
- }
-}
-
-#[derive(Debug)]
-pub enum GzHeaderState {
- Start(u8, [u8; 10]),
- Xlen(Option<Box<Crc>>, u8, [u8; 2]),
- Extra(Option<Box<Crc>>, u16),
- Filename(Option<Box<Crc>>),
- Comment(Option<Box<Crc>>),
- Crc(Option<Box<Crc>>, u8, [u8; 2]),
- Complete,
-}
-
-impl Default for GzHeaderState {
- fn default() -> Self {
- Self::Complete
- }
-}
-
-#[derive(Debug, Default)]
-pub struct GzHeaderParser {
- state: GzHeaderState,
- flags: u8,
- header: GzHeader,
-}
-
-impl GzHeaderParser {
- fn new() -> Self {
- GzHeaderParser {
- state: GzHeaderState::Start(0, [0; 10]),
- flags: 0,
- header: GzHeader::default(),
- }
- }
-
- fn parse<'a, R: Read>(&mut self, r: &'a mut R) -> Result<()> {
- loop {
- match &mut self.state {
- GzHeaderState::Start(count, buffer) => {
- while (*count as usize) < buffer.len() {
- *count += read_into(r, &mut buffer[*count as usize..])? as u8;
- }
- // Gzip identification bytes
- if buffer[0] != 0x1f || buffer[1] != 0x8b {
- return Err(bad_header());
- }
- // Gzip compression method (8 = deflate)
- if buffer[2] != 8 {
- return Err(bad_header());
- }
- self.flags = buffer[3];
- // RFC1952: "must give an error indication if any reserved bit is non-zero"
- if self.flags & FRESERVED != 0 {
- return Err(bad_header());
- }
- self.header.mtime = ((buffer[4] as u32) << 0)
- | ((buffer[5] as u32) << 8)
- | ((buffer[6] as u32) << 16)
- | ((buffer[7] as u32) << 24);
- let _xfl = buffer[8];
- self.header.operating_system = buffer[9];
- let crc = if self.flags & FHCRC != 0 {
- let mut crc = Box::new(Crc::new());
- crc.update(buffer);
- Some(crc)
- } else {
- None
- };
- self.state = GzHeaderState::Xlen(crc, 0, [0; 2]);
- }
- GzHeaderState::Xlen(crc, count, buffer) => {
- if self.flags & FEXTRA != 0 {
- while (*count as usize) < buffer.len() {
- *count += read_into(r, &mut buffer[*count as usize..])? as u8;
- }
- if let Some(crc) = crc {
- crc.update(buffer);
- }
- let xlen = parse_le_u16(&buffer);
- self.header.extra = Some(vec![0; xlen as usize]);
- self.state = GzHeaderState::Extra(crc.take(), 0);
- } else {
- self.state = GzHeaderState::Filename(crc.take());
- }
- }
- GzHeaderState::Extra(crc, count) => {
- debug_assert!(self.header.extra.is_some());
- let extra = self.header.extra.as_mut().unwrap();
- while (*count as usize) < extra.len() {
- *count += read_into(r, &mut extra[*count as usize..])? as u16;
- }
- if let Some(crc) = crc {
- crc.update(extra);
- }
- self.state = GzHeaderState::Filename(crc.take());
- }
- GzHeaderState::Filename(crc) => {
- if self.flags & FNAME != 0 {
- let filename = self.header.filename.get_or_insert_with(Vec::new);
- read_to_nul(r, filename)?;
- if let Some(crc) = crc {
- crc.update(filename);
- crc.update(b"\0");
- }
- }
- self.state = GzHeaderState::Comment(crc.take());
- }
- GzHeaderState::Comment(crc) => {
- if self.flags & FCOMMENT != 0 {
- let comment = self.header.comment.get_or_insert_with(Vec::new);
- read_to_nul(r, comment)?;
- if let Some(crc) = crc {
- crc.update(comment);
- crc.update(b"\0");
- }
- }
- self.state = GzHeaderState::Crc(crc.take(), 0, [0; 2]);
- }
- GzHeaderState::Crc(crc, count, buffer) => {
- if let Some(crc) = crc {
- debug_assert!(self.flags & FHCRC != 0);
- while (*count as usize) < buffer.len() {
- *count += read_into(r, &mut buffer[*count as usize..])? as u8;
- }
- let stored_crc = parse_le_u16(&buffer);
- let calced_crc = crc.sum() as u16;
- if stored_crc != calced_crc {
- return Err(corrupt());
- }
- }
- self.state = GzHeaderState::Complete;
- }
- GzHeaderState::Complete => {
- return Ok(());
- }
- }
- }
- }
-
- fn header(&self) -> Option<&GzHeader> {
- match self.state {
- GzHeaderState::Complete => Some(&self.header),
- _ => None,
- }
- }
-}
-
-impl From<GzHeaderParser> for GzHeader {
- fn from(parser: GzHeaderParser) -> Self {
- debug_assert!(matches!(parser.state, GzHeaderState::Complete));
- parser.header
- }
-}
-
-// Attempt to fill the `buffer` from `r`. Return the number of bytes read.
-// Return an error if EOF is read before the buffer is full. This differs
-// from `read` in that Ok(0) means that more data may be available.
-fn read_into<R: Read>(r: &mut R, buffer: &mut [u8]) -> Result<usize> {
- debug_assert!(!buffer.is_empty());
- match r.read(buffer) {
- Ok(0) => Err(ErrorKind::UnexpectedEof.into()),
- Ok(n) => Ok(n),
- Err(ref e) if e.kind() == ErrorKind::Interrupted => Ok(0),
- Err(e) => Err(e),
- }
-}
-
-// Read `r` up to the first nul byte, pushing non-nul bytes to `buffer`.
-fn read_to_nul<R: Read>(r: &mut R, buffer: &mut Vec<u8>) -> Result<()> {
- let mut bytes = r.bytes();
- loop {
- match bytes.next().transpose()? {
- Some(byte) if byte == 0 => {
- return Ok(());
- }
- Some(_) if buffer.len() == MAX_HEADER_BUF => {
- return Err(Error::new(
- ErrorKind::InvalidInput,
- "gzip header field too long",
- ));
- }
- Some(byte) => {
- buffer.push(byte);
- }
- None => {
- return Err(ErrorKind::UnexpectedEof.into());
- }
- }
- }
-}
-
-fn parse_le_u16(buffer: &[u8; 2]) -> u16 {
- (buffer[0] as u16) | ((buffer[1] as u16) << 8)
-}
-
-fn bad_header() -> Error {
- Error::new(ErrorKind::InvalidInput, "invalid gzip header")
-}
-
-fn corrupt() -> Error {
- Error::new(
- ErrorKind::InvalidInput,
- "corrupt gzip stream does not have a matching checksum",
- )
-}
-
-/// A builder structure to create a new gzip Encoder.
-///
-/// This structure controls header configuration options such as the filename.
-///
-/// # Examples
-///
-/// ```
-/// use std::io::prelude::*;
-/// # use std::io;
-/// use std::fs::File;
-/// use flate2::GzBuilder;
-/// use flate2::Compression;
-///
-/// // GzBuilder opens a file and writes a sample string using GzBuilder pattern
-///
-/// # fn sample_builder() -> Result<(), io::Error> {
-/// let f = File::create("examples/hello_world.gz")?;
-/// let mut gz = GzBuilder::new()
-/// .filename("hello_world.txt")
-/// .comment("test file, please delete")
-/// .write(f, Compression::default());
-/// gz.write_all(b"hello world")?;
-/// gz.finish()?;
-/// # Ok(())
-/// # }
-/// ```
-#[derive(Debug)]
-pub struct GzBuilder {
- extra: Option<Vec<u8>>,
- filename: Option<CString>,
- comment: Option<CString>,
- operating_system: Option<u8>,
- mtime: u32,
-}
-
-impl Default for GzBuilder {
- fn default() -> Self {
- Self::new()
- }
-}
-
-impl GzBuilder {
- /// Create a new blank builder with no header by default.
- pub fn new() -> GzBuilder {
- GzBuilder {
- extra: None,
- filename: None,
- comment: None,
- operating_system: None,
- mtime: 0,
- }
- }
-
- /// Configure the `mtime` field in the gzip header.
- pub fn mtime(mut self, mtime: u32) -> GzBuilder {
- self.mtime = mtime;
- self
- }
-
- /// Configure the `operating_system` field in the gzip header.
- pub fn operating_system(mut self, os: u8) -> GzBuilder {
- self.operating_system = Some(os);
- self
- }
-
- /// Configure the `extra` field in the gzip header.
- pub fn extra<T: Into<Vec<u8>>>(mut self, extra: T) -> GzBuilder {
- self.extra = Some(extra.into());
- self
- }
-
- /// Configure the `filename` field in the gzip header.
- ///
- /// # Panics
- ///
- /// Panics if the `filename` slice contains a zero.
- pub fn filename<T: Into<Vec<u8>>>(mut self, filename: T) -> GzBuilder {
- self.filename = Some(CString::new(filename.into()).unwrap());
- self
- }
-
- /// Configure the `comment` field in the gzip header.
- ///
- /// # Panics
- ///
- /// Panics if the `comment` slice contains a zero.
- pub fn comment<T: Into<Vec<u8>>>(mut self, comment: T) -> GzBuilder {
- self.comment = Some(CString::new(comment.into()).unwrap());
- self
- }
-
- /// Consume this builder, creating a writer encoder in the process.
- ///
- /// The data written to the returned encoder will be compressed and then
- /// written out to the supplied parameter `w`.
- pub fn write<W: Write>(self, w: W, lvl: Compression) -> write::GzEncoder<W> {
- write::gz_encoder(self.into_header(lvl), w, lvl)
- }
-
- /// Consume this builder, creating a reader encoder in the process.
- ///
- /// Data read from the returned encoder will be the compressed version of
- /// the data read from the given reader.
- pub fn read<R: Read>(self, r: R, lvl: Compression) -> read::GzEncoder<R> {
- read::gz_encoder(self.buf_read(BufReader::new(r), lvl))
- }
-
- /// Consume this builder, creating a reader encoder in the process.
- ///
- /// Data read from the returned encoder will be the compressed version of
- /// the data read from the given reader.
- pub fn buf_read<R>(self, r: R, lvl: Compression) -> bufread::GzEncoder<R>
- where
- R: BufRead,
- {
- bufread::gz_encoder(self.into_header(lvl), r, lvl)
- }
-
- fn into_header(self, lvl: Compression) -> Vec<u8> {
- let GzBuilder {
- extra,
- filename,
- comment,
- operating_system,
- mtime,
- } = self;
- let mut flg = 0;
- let mut header = vec![0u8; 10];
- if let Some(v) = extra {
- flg |= FEXTRA;
- header.push((v.len() >> 0) as u8);
- header.push((v.len() >> 8) as u8);
- header.extend(v);
- }
- if let Some(filename) = filename {
- flg |= FNAME;
- header.extend(filename.as_bytes_with_nul().iter().copied());
- }
- if let Some(comment) = comment {
- flg |= FCOMMENT;
- header.extend(comment.as_bytes_with_nul().iter().copied());
- }
- header[0] = 0x1f;
- header[1] = 0x8b;
- header[2] = 8;
- header[3] = flg;
- header[4] = (mtime >> 0) as u8;
- header[5] = (mtime >> 8) as u8;
- header[6] = (mtime >> 16) as u8;
- header[7] = (mtime >> 24) as u8;
- header[8] = if lvl.0 >= Compression::best().0 {
- 2
- } else if lvl.0 <= Compression::fast().0 {
- 4
- } else {
- 0
- };
-
- // Typically this byte indicates what OS the gz stream was created on,
- // but in an effort to have cross-platform reproducible streams just
- // default this value to 255. I'm not sure that if we "correctly" set
- // this it'd do anything anyway...
- header[9] = operating_system.unwrap_or(255);
- header
- }
-}
-
-#[cfg(test)]
-mod tests {
- use std::io::prelude::*;
-
- use super::{read, write, GzBuilder, GzHeaderParser};
- use crate::{Compression, GzHeader};
- use rand::{thread_rng, Rng};
-
- #[test]
- fn roundtrip() {
- let mut e = write::GzEncoder::new(Vec::new(), Compression::default());
- e.write_all(b"foo bar baz").unwrap();
- let inner = e.finish().unwrap();
- let mut d = read::GzDecoder::new(&inner[..]);
- let mut s = String::new();
- d.read_to_string(&mut s).unwrap();
- assert_eq!(s, "foo bar baz");
- }
-
- #[test]
- fn roundtrip_zero() {
- let e = write::GzEncoder::new(Vec::new(), Compression::default());
- let inner = e.finish().unwrap();
- let mut d = read::GzDecoder::new(&inner[..]);
- let mut s = String::new();
- d.read_to_string(&mut s).unwrap();
- assert_eq!(s, "");
- }
-
- #[test]
- fn roundtrip_big() {
- let mut real = Vec::new();
- let mut w = write::GzEncoder::new(Vec::new(), Compression::default());
- let v = crate::random_bytes().take(1024).collect::<Vec<_>>();
- for _ in 0..200 {
- let to_write = &v[..thread_rng().gen_range(0..v.len())];
- real.extend(to_write.iter().copied());
- w.write_all(to_write).unwrap();
- }
- let result = w.finish().unwrap();
- let mut r = read::GzDecoder::new(&result[..]);
- let mut v = Vec::new();
- r.read_to_end(&mut v).unwrap();
- assert_eq!(v, real);
- }
-
- #[test]
- fn roundtrip_big2() {
- let v = crate::random_bytes().take(1024 * 1024).collect::<Vec<_>>();
- let mut r = read::GzDecoder::new(read::GzEncoder::new(&v[..], Compression::default()));
- let mut res = Vec::new();
- r.read_to_end(&mut res).unwrap();
- assert_eq!(res, v);
- }
-
- // A Rust implementation of CRC that closely matches the C code in RFC1952.
- // Only use this to create CRCs for tests.
- struct Rfc1952Crc {
- /* Table of CRCs of all 8-bit messages. */
- crc_table: [u32; 256],
- }
-
- impl Rfc1952Crc {
- fn new() -> Self {
- let mut crc = Rfc1952Crc {
- crc_table: [0; 256],
- };
- /* Make the table for a fast CRC. */
- for n in 0usize..256 {
- let mut c = n as u32;
- for _k in 0..8 {
- if c & 1 != 0 {
- c = 0xedb88320 ^ (c >> 1);
- } else {
- c = c >> 1;
- }
- }
- crc.crc_table[n] = c;
- }
- crc
- }
-
- /*
- Update a running crc with the bytes buf and return
- the updated crc. The crc should be initialized to zero. Pre- and
- post-conditioning (one's complement) is performed within this
- function so it shouldn't be done by the caller.
- */
- fn update_crc(&self, crc: u32, buf: &[u8]) -> u32 {
- let mut c = crc ^ 0xffffffff;
-
- for b in buf {
- c = self.crc_table[(c as u8 ^ *b) as usize] ^ (c >> 8);
- }
- c ^ 0xffffffff
- }
-
- /* Return the CRC of the bytes buf. */
- fn crc(&self, buf: &[u8]) -> u32 {
- self.update_crc(0, buf)
- }
- }
-
- #[test]
- fn roundtrip_header() {
- let mut header = GzBuilder::new()
- .mtime(1234)
- .operating_system(57)
- .filename("filename")
- .comment("comment")
- .into_header(Compression::fast());
-
- // Add a CRC to the header
- header[3] = header[3] ^ super::FHCRC;
- let rfc1952_crc = Rfc1952Crc::new();
- let crc32 = rfc1952_crc.crc(&header);
- let crc16 = crc32 as u16;
- header.extend(&crc16.to_le_bytes());
-
- let mut parser = GzHeaderParser::new();
- parser.parse(&mut header.as_slice()).unwrap();
- let actual = parser.header().unwrap();
- assert_eq!(
- actual,
- &GzHeader {
- extra: None,
- filename: Some("filename".as_bytes().to_vec()),
- comment: Some("comment".as_bytes().to_vec()),
- operating_system: 57,
- mtime: 1234
- }
- )
- }
-
- #[test]
- fn fields() {
- let r = vec![0, 2, 4, 6];
- let e = GzBuilder::new()
- .filename("foo.rs")
- .comment("bar")
- .extra(vec![0, 1, 2, 3])
- .read(&r[..], Compression::default());
- let mut d = read::GzDecoder::new(e);
- assert_eq!(d.header().unwrap().filename(), Some(&b"foo.rs"[..]));
- assert_eq!(d.header().unwrap().comment(), Some(&b"bar"[..]));
- assert_eq!(d.header().unwrap().extra(), Some(&b"\x00\x01\x02\x03"[..]));
- let mut res = Vec::new();
- d.read_to_end(&mut res).unwrap();
- assert_eq!(res, vec![0, 2, 4, 6]);
- }
-
- #[test]
- fn keep_reading_after_end() {
- let mut e = write::GzEncoder::new(Vec::new(), Compression::default());
- e.write_all(b"foo bar baz").unwrap();
- let inner = e.finish().unwrap();
- let mut d = read::GzDecoder::new(&inner[..]);
- let mut s = String::new();
- d.read_to_string(&mut s).unwrap();
- assert_eq!(s, "foo bar baz");
- d.read_to_string(&mut s).unwrap();
- assert_eq!(s, "foo bar baz");
- }
-
- #[test]
- fn qc_reader() {
- ::quickcheck::quickcheck(test as fn(_) -> _);
-
- fn test(v: Vec<u8>) -> bool {
- let r = read::GzEncoder::new(&v[..], Compression::default());
- let mut r = read::GzDecoder::new(r);
- let mut v2 = Vec::new();
- r.read_to_end(&mut v2).unwrap();
- v == v2
- }
- }
-
- #[test]
- fn flush_after_write() {
- let mut f = write::GzEncoder::new(Vec::new(), Compression::default());
- write!(f, "Hello world").unwrap();
- f.flush().unwrap();
- }
-}
diff --git a/vendor/flate2/src/gz/read.rs b/vendor/flate2/src/gz/read.rs
deleted file mode 100644
index 9dbadbd..0000000
--- a/vendor/flate2/src/gz/read.rs
+++ /dev/null
@@ -1,378 +0,0 @@
-use std::io;
-use std::io::prelude::*;
-
-use super::bufread;
-use super::{GzBuilder, GzHeader};
-use crate::bufreader::BufReader;
-use crate::Compression;
-
-/// A gzip streaming encoder
-///
-/// This structure implements a [`Read`] interface. When read from, it reads
-/// uncompressed data from the underlying [`Read`] and provides the compressed data.
-///
-/// [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
-///
-/// # Examples
-///
-/// ```
-/// use std::io::prelude::*;
-/// use std::io;
-/// use flate2::Compression;
-/// use flate2::read::GzEncoder;
-///
-/// // Return a vector containing the GZ compressed version of hello world
-///
-/// fn gzencode_hello_world() -> io::Result<Vec<u8>> {
-/// let mut ret_vec = Vec::new();
-/// let bytestring = b"hello world";
-/// let mut gz = GzEncoder::new(&bytestring[..], Compression::fast());
-/// gz.read_to_end(&mut ret_vec)?;
-/// Ok(ret_vec)
-/// }
-/// ```
-#[derive(Debug)]
-pub struct GzEncoder<R> {
- inner: bufread::GzEncoder<BufReader<R>>,
-}
-
-pub fn gz_encoder<R: Read>(inner: bufread::GzEncoder<BufReader<R>>) -> GzEncoder<R> {
- GzEncoder { inner }
-}
-
-impl<R: Read> GzEncoder<R> {
- /// Creates a new encoder which will use the given compression level.
- ///
- /// The encoder is not configured specially for the emitted header. For
- /// header configuration, see the `GzBuilder` type.
- ///
- /// The data read from the stream `r` will be compressed and available
- /// through the returned reader.
- pub fn new(r: R, level: Compression) -> GzEncoder<R> {
- GzBuilder::new().read(r, level)
- }
-}
-
-impl<R> GzEncoder<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 reader.
- ///
- /// Note that mutation of the reader 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()
- }
-
- /// Returns the underlying stream, consuming this encoder
- pub fn into_inner(self) -> R {
- self.inner.into_inner().into_inner()
- }
-}
-
-impl<R: Read> Read for GzEncoder<R> {
- fn read(&mut self, into: &mut [u8]) -> io::Result<usize> {
- self.inner.read(into)
- }
-}
-
-impl<R: Read + Write> Write for GzEncoder<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()
- }
-}
-
-/// A decoder for a single member of a [gzip file].
-///
-/// This structure implements a [`Read`] interface. When read from, it reads
-/// compressed data from the underlying [`Read`] and provides the uncompressed data.
-///
-/// After reading a single member of the gzip data this reader will return
-/// Ok(0) even if there are more bytes available in the underlying reader.
-/// `GzDecoder` may have read additional bytes past the end of the gzip data.
-/// If you need the following bytes, wrap the `Reader` in a `std::io::BufReader`
-/// and use `bufread::GzDecoder` instead.
-///
-/// To handle gzip files that may have multiple members, see [`MultiGzDecoder`]
-/// or read more
-/// [in the introduction](../index.html#about-multi-member-gzip-files).
-///
-/// [gzip file]: https://www.rfc-editor.org/rfc/rfc1952#page-5
-///
-/// # Examples
-///
-/// ```
-/// use std::io::prelude::*;
-/// use std::io;
-/// # use flate2::Compression;
-/// # use flate2::write::GzEncoder;
-/// use flate2::read::GzDecoder;
-///
-/// # fn main() {
-/// # let mut e = GzEncoder::new(Vec::new(), Compression::default());
-/// # e.write_all(b"Hello World").unwrap();
-/// # let bytes = e.finish().unwrap();
-/// # println!("{}", decode_reader(bytes).unwrap());
-/// # }
-/// #
-/// // Uncompresses a Gz Encoded vector of bytes and returns a string or error
-/// // Here &[u8] implements Read
-///
-/// fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
-/// let mut gz = GzDecoder::new(&bytes[..]);
-/// let mut s = String::new();
-/// gz.read_to_string(&mut s)?;
-/// Ok(s)
-/// }
-/// ```
-#[derive(Debug)]
-pub struct GzDecoder<R> {
- inner: bufread::GzDecoder<BufReader<R>>,
-}
-
-impl<R: Read> GzDecoder<R> {
- /// Creates a new decoder from the given reader, immediately parsing the
- /// gzip header.
- pub fn new(r: R) -> GzDecoder<R> {
- GzDecoder {
- inner: bufread::GzDecoder::new(BufReader::new(r)),
- }
- }
-}
-
-impl<R> GzDecoder<R> {
- /// Returns the header associated with this stream, if it was valid.
- pub fn header(&self) -> Option<&GzHeader> {
- self.inner.header()
- }
-
- /// Acquires a reference to the underlying reader.
- ///
- /// Note that the decoder may have read past the end of the gzip data.
- /// To prevent this use [`bufread::GzDecoder`] instead.
- 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 decoder continues to be used.
- ///
- /// Note that the decoder may have read past the end of the gzip data.
- /// To prevent this use [`bufread::GzDecoder`] instead.
- pub fn get_mut(&mut self) -> &mut R {
- self.inner.get_mut().get_mut()
- }
-
- /// Consumes this decoder, returning the underlying reader.
- ///
- /// Note that the decoder may have read past the end of the gzip data.
- /// Subsequent reads will skip those bytes. To prevent this use
- /// [`bufread::GzDecoder`] instead.
- pub fn into_inner(self) -> R {
- self.inner.into_inner().into_inner()
- }
-}
-
-impl<R: Read> Read for GzDecoder<R> {
- fn read(&mut self, into: &mut [u8]) -> io::Result<usize> {
- self.inner.read(into)
- }
-}
-
-impl<R: Read + Write> Write for GzDecoder<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()
- }
-}
-
-/// A gzip streaming decoder that decodes a [gzip file] that may have multiple members.
-///
-/// This structure implements a [`Read`] interface. When read from, it reads
-/// compressed data from the underlying [`Read`] and provides the uncompressed
-/// data.
-///
-/// A gzip file consists of a series of *members* concatenated one after another.
-/// MultiGzDecoder decodes all members of a file and returns Ok(0) once the
-/// underlying reader does.
-///
-/// To handle members seperately, see [GzDecoder] or read more
-/// [in the introduction](../index.html#about-multi-member-gzip-files).
-///
-/// [gzip file]: https://www.rfc-editor.org/rfc/rfc1952#page-5
-///
-/// # Examples
-///
-/// ```
-/// use std::io::prelude::*;
-/// use std::io;
-/// # use flate2::Compression;
-/// # use flate2::write::GzEncoder;
-/// use flate2::read::MultiGzDecoder;
-///
-/// # fn main() {
-/// # let mut e = GzEncoder::new(Vec::new(), Compression::default());
-/// # e.write_all(b"Hello World").unwrap();
-/// # let bytes = e.finish().unwrap();
-/// # println!("{}", decode_reader(bytes).unwrap());
-/// # }
-/// #
-/// // Uncompresses a Gz Encoded vector of bytes and returns a string or error
-/// // Here &[u8] implements Read
-///
-/// fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
-/// let mut gz = MultiGzDecoder::new(&bytes[..]);
-/// let mut s = String::new();
-/// gz.read_to_string(&mut s)?;
-/// Ok(s)
-/// }
-/// ```
-#[derive(Debug)]
-pub struct MultiGzDecoder<R> {
- inner: bufread::MultiGzDecoder<BufReader<R>>,
-}
-
-impl<R: Read> MultiGzDecoder<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) -> MultiGzDecoder<R> {
- MultiGzDecoder {
- inner: bufread::MultiGzDecoder::new(BufReader::new(r)),
- }
- }
-}
-
-impl<R> MultiGzDecoder<R> {
- /// Returns the current header associated with this stream, if it's valid.
- pub fn header(&self) -> Option<&GzHeader> {
- self.inner.header()
- }
-
- /// 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 decoder 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 MultiGzDecoder<R> {
- fn read(&mut self, into: &mut [u8]) -> io::Result<usize> {
- self.inner.read(into)
- }
-}
-
-impl<R: Read + Write> Write for MultiGzDecoder<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(test)]
-mod tests {
- use std::io::{Cursor, ErrorKind, Read, Result, Write};
-
- use super::GzDecoder;
-
- //a cursor turning EOF into blocking errors
- #[derive(Debug)]
- pub struct BlockingCursor {
- pub cursor: Cursor<Vec<u8>>,
- }
-
- impl BlockingCursor {
- pub fn new() -> BlockingCursor {
- BlockingCursor {
- cursor: Cursor::new(Vec::new()),
- }
- }
-
- pub fn set_position(&mut self, pos: u64) {
- return self.cursor.set_position(pos);
- }
- }
-
- impl Write for BlockingCursor {
- fn write(&mut self, buf: &[u8]) -> Result<usize> {
- return self.cursor.write(buf);
- }
- fn flush(&mut self) -> Result<()> {
- return self.cursor.flush();
- }
- }
-
- impl Read for BlockingCursor {
- fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
- //use the cursor, except it turns eof into blocking error
- let r = self.cursor.read(buf);
- match r {
- Err(ref err) => {
- if err.kind() == ErrorKind::UnexpectedEof {
- return Err(ErrorKind::WouldBlock.into());
- }
- }
- Ok(0) => {
- //regular EOF turned into blocking error
- return Err(ErrorKind::WouldBlock.into());
- }
- Ok(_n) => {}
- }
- return r;
- }
- }
-
- #[test]
- fn blocked_partial_header_read() {
- // this is a reader which receives data afterwards
- let mut r = BlockingCursor::new();
- let data = vec![1, 2, 3];
-
- match r.write_all(&data) {
- Ok(()) => {}
- _ => {
- panic!("Unexpected result for write_all");
- }
- }
- r.set_position(0);
-
- // this is unused except for the buffering
- let mut decoder = GzDecoder::new(r);
- let mut out = Vec::with_capacity(7);
- match decoder.read(&mut out) {
- Err(e) => {
- assert_eq!(e.kind(), ErrorKind::WouldBlock);
- }
- _ => {
- panic!("Unexpected result for decoder.read");
- }
- }
- }
-}
diff --git a/vendor/flate2/src/gz/write.rs b/vendor/flate2/src/gz/write.rs
deleted file mode 100644
index 74d6c5a..0000000
--- a/vendor/flate2/src/gz/write.rs
+++ /dev/null
@@ -1,641 +0,0 @@
-use std::cmp;
-use std::io;
-use std::io::prelude::*;
-
-use super::{corrupt, GzBuilder, GzHeader, GzHeaderParser};
-use crate::crc::{Crc, CrcWriter};
-use crate::zio;
-use crate::{Compress, Compression, Decompress, Status};
-
-/// A gzip streaming encoder
-///
-/// This structure exposes a [`Write`] interface that will emit compressed data
-/// to the underlying writer `W`.
-///
-/// [`Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
-///
-/// # Examples
-///
-/// ```
-/// use std::io::prelude::*;
-/// use flate2::Compression;
-/// use flate2::write::GzEncoder;
-///
-/// // Vec<u8> implements Write to print the compressed bytes of sample string
-/// # fn main() {
-///
-/// let mut e = GzEncoder::new(Vec::new(), Compression::default());
-/// e.write_all(b"Hello World").unwrap();
-/// println!("{:?}", e.finish().unwrap());
-/// # }
-/// ```
-#[derive(Debug)]
-pub struct GzEncoder<W: Write> {
- inner: zio::Writer<W, Compress>,
- crc: Crc,
- crc_bytes_written: usize,
- header: Vec<u8>,
-}
-
-pub fn gz_encoder<W: Write>(header: Vec<u8>, w: W, lvl: Compression) -> GzEncoder<W> {
- GzEncoder {
- inner: zio::Writer::new(w, Compress::new(lvl, false)),
- crc: Crc::new(),
- header,
- crc_bytes_written: 0,
- }
-}
-
-impl<W: Write> GzEncoder<W> {
- /// Creates a new encoder which will use the given compression level.
- ///
- /// The encoder is not configured specially for the emitted header. For
- /// header configuration, see the `GzBuilder` type.
- ///
- /// The data written to the returned encoder will be compressed and then
- /// written to the stream `w`.
- pub fn new(w: W, level: Compression) -> GzEncoder<W> {
- GzBuilder::new().write(w, level)
- }
-
- /// Acquires a reference to the underlying writer.
- pub fn get_ref(&self) -> &W {
- self.inner.get_ref()
- }
-
- /// Acquires a mutable reference to the underlying writer.
- ///
- /// Note that mutation of the writer may result in surprising results if
- /// this encoder is continued to be used.
- pub fn get_mut(&mut self) -> &mut W {
- self.inner.get_mut()
- }
-
- /// Attempt to finish this output stream, writing out final chunks of data.
- ///
- /// Note that this function can only be used once data has finished being
- /// written to the output stream. After this function is called then further
- /// calls to `write` may result in a panic.
- ///
- /// # Panics
- ///
- /// Attempts to write data to this stream may result in a panic after this
- /// function is called.
- ///
- /// # Errors
- ///
- /// This function will perform I/O to complete this stream, and any I/O
- /// errors which occur will be returned from this function.
- pub fn try_finish(&mut self) -> io::Result<()> {
- self.write_header()?;
- self.inner.finish()?;
-
- while self.crc_bytes_written < 8 {
- let (sum, amt) = (self.crc.sum(), self.crc.amount());
- let buf = [
- (sum >> 0) as u8,
- (sum >> 8) as u8,
- (sum >> 16) as u8,
- (sum >> 24) as u8,
- (amt >> 0) as u8,
- (amt >> 8) as u8,
- (amt >> 16) as u8,
- (amt >> 24) as u8,
- ];
- let inner = self.inner.get_mut();
- let n = inner.write(&buf[self.crc_bytes_written..])?;
- self.crc_bytes_written += n;
- }
- Ok(())
- }
-
- /// Finish encoding this stream, returning the underlying writer once the
- /// encoding is done.
- ///
- /// Note that this function may not be suitable to call in a situation where
- /// the underlying stream is an asynchronous I/O stream. To finish a stream
- /// the `try_finish` (or `shutdown`) method should be used instead. To
- /// re-acquire ownership of a stream it is safe to call this method after
- /// `try_finish` or `shutdown` has returned `Ok`.
- ///
- /// # Errors
- ///
- /// This function will perform I/O to complete this stream, and any I/O
- /// errors which occur will be returned from this function.
- pub fn finish(mut self) -> io::Result<W> {
- self.try_finish()?;
- Ok(self.inner.take_inner())
- }
-
- fn write_header(&mut self) -> io::Result<()> {
- while !self.header.is_empty() {
- let n = self.inner.get_mut().write(&self.header)?;
- self.header.drain(..n);
- }
- Ok(())
- }
-}
-
-impl<W: Write> Write for GzEncoder<W> {
- fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
- assert_eq!(self.crc_bytes_written, 0);
- self.write_header()?;
- let n = self.inner.write(buf)?;
- self.crc.update(&buf[..n]);
- Ok(n)
- }
-
- fn flush(&mut self) -> io::Result<()> {
- assert_eq!(self.crc_bytes_written, 0);
- self.write_header()?;
- self.inner.flush()
- }
-}
-
-impl<R: Read + Write> Read for GzEncoder<R> {
- fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
- self.get_mut().read(buf)
- }
-}
-
-impl<W: Write> Drop for GzEncoder<W> {
- fn drop(&mut self) {
- if self.inner.is_present() {
- let _ = self.try_finish();
- }
- }
-}
-
-/// A decoder for a single member of a [gzip file].
-///
-/// This structure exposes a [`Write`] interface, receiving compressed data and
-/// writing uncompressed data to the underlying writer.
-///
-/// After decoding a single member of the gzip data this writer will return the number of bytes up to
-/// to the end of the gzip member and subsequent writes will return Ok(0) allowing the caller to
-/// handle any data following the gzip member.
-///
-/// To handle gzip files that may have multiple members, see [`MultiGzDecoder`]
-/// or read more
-/// [in the introduction](../index.html#about-multi-member-gzip-files).
-///
-/// [gzip file]: https://www.rfc-editor.org/rfc/rfc1952#page-5
-/// [`Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
-///
-/// # Examples
-///
-/// ```
-/// use std::io::prelude::*;
-/// use std::io;
-/// use flate2::Compression;
-/// use flate2::write::{GzEncoder, GzDecoder};
-///
-/// # fn main() {
-/// # let mut e = GzEncoder::new(Vec::new(), Compression::default());
-/// # e.write(b"Hello World").unwrap();
-/// # let bytes = e.finish().unwrap();
-/// # assert_eq!("Hello World", decode_writer(bytes).unwrap());
-/// # }
-/// // Uncompresses a gzip encoded vector of bytes and returns a string or error
-/// // Here Vec<u8> implements Write
-/// fn decode_writer(bytes: Vec<u8>) -> io::Result<String> {
-/// let mut writer = Vec::new();
-/// let mut decoder = GzDecoder::new(writer);
-/// decoder.write_all(&bytes[..])?;
-/// writer = decoder.finish()?;
-/// let return_string = String::from_utf8(writer).expect("String parsing error");
-/// Ok(return_string)
-/// }
-/// ```
-#[derive(Debug)]
-pub struct GzDecoder<W: Write> {
- inner: zio::Writer<CrcWriter<W>, Decompress>,
- crc_bytes: Vec<u8>,
- header_parser: GzHeaderParser,
-}
-
-const CRC_BYTES_LEN: usize = 8;
-
-impl<W: Write> GzDecoder<W> {
- /// Creates a new decoder which will write uncompressed data to the stream.
- ///
- /// When this encoder is dropped or unwrapped the final pieces of data will
- /// be flushed.
- pub fn new(w: W) -> GzDecoder<W> {
- GzDecoder {
- inner: zio::Writer::new(CrcWriter::new(w), Decompress::new(false)),
- crc_bytes: Vec::with_capacity(CRC_BYTES_LEN),
- header_parser: GzHeaderParser::new(),
- }
- }
-
- /// Returns the header associated with this stream.
- pub fn header(&self) -> Option<&GzHeader> {
- self.header_parser.header()
- }
-
- /// Acquires a reference to the underlying writer.
- pub fn get_ref(&self) -> &W {
- self.inner.get_ref().get_ref()
- }
-
- /// Acquires a mutable reference to the underlying writer.
- ///
- /// Note that mutating the output/input state of the stream may corrupt this
- /// object, so care must be taken when using this method.
- pub fn get_mut(&mut self) -> &mut W {
- self.inner.get_mut().get_mut()
- }
-
- /// Attempt to finish this output stream, writing out final chunks of data.
- ///
- /// Note that this function can only be used once data has finished being
- /// written to the output stream. After this function is called then further
- /// calls to `write` may result in a panic.
- ///
- /// # Panics
- ///
- /// Attempts to write data to this stream may result in a panic after this
- /// function is called.
- ///
- /// # Errors
- ///
- /// This function will perform I/O to finish the stream, returning any
- /// errors which happen.
- pub fn try_finish(&mut self) -> io::Result<()> {
- self.finish_and_check_crc()?;
- Ok(())
- }
-
- /// Consumes this decoder, flushing the output stream.
- ///
- /// This will flush the underlying data stream and then return the contained
- /// writer if the flush succeeded.
- ///
- /// Note that this function may not be suitable to call in a situation where
- /// the underlying stream is an asynchronous I/O stream. To finish a stream
- /// the `try_finish` (or `shutdown`) method should be used instead. To
- /// re-acquire ownership of a stream it is safe to call this method after
- /// `try_finish` or `shutdown` has returned `Ok`.
- ///
- /// # Errors
- ///
- /// This function will perform I/O to complete this stream, and any I/O
- /// errors which occur will be returned from this function.
- pub fn finish(mut self) -> io::Result<W> {
- self.finish_and_check_crc()?;
- Ok(self.inner.take_inner().into_inner())
- }
-
- fn finish_and_check_crc(&mut self) -> io::Result<()> {
- self.inner.finish()?;
-
- if self.crc_bytes.len() != 8 {
- return Err(corrupt());
- }
-
- let crc = ((self.crc_bytes[0] as u32) << 0)
- | ((self.crc_bytes[1] as u32) << 8)
- | ((self.crc_bytes[2] as u32) << 16)
- | ((self.crc_bytes[3] as u32) << 24);
- let amt = ((self.crc_bytes[4] as u32) << 0)
- | ((self.crc_bytes[5] as u32) << 8)
- | ((self.crc_bytes[6] as u32) << 16)
- | ((self.crc_bytes[7] as u32) << 24);
- if crc != self.inner.get_ref().crc().sum() {
- return Err(corrupt());
- }
- if amt != self.inner.get_ref().crc().amount() {
- return Err(corrupt());
- }
- Ok(())
- }
-}
-
-impl<W: Write> Write for GzDecoder<W> {
- fn write(&mut self, mut buf: &[u8]) -> io::Result<usize> {
- let buflen = buf.len();
- if self.header().is_none() {
- match self.header_parser.parse(&mut buf) {
- Err(err) => {
- if err.kind() == io::ErrorKind::UnexpectedEof {
- // all data read but header still not complete
- Ok(buflen)
- } else {
- Err(err)
- }
- }
- Ok(_) => {
- debug_assert!(self.header().is_some());
- // buf now contains the unread part of the original buf
- let n = buflen - buf.len();
- Ok(n)
- }
- }
- } else {
- let (n, status) = self.inner.write_with_status(buf)?;
-
- if status == Status::StreamEnd && n < buf.len() && self.crc_bytes.len() < 8 {
- let remaining = buf.len() - n;
- let crc_bytes = cmp::min(remaining, CRC_BYTES_LEN - self.crc_bytes.len());
- self.crc_bytes.extend(&buf[n..n + crc_bytes]);
- return Ok(n + crc_bytes);
- }
- Ok(n)
- }
- }
-
- fn flush(&mut self) -> io::Result<()> {
- self.inner.flush()
- }
-}
-
-impl<W: Read + Write> Read for GzDecoder<W> {
- fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
- self.inner.get_mut().get_mut().read(buf)
- }
-}
-
-/// A gzip streaming decoder that decodes a [gzip file] with multiple members.
-///
-/// This structure exposes a [`Write`] interface that will consume compressed data and
-/// write uncompressed data to the underlying writer.
-///
-/// A gzip file consists of a series of *members* concatenated one after another.
-/// `MultiGzDecoder` decodes all members of a file and writes them to the
-/// underlying writer one after another.
-///
-/// To handle members separately, see [GzDecoder] or read more
-/// [in the introduction](../index.html#about-multi-member-gzip-files).
-///
-/// [gzip file]: https://www.rfc-editor.org/rfc/rfc1952#page-5
-#[derive(Debug)]
-pub struct MultiGzDecoder<W: Write> {
- inner: GzDecoder<W>,
-}
-
-impl<W: Write> MultiGzDecoder<W> {
- /// Creates a new decoder which will write uncompressed data to the stream.
- /// If the gzip stream contains multiple members all will be decoded.
- pub fn new(w: W) -> MultiGzDecoder<W> {
- MultiGzDecoder {
- inner: GzDecoder::new(w),
- }
- }
-
- /// Returns the header associated with the current member.
- pub fn header(&self) -> Option<&GzHeader> {
- self.inner.header()
- }
-
- /// Acquires a reference to the underlying writer.
- pub fn get_ref(&self) -> &W {
- self.inner.get_ref()
- }
-
- /// Acquires a mutable reference to the underlying writer.
- ///
- /// Note that mutating the output/input state of the stream may corrupt this
- /// object, so care must be taken when using this method.
- pub fn get_mut(&mut self) -> &mut W {
- self.inner.get_mut()
- }
-
- /// Attempt to finish this output stream, writing out final chunks of data.
- ///
- /// Note that this function can only be used once data has finished being
- /// written to the output stream. After this function is called then further
- /// calls to `write` may result in a panic.
- ///
- /// # Panics
- ///
- /// Attempts to write data to this stream may result in a panic after this
- /// function is called.
- ///
- /// # Errors
- ///
- /// This function will perform I/O to finish the stream, returning any
- /// errors which happen.
- pub fn try_finish(&mut self) -> io::Result<()> {
- self.inner.try_finish()
- }
-
- /// Consumes this decoder, flushing the output stream.
- ///
- /// This will flush the underlying data stream and then return the contained
- /// writer if the flush succeeded.
- ///
- /// Note that this function may not be suitable to call in a situation where
- /// the underlying stream is an asynchronous I/O stream. To finish a stream
- /// the `try_finish` (or `shutdown`) method should be used instead. To
- /// re-acquire ownership of a stream it is safe to call this method after
- /// `try_finish` or `shutdown` has returned `Ok`.
- ///
- /// # Errors
- ///
- /// This function will perform I/O to complete this stream, and any I/O
- /// errors which occur will be returned from this function.
- pub fn finish(self) -> io::Result<W> {
- self.inner.finish()
- }
-}
-
-impl<W: Write> Write for MultiGzDecoder<W> {
- fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
- if buf.is_empty() {
- Ok(0)
- } else {
- match self.inner.write(buf) {
- Ok(0) => {
- // When the GzDecoder indicates that it has finished
- // create a new GzDecoder to handle additional data.
- self.inner.try_finish()?;
- let w = self.inner.inner.take_inner().into_inner();
- self.inner = GzDecoder::new(w);
- self.inner.write(buf)
- }
- res => res,
- }
- }
- }
-
- fn flush(&mut self) -> io::Result<()> {
- self.inner.flush()
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- const STR: &str = "Hello World Hello World Hello World Hello World Hello World \
- Hello World Hello World Hello World Hello World Hello World \
- Hello World Hello World Hello World Hello World Hello World \
- Hello World Hello World Hello World Hello World Hello World \
- Hello World Hello World Hello World Hello World Hello World";
-
- #[test]
- fn decode_writer_one_chunk() {
- let mut e = GzEncoder::new(Vec::new(), Compression::default());
- e.write(STR.as_ref()).unwrap();
- let bytes = e.finish().unwrap();
-
- let mut writer = Vec::new();
- let mut decoder = GzDecoder::new(writer);
- let n = decoder.write(&bytes[..]).unwrap();
- decoder.write(&bytes[n..]).unwrap();
- decoder.try_finish().unwrap();
- writer = decoder.finish().unwrap();
- let return_string = String::from_utf8(writer).expect("String parsing error");
- assert_eq!(return_string, STR);
- }
-
- #[test]
- fn decode_writer_partial_header() {
- let mut e = GzEncoder::new(Vec::new(), Compression::default());
- e.write(STR.as_ref()).unwrap();
- let bytes = e.finish().unwrap();
-
- let mut writer = Vec::new();
- let mut decoder = GzDecoder::new(writer);
- assert_eq!(decoder.write(&bytes[..5]).unwrap(), 5);
- let n = decoder.write(&bytes[5..]).unwrap();
- if n < bytes.len() - 5 {
- decoder.write(&bytes[n + 5..]).unwrap();
- }
- writer = decoder.finish().unwrap();
- let return_string = String::from_utf8(writer).expect("String parsing error");
- assert_eq!(return_string, STR);
- }
-
- #[test]
- fn decode_writer_partial_header_filename() {
- let filename = "test.txt";
- let mut e = GzBuilder::new()
- .filename(filename)
- .read(STR.as_bytes(), Compression::default());
- let mut bytes = Vec::new();
- e.read_to_end(&mut bytes).unwrap();
-
- let mut writer = Vec::new();
- let mut decoder = GzDecoder::new(writer);
- assert_eq!(decoder.write(&bytes[..12]).unwrap(), 12);
- let n = decoder.write(&bytes[12..]).unwrap();
- if n < bytes.len() - 12 {
- decoder.write(&bytes[n + 12..]).unwrap();
- }
- assert_eq!(
- decoder.header().unwrap().filename().unwrap(),
- filename.as_bytes()
- );
- writer = decoder.finish().unwrap();
- let return_string = String::from_utf8(writer).expect("String parsing error");
- assert_eq!(return_string, STR);
- }
-
- #[test]
- fn decode_writer_partial_header_comment() {
- let comment = "test comment";
- let mut e = GzBuilder::new()
- .comment(comment)
- .read(STR.as_bytes(), Compression::default());
- let mut bytes = Vec::new();
- e.read_to_end(&mut bytes).unwrap();
-
- let mut writer = Vec::new();
- let mut decoder = GzDecoder::new(writer);
- assert_eq!(decoder.write(&bytes[..12]).unwrap(), 12);
- let n = decoder.write(&bytes[12..]).unwrap();
- if n < bytes.len() - 12 {
- decoder.write(&bytes[n + 12..]).unwrap();
- }
- assert_eq!(
- decoder.header().unwrap().comment().unwrap(),
- comment.as_bytes()
- );
- writer = decoder.finish().unwrap();
- let return_string = String::from_utf8(writer).expect("String parsing error");
- assert_eq!(return_string, STR);
- }
-
- #[test]
- fn decode_writer_exact_header() {
- let mut e = GzEncoder::new(Vec::new(), Compression::default());
- e.write(STR.as_ref()).unwrap();
- let bytes = e.finish().unwrap();
-
- let mut writer = Vec::new();
- let mut decoder = GzDecoder::new(writer);
- assert_eq!(decoder.write(&bytes[..10]).unwrap(), 10);
- decoder.write(&bytes[10..]).unwrap();
- writer = decoder.finish().unwrap();
- let return_string = String::from_utf8(writer).expect("String parsing error");
- assert_eq!(return_string, STR);
- }
-
- #[test]
- fn decode_writer_partial_crc() {
- let mut e = GzEncoder::new(Vec::new(), Compression::default());
- e.write(STR.as_ref()).unwrap();
- let bytes = e.finish().unwrap();
-
- let mut writer = Vec::new();
- let mut decoder = GzDecoder::new(writer);
- let l = bytes.len() - 5;
- let n = decoder.write(&bytes[..l]).unwrap();
- decoder.write(&bytes[n..]).unwrap();
- writer = decoder.finish().unwrap();
- let return_string = String::from_utf8(writer).expect("String parsing error");
- assert_eq!(return_string, STR);
- }
-
- // Two or more gzip files concatenated form a multi-member gzip file. MultiGzDecoder will
- // concatenate the decoded contents of all members.
- #[test]
- fn decode_multi_writer() {
- let mut e = GzEncoder::new(Vec::new(), Compression::default());
- e.write(STR.as_ref()).unwrap();
- let bytes = e.finish().unwrap().repeat(2);
-
- let mut writer = Vec::new();
- let mut decoder = MultiGzDecoder::new(writer);
- let mut count = 0;
- while count < bytes.len() {
- let n = decoder.write(&bytes[count..]).unwrap();
- assert!(n != 0);
- count += n;
- }
- writer = decoder.finish().unwrap();
- let return_string = String::from_utf8(writer).expect("String parsing error");
- let expected = STR.repeat(2);
- assert_eq!(return_string, expected);
- }
-
- // GzDecoder consumes one gzip member and then returns 0 for subsequent writes, allowing any
- // additional data to be consumed by the caller.
- #[test]
- fn decode_extra_data() {
- let compressed = {
- let mut e = GzEncoder::new(Vec::new(), Compression::default());
- e.write(STR.as_ref()).unwrap();
- let mut b = e.finish().unwrap();
- b.push(b'x');
- b
- };
-
- let mut writer = Vec::new();
- let mut decoder = GzDecoder::new(writer);
- let mut consumed_bytes = 0;
- loop {
- let n = decoder.write(&compressed[consumed_bytes..]).unwrap();
- if n == 0 {
- break;
- }
- consumed_bytes += n;
- }
- writer = decoder.finish().unwrap();
- let actual = String::from_utf8(writer).expect("String parsing error");
- assert_eq!(actual, STR);
- assert_eq!(&compressed[consumed_bytes..], b"x");
- }
-}
Copyright © 2024 Valentin A. Popov. All Rights Reverse Engineered.