Method decompress

avro/src/codec.rs:146–222

Decompress a stream of bytes in-place.

(self, stream: &mut Vec<u8>)

    /// Decompress a stream of bytes in-place.
    pub fn decompress(self, stream: &mut Vec<u8>) -> AvroResult<()> {
        // Cap the decompressed output at the configured allocation budget so a
        // small compressed block cannot inflate to an enormous buffer (a
        // "decompression bomb") and exhaust memory.
        let max_bytes =
            crate::util::max_allocation_bytes(crate::util::DEFAULT_MAX_ALLOCATION_BYTES);
        *stream = match self {
            Codec::Null => return Ok(()),
            Codec::Deflate(_settings) => miniz_oxide::inflate::decompress_to_vec_with_limit(stream, max_bytes).map_err(|e| {
                use std::io::ErrorKind;
                use miniz_oxide::inflate::TINFLStatus;

                let details = match e.status {
                    TINFLStatus::FailedCannotMakeProgress | TINFLStatus::NeedsMoreInput => Details::DeflateDecompress(ErrorKind::UnexpectedEof.into()),
                    TINFLStatus::Adler32Mismatch | TINFLStatus::Failed | TINFLStatus::BadParam => Details::DeflateDecompress(ErrorKind::InvalidData.into()),
                    TINFLStatus::Done => Details::DeflateDecompress(std::io::Error::other("Unexpected error: miniz_oxide reported an error with a success status. Please report this to avro-rs developers.")),
                    // Output is larger than max allocation allowed
                    TINFLStatus::HasMoreOutput => Details::MemoryAllocation {
                        desired: None,
                        maximum: max_bytes,
                    },
                    other => Details::DeflateDecompress(std::io::Error::other(format!("Unexpected error: {other:?}")))
                };
                Error::new(details)
            })?,
            #[cfg(feature = "snappy")]
            Codec::Snappy => {
                // The block ends with a 4-byte CRC32; a truncated/corrupt block
                // shorter than that must error rather than underflow the slice.
                let data_end = stream
                    .len()
                    .checked_sub(4)
                    .ok_or(Details::BadSnappyLength(stream.len()))?;
                let decompressed_size = snap::raw::decompress_len(&stream[..data_end])
                    .map_err(Details::GetSnappyDecompressLen)?;
                // The decompressed size is taken from the (untrusted) block
                // header, so bound it before allocating for it.
                let decompressed_size = crate::util::safe_len(decompressed_size)?;
                let mut decoded = vec![0; decompressed_size];
                snap::raw::Decoder::new()
                    .decompress(&stream[..data_end], &mut decoded[..])
                    .map_err(Details::SnappyDecompress)?;

                let mut last_four: [u8; 4] = [0; 4];
                last_four.copy_from_slice(&stream[data_end..]);
                let expected: u32 = u32::from_be_bytes(last_four);

                let actual = crc_fast::crc32_iso_hdlc(&decoded);

                if expected != actual {
                    return Err(Details::SnappyCrc32{expected, actual}.into());
                }
                decoded
            }
            #[cfg(feature = "zstandard")]
            Codec::Zstandard(_settings) => {
                use std::io::{BufReader, Read};
                use zstd::zstd_safe;