Merge branch 'master' into oldpr384

Cargo.toml

@@ -28,10 +28,12 @@ bzip2 = { version = "0.4.4", optional = true }
 chrono = { version = "0.4.38", optional = true }
 constant_time_eq = { version = "0.3.0", optional = true }
 crc32fast = "1.4.0"
+displaydoc = { version = "0.2.4", default-features = false }
 flate2 = { version = "1.0.28", default-features = false, optional = true }
 hmac = { version = "0.12.1", optional = true, features = ["reset"] }
 pbkdf2 = { version = "0.12.2", optional = true }
 sha1 = { version = "0.10.6", optional = true }
+thiserror = "1.0.48"
 time = { workspace = true, optional = true, features = [
     "std",
 ] }

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/result.rs

@@ -1,67 +1,38 @@
+#![allow(unknown_lints)] // non_local_definitions isn't in Rust 1.70
+#![allow(non_local_definitions)]
 //! Error types that can be emitted from this library
 
+use displaydoc::Display;
+use thiserror::Error;
+
 use std::error::Error;
 use std::fmt;
 use std::io;
-use std::io::IntoInnerError;
 use std::num::TryFromIntError;
 
 /// Generic result type with ZipError as its error variant
 pub type ZipResult<T> = Result<T, ZipError>;
 
 /// Error type for Zip
-#[derive(Debug)]
+#[derive(Debug, Display, Error)]
 #[non_exhaustive]
 pub enum ZipError {
-    /// An Error caused by I/O
+    /// i/o error: {0}
-    Io(io::Error),
+    Io(#[from] io::Error),
 
-    /// This file is probably not a zip archive
+    /// invalid Zip archive: {0}
     InvalidArchive(&'static str),
 
-    /// This archive is not supported
+    /// unsupported Zip archive: {0}
     UnsupportedArchive(&'static str),
 
-    /// The requested file could not be found in the archive
+    /// specified file not found in archive
     FileNotFound,
 
     /// The password provided is incorrect
     InvalidPassword,
 }
 
-impl From<io::Error> for ZipError {
-    fn from(err: io::Error) -> ZipError {
-        ZipError::Io(err)
-    }
-}
-
-impl<W> From<IntoInnerError<W>> for ZipError {
-    fn from(value: IntoInnerError<W>) -> Self {
-        ZipError::Io(value.into_error())
-    }
-}
-
-impl fmt::Display for ZipError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            ZipError::Io(err) => write!(fmt, "{err}"),
-            ZipError::InvalidArchive(err) => write!(fmt, "invalid Zip archive: {err}"),
-            ZipError::UnsupportedArchive(err) => write!(fmt, "unsupported Zip archive: {err}"),
-            ZipError::FileNotFound => write!(fmt, "specified file not found in archive"),
-            ZipError::InvalidPassword => write!(fmt, "incorrect password for encrypted file"),
-        }
-    }
-}
-
-impl Error for ZipError {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        match self {
-            ZipError::Io(err) => Some(err),
-            _ => None,
-        }
-    }
-}
-
 impl ZipError {
     /// The text used as an error when a password is required and not supplied
     ///

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];
@@ -1418,7 +1419,10 @@ impl<W: Write + Seek> GenericZipWriter<W> {
             #[cfg(feature = "deflate-zopfli")]
             GenericZipWriter::ZopfliDeflater(w) => w.finish()?,
             #[cfg(feature = "deflate-zopfli")]
-            GenericZipWriter::BufferedZopfliDeflater(w) => w.into_inner()?.finish()?,
+            GenericZipWriter::BufferedZopfliDeflater(w) => w
+                .into_inner()
+                .map_err(|e| ZipError::Io(e.into_error()))?
+                .finish()?,
             #[cfg(feature = "bzip2")]
             GenericZipWriter::Bzip2(w) => w.finish()?,
             #[cfg(feature = "zstd")]

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);
+            }
+        }
+    }
+}