Add mtime, atime, ctime

1 files changed, 98 insertions, 48 deletions

diff --git a/src/zip/driver.rs b/src/zip/driver.rs
index c76d071..3793e31 100644
--- a/src/zip/driver.rs
+++ b/src/zip/driver.rs
@@ -1,13 +1,48 @@
 use crate::driver::{ArchiveRead, ArchiveWrite, Driver};
-use crate::zip::structs::{deserialize, EOCDR64Locator, ExtraHeader, CDR, EOCDR, EOCDR64};
+use crate::utils::ReadUtils;
+use crate::zip::structs::{deserialize, Cdr, Eocdr, Eocdr64, Eocdr64Locator, ExtraHeader};
 use crate::zip::{
     BitFlag, CompressionMethod, ZipError, ZipFileInfo, ZipFileReader, ZipFileWriter, ZipResult,
 };
-use chrono::{Local, NaiveDate, NaiveDateTime, NaiveTime};
+use chrono::{DateTime, Local, NaiveDate, NaiveDateTime, NaiveTime};
 use std::collections::HashMap as Map;
 use std::fs::File;
 use std::io::{Read, Seek, SeekFrom, Write};
 
+fn dos_to_local(date: u16, time: u16) -> ZipResult<DateTime<Local>> {
+    Ok(NaiveDateTime::new(
+        NaiveDate::from_ymd_opt(
+            (date as i32 >> 9 & 0x7F) + 1980,
+            date as u32 >> 5 & 0xF,
+            date as u32 & 0x1F,
+        )
+        .ok_or(ZipError::InvalidDate)?,
+        NaiveTime::from_hms_opt(
+            (time as u32 >> 11) & 0x1F,
+            (time as u32 >> 5) & 0x3F,
+            (time as u32 & 0x1F) * 2,
+        )
+        .ok_or(ZipError::InvalidTime)?,
+    )
+    .and_local_timezone(Local)
+    .unwrap())
+}
+
+fn ntfs_to_local(time: u64) -> ZipResult<DateTime<Local>> {
+    Ok(DateTime::from_timestamp(
+        (time / 10000000 - 11644473600) as i64,
+        (time % 10000000) as u32,
+    )
+    .ok_or(ZipError::InvalidTime)?
+    .with_timezone(&Local))
+}
+
+fn timestamp_to_local(time: i32) -> ZipResult<DateTime<Local>> {
+    Ok(DateTime::from_timestamp(time as i64, 0)
+        .ok_or(ZipError::InvalidTime)?
+        .with_timezone(&Local))
+}
+
 pub struct Zip<Io = File> {
     io: Io,
 
@@ -29,23 +64,16 @@ impl<Io: Read + Seek> ArchiveRead for Zip<Io> {
         // 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]
+        let pos = start
+            + io.read_vec(limit as usize - 18)?
                 .windows(4)
                 .rposition(|v| u32::from_le_bytes(v.try_into().unwrap()) == 0x06054b50)
-                .ok_or(ZipError::EOCDRNotFound)? as u64
-        };
+                .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 = deserialize(&buf).unwrap();
+        let buf = io.read_arr::<18>()?;
+        let eocdr: Eocdr = deserialize(&buf).unwrap();
         let comment = {
             let mut buf: Vec<u8> = vec![0; eocdr.comment_len as usize];
             io.read(&mut buf)?;
@@ -54,25 +82,18 @@ impl<Io: Read + Seek> ArchiveRead for Zip<Io> {
 
         // Try to find eocdr64locator
         io.seek(SeekFrom::Start(pos - 20))?;
-        let buf = {
-            let mut buf = [0; 20];
-            io.read(&mut buf)?;
-            buf
-        };
+        let buf = io.read_arr::<20>()?;
         let (cd_pointer, cd_size, cd_records) =
+            // If locator found then read eocdr64
             if u32::from_le_bytes(buf[0..4].try_into().unwrap()) == 0x07064b50 {
-                let eocdr64locator: EOCDR64Locator = deserialize(&buf[4..]).unwrap();
+                let eocdr64locator: Eocdr64Locator = deserialize(&buf[4..]).unwrap();
 
                 io.seek(SeekFrom::Start(eocdr64locator.eocdr64_pointer))?;
-                let buf = {
-                    let mut buf = [0; 56];
-                    io.read(&mut buf)?;
-                    buf
-                };
+                let buf = io.read_arr::<56>()?;
                 if u32::from_le_bytes(buf[0..4].try_into().unwrap()) != 0x06064b50 {
                     return Err(ZipError::InvalidEOCDR64Signature.into());
                 }
-                let eocdr64: EOCDR64 = deserialize(&buf[4..]).unwrap();
+                let eocdr64: Eocdr64 = deserialize(&buf[4..]).unwrap();
 
                 (eocdr64.cd_pointer, eocdr64.cd_size, eocdr64.cd_records)
             } else {
@@ -86,11 +107,7 @@ impl<Io: Read + Seek> ArchiveRead for Zip<Io> {
         // 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 buf = io.read_vec(cd_size as usize)?;
 
         let mut p: usize = 0;
         for _ in 0..cd_records {
@@ -98,7 +115,7 @@ impl<Io: Read + Seek> ArchiveRead for Zip<Io> {
                 return Err(ZipError::InvalidCDRSignature.into());
             }
             p += 4;
-            let cdr: CDR = deserialize(&buf[p..p + 42]).unwrap();
+            let cdr: Cdr = deserialize(&buf[p..p + 42]).unwrap();
             p += 42;
             let name = String::from_utf8(buf[p..p + cdr.name_len as usize].into())
                 .map_err(|_| ZipError::InvalidFileName)?;
@@ -113,11 +130,17 @@ impl<Io: Read + Seek> ArchiveRead for Zip<Io> {
             let mut size = cdr.size as u64;
             let mut header_pointer = cdr.header_pointer as u64;
 
+            let mut mtime = dos_to_local(cdr.dos_date, cdr.dos_time)?;
+            let mut atime = None;
+            let mut ctime = None;
+
+            // Parse extensible data fields
             let mut ep: usize = 0;
             while ep < cdr.extra_field_len as usize {
                 let header: ExtraHeader = deserialize(&extra_fields[ep..ep + 4]).unwrap();
                 ep += 4;
                 match header.id {
+                    // Zip64
                     0x0001 => {
                         if size == 0xFFFFFFFF {
                             compressed_size =
@@ -137,6 +160,46 @@ impl<Io: Read + Seek> ArchiveRead for Zip<Io> {
                             ep += 4
                         }
                     }
+                    // NTFS
+                    0x000a => {
+                        let mut tp = ep + 4;
+                        ep += header.size as usize;
+
+                        while tp < ep {
+                            let header: ExtraHeader =
+                                deserialize(&extra_fields[tp..tp + 4]).unwrap();
+                            tp += 4;
+                            match header.id {
+                                0x0001 => {
+                                    mtime = ntfs_to_local(u64::from_le_bytes(
+                                        extra_fields[tp..tp + 8].try_into().unwrap(),
+                                    ))?;
+                                    tp += 8;
+                                    atime = Some(ntfs_to_local(u64::from_le_bytes(
+                                        extra_fields[tp..tp + 8].try_into().unwrap(),
+                                    ))?);
+                                    tp += 8;
+                                    ctime = Some(ntfs_to_local(u64::from_le_bytes(
+                                        extra_fields[tp..tp + 8].try_into().unwrap(),
+                                    ))?);
+                                    tp += 8;
+                                }
+                                _ => {
+                                    tp += header.size as usize;
+                                }
+                            }
+                        }
+                    }
+                    // Unix
+                    0x000d => {
+                        atime = Some(timestamp_to_local(i32::from_le_bytes(
+                            extra_fields[ep..ep + 4].try_into().unwrap(),
+                        ))?);
+                        mtime = timestamp_to_local(i32::from_le_bytes(
+                            extra_fields[ep + 4..ep + 8].try_into().unwrap(),
+                        ))?;
+                        ep += header.size as usize
+                    }
                     _ => ep += header.size as usize,
                 }
             }
@@ -146,22 +209,9 @@ impl<Io: Read + Seek> ArchiveRead for Zip<Io> {
                 ZipFileInfo::new(
                     CompressionMethod::from_struct_id(cdr.compression_method)?,
                     BitFlag::new(cdr.bit_flag),
-                    NaiveDateTime::new(
-                        NaiveDate::from_ymd_opt(
-                            (cdr.dos_date as i32 >> 9 & 0x7F) + 1980,
-                            cdr.dos_date as u32 >> 5 & 0xF,
-                            cdr.dos_date as u32 & 0x1F,
-                        )
-                        .ok_or(ZipError::InvalidDate)?,
-                        NaiveTime::from_hms_opt(
-                            (cdr.dos_time as u32 >> 11) & 0x1F,
-                            (cdr.dos_time as u32 >> 5) & 0x3F,
-                            (cdr.dos_time as u32 & 0x1F) * 2,
-                        )
-                        .ok_or(ZipError::InvalidTime)?,
-                    )
-                    .and_local_timezone(Local)
-                    .unwrap(),
+                    mtime,
+                    atime,
+                    ctime,
                     cdr.crc,
                     compressed_size,
                     size,