Initial support for tokio

Cargo.toml

@@ -43,6 +43,8 @@ zstd = { version = "0.13.1", optional = true, default-features = false }
 zopfli = { version = "0.8.0", optional = true }
 deflate64 = { version = "0.1.8", optional = true }
 lzma-rs = { version = "0.3.0", default-features = false, optional = true }
+true = { version = "0.1.0", optional = true }
+tokio = { version = "1.37.0", optional = true }
 
 [target.'cfg(any(all(target_arch = "arm", target_pointer_width = "32"), target_arch = "mips", target_arch = "powerpc"))'.dependencies]
 crossbeam-utils = "0.8.19"
@@ -67,11 +69,12 @@ deflate = ["flate2/rust_backend", "_deflate-any"]
 
 # DEPRECATED: previously enabled `flate2/miniz_oxide` which is equivalent to `flate2/rust_backend`
 deflate-miniz = ["deflate", "_deflate-any"]
-
 deflate-zlib = ["flate2/zlib", "_deflate-any"]
 deflate-zlib-ng = ["flate2/zlib-ng", "_deflate-any"]
 deflate-zopfli = ["zopfli", "_deflate-any"]
 lzma = ["lzma-rs/stream"]
+sync = []
+tokio = ["tokio/io-util"]
 unreserved = []
 default = [
     "aes-crypto",
@@ -81,6 +84,7 @@ default = [
     "deflate-zlib-ng",
     "deflate-zopfli",
     "lzma",
+    "sync",
     "time",
     "zstd",
 ]

src/build.rs

@@ -4,4 +4,9 @@
     if var("CARGO_FEATURE_DEFLATE_MINIZ").is_ok() {
         println!("cargo:warning=Feature `deflate-miniz` is deprecated; replace it with `deflate`");
     }
+    #[cfg(not(any(feature = "sync", feature = "tokio")))]
+    compile_error!("Missing Required feature");
+
+    #[cfg(all(feature = "sync", feature = "tokio"))]
+    compile_error!("The features sync and tokio cannot be used together")
 }

src/spec.rs

@@ -1,3 +1,6 @@
+#[cfg(feature = "tokio")]
+use tokio::io::{AsyncRead, AsyncReadExt, AsyncSeek, AsyncSeekExt};
+
 use crate::result::{ZipError, ZipResult};
 use crate::unstable::{LittleEndianReadExt, LittleEndianWriteExt};
 use core::mem::size_of_val;
@@ -112,6 +115,7 @@ pub struct Zip64CentralDirectoryEndLocator {
     pub number_of_disks: u32,
 }
 
+#[cfg(feature = "sync")]
 impl Zip64CentralDirectoryEndLocator {
     pub fn parse<T: Read>(reader: &mut T) -> ZipResult<Zip64CentralDirectoryEndLocator> {
         let magic = reader.read_u32_le()?;
@@ -140,6 +144,30 @@ impl Zip64CentralDirectoryEndLocator {
     }
 }
 
+#[cfg(feature = "tokio")]
+impl Zip64CentralDirectoryEndLocator {
+    pub async fn parse<T>(reader: &mut T) -> ZipResult<Self>
+    where
+        T: AsyncRead + Unpin,
+    {
+        let magic = reader.read_u32_le().await?;
+        if magic != ZIP64_CENTRAL_DIRECTORY_END_LOCATOR_SIGNATURE {
+            return Err(ZipError::InvalidArchive(
+                "Invalid zip64 locator digital signature header",
+            ));
+        }
+        let disk_with_central_directory = reader.read_u32_le().await?;
+        let end_of_central_directory_offset = reader.read_u64_le().await?;
+        let number_of_disks = reader.read_u32_le().await?;
+
+        Ok(Self {
+            disk_with_central_directory,
+            end_of_central_directory_offset,
+            number_of_disks,
+        })
+    }
+}
+
 pub struct Zip64CentralDirectoryEnd {
     pub version_made_by: u16,
     pub version_needed_to_extract: u16,
@@ -152,6 +180,7 @@ pub struct Zip64CentralDirectoryEnd {
     //pub extensible_data_sector: Vec<u8>, <-- We don't do anything with this at the moment.
 }
 
+#[cfg(feature = "sync")]
 impl Zip64CentralDirectoryEnd {
     pub fn find_and_parse<T: Read + Seek>(
         reader: &mut T,
@@ -227,6 +256,69 @@ impl Zip64CentralDirectoryEnd {
     }
 }
 
+#[cfg(feature = "tokio")]
+impl Zip64CentralDirectoryEnd {
+    pub async fn find_and_parse<T>(
+        reader: &mut T,
+        nominal_offset: u64,
+        search_upper_bound: u64,
+    ) -> ZipResult<Vec<(Self, u64)>>
+    where
+        T: AsyncRead + AsyncSeek + Unpin,
+    {
+        let mut results = Vec::new();
+        let mut pos = search_upper_bound;
+
+        while pos >= nominal_offset {
+            let mut have_signature = false;
+            reader.seek(tokio::io::SeekFrom::Start(pos)).await?;
+            if reader.read_u32_le().await? == ZIP64_CENTRAL_DIRECTORY_END_SIGNATURE {
+                have_signature = true;
+                let archive_offset = pos - nominal_offset;
+
+                let _record_size = reader.read_u64_le().await?;
+                let version_made_by = reader.read_u16_le().await?;
+                let version_needed_to_extract = reader.read_u16_le().await?;
+                let disk_number = reader.read_u32_le().await?;
+                let disk_with_central_directory = reader.read_u32_le().await?;
+                let number_of_files_on_this_disk = reader.read_u64_le().await?;
+                let number_of_files = reader.read_u64_le().await?;
+                let central_directory_size = reader.read_u64_le().await?;
+                let central_directory_offset = reader.read_u64_le().await?;
+
+                results.push((
+                    Self {
+                        version_made_by,
+                        version_needed_to_extract,
+                        disk_number,
+                        disk_with_central_directory,
+                        number_of_files_on_this_disk,
+                        number_of_files,
+                        central_directory_size,
+                        central_directory_offset,
+                    },
+                    archive_offset,
+                ));
+            }
+            pos = match pos.checked_sub(if have_signature {
+                size_of_val(&ZIP64_CENTRAL_DIRECTORY_END_SIGNATURE) as u64
+            } else {
+                1
+            }) {
+                None => break,
+                Some(p) => p,
+            }
+        }
+        if results.is_empty() {
+            Err(ZipError::InvalidArchive(
+                "Could not find ZIP64 central directory end",
+            ))
+        } else {
+            Ok(results)
+        }
+    }
+}
+
 /// Converts a path to the ZIP format (forward-slash-delimited and normalized).
 pub(crate) fn path_to_string<T: AsRef<Path>>(path: T) -> Box<str> {
     let mut maybe_original = None;