Use object for parsing archives, and handle macOS fat archives

Cargo.toml

@@ -86,6 +86,7 @@ nix = { version = "0.26.2", optional = true }
 rouille = { version = "3.5", optional = true, default-features = false, features = ["ssl"] }
 syslog = { version = "6", optional = true }
 version-compare = { version = "0.1.1", optional = true }
+object = "0.30"
 
 [dev-dependencies]
 assert_cmd = "2.0.10"
@@ -115,9 +116,9 @@ features = [
 [features]
 default = ["all"]
 all = ["dist-client", "redis", "s3", "memcached", "gcs", "azure", "gha", "webdav"]
-azure = ["opendal","reqsign"]
-s3 = ["opendal","reqsign"]
-gcs = ["opendal","reqsign", "url", "reqwest/blocking"]
+azure = ["opendal", "reqsign"]
+s3 = ["opendal", "reqsign"]
+gcs = ["opendal", "reqsign", "url", "reqwest/blocking"]
 gha = ["opendal"]
 webdav = ["opendal"]
 memcached = ["opendal/services-memcached"]

src/util.rs

@@ -13,11 +13,11 @@
 // limitations under the License.
 
 use crate::mock_command::{CommandChild, RunCommand};
-use ar::Archive;
 use blake3::Hasher as blake3_Hasher;
 use byteorder::{BigEndian, ByteOrder};
 use fs::File;
 use fs_err as fs;
+use object::{macho, read::archive::ArchiveFile, read::macho::FatArch};
 use serde::Serialize;
 use std::ffi::{OsStr, OsString};
 use std::hash::Hasher;
@@ -145,13 +145,22 @@ pub async fn hash_all_archives(
         let path = path.clone();
         pool.spawn_blocking(move || -> Result<String> {
             let mut m = Digest::new();
-            let reader = File::open(&path)
+            let data = fs::read(&path)
                 .with_context(|| format!("Failed to open file for hashing: {:?}", path))?;
-            let mut archive = Archive::new(reader);
-            while let Some(entry) = archive.next_entry() {
-                let entry = entry?;
-                m.update(entry.header().identifier());
-                update_from_reader(&mut m, entry)?;
+
+            match macho::FatHeader::parse(&*data) {
+                Ok(h) if h.magic.get(object::endian::BigEndian) == object::macho::FAT_MAGIC => {
+                    for arch in macho::FatHeader::parse_arch32(&*data)? {
+                        hash_regular_archive(&mut m, arch.data(&*data)?)?;
+                    }
+                }
+                Ok(h) if h.magic.get(object::endian::BigEndian) == object::macho::FAT_MAGIC_64 => {
+                    for arch in macho::FatHeader::parse_arch64(&*data)? {
+                        hash_regular_archive(&mut m, arch.data(&*data)?)?;
+                    }
+                }
+                // Not a FatHeader at all, regular archive.
+                _ => hash_regular_archive(&mut m, &*data)?,
             }
             Ok(m.finish())
         })
@@ -170,15 +179,12 @@ pub async fn hash_all_archives(
     Ok(hashes.into_iter().map(|res| res.unwrap()).collect())
 }
 
-/// Update the digest `m` with all data from `reader`.
-fn update_from_reader<R: Read>(m: &mut Digest, mut reader: R) -> Result<()> {
-    loop {
-        let mut buffer = [0; 1024];
-        let count = reader.read(&mut buffer[..])?;
-        if count == 0 {
-            break;
-        }
-        m.update(&buffer[..count]);
+fn hash_regular_archive(m: &mut Digest, data: &[u8]) -> Result<()> {
+    let archive = ArchiveFile::parse(&*data)?;
+    for entry in archive.members() {
+        let entry = entry?;
+        m.update(entry.name());
+        m.update(entry.data(&*data)?);
     }
     Ok(())
 }