Add simple zip reader

1 files changed, 143 insertions, 0 deletions

diff --git a/src/zip/driver.rs b/src/zip/driver.rs
new file mode 100644
index 0000000..733d44b
--- /dev/null
+++ b/src/zip/driver.rs
@@ -0,0 +1,143 @@
+use crate::driver::{ArchiveRead, ArchiveWrite, Driver};
+use crate::zip::error::{ZipError, ZipResult};
+use crate::zip::structs::{EOCDR64Locator, CDR, EOCDR, EOCDR64};
+use crate::zip::ZipFile;
+use std::collections::HashMap as Map;
+use std::fs::File;
+use std::io::{Read, Seek, SeekFrom, Write};
+
+pub struct Zip<IO = File> {
+    io: IO,
+
+    files: Map<String, ZipFile>,
+    comment: String,
+}
+
+impl<IO> Driver for Zip<IO> {
+    type Error = ZipError;
+
+    type IO = IO;
+    type File = ZipFile;
+}
+
+impl<IO: Read + Seek> ArchiveRead for Zip<IO> {
+    fn read(mut io: Self::IO) -> ZipResult<Self> {
+        // Search eocdr
+        let limit = 65557.min(io.seek(SeekFrom::End(0))?) as i64;
+        let start = io.seek(SeekFrom::End(-limit))?;
+        let pos = start + {
+            let mut buf = vec![0; limit as usize];
+            io.read(&mut buf)?;
+            buf[..buf.len() - 18]
+                .windows(4)
+                .rposition(|v| u32::from_le_bytes(v.try_into().unwrap()) == 0x06054b50)
+                .ok_or(ZipError::EOCDRNotFound)? as u64
+        };
+
+        // Read eocdr
+        io.seek(SeekFrom::Start(pos + 4))?;
+        let buf = {
+            let mut buf = [0; 18];
+            io.read(&mut buf)?;
+            buf
+        };
+        let eocdr: EOCDR = bincode::deserialize(&buf).map_err(|_| ZipError::InvalidEOCDR)?;
+        let comment = {
+            let mut buf = vec![0; eocdr.comment_len as usize];
+            io.read(&mut buf)?;
+            String::from_utf8(buf).map_err(|_| ZipError::InvalidArchiveComment)?
+        };
+
+        // Try to find eocdr64locator
+        io.seek(SeekFrom::Start(pos - 20))?;
+        let buf = {
+            let mut buf = [0; 20];
+            io.read(&mut buf)?;
+            buf
+        };
+        let (cd_pointer, cd_size, cd_records) =
+            if u32::from_le_bytes(buf[0..4].try_into().unwrap()) == 0x07064b50 {
+                let eocdr64locator: EOCDR64Locator =
+                    bincode::deserialize(&buf[4..]).map_err(|_| ZipError::InvalidEOCDR64Locator)?;
+
+                io.seek(SeekFrom::Start(eocdr64locator.eocdr64_pointer))?;
+                let buf = {
+                    let mut buf = [0; 56];
+                    io.read(&mut buf)?;
+                    buf
+                };
+                if u32::from_le_bytes(buf[0..4].try_into().unwrap()) != 0x06064b50 {
+                    return Err(ZipError::InvalidEOCDR64Signature.into());
+                }
+                let eocdr64: EOCDR64 =
+                    bincode::deserialize(&buf[4..]).map_err(|_| ZipError::InvalidEOCDR64)?;
+
+                (eocdr64.cd_pointer, eocdr64.cd_size, eocdr64.cd_records)
+            } else {
+                (
+                    eocdr.cd_pointer as u64,
+                    eocdr.cd_size as u64,
+                    eocdr.cd_records as u64,
+                )
+            };
+
+        // Read cd records
+        let mut files = Map::with_capacity(cd_records as usize);
+        io.seek(SeekFrom::Start(cd_pointer))?;
+        let buf = {
+            let mut buf = vec![0; cd_size as usize];
+            io.read(&mut buf)?;
+            buf
+        };
+        let mut records = buf.as_slice();
+
+        for _ in 0..cd_records {
+            let buf = {
+                let mut buf = [0; 46];
+                records.read(&mut buf)?;
+                buf
+            };
+
+            if u32::from_le_bytes(buf[0..4].try_into().unwrap()) != 0x02014b50 {
+                return Err(ZipError::InvalidCDRSignature.into());
+            }
+            let cdr: CDR = bincode::deserialize(&buf[4..]).map_err(|_| ZipError::InvalidCDR)?;
+            let name = {
+                let mut buf = vec![0; cdr.name_len as usize];
+                records.read(&mut buf)?;
+                String::from_utf8(buf).map_err(|_| ZipError::InvalidFileName)?
+            };
+            let extra_fields = {
+                let mut buf = vec![0; cdr.extra_field_len as usize];
+                records.read(&mut buf)?;
+                buf
+            };
+            let comment = {
+                let mut buf = vec![0; cdr.comment_len as usize];
+                records.read(&mut buf)?;
+                String::from_utf8(buf).map_err(|_| ZipError::InvalidFileComment)?
+            };
+
+            files.insert(
+                name.clone(),
+                ZipFile::new(
+                    name,
+                    cdr.dos_date,
+                    cdr.dos_time,
+                    cdr.compression_method,
+                    cdr.compressed_size as u64,
+                    cdr.size as u64,
+                    comment,
+                ),
+            );
+        }
+
+        Ok(Self { io, files, comment })
+    }
+}
+
+impl<IO: Read + Seek> Zip<IO> {}
+
+impl<IO: Read + Write + Seek> ArchiveWrite for Zip<IO> {}
+
+impl<IO: Read + Write> Zip<IO> {}