add ExtraFieldMagic and Zip64ExtraFieldBlock

src/spec.rs

@@ -56,6 +56,43 @@ pub(crate) const CENTRAL_DIRECTORY_END_SIGNATURE: Magic = Magic::literal(0x06054
 pub const ZIP64_CENTRAL_DIRECTORY_END_SIGNATURE: Magic = Magic::literal(0x06064b50);
 pub(crate) const ZIP64_CENTRAL_DIRECTORY_END_LOCATOR_SIGNATURE: Magic = Magic::literal(0x07064b50);
 
+/// Similar to [`Magic`], but used for extra field tags as per section 4.5.3 of APPNOTE.TXT.
+#[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct ExtraFieldMagic(u16);
+
+/* TODO: maybe try to use this for parsing extra fields as well as writing them? */
+#[allow(dead_code)]
+impl ExtraFieldMagic {
+    pub(crate) const fn literal(x: u16) -> Self {
+        Self(x)
+    }
+
+    #[inline(always)]
+    pub(crate) const fn from_le_bytes(bytes: [u8; 2]) -> Self {
+        Self(u16::from_le_bytes(bytes))
+    }
+
+    #[inline(always)]
+    pub(crate) const fn to_le_bytes(self) -> [u8; 2] {
+        self.0.to_le_bytes()
+    }
+
+    #[allow(clippy::wrong_self_convention)]
+    #[inline(always)]
+    pub(crate) fn from_le(self) -> Self {
+        Self(u16::from_le(self.0))
+    }
+
+    #[allow(clippy::wrong_self_convention)]
+    #[inline(always)]
+    pub(crate) fn to_le(self) -> Self {
+        Self(u16::to_le(self.0))
+    }
+}
+
+pub const ZIP64_EXTRA_FIELD_TAG: ExtraFieldMagic = ExtraFieldMagic::literal(0x0001);
+
 pub const ZIP64_BYTES_THR: u64 = u32::MAX as u64;
 pub const ZIP64_ENTRY_THR: usize = u16::MAX as usize;
 

src/types.rs

@@ -3,6 +3,7 @@ use crate::cp437::FromCp437;
 use crate::write::{FileOptionExtension, FileOptions};
 use path::{Component, Path, PathBuf};
 use std::fmt;
+use std::mem;
 use std::path;
 use std::sync::{Arc, OnceLock};
 
@@ -706,27 +707,25 @@ impl ZipFileData {
         }) | if self.encrypted { 1u16 << 0 } else { 0 }
     }
 
-    pub(crate) fn local_block(&self) -> ZipResult<ZipLocalEntryBlock> {
+    fn clamp_size_field(&self, field: u64) -> u32 {
-        let (compressed_size, uncompressed_size) = if self.large_file {
-            (spec::ZIP64_BYTES_THR as u32, spec::ZIP64_BYTES_THR as u32)
-        } else {
-            (
-                self.compressed_size.try_into().unwrap(),
-                self.uncompressed_size.try_into().unwrap(),
-            )
-        };
-
-        let mut extra_field_length = self.extra_field_len();
         if self.large_file {
-            /* TODO: magic number */
+            spec::ZIP64_BYTES_THR as u32
-            extra_field_length += 20;
+        } else {
+            field.min(spec::ZIP64_BYTES_THR).try_into().unwrap()
         }
-        if extra_field_length + self.central_extra_field_len() > u16::MAX as usize {
+    }
-            return Err(ZipError::InvalidArchive(
+
-                "Local + central extra data fields are too large",
+    pub(crate) fn local_block(&self) -> ZipResult<ZipLocalEntryBlock> {
-            ));
+        let compressed_size: u32 = self.clamp_size_field(self.compressed_size);
-        }
+        let uncompressed_size: u32 = self.clamp_size_field(self.uncompressed_size);
-        let extra_field_length: u16 = extra_field_length.try_into().unwrap();
+
+        let extra_block_len: usize = self
+            .zip64_extra_field_block()
+            .map(|block| block.full_size())
+            .unwrap_or(0);
+        let extra_field_length: u16 = (self.extra_field_len() + extra_block_len)
+            .try_into()
+            .map_err(|_| ZipError::InvalidArchive("Extra data field is too large"))?;
 
         let last_modified_time = self
             .last_modified_time
@@ -786,6 +785,48 @@ impl ZipFileData {
                 .unwrap(),
         }
     }
+
+    pub fn zip64_extra_field_block(&self) -> Option<Zip64ExtraFieldBlock> {
+        let uncompressed_size: Option<u64> =
+            if self.uncompressed_size > spec::ZIP64_BYTES_THR || self.large_file {
+                Some(spec::ZIP64_BYTES_THR)
+            } else {
+                None
+            };
+        let compressed_size: Option<u64> =
+            if self.compressed_size > spec::ZIP64_BYTES_THR || self.large_file {
+                Some(spec::ZIP64_BYTES_THR)
+            } else {
+                None
+            };
+        let header_start: Option<u64> = if self.header_start > spec::ZIP64_BYTES_THR {
+            Some(spec::ZIP64_BYTES_THR)
+        } else {
+            None
+        };
+
+        let mut size: u16 = 0;
+        if uncompressed_size.is_some() {
+            size += mem::size_of::<u64>() as u16;
+        }
+        if compressed_size.is_some() {
+            size += mem::size_of::<u64>() as u16;
+        }
+        if header_start.is_some() {
+            size += mem::size_of::<u64>() as u16;
+        }
+        if size == 0 {
+            return None;
+        }
+
+        Some(Zip64ExtraFieldBlock {
+            magic: spec::ZIP64_EXTRA_FIELD_TAG,
+            size,
+            uncompressed_size,
+            compressed_size,
+            header_start,
+        })
+    }
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -882,6 +923,53 @@ impl Block for ZipLocalEntryBlock {
     ];
 }
 
+#[derive(Copy, Clone, Debug)]
+pub(crate) struct Zip64ExtraFieldBlock {
+    magic: spec::ExtraFieldMagic,
+    size: u16,
+    uncompressed_size: Option<u64>,
+    compressed_size: Option<u64>,
+    header_start: Option<u64>,
+    // Excluded fields:
+    // u32: disk start number
+}
+
+impl Zip64ExtraFieldBlock {
+    pub fn full_size(&self) -> usize {
+        assert!(self.size > 0);
+        self.size as usize + mem::size_of::<spec::ExtraFieldMagic>() + mem::size_of::<u16>()
+    }
+
+    pub fn serialize(self) -> Box<[u8]> {
+        let Self {
+            magic,
+            size,
+            uncompressed_size,
+            compressed_size,
+            header_start,
+        } = self;
+
+        let full_size = self.full_size();
+
+        let mut ret = Vec::with_capacity(full_size);
+        ret.extend(magic.to_le_bytes());
+        ret.extend(u16::to_le_bytes(size));
+
+        if let Some(uncompressed_size) = uncompressed_size {
+            ret.extend(u64::to_le_bytes(uncompressed_size));
+        }
+        if let Some(compressed_size) = compressed_size {
+            ret.extend(u64::to_le_bytes(compressed_size));
+        }
+        if let Some(header_start) = header_start {
+            ret.extend(u64::to_le_bytes(header_start));
+        }
+        debug_assert_eq!(ret.len(), full_size);
+
+        ret.into_boxed_slice()
+    }
+}
+
 /// The encryption specification used to encrypt a file with AES.
 ///
 /// According to the [specification](https://www.winzip.com/win/en/aes_info.html#winzip11) AE-2

src/write.rs

@@ -8,7 +8,9 @@ use crate::result::{ZipError, ZipResult};
 use crate::spec::{self, Block};
 #[cfg(feature = "aes-crypto")]
 use crate::types::AesMode;
-use crate::types::{ffi, AesVendorVersion, DateTime, ZipFileData, ZipRawValues, DEFAULT_VERSION};
+use crate::types::{
+    ffi, AesVendorVersion, DateTime, ZipFileData, ZipLocalEntryBlock, ZipRawValues, DEFAULT_VERSION,
+};
 use crate::write::ffi::S_IFLNK;
 #[cfg(any(feature = "_deflate-any", feature = "bzip2", feature = "zstd",))]
 use core::num::NonZeroU64;
@@ -1818,12 +1820,10 @@ fn validate_extra_data(header_id: u16, data: &[u8]) -> ZipResult<()> {
 fn write_local_zip64_extra_field<T: Write>(writer: &mut T, file: &ZipFileData) -> ZipResult<()> {
     // This entry in the Local header MUST include BOTH original
     // and compressed file size fields.
-    writer.write_u16_le(0x0001)?;
+    assert!(file.large_file);
-    writer.write_u16_le(16)?;
+    let block = file.zip64_extra_field_block().unwrap();
-    writer.write_u64_le(file.uncompressed_size)?;
+    let block = block.serialize();
-    writer.write_u64_le(file.compressed_size)?;
+    writer.write_all(&block)?;
-    // Excluded fields:
-    // u32: disk start number
     Ok(())
 }
 
@@ -1831,52 +1831,34 @@ fn update_local_zip64_extra_field<T: Write + Seek>(
     writer: &mut T,
     file: &ZipFileData,
 ) -> ZipResult<()> {
-    let zip64_extra_field = file.header_start + 30 + file.file_name_raw.len() as u64;
+    assert!(file.large_file);
-    writer.seek(SeekFrom::Start(zip64_extra_field + 4))?;
+
-    writer.write_u64_le(file.uncompressed_size)?;
+    let zip64_extra_field = file.header_start
-    writer.write_u64_le(file.compressed_size)?;
+        + mem::size_of::<ZipLocalEntryBlock>() as u64
-    // Excluded fields:
+        + file.file_name_raw.len() as u64;
-    // u32: disk start number
+
+    writer.seek(SeekFrom::Start(zip64_extra_field))?;
+
+    let block = file.zip64_extra_field_block().unwrap();
+    let block = block.serialize();
+    writer.write_all(&block)?;
     Ok(())
 }
 
-/* TODO: make this use the Block trait somehow! */
 fn write_central_zip64_extra_field<T: Write>(writer: &mut T, file: &ZipFileData) -> ZipResult<u16> {
     // The order of the fields in the zip64 extended
     // information record is fixed, but the fields MUST
     // only appear if the corresponding Local or Central
     // directory record field is set to 0xFFFF or 0xFFFFFFFF.
-    let mut size = 0;
+    match file.zip64_extra_field_block() {
-    let uncompressed_size = file.uncompressed_size > spec::ZIP64_BYTES_THR;
+        None => Ok(0),
-    let compressed_size = file.compressed_size > spec::ZIP64_BYTES_THR;
+        Some(block) => {
-    let header_start = file.header_start > spec::ZIP64_BYTES_THR;
+            let block = block.serialize();
-    if uncompressed_size {
+            writer.write_all(&block)?;
-        size += 8;
+            let len: u16 = block.len().try_into().unwrap();
-    }
+            Ok(len)
-    if compressed_size {
-        size += 8;
-    }
-    if header_start {
-        size += 8;
-    }
-    if size > 0 {
-        writer.write_u16_le(0x0001)?;
-        writer.write_u16_le(size)?;
-        size += 4;
-
-        if uncompressed_size {
-            writer.write_u64_le(file.uncompressed_size)?;
         }
-        if compressed_size {
-            writer.write_u64_le(file.compressed_size)?;
-        }
-        if header_start {
-            writer.write_u64_le(file.header_start)?;
-        }
-        // Excluded fields:
-        // u32: disk start number
     }
-    Ok(size)
 }
 
 #[cfg(not(feature = "unreserved"))]