Add Raw Write Mode

[nickbabcock]

Currently, rawzip requires all zip entry data to be written as uncompressed bytes, with the library automatically calculating CRC32 checksums and tracking uncompressed size. This forces users to decompress and recompress data when transcoding or modifying only a subset of entries in existing zip files.

Prior art:

• Go's archive/zip package provides CreateRaw() and OpenRaw() methods that allow direct writing of already-compressed data without decompression/recompression.
• Similarly, the zip crate has ZipWriter::raw_copy_file that copies an existing zip entry with decompression

My preference would be something more akin to Go's implementation as if one already has compressed data (and it's not from a zip file), then the zip crate seems too limiting.

The API could be something like:

  impl<W: Write> ZipArchiveWriter<W> {
      // Maybe even name: AsRef<[u8]> to allow what otherwise would be invalid names
      pub fn new_raw_file(&mut self, name: &str) -> ZipRawFileBuilder<'_, W> {
      }
  }

  pub struct ZipRawFileBuilder<'a, W> {
      archive: &'a mut ZipArchiveWriter<W>,
      name: &'a str,
      compression_method: CompressionMethod,
      modification_time: Option<UtcDateTime>,
      unix_permissions: Option<u32>,
  }

  impl<'a, W> ZipRawFileBuilder<'a, W> {
      pub fn compression_method(mut self, method: CompressionMethod) -> Self {}
      pub fn last_modified(mut self, modification_time: UtcDateTime) -> Self {}
      pub fn unix_permissions(mut self, permissions: u32) -> Self {}
      pub fn create(self) -> Result<ZipRawEntryWriter<'a, W>, Error> { }
  }

  pub struct ZipRawEntryWriter<'a, W> {
      inner: &'a mut ZipArchiveWriter<W>,
      compressed_bytes: u64,
  }

  impl<W: Write> ZipRawEntryWriter<'_, W> {
      pub fn get_mut(&mut self) -> &mut ZipArchiveWriter<W> {
          self.inner
      }

      pub fn finish(self, output: DataDescriptorOutput) -> Result<u64, Error> {
          // Write data descriptor with provided metadata
          // Add entry to central directory
          // Return compressed bytes written
      }
  }

  impl<W: Write> Write for ZipRawEntryWriter<'_, W> {
      fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
          let bytes_written = self.inner.writer.write(buf)?;
          self.compressed_bytes += bytes_written as u64;
          Ok(bytes_written)
      }

      fn flush(&mut self) -> io::Result<()> {
          self.inner.writer.flush()
      }
  }

I could see a use case for having a bit-for-bit identical copy of local file headers and central directory record (which this won't do)

[chenxiaolong]

This would be awesome to have!

Another example of prior art (though more verbose than the Go implementation you mentioned) is in the minizip-ng C library, which has:

// Reading
mz_zip_entry_read_open(handle, 1 /* raw mode */, password);

// Writing
mz_zip_entry_write_open(handle, file_info, compress_level, 1 /* raw mode */, password);
// (Write data...)
mz_zip_entry_close_raw(handle, uncompressed_size, crc);

ZipRawEntryWriter::finish(self, output: DataDescriptorOutput) seems pretty similar to mz_zip_entry_close_raw(). I like the proposed API. (I think minizip-ng makes data descriptors optional though, depending on whether the user tells the library if the underlying writer is seekable.)

[nickbabcock]

Thanks for calling out minizip-ng, that is a good example, and inspiration should be taken from it.

I am ok ignoring the streaming (non-seekable) behavior for now, it's not something I want to encourage 😄

[nickbabcock]

I have an instance where I'm transcoding poorly deflated zips into zstd zips with much better compression ratios, and thought to myself "it would be nice to do this transcode and able to keep the local and central directory entries exactly the same (sans-offsets and sizes), and not need to recompute the crc"

It's an interesting use case -- not sure if a single raw api could tackle all of them, but I figured I'd jot it down here before I forgot.