feat(decompression-plz): added ExtraRaw variant to DecompressionError

Author: darkseid-is

decompression-plz/src/decompression/dstruct.rs

@@ -8,7 +8,7 @@ use header_plz::body_headers::{
 use crate::decompression::{
     magic_bytes::is_compressed,
     multi::{decompress_multi, error::MultiDecompressError},
-    single::decompress_single,
+    single::{decompress_single, error::DecompressError},
 };
 
 pub struct DecompressionStruct<'a> {
@@ -128,7 +128,7 @@ impl<'a> DecompressionStruct<'a> {
         );
         if let Err(e) = result {
             self.push_last_encoding(last_encoding);
-            return Err(e);
+            return Err(e.into());
         }
         let output = self.writer.get_mut().split();
         if !self.is_encodings_empty() {
@@ -144,20 +144,22 @@ impl<'a> DecompressionStruct<'a> {
         mut writer: &mut Writer<&mut BytesMut>,
         content_encoding: &ContentEncoding,
         len: u64,
-    ) -> Result<(), MultiDecompressError> {
+    ) -> Result<(), DecompressError> {
         if let ContentEncoding::Deflate = content_encoding {
             let mut reader = flate2::read::ZlibDecoder::new(input);
-            std::io::copy(&mut reader, &mut writer)?;
+            std::io::copy(&mut reader, &mut writer)
+                .map_err(DecompressError::Copy)?;
             if reader.total_in() != len {
-                return Err(MultiDecompressError::extra_raw());
+                return Err(DecompressError::deflate());
             }
             return Ok(());
         }
-        decompress_single(&mut input, &mut writer, content_encoding)
-            .map_err(|_| MultiDecompressError::extra_raw())?;
+        // others
+        decompress_single(&mut input, &mut writer, content_encoding)?;
         let (_, extra_curs) = input.get_ref();
+        // brotli
         if extra_curs.position() == 0 {
-            return Err(MultiDecompressError::extra_raw());
+            return Err(DecompressError::extra_raw(content_encoding.clone()));
         }
         Ok(())
     }
@@ -462,8 +464,16 @@ mod tests {
 
             let err = ds.try_decompress_main_plus_extra().unwrap_err();
 
-            assert_eq!(err.reason, MultiDecompressErrorReason::ExtraRaw);
-            assert!(matches!(err.error, DecompressError::Copy(_)));
+            assert_eq!(err.reason, MultiDecompressErrorReason::Corrupt);
+            match encoding {
+                ContentEncoding::Zstd => {
+                    assert!(matches!(err.error, DecompressError::Zstd(_)))
+                }
+                _ => {
+                    assert!(matches!(err.error, DecompressError::ExtraRaw(_)))
+                }
+            }
+
             assert_eq!(ds.encoding_info, original_info);
         }
     }

decompression-plz/src/decompression/multi/error.rs

@@ -29,14 +29,6 @@ impl MultiDecompressError {
         Self::corrupt(DecompressError::Deflate(e))
     }
 
-    pub fn extra_raw() -> Self {
-        let e = std::io::Error::from(std::io::ErrorKind::InvalidData);
-        MultiDecompressError::new(
-            MultiDecompressErrorReason::ExtraRaw,
-            DecompressError::Copy(e),
-        )
-    }
-
     pub fn reason(&self) -> &MultiDecompressErrorReason {
         &self.reason
     }
@@ -80,6 +72,12 @@ impl From<MultiDecompressError> for DecompressError {
     }
 }
 
+impl From<DecompressError> for MultiDecompressError {
+    fn from(e: DecompressError) -> Self {
+        MultiDecompressError::new(MultiDecompressErrorReason::Corrupt, e)
+    }
+}
+
 #[cfg_attr(test, derive(PartialEq, Eq))]
 #[derive(Debug, Error)]
 pub enum MultiDecompressErrorReason {
@@ -93,8 +91,6 @@ pub enum MultiDecompressErrorReason {
     },
     #[error("Copy")]
     Copy,
-    #[error("ExtraRaw")]
-    ExtraRaw,
 }
 
 impl MultiDecompressErrorReason {

decompression-plz/src/decompression/single/error.rs

@@ -1,3 +1,4 @@
+use header_plz::body_headers::content_encoding::ContentEncoding;
 use std::io::Error;
 use thiserror::Error;
 
@@ -18,4 +19,17 @@ pub enum DecompressError {
     Identity(Error),
     #[error("unknown| {0}")]
     Unknown(String),
+
+    #[error("extra raw")]
+    ExtraRaw(ContentEncoding),
+}
+
+impl DecompressError {
+    pub fn deflate() -> Self {
+        DecompressError::ExtraRaw(ContentEncoding::Deflate)
+    }
+
+    pub fn extra_raw(encoding: ContentEncoding) -> Self {
+        DecompressError::ExtraRaw(encoding)
+    }
 }