chore(cargo): upgrade async_zip to 0.0.17

Author: link2xt

Cargo.lock

@@ -44,7 +44,7 @@ async-channel = { workspace = true }
 async-imap = { version = "0.10.1", default-features = false, features = ["runtime-tokio"] }
 async-native-tls = { version = "0.5", default-features = false, features = ["runtime-tokio"] }
 async-smtp = { version = "0.9", default-features = false, features = ["runtime-tokio"] }
-async_zip = { version = "0.0.12", default-features = false, features = ["deflate", "fs"] }
+async_zip = { version = "0.0.17", default-features = false, features = ["deflate", "tokio-fs"] }
 base64 = { workspace = true }
 brotli = { version = "6", default-features=false, features = ["std"] }
 bytes = "1"

Cargo.toml

@@ -29,7 +29,6 @@ use lettre_email::PartBuilder;
 use rusqlite::OptionalExtension;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use tokio::io::AsyncReadExt;
 
 use crate::chat::{self, Chat};
 use crate::constants::Chattype;
@@ -195,7 +194,7 @@ fn find_zip_entry<'a>(
     name: &str,
 ) -> Option<(usize, &'a async_zip::StoredZipEntry)> {
     for (i, ent) in file.entries().iter().enumerate() {
-        if ent.entry().filename() == name {
+        if ent.filename().as_bytes() == name.as_bytes() {
             return Some((i, ent));
         }
     }
@@ -212,7 +211,7 @@ impl Context {
             return Ok(false);
         }
 
-        let archive = match async_zip::read::mem::ZipFileReader::new(file.to_vec()).await {
+        let archive = match async_zip::base::read::mem::ZipFileReader::new(file.to_vec()).await {
             Ok(archive) => archive,
             Err(_) => {
                 info!(self, "{} cannot be opened as zip-file", &filename);
@@ -235,7 +234,7 @@ impl Context {
             bail!("{} is not a valid webxdc file", filename);
         }
 
-        let valid = match async_zip::read::fs::ZipFileReader::new(path).await {
+        let valid = match async_zip::tokio::read::fs::ZipFileReader::new(path).await {
             Ok(archive) => {
                 if find_zip_entry(archive.file(), "index.html").is_none() {
                     warn!(self, "{} misses index.html", filename);
@@ -791,12 +790,15 @@ fn parse_webxdc_manifest(bytes: &[u8]) -> Result<WebxdcManifest> {
     Ok(manifest)
 }
 
-async fn get_blob(archive: &async_zip::read::fs::ZipFileReader, name: &str) -> Result<Vec<u8>> {
+async fn get_blob(
+    archive: &async_zip::tokio::read::fs::ZipFileReader,
+    name: &str,
+) -> Result<Vec<u8>> {
     let (i, _) = find_zip_entry(archive.file(), name)
         .ok_or_else(|| anyhow!("no entry found for {}", name))?;
-    let mut reader = archive.entry(i).await?;
+    let mut reader = archive.reader_with_entry(i).await?;
     let mut buf = Vec::new();
-    reader.read_to_end(&mut buf).await?;
+    reader.read_to_end_checked(&mut buf).await?;
     Ok(buf)
 }
 
@@ -806,12 +808,12 @@ impl Message {
     async fn get_webxdc_archive(
         &self,
         context: &Context,
-    ) -> Result<async_zip::read::fs::ZipFileReader> {
+    ) -> Result<async_zip::tokio::read::fs::ZipFileReader> {
         let path = self
             .get_file(context)
             .ok_or_else(|| format_err!("No webxdc instance file."))?;
         let path_abs = get_abs_path(context, &path);
-        let archive = async_zip::read::fs::ZipFileReader::new(path_abs).await?;
+        let archive = async_zip::tokio::read::fs::ZipFileReader::new(path_abs).await?;
         Ok(archive)
     }