7 files changed, 142 insertions, 26 deletions

diff --git a/src/zip/archive.rs b/src/zip/archive.rs
index 9a244fc..79e8ca1 100644
--- a/src/zip/archive.rs
+++ b/src/zip/archive.rs
@@ -1,10 +1,10 @@
 use crate::{Archive, Zip};
 use std::io::{Read, Seek, Write};
 
-impl<IO: Read + Seek> Archive<Zip<IO>> {
+impl<Io: Read + Seek> Archive<Zip<Io>> {
     pub fn comment(&self) -> &String {
         self.driver.comment()
     }
 }
 
-impl<IO: Read + Write + Seek> Archive<Zip<IO>> {}
+impl<Io: Read + Write + Seek> Archive<Zip<Io>> {}
diff --git a/src/zip/driver.rs b/src/zip/driver.rs
index 650344e..0db845d 100644
--- a/src/zip/driver.rs
+++ b/src/zip/driver.rs
@@ -1,27 +1,27 @@
 use crate::driver::{ArchiveRead, ArchiveWrite, Driver};
-use crate::zip::file::{BitFlag, CompressionMethod};
 use crate::zip::structs::{deserialize, EOCDR64Locator, ExtraHeader, CDR, EOCDR, EOCDR64};
-use crate::zip::{ZipError, ZipFile, ZipResult};
+use crate::zip::{BitFlag, CompressionMethod, ZipError, ZipFile, ZipFileInfo, ZipResult};
 use chrono::{Local, NaiveDate, NaiveDateTime, NaiveTime};
 use std::collections::HashMap as Map;
 use std::io::{Read, Seek, SeekFrom, Write};
 
-pub struct Zip<IO> {
-    io: IO,
+pub struct Zip<Io> {
+    io: Io,
 
-    files: Map<String, ZipFile>,
+    files: Map<String, ZipFileInfo>,
     comment: String,
 }
 
-impl<IO> Driver for Zip<IO> {
+impl<Io> Driver for Zip<Io> {
     type Error = ZipError;
 
-    type IO = IO;
-    type File = ZipFile;
+    type Io = Io;
+    type FileDriver<'d> = ZipFile<'d, Self::Io> where Self::Io: 'd;
+    type FileInfo = ZipFileInfo;
 }
 
-impl<IO: Read + Seek> ArchiveRead for Zip<IO> {
-    fn read(mut io: Self::IO) -> ZipResult<Self> {
+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))?;
@@ -137,7 +137,7 @@ impl<IO: Read + Seek> ArchiveRead for Zip<IO> {
 
             files.insert(
                 name.clone(),
-                ZipFile::new(
+                ZipFileInfo::new(
                     CompressionMethod::from_struct_id(cdr.compression_method)?,
                     BitFlag::new(cdr.bit_flag),
                     NaiveDateTime::new(
@@ -169,23 +169,27 @@ impl<IO: Read + Seek> ArchiveRead for Zip<IO> {
         Ok(Self { io, files, comment })
     }
 
-    fn files(&self) -> Vec<&Self::File> {
-        let mut files: Vec<&Self::File> = self.files.values().collect();
+    fn files(&self) -> Vec<&Self::FileInfo> {
+        let mut files: Vec<&Self::FileInfo> = self.files.values().collect();
         files.sort_by_key(|f| &f.name);
         files
     }
 
-    fn get_file(&self, name: &str) -> Option<&Self::File> {
+    fn get_file_info(&self, name: &str) -> Option<&Self::FileInfo> {
         self.files.get(name)
     }
+
+    fn get_file_reader<'d>(&'d mut self, name: &str) -> Option<Self::FileDriver<'d>> {
+        Some(ZipFile::new(&mut self.io, self.files.get(name)?).unwrap())
+    }
 }
 
-impl<IO: Read + Seek> Zip<IO> {
+impl<Io: Read + Seek> Zip<Io> {
     pub fn comment(&self) -> &String {
         &self.comment
     }
 }
 
-impl<IO: Read + Write + Seek> ArchiveWrite for Zip<IO> {}
+impl<Io: Read + Write + Seek> ArchiveWrite for Zip<Io> {}
 
-impl<IO: Read + Write + Seek> Zip<IO> {}
+impl<Io: Read + Write + Seek> Zip<Io> {}
diff --git a/src/zip/error.rs b/src/zip/error.rs
index 1c5527c..d82de78 100644
--- a/src/zip/error.rs
+++ b/src/zip/error.rs
@@ -8,6 +8,7 @@ pub type ZipResult<T> = ArchiveResult<T, ZipError>;
 pub enum ZipError {
     EOCDRNotFound,
     InvalidEOCDR64Signature,
+    InvalidFileHeaderSignature,
     InvalidCDRSignature,
 
     InvalidArchiveComment,
@@ -17,6 +18,8 @@ pub enum ZipError {
     InvalidTime,
     InvalidFileName,
     InvalidFileComment,
+
+    NegativeFileOffset,
 }
 
 impl From<ZipError> for ArchiveError<ZipError> {
@@ -38,6 +41,9 @@ impl Display for ZipError {
                     "Invalid signature of zip64 end of central directory record"
                 )
             }
+            Self::InvalidFileHeaderSignature => {
+                write!(f, "Invalid file header signature")
+            }
             Self::InvalidCDRSignature => {
                 write!(f, "Invalid signature of central directory record")
             }
@@ -49,6 +55,8 @@ impl Display for ZipError {
             Self::InvalidTime => write!(f, "Invalid time"),
             Self::InvalidFileName => write!(f, "Invalid file name"),
             Self::InvalidFileComment => write!(f, "Invalid file comment"),
+
+            Self::NegativeFileOffset => write!(f, "Negative file offset"),
         }
     }
 }
diff --git a/src/zip/file_driver.rs b/src/zip/file_driver.rs
new file mode 100644
index 0000000..47b4242
--- /dev/null
+++ b/src/zip/file_driver.rs
@@ -0,0 +1,99 @@
+use crate::driver::FileDriver;
+use crate::zip::{ZipError, ZipFileInfo, ZipResult};
+use std::io::{
+    Error as IoError, ErrorKind as IoErrorKind, Read, Result as IoResult, Seek, SeekFrom, Take,
+    Write,
+};
+
+pub struct ZipFile<'d, Io> {
+    io: &'d mut Io,
+    info: &'d ZipFileInfo,
+
+    bounds: (u64, u64),
+    cursor: u64,
+}
+
+impl<'d, Io> FileDriver for ZipFile<'d, Io> {
+    type Io = Io;
+    type FileInfo = ZipFileInfo;
+
+    fn info(&self) -> &Self::FileInfo {
+        self.info
+    }
+}
+
+impl<'d, Io: Read + Seek> ZipFile<'d, Io> {
+    pub fn new(io: &'d mut Io, info: &'d ZipFileInfo) -> ZipResult<Self> {
+        io.seek(SeekFrom::Start(info.header_pointer))?;
+        let buf = {
+            let mut buf = [0; 30];
+            io.read(&mut buf)?;
+            buf
+        };
+        if u32::from_le_bytes(buf[..4].try_into().unwrap()) != 0x04034b50 {
+            return Err(ZipError::InvalidFileHeaderSignature.into());
+        }
+        let data_pointer = info.header_pointer
+            + 30
+            + 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,
+            info,
+
+            bounds: (data_pointer, data_pointer + info.compressed_size),
+            cursor: data_pointer,
+        })
+    }
+}
+
+impl<'d, Io: Read> Read for ZipFile<'d, Io> {
+    fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
+        let upper = buf.len().min((self.bounds.1 - self.cursor) as usize);
+        self.cursor += upper as u64;
+        self.io.read(&mut buf[..upper])
+    }
+}
+
+impl<'d, Io: Write> Write for ZipFile<'d, Io> {
+    fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
+        todo!()
+    }
+
+    fn flush(&mut self) -> IoResult<()> {
+        todo!()
+    }
+}
+
+impl<'d, Io: Seek> Seek for ZipFile<'d, Io> {
+    fn seek(&mut self, pos: SeekFrom) -> IoResult<u64> {
+        self.cursor = match pos {
+            SeekFrom::Start(offset) => self.bounds.0 + offset,
+            SeekFrom::End(offset) => {
+                let cursor = self.bounds.1.saturating_add_signed(offset);
+                if cursor < self.bounds.0 {
+                    return Err(IoError::new(
+                        IoErrorKind::InvalidInput,
+                        ZipError::NegativeFileOffset,
+                    ));
+                }
+                cursor
+            }
+            SeekFrom::Current(offset) => {
+                let cursor = self.cursor.saturating_add_signed(offset);
+                if cursor < self.bounds.0 {
+                    return Err(IoError::new(
+                        IoErrorKind::InvalidInput,
+                        ZipError::NegativeFileOffset,
+                    ));
+                }
+                cursor
+            }
+        }
+        .min(self.bounds.1);
+
+        Ok(self.io.seek(SeekFrom::Start(self.cursor))? - self.bounds.0)
+    }
+}
diff --git a/src/zip/file.rs b/src/zip/file_info.rs
index 5b0723f..88322be 100644
--- a/src/zip/file.rs
+++ b/src/zip/file_info.rs
@@ -1,7 +1,8 @@
-use crate::driver::ArchiveFile;
+use crate::driver::ArchiveFileInfo;
 use crate::zip::{ZipError, ZipResult};
 use chrono::{DateTime, Local};
 
+#[derive(Debug)]
 pub enum CompressionMethod {
     Store,
     Deflate,
@@ -28,6 +29,7 @@ impl CompressionMethod {
     }
 }
 
+#[derive(Debug)]
 pub struct BitFlag {
     flag: u16,
 }
@@ -119,7 +121,8 @@ impl BitFlag {
     }
 }
 
-pub struct ZipFile {
+#[derive(Debug)]
+pub struct ZipFileInfo {
     pub compression_method: CompressionMethod,
     pub bit_flag: BitFlag,
     pub datetime: DateTime<Local>,
@@ -131,7 +134,7 @@ pub struct ZipFile {
     pub comment: String,
 }
 
-impl ZipFile {
+impl ZipFileInfo {
     pub fn new(
         compression_method: CompressionMethod,
         bit_flag: BitFlag,
@@ -157,4 +160,4 @@ impl ZipFile {
     }
 }
 
-impl ArchiveFile for ZipFile {}
+impl ArchiveFileInfo for ZipFileInfo {}
diff --git a/src/zip/mod.rs b/src/zip/mod.rs
index 89d748b..3fe8384 100644
--- a/src/zip/mod.rs
+++ b/src/zip/mod.rs
@@ -1,12 +1,14 @@
 mod archive;
 mod driver;
 mod error;
-mod file;
+mod file_driver;
+mod file_info;
 mod structs;
 
 pub use driver::Zip;
 pub use error::{ZipError, ZipResult};
-pub use file::{bit, BitFlag, CompressionMethod, ZipFile};
+pub use file_driver::ZipFile;
+pub use file_info::{bit, BitFlag, CompressionMethod, ZipFileInfo};
 
 #[cfg(test)]
 mod tests;
diff --git a/src/zip/tests.rs b/src/zip/tests.rs
index d64e626..05e076d 100644
--- a/src/zip/tests.rs
+++ b/src/zip/tests.rs
@@ -1,4 +1,4 @@
-use crate::zip::file::{bit::DeflateMode, BitFlag};
+use crate::zip::file_info::{bit::DeflateMode, BitFlag};
 
 #[test]
 fn test_bit_flag() {