Merge pull request #82 from zip-rs/oldpr437a

feat: Add support for extended timestamps

src/extra_fields/extended_timestamp.rs

@@ -0,0 +1,88 @@
+use std::io::Read;
+
+use byteorder::LittleEndian;
+use byteorder::ReadBytesExt;
+
+use crate::result::{ZipError, ZipResult};
+
+/// extended timestamp, as described in <https://libzip.org/specifications/extrafld.txt>
+
+#[derive(Debug, Clone)]
+pub struct ExtendedTimestamp {
+    mod_time: Option<u32>,
+    ac_time: Option<u32>,
+    cr_time: Option<u32>,
+}
+
+impl ExtendedTimestamp {
+    /// creates an extended timestamp struct by reading the required bytes from the reader.
+    ///
+    /// This method assumes that the length has already been read, therefore
+    /// it must be passed as an argument
+    pub fn try_from_reader<R>(reader: &mut R, len: u16) -> ZipResult<Self>
+    where
+        R: Read,
+    {
+        let flags = reader.read_u8()?;
+
+        // the `flags` field refers to the local headers and might not correspond
+        // to the len field. If the length field is 1+4, we assume that only
+        // the modification time has been set
+
+        // > Those times that are present will appear in the order indicated, but
+        // > any combination of times may be omitted.  (Creation time may be
+        // > present without access time, for example.)  TSize should equal
+        // > (1 + 4*(number of set bits in Flags)), as the block is currently
+        // > defined.
+        if len != 5 && len as u32 != 1 + 4 * flags.count_ones() {
+            //panic!("found len {len} and flags {flags:08b}");
+            return Err(ZipError::UnsupportedArchive(
+                "flags and len don't match in extended timestamp field",
+            ));
+        }
+
+        if flags & 0b11111000 != 0 {
+            return Err(ZipError::UnsupportedArchive(
+                "found unsupported timestamps in the extended timestamp header",
+            ));
+        }
+
+        let mod_time = if (flags & 0b00000001u8 == 0b00000001u8) || len == 5 {
+            Some(reader.read_u32::<LittleEndian>()?)
+        } else {
+            None
+        };
+
+        let ac_time = if flags & 0b00000010u8 == 0b00000010u8 && len > 5 {
+            Some(reader.read_u32::<LittleEndian>()?)
+        } else {
+            None
+        };
+
+        let cr_time = if flags & 0b00000100u8 == 0b00000100u8 && len > 5 {
+            Some(reader.read_u32::<LittleEndian>()?)
+        } else {
+            None
+        };
+        Ok(Self {
+            mod_time,
+            ac_time,
+            cr_time,
+        })
+    }
+
+    /// returns the last modification timestamp
+    pub fn mod_time(&self) -> Option<&u32> {
+        self.mod_time.as_ref()
+    }
+
+    /// returns the last access timestamp
+    pub fn ac_time(&self) -> Option<&u32> {
+        self.ac_time.as_ref()
+    }
+
+    /// returns the creation timestamp
+    pub fn cr_time(&self) -> Option<&u32> {
+        self.cr_time.as_ref()
+    }
+}

src/extra_fields/mod.rs

@@ -0,0 +1,28 @@
+//! types for extra fields
+
+/// marker trait to denote the place where this extra field has been stored
+pub trait ExtraFieldVersion {}
+
+/// use this to mark extra fields specified in a local header
+
+#[derive(Debug, Clone)]
+pub struct LocalHeaderVersion;
+
+/// use this to mark extra fields specified in the central header
+
+#[derive(Debug, Clone)]
+pub struct CentralHeaderVersion;
+
+impl ExtraFieldVersion for LocalHeaderVersion {}
+impl ExtraFieldVersion for CentralHeaderVersion {}
+
+mod extended_timestamp;
+
+pub use extended_timestamp::*;
+
+/// contains one extra field
+#[derive(Debug, Clone)]
+pub enum ExtraField {
+    /// extended timestamp, as described in <https://libzip.org/specifications/extrafld.txt>
+    ExtendedTimestamp(ExtendedTimestamp),
+}

src/lib.rs

@@ -39,12 +39,14 @@ mod aes_ctr;
 mod compression;
 mod cp437;
 mod crc32;
+pub mod extra_fields;
 pub mod read;
 pub mod result;
 mod spec;
 mod types;
 pub mod write;
 mod zipcrypto;
+pub use extra_fields::ExtraField;
 
 #[doc = "Unstable APIs\n\
 \

src/read.rs

@@ -5,6 +5,7 @@ use crate::aes::{AesReader, AesReaderValid};
 use crate::compression::CompressionMethod;
 use crate::cp437::FromCp437;
 use crate::crc32::Crc32Reader;
+use crate::extra_fields::{ExtendedTimestamp, ExtraField};
 use crate::read::zip_archive::Shared;
 use crate::result::{ZipError, ZipResult};
 use crate::spec;
@@ -836,6 +837,7 @@ fn central_header_to_zip_file_inner<R: Read>(
         external_attributes: external_file_attributes,
         large_file: false,
         aes_mode: None,
+        extra_fields: Vec::new(),
     };
 
     match parse_extra_field(&mut result) {
@@ -918,6 +920,17 @@ fn parse_extra_field(file: &mut ZipFileData) -> ZipResult<()> {
                     CompressionMethod::from_u16(compression_method)
                 };
             }
+            0x5455 => {
+                // extended timestamp
+                // https://libzip.org/specifications/extrafld.txt
+
+                file.extra_fields.push(ExtraField::ExtendedTimestamp(
+                    ExtendedTimestamp::try_from_reader(&mut reader, len)?,
+                ));
+
+                // the reader for ExtendedTimestamp consumes `len` bytes
+                len_left = 0;
+            }
             _ => {
                 // Other fields are ignored
             }
@@ -1087,6 +1100,11 @@ impl<'a> ZipFile<'a> {
     pub fn central_header_start(&self) -> u64 {
         self.data.central_header_start
     }
+
+    /// iterate through all extra fields
+    pub fn extra_data_fields(&self) -> impl Iterator<Item = &ExtraField> {
+        self.data.extra_fields.iter()
+    }
 }
 
 impl<'a> Read for ZipFile<'a> {
@@ -1114,6 +1132,7 @@ impl<'a> Drop for ZipFile<'a> {
                 }
             };
 
+            #[allow(clippy::unused_io_amount)]
             loop {
                 match reader.read(&mut buffer) {
                     Ok(0) => break,
@@ -1204,6 +1223,7 @@ pub fn read_zipfile_from_stream<'a, R: Read>(reader: &'a mut R) -> ZipResult<Opt
         external_attributes: 0,
         large_file: false,
         aes_mode: None,
+        extra_fields: Vec::new(),
     };
 
     match parse_extra_field(&mut result) {

src/types.rs

@@ -45,6 +45,7 @@ mod atomic {
     }
 }
 
+use crate::extra_fields::ExtraField;
 use crate::result::DateTimeRangeError;
 #[cfg(feature = "time")]
 use time::{error::ComponentRange, Date, Month, OffsetDateTime, PrimitiveDateTime, Time};
@@ -371,6 +372,9 @@ pub struct ZipFileData {
     pub large_file: bool,
     /// AES mode if applicable
     pub aes_mode: Option<(AesMode, AesVendorVersion)>,
+
+    /// extra fields, see <https://libzip.org/specifications/extrafld.txt>
+    pub extra_fields: Vec<ExtraField>,
 }
 
 impl ZipFileData {
@@ -544,6 +548,7 @@ mod test {
             external_attributes: 0,
             large_file: false,
             aes_mode: None,
+            extra_fields: Vec::new(),
         };
         assert_eq!(data.file_name_sanitized(), PathBuf::from("path/etc/passwd"));
     }

src/write.rs

@@ -696,6 +696,7 @@ impl<W: Write + Seek> ZipWriter<W> {
                 external_attributes: permissions << 16,
                 large_file: options.large_file,
                 aes_mode: None,
+                extra_fields: Vec::new(),
             };
             let index = self.insert_file_data(file)?;
             let file = &mut self.files[index];

tests/zip_extended_timestamp.rs

@@ -0,0 +1,19 @@
+use std::io;
+use zip::ZipArchive;
+
+#[test]
+fn test_extended_timestamp() {
+    let mut v = Vec::new();
+    v.extend_from_slice(include_bytes!("../tests/data/extended_timestamp.zip"));
+    let mut archive = ZipArchive::new(io::Cursor::new(v)).expect("couldn't open test zip file");
+
+    for field in archive.by_name("test.txt").unwrap().extra_data_fields() {
+        match field {
+            zip::ExtraField::ExtendedTimestamp(ts) => {
+                assert!(ts.ac_time().is_none());
+                assert!(ts.cr_time().is_none());
+                assert_eq!(*ts.mod_time().unwrap(), 1714635025);
+            }
+        }
+    }
+}