openpack 0.2.2

Safe archive-reader for ZIP-derived formats (ZIP, CRX, JAR, APK, IPA) with BOM-safe checks.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

use std::ffi::OsStr;
use std::fs::File;
use std::path::Path;

use memmap2::Mmap;

use crate::types::{ArchiveFormat, OpenPackError};

pub(crate) fn detect_format(path: &Path, bytes: &[u8]) -> Result<ArchiveFormat, OpenPackError> {
    let ext = path
        .extension()
        .and_then(OsStr::to_str)
        .map(|value| value.to_ascii_lowercase());

    // If the path extension explicitly signals a known ZIP-derived archive, prefer it.
    if let Some(ext_str) = ext.as_deref() {
        match ext_str {
            "jar" => return Ok(ArchiveFormat::Jar),
            "apk" => return Ok(ArchiveFormat::Apk),
            "ipa" => return Ok(ArchiveFormat::Ipa),
            "zip" => return Ok(ArchiveFormat::Zip),
            "crx" => {
                if bytes.starts_with(b"PK\x03\x04") {
                    return Ok(ArchiveFormat::Zip);
                }
                #[cfg(feature = "crx")]
                {
                    return Ok(ArchiveFormat::Crx);
                }
                #[cfg(not(feature = "crx"))]
                {
                    return Err(OpenPackError::Unsupported);
                }
            }
            _ => {}
        }
    }

    // Extension did not identify the format; fall back to magic bytes.
    if bytes.starts_with(b"Cr24") {
        #[cfg(feature = "crx")]
        {
            return Ok(ArchiveFormat::Crx);
        }
        #[cfg(not(feature = "crx"))]
        {
            return Err(OpenPackError::Unsupported);
        }
    }

    if bytes.starts_with(b"PK") {
        return Ok(ArchiveFormat::Zip);
    }

    if bytes.len() >= 2 && &bytes[0..2] == b"\x1F\x8B" {
        // GZIP / tar.gz detected — not supported by this crate by default.
        return Err(OpenPackError::Unsupported);
    }

    // Unknown format / extension without recognizable magic
    Err(OpenPackError::Unsupported)
}

pub(crate) fn read_archive_bytes(file: File, file_len: u64) -> Result<Mmap, OpenPackError> {
    // Ensure archive fits into platform memory indexing
    let _capacity = usize::try_from(file_len)
        .map_err(|_| OpenPackError::LimitExceeded("archive too large for platform".into()))?;
    // Safety: memory-map the file for zero-copy access.
    let mmap = unsafe {
        memmap2::MmapOptions::new()
            .map(&file)
            .map_err(OpenPackError::Io)?
    };
    Ok(mmap)
}