1 files changed, 40 insertions, 48 deletions

diff --git a/src/zip/file/read.rs b/src/zip/file/read.rs
index aa665c3..c26b304 100644
--- a/src/zip/file/read.rs
+++ b/src/zip/file/read.rs
@@ -17,11 +17,12 @@ enum Encryption<Io: Read> {
 }
 
 impl<Io: Read> Encryption<Io> {
-    pub fn new(io: Io, method: EncryptionMethod, password: Option<&str>) -> ZipResult<Self> {
-        Ok(match method {
+    pub fn new(io: Io, info: &ZipFileInfo, password: Option<&[u8]>) -> ZipResult<Self> {
+        Ok(match info.encryption_method {
             EncryptionMethod::None => Self::None(io),
-            EncryptionMethod::Weak => Self::Weak(WeakDecoder::new(
+            EncryptionMethod::Weak(check) => Self::Weak(WeakDecoder::new(
                 io,
+                check,
                 password.ok_or(ZipError::PasswordIsNotSpecified)?,
             )?),
             EncryptionMethod::Unsupported => {
@@ -61,12 +62,29 @@ enum Compression<Io: Read> {
 }
 
 impl<Io: Read + Seek> Compression<Io> {
-    pub fn new(io: Io, method: CompressionMethod) -> ZipResult<Self> {
-        Ok(match method {
+    pub fn new(mut io: Io, info: &ZipFileInfo) -> ZipResult<Self> {
+        Ok(match info.compression_method {
             CompressionMethod::Store => Self::Store(io),
             CompressionMethod::Deflate => Self::Deflate(DeflateDecoder::new(io)),
             CompressionMethod::BZip2 => Self::BZip2(BzDecoder::new(io)),
-            CompressionMethod::Lzma => panic!(),
+            CompressionMethod::Lzma => {
+                let buf = io.read_arr::<9>()?;
+                Compression::Xz(XzDecoder::new_stream(
+                    io,
+                    Stream::new_raw_decoder(
+                        Filters::new().lzma1(
+                            LzmaOptions::new()
+                                .literal_context_bits((buf[4] % 9) as u32)
+                                .literal_position_bits((buf[4] / 9 % 5) as u32)
+                                .position_bits((buf[4] / 45) as u32)
+                                .dict_size(
+                                    u32::from_le_bytes(buf[5..9].try_into().unwrap()).max(4096),
+                                ),
+                        ),
+                    )
+                    .unwrap(),
+                ))
+            }
             CompressionMethod::Zstd => Self::Zstd(ZstdDecoder::new(io)?),
             CompressionMethod::Xz => Self::Xz(XzDecoder::new(io)),
             CompressionMethod::Unsupported(id) => {
@@ -108,14 +126,14 @@ pub struct ZipFileReader<'d, Io: Read> {
 impl<'d, Io: Read> FileDriver for ZipFileReader<'d, Io> {
     type Io = Io;
     type FileInfo = ZipFileInfo;
-
-    fn info(&self) -> &Self::FileInfo {
-        self.info
-    }
 }
 
 impl<'d, Io: Read + Seek> ZipFileReader<'d, Io> {
-    pub fn new(io: &'d mut Io, info: &'d ZipFileInfo, password: Option<&str>) -> ZipResult<Self> {
+    pub(crate) fn new(
+        io: &'d mut Io,
+        info: &'d ZipFileInfo,
+        password: Option<&[u8]>,
+    ) -> ZipResult<Self> {
         io.seek(SeekFrom::Start(info.header_pointer))?;
 
         let buf = io.read_arr::<30>()?;
@@ -127,49 +145,23 @@ impl<'d, Io: Read + Seek> ZipFileReader<'d, Io> {
             + u16::from_le_bytes(buf[26..28].try_into().unwrap()) as u64
             + u16::from_le_bytes(buf[28..30].try_into().unwrap()) as u64;
 
-        io.seek(SeekFrom::Start(data_pointer))?;
-
         Ok(Self {
-            io: match info.compression_method {
-                CompressionMethod::Lzma => {
-                    let buf = io.read_arr::<9>()?;
-                    Compression::Xz(XzDecoder::new_stream(
-                        Encryption::new(
-                            IoCursor::new(
-                                io,
-                                data_pointer + 9,
-                                data_pointer + info.compressed_size,
-                            )?,
-                            info.encryption_method,
-                            password,
-                        )?,
-                        Stream::new_raw_decoder(
-                            Filters::new().lzma1(
-                                LzmaOptions::new()
-                                    .literal_context_bits((buf[4] % 9) as u32)
-                                    .literal_position_bits((buf[4] / 9 % 5) as u32)
-                                    .position_bits((buf[4] / 45) as u32)
-                                    .dict_size(
-                                        u32::from_le_bytes(buf[5..9].try_into().unwrap()).max(4096),
-                                    ),
-                            ),
-                        )
-                        .unwrap(),
-                    ))
-                }
-                _ => Compression::new(
-                    Encryption::new(
-                        IoCursor::new(io, data_pointer, data_pointer + info.compressed_size)?,
-                        info.encryption_method,
-                        password,
-                    )?,
-                    info.compression_method,
+            io: Compression::new(
+                Encryption::new(
+                    IoCursor::new(io, data_pointer, data_pointer + info.compressed_size)?,
+                    info,
+                    password,
                 )?,
-            },
+                info,
+            )?,
             info,
         })
     }
 
+    pub fn info(&self) -> &ZipFileInfo {
+        self.info
+    }
+
     pub fn is_seekable(&self) -> bool {
         match self.io {
             Compression::Store(Encryption::None(..)) => true,