Crate wow_mpq 

wow_mpq - MPQ Archive Library

A high-performance, safe Rust implementation of the MPQ (Mo’PaQ) archive format used by Blizzard Entertainment games.

About the Name

wow_mpq is named after the original format name “Mo’PaQ” (Mike O’Brien Pack), which was later shortened to MPQ. This library provides the core MPQ functionality.

Features

• Support for all MPQ format versions (v1-v4)
• Full compatibility with StormLib API through FFI
• Multiple compression algorithms (zlib, bzip2, LZMA, etc.)
• Digital signature support (verification and generation)
• Strong security with signature verification
• Comprehensive error handling
• Optional memory-mapped files for high-performance access
• SIMD-accelerated operations for maximum performance

Examples

Basic Usage

use wow_mpq::{Archive, OpenOptions};

// Open an existing MPQ archive
let mut archive = Archive::open("example.mpq")?;

// List files in the archive
for entry in archive.list()? {
    println!("{}", entry.name);
}

// Extract a specific file
let data = archive.read_file("war3map.j")?;

Memory-Mapped High Performance Access

use wow_mpq::{Archive, OpenOptions};

// Open archive with memory mapping enabled for better performance
let mut archive = OpenOptions::new()
    .enable_memory_mapping()
    .open("large_archive.mpq")?;

// High-performance file reading using memory mapping
let data = archive.read_file_mapped("large_file.m2")?;
println!("Read {} bytes using memory mapping", data.len());

Digital Signatures

use wow_mpq::crypto::{generate_weak_signature, SignatureInfo, WEAK_SIGNATURE_FILE_SIZE};
use std::io::Cursor;

// Generate a weak signature for an archive
let archive_data = std::fs::read("archive.mpq")?;
let archive_size = archive_data.len() as u64;

let sig_info = SignatureInfo::new_weak(
    0,                               // Archive start offset
    archive_size,                    // Archive size
    archive_size,                    // Signature position (at end)
    WEAK_SIGNATURE_FILE_SIZE as u64, // Signature file size
    vec![],                          // Empty initially
);

let cursor = Cursor::new(&archive_data);
let signature_file = generate_weak_signature(cursor, &sig_info)?;

SIMD-Accelerated Operations

use wow_mpq::simd::SimdOps;

// Create SIMD operations with runtime CPU detection
let simd = SimdOps::new();

// Hardware-accelerated CRC32 calculation
let crc = simd.crc32(b"test data", 0);

// SIMD-accelerated hash for large batch operations
let hash = simd.hash_string_simd(b"filename.mdx", 0);

// Check available SIMD features
println!("SIMD support available: {}", simd.has_simd_support());

Re-exports

pub use archive::Archive;

pub use archive::ArchiveInfo;

pub use archive::FileEntry;

pub use archive::FileInfo;

pub use archive::Md5Status;

pub use archive::OpenOptions;

pub use archive::SignatureStatus;

pub use archive::TableInfo;

pub use archive::UserDataInfo;

pub use buffer_pool::BufferPool;

pub use buffer_pool::BufferSize;

pub use buffer_pool::PoolConfig;

pub use buffer_pool::PoolStatistics;

pub use builder::ArchiveBuilder;

pub use builder::AttributesOption;

pub use builder::ListfileOption;

pub use compare::CompareOptions;

pub use compare::ComparisonResult;

pub use compare::ComparisonSummary;

pub use compare::FileComparison;

pub use compare::MetadataComparison;

pub use compare::compare_archives;

pub use error::Error;

pub use error::Result;

pub use header::FormatVersion;

pub use header::MpqHeader;

pub use modification::AddFileOptions;

pub use modification::MutableArchive;

pub use patch_chain::ChainInfo;

pub use patch_chain::PatchChain;

pub use rebuild::RebuildOptions;

pub use rebuild::RebuildSummary;

pub use rebuild::rebuild_archive;

pub use tables::BetFileInfo;

pub use tables::BetTable;

pub use tables::BlockEntry;

pub use tables::BlockTable;

pub use tables::HashEntry;

pub use tables::HashTable;

pub use tables::HetTable;

pub use crypto::decrypt_block;

pub use crypto::decrypt_dword;

pub use crypto::encrypt_block;

pub use crypto::hash_string;

pub use crypto::hash_type;

pub use crypto::jenkins_hash;

pub use compression::compress;

pub use compression::decompress;

pub use archive::decrypt_file_data;

pub use io::AsyncArchiveReader;async

pub use io::AsyncConfig;async

pub use io::AsyncDecompressionMonitor;async

pub use io::AsyncMetrics;async

pub use io::AsyncOperationStats;async

pub use io::MemoryMapConfig;mmap

pub use io::MemoryMapManager;mmap

pub use io::MemoryMapStats;mmap

pub use io::MemoryMappedArchive;mmap

pub use simd::CpuFeatures;simd

pub use simd::SimdOps;simd

pub use security::DecompressionMonitor;

pub use security::SecurityLimits;

pub use security::SessionTracker;

Modules

archive

MPQ archive handling

buffer_pool

Thread-safe buffer pooling for performance optimization

builder

Archive builder for creating MPQ archives

compare

MPQ Archive Comparison Functionality

compression

Compression and decompression algorithms for MPQ files

crypto

Cryptographic operations for MPQ files

database

Database functionality for storing and retrieving MPQ filename-to-hash mappings

debug

Debug utilities for inspecting MPQ archive internals.

error

Error types for the MPQ library

header

MPQ header structures and parsing

io

I/O abstractions for MPQ archives

modification

Archive modification support

parallel

Parallel processing utilities for MPQ archives

patch

MPQ patch file support

patch_chain

Patch chain implementation for handling multiple MPQ archives with priority

path

Path utilities for MPQ archives

rebuild

MPQ Archive Rebuild Functionality

security

Security validation module for MPQ archives

signatures

MPQ signature constants

simdsimd

SIMD-accelerated operations with runtime CPU detection

single_archive_parallel

Single archive parallel processing support

special_files

Special MPQ files handling: (listfile), (attributes), (signature), etc.

tables

MPQ table structures (hash, block, HET, BET)

test_utilstest-utils

Test utilities for MPQ archives

Functions

calculate_sector_size

Block size calculation

is_power_of_two

Check if a value is a power of two