Create file driver and implement file reader

16 files changed, 256 insertions, 50 deletions

diff --git a/src/archive.rs b/src/archive.rs
index e635007..4a70867 100644
--- a/src/archive.rs
+++ b/src/archive.rs
@@ -1,5 +1,5 @@
 use crate::driver::{ArchiveRead, ArchiveWrite, Driver};
-use crate::ArchiveResult;
+use crate::{ArchiveFile, ArchiveResult};
 use std::fs::File;
 use std::io::{Read, Write};
 use std::path::Path;
@@ -10,9 +10,9 @@ pub struct Archive<D: Driver> {
 
 impl<D: ArchiveRead> Archive<D>
 where
-    D::IO: std::io::Read,
+    D::Io: std::io::Read,
 {
-    pub fn read(io: D::IO) -> ArchiveResult<Self, D::Error> {
+    pub fn read(io: D::Io) -> ArchiveResult<Self, D::Error> {
         Ok(Self {
             driver: D::read(io)?,
         })
@@ -20,18 +20,22 @@ where
 
     pub fn read_from_file(path: impl AsRef<Path>) -> ArchiveResult<Self, D::Error>
     where
-        D: ArchiveRead<IO = File>,
+        D: ArchiveRead<Io = File>,
     {
         Self::read(File::open(path)?)
     }
 
-    pub fn files(&self) -> Vec<&D::File> {
+    pub fn files(&self) -> Vec<&D::FileInfo> {
         self.driver.files()
     }
 
-    pub fn get_file(&self, name: &str) -> Option<&D::File> {
-        self.driver.get_file(name)
+    pub fn get_file_info(&self, name: &str) -> Option<&D::FileInfo> {
+        self.driver.get_file_info(name)
+    }
+
+    pub fn get_file_reader<'d>(&'d mut self, name: &str) -> Option<ArchiveFile<D::FileDriver<'d>>> {
+        Some(ArchiveFile::new(self.driver.get_file_reader(name)?))
     }
 }
 
-impl<D: ArchiveWrite> Archive<D> where D::IO: Read + Write {}
+impl<D: ArchiveWrite> Archive<D> where D::Io: Read + Write {}
diff --git a/src/driver/driver.rs b/src/driver/driver.rs
index 9c18e1f..5bd2319 100644
--- a/src/driver/driver.rs
+++ b/src/driver/driver.rs
@@ -1,4 +1,4 @@
-use crate::driver::ArchiveFile;
+use crate::driver::{ArchiveFileInfo, FileDriver};
 use crate::ArchiveResult;
 use std::error::Error;
 use std::io::{Read, Write};
@@ -6,26 +6,33 @@ use std::io::{Read, Write};
 pub trait Driver: Sized {
     type Error: Error;
 
-    type IO;
-    type File: ArchiveFile;
+    type Io;
+    type FileInfo: ArchiveFileInfo;
+    type FileDriver<'d>: FileDriver
+    where
+        Self::FileInfo: 'd,
+        Self::Io: 'd;
 }
 
 pub trait ArchiveRead: Driver
 where
-    Self::IO: Read,
+    Self::Io: Read,
 {
     // Create driver instance
-    fn read(io: Self::IO) -> ArchiveResult<Self, Self::Error>;
+    fn read(io: Self::Io) -> ArchiveResult<Self, Self::Error>;
 
     // Return vec of files (sorted by name)
-    fn files(&self) -> Vec<&Self::File>;
+    fn files(&self) -> Vec<&Self::FileInfo>;
 
-    // Return file by name
-    fn get_file(&self, name: &str) -> Option<&Self::File>;
+    // Return file info by name
+    fn get_file_info(&self, name: &str) -> Option<&Self::FileInfo>;
+
+    // Return file reader by name
+    fn get_file_reader<'d>(&'d mut self, name: &str) -> Option<Self::FileDriver<'d>>;
 }
 
-pub trait ArchiveWrite: ArchiveRead
+pub trait ArchiveWrite: Driver
 where
-    Self::IO: Read + Write,
+    Self::Io: Read + Write,
 {
 }
diff --git a/src/driver/file.rs b/src/driver/file.rs
index a4974f3..125c9c3 100644
--- a/src/driver/file.rs
+++ b/src/driver/file.rs
@@ -1 +1,8 @@
-pub trait ArchiveFile {}
+pub trait ArchiveFileInfo {}
+
+pub trait FileDriver {
+    type Io;
+    type FileInfo: ArchiveFileInfo;
+
+    fn info(&self) -> &Self::FileInfo;
+}
diff --git a/src/driver/mod.rs b/src/driver/mod.rs
index 36ee6b5..b637a34 100644
--- a/src/driver/mod.rs
+++ b/src/driver/mod.rs
@@ -2,4 +2,4 @@ mod driver;
 mod file;
 
 pub use driver::{ArchiveRead, ArchiveWrite, Driver};
-pub use file::ArchiveFile;
+pub use file::{ArchiveFileInfo, FileDriver};
diff --git a/src/error.rs b/src/error.rs
index 7172d04..97a4e62 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -6,21 +6,21 @@ pub type ArchiveResult<T, E> = Result<T, ArchiveError<E>>;
 
 #[derive(Debug)]
 pub enum ArchiveError<E: Error> {
-    IO { error: io::Error },
+    Io { error: io::Error },
     Serde { message: String },
     Archivator { module: String, error: E },
 }
 
 impl<E: Error> From<io::Error> for ArchiveError<E> {
     fn from(value: io::Error) -> Self {
-        Self::IO { error: value }
+        Self::Io { error: value }
     }
 }
 
 impl<E: Error> Display for ArchiveError<E> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::IO { error } => writeln!(f, "IO: {error}"),
+            Self::Io { error } => writeln!(f, "IO: {error}"),
             Self::Serde { message } => writeln!(f, "Serde: {message}"),
             Self::Archivator { module, error } => writeln!(f, "{module}: {error}"),
         }
diff --git a/src/file.rs b/src/file.rs
new file mode 100644
index 0000000..f284b98
--- /dev/null
+++ b/src/file.rs
@@ -0,0 +1,38 @@
+use crate::driver::FileDriver;
+use std::io::{Read, Result as IoResult, Seek, Write};
+
+pub struct ArchiveFile<D: FileDriver> {
+    pub(crate) driver: D,
+}
+
+impl<D: FileDriver> ArchiveFile<D> {
+    pub fn new(driver: D) -> Self {
+        Self { driver }
+    }
+
+    pub fn info(&self) -> &D::FileInfo {
+        self.driver.info()
+    }
+}
+
+impl<D: FileDriver + Read> Read for ArchiveFile<D> {
+    fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
+        self.driver.read(buf)
+    }
+}
+
+impl<D: FileDriver + Write> Write for ArchiveFile<D> {
+    fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
+        self.driver.write(buf)
+    }
+
+    fn flush(&mut self) -> IoResult<()> {
+        self.driver.flush()
+    }
+}
+
+impl<D: FileDriver + Seek> Seek for ArchiveFile<D> {
+    fn seek(&mut self, pos: std::io::SeekFrom) -> IoResult<u64> {
+        self.driver.seek(pos)
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index c9cd1ad..26722c2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,5 +1,6 @@
 mod archive;
 mod error;
+mod file;
 
 pub mod driver;
 pub mod structs;
@@ -7,4 +8,6 @@ pub mod zip;
 
 pub use archive::Archive;
 pub use error::{ArchiveError, ArchiveResult};
+pub use file::ArchiveFile;
+
 pub use zip::Zip;
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() {
diff --git a/tests/files/zip.zip b/tests/files/zip.zip
index e17bbb7..f3a090b 100644
--- a/tests/files/zip.zip
+++ b/tests/files/zip.zip
diff --git a/tests/zip.rs b/tests/zip.rs
index 65244c1..25f1f76 100644
--- a/tests/zip.rs
+++ b/tests/zip.rs
@@ -1,8 +1,9 @@
 use archivator::{Archive, Zip};
+use std::io::{Read, Seek, SeekFrom};
 
 #[test]
 fn test_zip() {
-    let archive = Archive::<Zip<_>>::read_from_file("tests/files/zip.zip").unwrap();
+    let mut archive = Archive::<Zip<_>>::read_from_file("tests/files/zip.zip").unwrap();
 
     assert_eq!(archive.comment(), "archive comment");
     assert_eq!(
@@ -13,4 +14,34 @@ fn test_zip() {
             .collect::<Vec<&String>>(),
         vec!["a", "b", "c"]
     );
+
+    let mut f = archive.get_file_reader("a").unwrap();
+
+    let mut data = String::new();
+    f.read_to_string(&mut data).unwrap();
+    assert_eq!(data, "file data \"a\"");
+
+    assert_eq!(f.seek(SeekFrom::Start(5)).unwrap(), 5);
+    let mut data = String::new();
+    f.read_to_string(&mut data).unwrap();
+    assert_eq!(data, "data \"a\"");
+
+    assert_eq!(f.seek(SeekFrom::Start(0)).unwrap(), 0);
+    let mut data = vec![0; 4];
+    f.read(&mut data).unwrap();
+    assert_eq!(String::from_utf8(data).unwrap(), "file");
+
+    assert_eq!(f.seek(SeekFrom::Current(1)).unwrap(), 5);
+    let mut data = vec![0; 4];
+    f.read(&mut data).unwrap();
+    assert_eq!(String::from_utf8(data).unwrap(), "data");
+
+    assert_eq!(f.seek(SeekFrom::End(-3)).unwrap(), 10);
+    let mut data = vec![0; 3];
+    f.read(&mut data).unwrap();
+    assert_eq!(String::from_utf8(data).unwrap(), "\"a\"");
+
+    assert_eq!(f.seek(SeekFrom::Current(0)).unwrap(), 13);
+    f.seek(SeekFrom::End(-100)).unwrap_err();
+    assert_eq!(f.seek(SeekFrom::Current(0)).unwrap(), 13);
 }