Merge branch 'master' into fix-some-imports

Author: Pr0methean

.github/workflows/ci.yaml

@@ -60,7 +60,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v5
-    - run: sudo apt install gcc-s390x-linux-gnu
+    - run: sudo apt-get update
+    - run: sudo apt-get install crossbuild-essential-s390x
     - run: rustup toolchain add nightly-x86_64-unknown-linux-gnu
     - run: rustup toolchain add --force-non-host stable-s390x-unknown-linux-gnu
     - run: rustup target add s390x-unknown-linux-gnu --toolchain stable-s390x-unknown-linux-gnu

Cargo.toml

@@ -77,6 +77,10 @@ deflate-flate2 = ["_deflate-any", "dep:flate2"]
 deflate-flate2-zlib-rs = ["deflate-flate2", "flate2/zlib-rs"]
 # Pull in flate2 and the zlib backend; only use this if you need a dynamically linked system zlib
 deflate-flate2-zlib = ["deflate-flate2", "flate2/zlib"]
+# Pull in flate2 and the zlib-ng backend; a modern fork of zlib
+deflate-flate2-zlib-ng = ["deflate-flate2", "flate2/zlib-ng"]
+# Pull in flate2 and the zlib-ng backend with a zlib-compatible API
+deflate-flate2-zlib-ng-compat = ["deflate-flate2", "flate2/zlib-ng-compat"]
 # Pull in zopfli (write-only DEFLATE, slower than flate2 with better compression ratios)
 deflate-zopfli = ["dep:zopfli", "_deflate-any"]
 jiff-02 = ["dep:jiff"]

src/compression.rs

@@ -139,6 +139,15 @@ impl CompressionMethod {
     pub const AES: Self = CompressionMethod::Aes;
     #[cfg(not(feature = "aes-crypto"))]
     pub const AES: Self = CompressionMethod::Unsupported(99);
+
+    #[cfg(feature = "_deflate-any")]
+    pub const DEFAULT: Self = CompressionMethod::Deflated;
+
+    #[cfg(all(not(feature = "_deflate-any"), feature = "bzip2"))]
+    pub const DEFAULT: Self = CompressionMethod::Bzip2;
+
+    #[cfg(all(not(feature = "_deflate-any"), not(feature = "bzip2")))]
+    pub const DEFAULT: Self = CompressionMethod::Stored;
 }
 impl CompressionMethod {
     pub(crate) const fn parse_from_u16(val: u16) -> Self {
@@ -229,11 +238,7 @@ impl CompressionMethod {
 
 impl Default for CompressionMethod {
     fn default() -> Self {
-        #[cfg(feature = "_deflate-any")]
-        return CompressionMethod::Deflated;
-
-        #[cfg(not(feature = "_deflate-any"))]
-        return CompressionMethod::Stored;
+        Self::DEFAULT
     }
 }
 

src/read.rs

@@ -1656,7 +1656,7 @@ impl<'a, R: Read> ZipFile<'a, R> {
     /// `foo/../bar` as `foo/bar` (instead of `bar`). Because of this,
     /// [`ZipFile::enclosed_name`] is the better option in most scenarios.
     ///
-    /// [`ParentDir`]: `PathBuf::Component::ParentDir`
+    /// [`ParentDir`]: `Component::ParentDir`
     pub fn mangled_name(&self) -> PathBuf {
         self.get_metadata().file_name_sanitized()
     }

src/spec.rs

@@ -91,7 +91,7 @@ impl ExtraFieldMagic {
 /// The file size at which a ZIP64 record becomes necessary.
 ///
 /// If a file larger than this threshold attempts to be written, compressed or uncompressed, and
-/// [`FileOptions::large_file()`](crate::write::FileOptions) was not true, then [`ZipWriter`] will
+/// [`FileOptions::large_file()`](crate::write::FileOptions::large_file) was not true, then [`crate::ZipWriter`] will
 /// raise an [`io::Error`] with [`io::ErrorKind::Other`].
 ///
 /// If the zip file itself is larger than this value, then a zip64 central directory record will be
@@ -107,32 +107,32 @@ impl ExtraFieldMagic {
 ///
 /// let mut zip = ZipWriter::new(Cursor::new(Vec::new()));
 /// // Writing an extremely large file for this test is faster without compression.
-/// let options = SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
 ///
 /// let big_len: usize = (zip::ZIP64_BYTES_THR as usize) + 1;
 /// let big_buf = vec![0u8; big_len];
 /// {
-/// zip.start_file("zero.dat", options)?;
-/// // This is too big!
-/// let res = zip.write_all(&big_buf[..]).err().unwrap();
-/// assert_eq!(res.kind(), io::ErrorKind::Other);
-/// let description = format!("{}", &res);
-/// assert_eq!(description, "Large file option has not been set");
-/// }
-/// {
-/// // Attempting to write anything further to the same zip will still succeed, but the previous
-/// // failing entry has been removed.
-/// zip.start_file("one.dat", options)?;
-/// let zip = zip.finish_into_readable()?;
-/// let names: Vec<_> = zip.file_names().collect();
-/// assert_eq!(&names, &["one.dat"]);
+///     let options = SimpleFileOptions::default()
+///         .compression_method(zip::CompressionMethod::Stored);
+///     zip.start_file("zero.dat", options)?;
+///     // This is too big!
+///     let res = zip.write_all(&big_buf[..]).err().unwrap();
+///     assert_eq!(res.kind(), io::ErrorKind::Other);
+///     let description = format!("{}", &res);
+///     assert_eq!(description, "Large file option has not been set");
+///     // Attempting to write anything further to the same zip will still succeed, but the previous
+///     // failing entry has been removed.
+///     zip.start_file("one.dat", options)?;
+///     let zip = zip.finish_into_readable()?;
+///     let names: Vec<_> = zip.file_names().collect();
+///     assert_eq!(&names, &["one.dat"]);
 /// }
 ///
 /// // Create a new zip output.
 /// let mut zip = ZipWriter::new(Cursor::new(Vec::new()));
 /// // This time, create a zip64 record for the file.
 /// let options = SimpleFileOptions::default()
-///      .compression_method(zip::CompressionMethod::Stored).large_file(true);
+///      .compression_method(zip::CompressionMethod::Stored)
+///      .large_file(true);
 /// zip.start_file("zero.dat", options)?;
 /// // This succeeds because we specified that it could be a large file.
 /// assert!(zip.write_all(&big_buf[..]).is_ok());
@@ -144,7 +144,7 @@ pub const ZIP64_BYTES_THR: u64 = u32::MAX as u64;
 /// The number of entries within a single zip necessary to allocate a zip64 central
 /// directory record.
 ///
-/// If more than this number of entries is written to a [`ZipWriter`], then [`ZipWriter::finish()`]
+/// If more than this number of entries is written to a [`crate::ZipWriter`], then [`crate::ZipWriter::finish()`]
 /// will write out extra zip64 data to the end of the zip file.
 pub const ZIP64_ENTRY_THR: usize = u16::MAX as usize;
 

src/types.rs

@@ -154,6 +154,12 @@ impl PartialOrd for DateTime {
 }
 
 impl DateTime {
+    /// Constructs a default datetime of 1980-01-01 00:00:00.
+    pub const DEFAULT: Self = DateTime {
+        datepart: 0b0000000000100001,
+        timepart: 0,
+    };
+
     /// Returns the current time if possible, otherwise the default of 1980-01-01.
     #[cfg(feature = "time")]
     pub fn default_for_write() -> Self {
@@ -274,10 +280,7 @@ impl From<DateTime> for (u16, u16) {
 impl Default for DateTime {
     /// Constructs an 'default' datetime of 1980-01-01 00:00:00
     fn default() -> DateTime {
-        DateTime {
-            datepart: 0b0000000000100001,
-            timepart: 0,
-        }
+        DateTime::DEFAULT
     }
 }
 
@@ -977,10 +980,21 @@ impl ZipFileData {
     pub(crate) fn write_data_descriptor<W: std::io::Write>(
         &self,
         writer: &mut W,
+        auto_large_file: bool,
     ) -> Result<(), ZipError> {
         if self.large_file {
             return self.zip64_data_descriptor_block().write(writer);
         }
+        if self.compressed_size > spec::ZIP64_BYTES_THR
+            || self.uncompressed_size > spec::ZIP64_BYTES_THR
+        {
+            if auto_large_file {
+                return self.zip64_data_descriptor_block().write(writer);
+            }
+            return Err(ZipError::Io(std::io::Error::other(
+                "Large file option has not been set - use .large_file(true) in options",
+            )));
+        }
         self.data_descriptor_block().write(writer)
     }
 

src/write.rs

@@ -182,6 +182,7 @@ pub(crate) mod zip_writer {
         pub(super) zip64_comment: Option<Box<[u8]>>,
         pub(super) flush_on_finish_file: bool,
         pub(super) seek_possible: bool,
+        pub(crate) auto_large_file: bool,
     }
 
     impl<W: Write + Seek> Debug for ZipWriter<W> {
@@ -395,10 +396,9 @@ impl<T: FileOptionExtension> FileOptions<'_, T> {
 
     /// Set the compression method for the new file
     ///
-    /// The default is `CompressionMethod::Deflated` if it is enabled. If not,
-    /// `CompressionMethod::Bzip2` is the default if it is enabled. If neither `bzip2` nor `deflate`
-    /// is enabled, `CompressionMethod::Zlib` is the default. If all else fails,
-    /// `CompressionMethod::Stored` becomes the default and files are written uncompressed.
+    /// The default is [`CompressionMethod::Deflated`] if it is enabled. If not,
+    /// [`CompressionMethod::Bzip2`] is the default if it is enabled. If neither `bzip2` nor `deflate`
+    /// is enabled, [`CompressionMethod::Stored`] becomes the default and files are written uncompressed.
     #[must_use]
     pub const fn compression_method(mut self, method: CompressionMethod) -> Self {
         self.compression_method = method;
@@ -522,6 +522,28 @@ impl FileOptions<'_, ExtendedFileOptions> {
         self
     }
 }
+impl FileOptions<'static, ()> {
+    /// Constructs a const FileOptions object.
+    ///
+    /// Note: This value is different than the return value of [`FileOptions::default()`]:
+    ///
+    /// - The `last_modified_time` is [`DateTime::DEFAULT`]. This corresponds to 1980-01-01 00:00:00
+    pub const DEFAULT: Self = Self {
+        compression_method: CompressionMethod::DEFAULT,
+        compression_level: None,
+        last_modified_time: DateTime::DEFAULT,
+        large_file: false,
+        permissions: None,
+        encrypt_with: None,
+        extended_options: (),
+        alignment: 1,
+        #[cfg(feature = "deflate-zopfli")]
+        zopfli_buffer_size: Some(1 << 15),
+        #[cfg(feature = "aes-crypto")]
+        aes_mode: None,
+    };
+}
+
 impl<T: FileOptionExtension> Default for FileOptions<'_, T> {
     /// Construct a new FileOptions object
     fn default() -> Self {
@@ -614,6 +636,7 @@ impl<A: Read + Write + Seek> ZipWriter<A> {
             writing_raw: true, // avoid recomputing the last file's header
             flush_on_finish_file: false,
             seek_possible: true,
+            auto_large_file: false,
         })
     }
 
@@ -772,9 +795,16 @@ impl<W: Write + Seek> ZipWriter<W> {
             zip64_comment: None,
             flush_on_finish_file: false,
             seek_possible: true,
+            auto_large_file: false,
         }
     }
 
+    /// Set automatically large file to true if needed
+    pub fn set_auto_large_file(mut self) -> Self {
+        self.auto_large_file = true;
+        self
+    }
+
     /// Returns true if a file is currently open for writing.
     pub const fn is_writing_file(&self) -> bool {
         self.writing_to_file && !self.inner.is_closed()
@@ -1075,7 +1105,7 @@ impl<W: Write + Seek> ZipWriter<W> {
             };
             update_aes_extra_data(writer, file)?;
             if file.using_data_descriptor {
-                file.write_data_descriptor(writer)?;
+                file.write_data_descriptor(writer, self.auto_large_file)?;
             } else {
                 update_local_file_header(writer, file)?;
                 writer.seek(SeekFrom::Start(file_end))?;
@@ -1622,6 +1652,7 @@ impl<W: Write> ZipWriter<StreamWriter<W>> {
             zip64_comment: None,
             flush_on_finish_file: false,
             seek_possible: false,
+            auto_large_file: false,
         }
     }
 }