Mopaq pass 3a/3b: file lookup and SFileOpenFileEx unit chain
3a: GetFileBlockEntry, FindFileInOneArchive, SearchHashTable, ARCHIVEREC::GetBlockEntry/BuildBlockKeys, FindBlockEntry, CheckFileExistsOnDisk, SFileFileExists, Digest<16> operators. BLOCKENTRY m_fileTime/m_crc order fixed. 3b: IOMpqUnit family (archive/read-only/disk), IOChecksumUnit with CRC and MD5 units, IOMpqReadUnit sector reader with worker pool, Blizzard::Util::MD5, HashMap, signature table, IORangeUnit/IOAlignUnit factories, ARCHIVEREC::SetMD5Check/SetBlockEntry, SFileOpenFileEx. Folded-slot docs added. Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
This commit is contained in:
@@ -2,6 +2,7 @@
|
||||
#define ENGINE_SOURCE_BLIZZARDCORE_INCLUDE_BLIZZARD_UTIL_DIGEST_H
|
||||
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
|
||||
namespace Blizzard {
|
||||
namespace Util {
|
||||
@@ -11,9 +12,42 @@ struct Digest {
|
||||
/* 0000 */ uint8_t m_data[N];
|
||||
|
||||
bool operator<(const Digest& other) const;
|
||||
bool operator==(const Digest& other) const;
|
||||
bool operator!=(const Digest& other) const;
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
// VERIFY: 182eff5b manual
|
||||
// OFFSET: 0x00429540
|
||||
template <int N>
|
||||
bool Blizzard::Util::Digest<N>::operator<(const Digest& other) const {
|
||||
for (int32_t i = 0; i < N; i++) {
|
||||
if (this->m_data[i] < other.m_data[i]) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (this->m_data[i] > other.m_data[i]) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// VERIFY: 06cb648f manual
|
||||
// OFFSET: 0x00668750
|
||||
template <int N>
|
||||
bool Blizzard::Util::Digest<N>::operator==(const Digest& other) const {
|
||||
return memcmp(this->m_data, other.m_data, N) == 0;
|
||||
}
|
||||
|
||||
// VERIFY: 951b079f manual
|
||||
// OFFSET: 0x004221A0
|
||||
template <int N>
|
||||
bool Blizzard::Util::Digest<N>::operator!=(const Digest& other) const {
|
||||
return memcmp(this->m_data, other.m_data, N) != 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,4 +1,81 @@
|
||||
#ifndef ENGINE_SOURCE_BLIZZARDCORE_INCLUDE_BLIZZARD_UTIL_HASHMAP_H
|
||||
#define ENGINE_SOURCE_BLIZZARDCORE_INCLUDE_BLIZZARD_UTIL_HASHMAP_H
|
||||
|
||||
#include <cstdint>
|
||||
#include "Engine/Source/Storm/H/storm.h"
|
||||
|
||||
namespace Blizzard {
|
||||
namespace Util {
|
||||
|
||||
template <class K, class V>
|
||||
class HashMap {
|
||||
public:
|
||||
struct Entry {
|
||||
/* 0000 */ K m_key;
|
||||
/* 0008 */ V m_value;
|
||||
};
|
||||
|
||||
/* 0000 */ Entry* m_entries;
|
||||
/* 0004 */ uint32_t m_count;
|
||||
/* 0008 */ uint32_t m_capacity;
|
||||
|
||||
~HashMap();
|
||||
bool Find(const K& key, uint32_t* index);
|
||||
bool Get(const K& key, V* value);
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
// INLINED
|
||||
template <class K, class V>
|
||||
Blizzard::Util::HashMap<K, V>::~HashMap() {
|
||||
for (uint32_t i = 0; i < this->m_capacity; i++) {
|
||||
if (this->m_entries[i].m_key.m_lo) {
|
||||
this->m_entries[i].m_key.m_lo = 0;
|
||||
this->m_entries[i].m_key.m_hi = 0;
|
||||
}
|
||||
}
|
||||
|
||||
this->m_count = 0;
|
||||
|
||||
if (this->m_entries) {
|
||||
SMemFree(this->m_entries, __FILE__, __LINE__, 0);
|
||||
this->m_entries = nullptr;
|
||||
this->m_capacity = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// VERIFY: 23f50510 manual
|
||||
// OFFSET: 0x00433BA0
|
||||
template <class K, class V>
|
||||
bool Blizzard::Util::HashMap<K, V>::Find(const K& key, uint32_t* index) {
|
||||
if (!this->m_capacity) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (*index = key.m_lo & (this->m_capacity - 1); this->m_entries[*index].m_key.m_lo; *index = (*index + 1) & (this->m_capacity - 1)) {
|
||||
if (this->m_entries[*index].m_key.m_lo == key.m_lo && this->m_entries[*index].m_key.m_hi == key.m_hi) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// VERIFY: d994337d manual
|
||||
// OFFSET: 0x00435EA0
|
||||
template <class K, class V>
|
||||
bool Blizzard::Util::HashMap<K, V>::Get(const K& key, V* value) {
|
||||
uint32_t index;
|
||||
|
||||
if (!this->Find(key, &index)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
*value = this->m_entries[index].m_value;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
#ifndef ENGINE_SOURCE_BLIZZARDCORE_INCLUDE_BLIZZARD_UTIL_MD5_H
|
||||
#define ENGINE_SOURCE_BLIZZARDCORE_INCLUDE_BLIZZARD_UTIL_MD5_H
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
namespace Blizzard {
|
||||
namespace Util {
|
||||
|
||||
class MD5 {
|
||||
public:
|
||||
/* 0000 */ uint32_t m_count[2];
|
||||
/* 0008 */ uint32_t m_state[4];
|
||||
/* 0018 */ uint8_t m_buffer[64];
|
||||
|
||||
MD5();
|
||||
void Finish(uint8_t* digest);
|
||||
void Process(const uint8_t* block);
|
||||
void Process(const void* data, uint32_t size);
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,881 @@
|
||||
#include <algorithm>
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <new>
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/iounit/IOUnitContainer.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/Mopaq/IOMpqUnit.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/Mopaq/MPQEncrypt.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/Mopaq/MPQGlobals.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/Mopaq/SComp.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/Mopaq/SFile.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/Mopaq/SFileSignatures.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/File/File.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/Hardware/Hardware.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/Lock/Lock.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/String/String.h"
|
||||
#include "ThirdParty/zlib/contrib/blast/blast.h"
|
||||
#include "ThirdParty/zlib/zlib.h"
|
||||
|
||||
// VERIFY: 4faeb939 manual
|
||||
// OFFSET: 0x00431DB0
|
||||
IOMpqUnit::IOMpqUnit(System_SFile::ARCHIVEREC* archive, const char* name, bool ownsMemory, IOUnit* next) : IOUnit(next, ownsMemory), unk_0010(0), m_archive(archive), m_name((name ? static_cast<uint32_t>(strlen(name)) : 0) + 1) {
|
||||
Blizzard::String::Copy(this->m_name.m_data, name, this->m_name.m_count);
|
||||
|
||||
if (this->m_archive) {
|
||||
this->m_archive->m_internalRefs.Increment();
|
||||
}
|
||||
}
|
||||
|
||||
// VERIFY: a7d3cb7f auto
|
||||
// OFFSET: 0x00429630
|
||||
uint32_t IOMpqUnit::GetType() {
|
||||
return 'mpq ';
|
||||
}
|
||||
|
||||
// INLINED
|
||||
IOMpqUnit::~IOMpqUnit() {
|
||||
}
|
||||
|
||||
// VERIFY: 915c8823 auto
|
||||
// OFFSET: 0x00454060
|
||||
bool IOMpqUnit::Close() {
|
||||
if (this->m_archive) {
|
||||
this->m_archive->RemoveInternalArchiveRef();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
System_SFile::ARCHIVEREC* IOMpqUnit::GetArchive() {
|
||||
return this->m_archive;
|
||||
}
|
||||
|
||||
const char* IOMpqUnit::GetName() {
|
||||
return this->m_name.m_data;
|
||||
}
|
||||
|
||||
// VERIFY: 48195ff4 manual
|
||||
// OFFSET: 0x00437640
|
||||
IOMpqArchiveUnit::IOMpqArchiveUnit(System_SFile::ARCHIVEREC* archive, const char* name, uint32_t blockIndex, bool ownsMemory, IOUnit* next) : IOMpqUnit(archive, name, ownsMemory, next) {
|
||||
this->m_blockIndex = blockIndex;
|
||||
this->m_blockEntry = archive->GetBlockEntry(blockIndex);
|
||||
|
||||
if (this->m_blockEntry.m_md5Check) {
|
||||
System_SFile::s_signatures.GetSignature(name, &this->m_blockEntry.m_md5);
|
||||
}
|
||||
}
|
||||
|
||||
// VERIFY: 8184d4ce auto
|
||||
// OFFSET: 0x00431EB0
|
||||
bool IOMpqArchiveUnit::GetFileSize(int64_t* size) {
|
||||
*size = this->m_blockEntry.m_fileSize;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool IOMpqArchiveUnit::SetFileSize(int64_t size) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// INLINED
|
||||
IOMpqArchiveUnit::~IOMpqArchiveUnit() {
|
||||
}
|
||||
|
||||
// VERIFY: 31dccac3 manual
|
||||
// OFFSET: 0x00431EF0
|
||||
const char* IOMpqArchiveUnit::GetPath() {
|
||||
return this->GetName();
|
||||
}
|
||||
|
||||
// VERIFY: 0c8748b4 auto
|
||||
// OFFSET: 0x00431ED0
|
||||
bool IOMpqArchiveUnit::GetCompressedSize(int64_t* size) {
|
||||
*size = this->m_blockEntry.m_compressedSize;
|
||||
return true;
|
||||
}
|
||||
|
||||
// VERIFY: 3f0e5717 auto
|
||||
// OFFSET: 0x00431F00
|
||||
IOUnit* IOMpqArchiveUnit::GetBaseUnit() {
|
||||
return this->m_archive->m_file;
|
||||
}
|
||||
|
||||
// VERIFY: 1be0c5bf auto
|
||||
// OFFSET: 0x00431F10
|
||||
int64_t IOMpqArchiveUnit::GetOffset() {
|
||||
return this->m_blockEntry.m_offset;
|
||||
}
|
||||
|
||||
// VERIFY: e6452137 auto
|
||||
// OFFSET: 0x00431F20
|
||||
uint64_t IOMpqArchiveUnit::GetFileTime() {
|
||||
return this->m_blockEntry.m_fileTime;
|
||||
}
|
||||
|
||||
// VERIFY: fa7d866e auto
|
||||
// OFFSET: 0x00431F30
|
||||
uint32_t IOMpqArchiveUnit::GetCrc() {
|
||||
return this->m_blockEntry.m_crc;
|
||||
}
|
||||
|
||||
// VERIFY: c2fc05db auto
|
||||
// OFFSET: 0x00431F40
|
||||
const Blizzard::Util::Digest<16>* IOMpqArchiveUnit::GetMd5() {
|
||||
return &this->m_blockEntry.m_md5;
|
||||
}
|
||||
|
||||
// VERIFY: 9e9495a5 auto
|
||||
// OFFSET: 0x00431F50
|
||||
bool IOMpqArchiveUnit::HasMd5Check() {
|
||||
return this->m_blockEntry.m_md5Check;
|
||||
}
|
||||
|
||||
// VERIFY: 636246fc auto
|
||||
// OFFSET: 0x00431F80
|
||||
void IOMpqArchiveUnit::DisableMd5Check() {
|
||||
this->m_archive->SetMD5Check(this->m_blockIndex, false);
|
||||
this->m_blockEntry.m_md5Check = false;
|
||||
}
|
||||
|
||||
// VERIFY: 5faa24df auto
|
||||
// OFFSET: 0x00431F60
|
||||
uint32_t IOMpqArchiveUnit::GetFlags() {
|
||||
return this->m_blockEntry.m_flags;
|
||||
}
|
||||
|
||||
// VERIFY: 22f28fcc auto
|
||||
// OFFSET: 0x00431FA0
|
||||
bool IOMpqArchiveUnit::MarkDeleted() {
|
||||
this->m_blockEntry.m_flags |= 0x2000000;
|
||||
this->m_archive->SetBlockEntry(this->m_blockIndex, this->m_blockEntry);
|
||||
return true;
|
||||
}
|
||||
|
||||
// VERIFY: f5430f38 auto
|
||||
// OFFSET: 0x00431F70
|
||||
bool IOMpqArchiveUnit::IsEncrypted() {
|
||||
return (this->m_blockEntry.m_flags & 0xF0000) != 0;
|
||||
}
|
||||
|
||||
// VERIFY: 41863b5d manual
|
||||
// OFFSET: 0x004396E0
|
||||
IOMpqArchiveReadUnit* IOMpqArchiveReadUnit::Create(IOUnitContainer* container, System_SFile::ARCHIVEREC* archive, const char* name, uint32_t blockIndex, IOUnit* next) {
|
||||
if (!next) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool ownsMemory;
|
||||
void* memory = IOUnitContainer::Alloc(container, sizeof(IOMpqArchiveReadUnit), &ownsMemory);
|
||||
|
||||
if (!memory) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return new (memory) IOMpqArchiveReadUnit(archive, name, blockIndex, ownsMemory, next);
|
||||
}
|
||||
|
||||
// INLINED
|
||||
IOMpqArchiveReadUnit::IOMpqArchiveReadUnit(System_SFile::ARCHIVEREC* archive, const char* name, uint32_t blockIndex, bool ownsMemory, IOUnit* next) : IOMpqArchiveUnit(archive, name, blockIndex, ownsMemory, next) {
|
||||
}
|
||||
|
||||
bool IOMpqArchiveReadUnit::Write(const void* buffer, int64_t offset, uint32_t count) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// VERIFY: 6194de2c manual
|
||||
// OFFSET: 0x00435380
|
||||
IOMpqDiskUnit* IOMpqDiskUnit::Create(IOUnitContainer* container, System_SFile::ARCHIVEREC* archive, const char* name, const char* path, IOUnit* next) {
|
||||
if (!next) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool ownsMemory;
|
||||
void* memory = IOUnitContainer::Alloc(container, sizeof(IOMpqDiskUnit), &ownsMemory);
|
||||
|
||||
if (!memory) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return new (memory) IOMpqDiskUnit(archive, name, path, ownsMemory, next);
|
||||
}
|
||||
|
||||
// VERIFY: 27a64d53 manual
|
||||
// OFFSET: 0x00432050
|
||||
IOMpqDiskUnit::IOMpqDiskUnit(System_SFile::ARCHIVEREC* archive, const char* name, const char* path, bool ownsMemory, IOUnit* next) : IOMpqUnit(archive, name, ownsMemory, next), m_path((path ? static_cast<uint32_t>(strlen(path)) : 0) + 1) {
|
||||
Blizzard::String::Copy(this->m_path.m_data, path, this->m_path.m_count);
|
||||
}
|
||||
|
||||
// INLINED
|
||||
IOMpqDiskUnit::~IOMpqDiskUnit() {
|
||||
}
|
||||
|
||||
// VERIFY: deabac3d auto
|
||||
// OFFSET: 0x00432130
|
||||
const char* IOMpqDiskUnit::GetPath() {
|
||||
return this->m_path.m_data;
|
||||
}
|
||||
|
||||
bool IOMpqDiskUnit::GetCompressedSize(int64_t* size) {
|
||||
return this->m_next->GetFileSize(size);
|
||||
}
|
||||
|
||||
IOUnit* IOMpqDiskUnit::GetBaseUnit() {
|
||||
return this->m_next;
|
||||
}
|
||||
|
||||
int64_t IOMpqDiskUnit::GetOffset() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint64_t IOMpqDiskUnit::GetFileTime() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint32_t IOMpqDiskUnit::GetCrc() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
// VERIFY: 70a1b3db auto
|
||||
// OFFSET: 0x00432120
|
||||
const Blizzard::Util::Digest<16>* IOMpqDiskUnit::GetMd5() {
|
||||
return &System_SFile::s_emptyMd5;
|
||||
}
|
||||
|
||||
bool IOMpqDiskUnit::HasMd5Check() {
|
||||
return false;
|
||||
}
|
||||
|
||||
void IOMpqDiskUnit::DisableMd5Check() {
|
||||
}
|
||||
|
||||
uint32_t IOMpqDiskUnit::GetFlags() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool IOMpqDiskUnit::MarkDeleted() {
|
||||
return false;
|
||||
}
|
||||
|
||||
bool IOMpqDiskUnit::IsEncrypted() {
|
||||
return false;
|
||||
}
|
||||
|
||||
// VERIFY: 36098579 manual
|
||||
// OFFSET: 0x004351E0
|
||||
IOUnit* IOMpqReadUnit::Create(IOUnitContainer* container, uint32_t fileSize, uint32_t compressedSize, uint32_t sectorSize, uint32_t flags, uint32_t key, IOUnit* next) {
|
||||
if (!next) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (!fileSize) {
|
||||
return next;
|
||||
}
|
||||
|
||||
uint32_t sectorCount = (fileSize + sectorSize - 1) / sectorSize;
|
||||
|
||||
bool ownsMemory;
|
||||
void* memory = IOUnitContainer::Alloc(container, sizeof(IOMpqReadUnit), &ownsMemory);
|
||||
|
||||
if (!memory) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return new (memory) IOMpqReadUnit(fileSize, compressedSize, sectorCount, sectorSize, flags, key, ownsMemory, next);
|
||||
}
|
||||
|
||||
// VERIFY: cd8765a0 manual
|
||||
// OFFSET: 0x00435290
|
||||
IOUnit* IOMpqReadUnit::CreateSingle(IOUnitContainer* container, uint32_t fileSize, uint32_t compressedSize, uint32_t flags, uint32_t key, IOUnit* next) {
|
||||
if (!next) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (!fileSize) {
|
||||
return next;
|
||||
}
|
||||
|
||||
bool ownsMemory;
|
||||
void* memory = IOUnitContainer::Alloc(container, sizeof(IOMpqReadUnit), &ownsMemory);
|
||||
|
||||
if (!memory) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return new (memory) IOMpqReadUnit(fileSize, compressedSize, flags, key, ownsMemory, next);
|
||||
}
|
||||
|
||||
// VERIFY: a2649e4d manual
|
||||
// OFFSET: 0x00459B90
|
||||
bool IOMpqReadUnit::DecompressBlocks(IOMpqReadUnit* unit, uint32_t offset, uint32_t size, uint8_t* source, uint32_t first, uint32_t count, uint8_t* dest) {
|
||||
uint32_t sector = first;
|
||||
bool hasChecksums = unit->m_checksums.m_count != 0;
|
||||
uint32_t end = first + count;
|
||||
|
||||
if (first >= end) {
|
||||
return true;
|
||||
}
|
||||
|
||||
while (true) {
|
||||
uint32_t compressedSize = unit->m_sectorOffsets.m_data[sector + 1] - unit->m_sectorOffsets.m_data[sector];
|
||||
uint32_t sectorSize = sector >= unit->m_sectorOffsets.m_count - 3 ? unit->m_lastSectorSize : unit->m_sectorSize;
|
||||
|
||||
if (unit->m_flags & 0xF0000) {
|
||||
System_MPQEncrypt::Decrypt(reinterpret_cast<uint32_t*>(source), compressedSize & ~3u, sector + unit->m_key);
|
||||
}
|
||||
|
||||
if (hasChecksums) {
|
||||
uint32_t checksum = unit->m_checksums.m_data[sector];
|
||||
|
||||
if (checksum) {
|
||||
uint32_t adler = adler32(0, source, compressedSize);
|
||||
|
||||
if (!adler) {
|
||||
adler = -1;
|
||||
}
|
||||
|
||||
if (adler != checksum) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t outSize = sectorSize;
|
||||
uint32_t method = unit->m_flags & 0xFF00;
|
||||
|
||||
if (method == 0x100) {
|
||||
System_SComp::PkwareBuffer buffer;
|
||||
buffer.m_output = dest;
|
||||
buffer.m_outputPos = 0;
|
||||
buffer.m_outputSize = sectorSize;
|
||||
buffer.m_input = source;
|
||||
buffer.m_inputSize = compressedSize;
|
||||
|
||||
if (blast(System_SComp::PkwareBufferRead, &buffer, System_SComp::PkwareBufferWrite, &buffer)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
outSize = buffer.m_outputPos;
|
||||
} else if (method != 0x200 || !System_SComp::Decompress(dest, &outSize, source, compressedSize)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (sectorSize != outSize) {
|
||||
return false;
|
||||
}
|
||||
|
||||
dest += outSize;
|
||||
source += compressedSize;
|
||||
|
||||
if (++sector >= end) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// VERIFY: 6ceb9959 auto
|
||||
// OFFSET: 0x0045D860
|
||||
void IOMpqReadUnit::DecompressSectors(void* param) {
|
||||
SectorJob* job = static_cast<SectorJob*>(param);
|
||||
uint32_t sector = job->m_first;
|
||||
uint8_t* scratch = job->m_scratch;
|
||||
uint32_t none = 0;
|
||||
|
||||
job->m_success = false;
|
||||
job->m_scratchLeft = job->m_scratchSize;
|
||||
job->m_destCursor = job->m_dest;
|
||||
|
||||
while (true) {
|
||||
uint32_t compressed = job->m_unit->CountCompressed(sector, job->m_end);
|
||||
|
||||
if (compressed) {
|
||||
if (!job->m_unit->DecompressRun(sector, compressed, &job->m_destCursor, &scratch, &job->m_scratchLeft)) {
|
||||
return;
|
||||
}
|
||||
|
||||
sector += compressed;
|
||||
|
||||
if (sector >= job->m_end) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t uncompressed = job->m_unit->CountUncompressed(sector, job->m_end);
|
||||
|
||||
if (uncompressed) {
|
||||
if (!job->m_unit->VerifyRun(sector, uncompressed, &job->m_destCursor, nullptr, &none)) {
|
||||
return;
|
||||
}
|
||||
|
||||
sector += uncompressed;
|
||||
|
||||
if (sector >= job->m_end) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
job->m_success = true;
|
||||
}
|
||||
|
||||
// VERIFY: 2652cd24 auto
|
||||
// OFFSET: 0x004342F0
|
||||
void IOMpqReadUnit::ReadSectors(SectorJob* job) {
|
||||
uint32_t sector = job->m_first;
|
||||
uint8_t* scratch = job->m_scratch;
|
||||
uint32_t none = 0;
|
||||
|
||||
job->m_success = false;
|
||||
job->m_scratchLeft = job->m_scratchSize;
|
||||
job->m_destCursor = job->m_dest;
|
||||
|
||||
while (true) {
|
||||
uint32_t compressed = job->m_unit->CountCompressed(sector, job->m_end);
|
||||
|
||||
if (compressed) {
|
||||
if (!job->m_unit->ReadRun(sector, compressed, &job->m_destCursor, &scratch, &job->m_scratchLeft)) {
|
||||
return;
|
||||
}
|
||||
|
||||
sector += compressed;
|
||||
|
||||
if (sector >= job->m_end) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t uncompressed = job->m_unit->CountUncompressed(sector, job->m_end);
|
||||
|
||||
if (uncompressed) {
|
||||
if (!job->m_unit->ReadRun(sector, uncompressed, &job->m_destCursor, nullptr, &none)) {
|
||||
return;
|
||||
}
|
||||
|
||||
sector += uncompressed;
|
||||
|
||||
if (sector >= job->m_end) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
job->m_success = true;
|
||||
}
|
||||
|
||||
// VERIFY: 26ab9193 manual
|
||||
// OFFSET: 0x0042BAC0
|
||||
bool IOMpqReadUnit::VerifyBlocks(IOMpqReadUnit* unit, uint32_t offset, uint32_t size, uint8_t* source, uint32_t first, uint32_t count, uint8_t* dest) {
|
||||
bool hasChecksums = unit->m_checksums.m_count != 0;
|
||||
|
||||
if (!(unit->m_flags & 0xF0000) && !hasChecksums) {
|
||||
return true;
|
||||
}
|
||||
|
||||
uint32_t sector = first;
|
||||
|
||||
if (first >= first + count) {
|
||||
return true;
|
||||
}
|
||||
|
||||
while (true) {
|
||||
uint32_t sectorSize = sector >= unit->m_sectorOffsets.m_count - 3 ? unit->m_lastSectorSize : unit->m_sectorSize;
|
||||
|
||||
if (unit->m_flags & 0xF0000) {
|
||||
System_MPQEncrypt::Decrypt(reinterpret_cast<uint32_t*>(dest), sectorSize & ~3u, sector + unit->m_key);
|
||||
}
|
||||
|
||||
if (hasChecksums) {
|
||||
uint32_t checksum = unit->m_checksums.m_data[sector];
|
||||
|
||||
if (checksum) {
|
||||
uint32_t adler = adler32(0, dest, sectorSize);
|
||||
|
||||
if (!adler) {
|
||||
adler = -1;
|
||||
}
|
||||
|
||||
if (adler != checksum) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
dest += sectorSize;
|
||||
|
||||
if (++sector >= first + count) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// VERIFY: 7713b1e2 manual
|
||||
// OFFSET: 0x00430EB0
|
||||
IOMpqReadUnit::IOMpqReadUnit(uint32_t fileSize, uint32_t compressedSize, uint32_t sectorCount, uint32_t sectorSize, uint32_t flags, uint32_t key, bool ownsMemory, IOUnit* next) : IOUnit(next, ownsMemory), m_sectorOffsets(sectorCount + 2), m_checksums(0) {
|
||||
this->m_key = key;
|
||||
this->m_flags = flags;
|
||||
this->m_fileSize = fileSize;
|
||||
this->m_sectorSize = sectorSize;
|
||||
this->m_lastSectorSize = fileSize % sectorSize;
|
||||
|
||||
if (!this->m_lastSectorSize) {
|
||||
this->m_lastSectorSize = sectorSize;
|
||||
}
|
||||
|
||||
this->m_sectorOffsets.m_data[0] = -3;
|
||||
this->m_sectorOffsets.m_data[1] = compressedSize;
|
||||
}
|
||||
|
||||
// VERIFY: faed398b manual
|
||||
// OFFSET: 0x00430FD0
|
||||
IOMpqReadUnit::IOMpqReadUnit(uint32_t fileSize, uint32_t compressedSize, uint32_t flags, uint32_t key, bool ownsMemory, IOUnit* next) : IOUnit(next, ownsMemory), m_sectorOffsets(3), m_checksums(0) {
|
||||
this->m_sectorSize = fileSize;
|
||||
this->m_lastSectorSize = fileSize;
|
||||
this->m_flags = flags;
|
||||
this->m_fileSize = fileSize;
|
||||
this->m_key = key;
|
||||
this->m_sectorOffsets.m_data[0] = 0;
|
||||
this->m_sectorOffsets.m_data[1] = compressedSize;
|
||||
}
|
||||
|
||||
// VERIFY: b5e816a0 auto
|
||||
// OFFSET: 0x00429770
|
||||
uint32_t IOMpqReadUnit::GetType() {
|
||||
return 'mpqR';
|
||||
}
|
||||
|
||||
// VERIFY: 04968570 manual
|
||||
// OFFSET: 0x0045D900
|
||||
bool IOMpqReadUnit::Read(void* buffer, int64_t offset, uint32_t count, uint32_t* bytesRead) {
|
||||
if (!count) {
|
||||
return true;
|
||||
}
|
||||
|
||||
uint32_t state = this->m_sectorOffsets.m_data[0];
|
||||
|
||||
if (state >= 0xFFFFFFFD) {
|
||||
if (state == 0xFFFFFFFF) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!this->LoadSectorTable()) {
|
||||
Blizzard::File::AddToLastErrorStack(0, "LoadSectorTable failed", 4);
|
||||
this->m_sectorOffsets.m_data[0] = state + 1;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t start = static_cast<uint32_t>(offset);
|
||||
|
||||
if (start + count > this->m_fileSize) {
|
||||
if (!bytesRead) {
|
||||
return false;
|
||||
}
|
||||
|
||||
count = this->m_fileSize - start;
|
||||
}
|
||||
|
||||
uint32_t first = start / this->m_sectorSize;
|
||||
uint32_t sectors = (this->m_sectorSize + start + count - 1) / this->m_sectorSize - first;
|
||||
uint32_t workerCount;
|
||||
|
||||
if (sectors >= 8) {
|
||||
workerCount = sectors >> 2;
|
||||
Blizzard::Hardware::GetProcessorFeatures();
|
||||
workerCount = std::min(std::min(workerCount, System_Hardware::s_processorFeatures.m_processorCount), 8u) - 1;
|
||||
} else {
|
||||
workerCount = 0;
|
||||
}
|
||||
|
||||
if (System_SFile::s_threadingMode == 1) {
|
||||
workerCount >>= 1;
|
||||
} else if (System_SFile::s_threadingMode == 2) {
|
||||
workerCount = 0;
|
||||
}
|
||||
|
||||
System_MPQGlobals::Worker* workers[7];
|
||||
System_MPQGlobals::GetWorkerPool()->Acquire(workerCount, workers);
|
||||
|
||||
uint32_t perJob = sectors / (workerCount + 1);
|
||||
uint32_t extra = sectors % (workerCount + 1);
|
||||
bool dispatched[7] = {};
|
||||
Blizzard::Memory::TempBuffer<uint8_t, 0x20000> scratch(0x20000);
|
||||
uint8_t* scratchPtr = scratch.m_data;
|
||||
uint32_t scratchSize = 0x20000;
|
||||
uint8_t* dest = static_cast<uint8_t*>(buffer);
|
||||
SectorJob jobs[8];
|
||||
|
||||
for (uint32_t i = 0;; i++) {
|
||||
SectorJob* job = &jobs[i];
|
||||
job->m_unit = this;
|
||||
job->m_first = first;
|
||||
job->m_end = first + perJob + (i < extra);
|
||||
job->m_scratch = scratchPtr;
|
||||
job->m_scratchSize = scratchSize;
|
||||
job->m_dest = dest;
|
||||
|
||||
ReadSectors(job);
|
||||
|
||||
first = job->m_end;
|
||||
scratchSize = job->m_scratchLeft;
|
||||
scratchPtr = scratch.m_buffer + 0x20000 - scratchSize;
|
||||
dest = job->m_destCursor;
|
||||
|
||||
if (job->m_success) {
|
||||
if (i >= workerCount) {
|
||||
DecompressSectors(job);
|
||||
} else {
|
||||
System_MPQGlobals::Worker* worker = workers[i];
|
||||
|
||||
if (!worker->m_proc) {
|
||||
worker->m_proc = DecompressSectors;
|
||||
worker->m_param = job;
|
||||
Blizzard::Lock::EventSet(worker->m_start.m_event);
|
||||
}
|
||||
|
||||
dispatched[i] = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (i + 1 > workerCount) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < workerCount; i++) {
|
||||
if (dispatched[i]) {
|
||||
Blizzard::Lock::EventWaitForever(workers[i]->m_done.m_event);
|
||||
}
|
||||
}
|
||||
|
||||
System_MPQGlobals::GetWorkerPool()->Release(workerCount, workers);
|
||||
|
||||
for (uint32_t i = 0; jobs[i].m_success;) {
|
||||
if (++i > workerCount) {
|
||||
if (bytesRead) {
|
||||
*bytesRead = count;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
Blizzard::File::AddToLastErrorStack(0, "ReadSectors/DecompressData failed", 4);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool IOMpqReadUnit::Write(const void* buffer, int64_t offset, uint32_t count) {
|
||||
return false;
|
||||
}
|
||||
|
||||
bool IOMpqReadUnit::Flush() {
|
||||
return true;
|
||||
}
|
||||
|
||||
// VERIFY: 630ff2f3 auto
|
||||
// OFFSET: 0x00426890
|
||||
bool IOMpqReadUnit::GetFileSize(int64_t* size) {
|
||||
*size = this->m_fileSize;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool IOMpqReadUnit::SetFileSize(int64_t size) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// INLINED
|
||||
IOMpqReadUnit::~IOMpqReadUnit() {
|
||||
}
|
||||
|
||||
bool IOMpqReadUnit::Close() {
|
||||
return true;
|
||||
}
|
||||
|
||||
// VERIFY: a824d722 manual
|
||||
// OFFSET: 0x0042FB60
|
||||
uint32_t IOMpqReadUnit::CountCompressed(uint32_t first, uint32_t end) {
|
||||
uint32_t* offsets = this->m_sectorOffsets.m_data;
|
||||
uint32_t previous = offsets[first];
|
||||
uint32_t sector = first;
|
||||
|
||||
if (first < end) {
|
||||
uint32_t last = this->m_sectorOffsets.m_count - 3;
|
||||
|
||||
do {
|
||||
uint32_t next = offsets[sector + 1];
|
||||
uint32_t sectorSize = sector >= last ? this->m_lastSectorSize : this->m_sectorSize;
|
||||
|
||||
if (next - previous == sectorSize) {
|
||||
break;
|
||||
}
|
||||
|
||||
sector++;
|
||||
previous = next;
|
||||
} while (sector < end);
|
||||
}
|
||||
|
||||
return sector - first;
|
||||
}
|
||||
|
||||
// VERIFY: fc6c70df manual
|
||||
// OFFSET: 0x0042FC60
|
||||
uint32_t IOMpqReadUnit::CountUncompressed(uint32_t first, uint32_t end) {
|
||||
uint32_t* offsets = this->m_sectorOffsets.m_data;
|
||||
uint32_t previous = offsets[first];
|
||||
uint32_t sector = first;
|
||||
|
||||
if (first < end) {
|
||||
uint32_t last = this->m_sectorOffsets.m_count - 3;
|
||||
|
||||
do {
|
||||
uint32_t next = offsets[sector + 1];
|
||||
uint32_t sectorSize = sector >= last ? this->m_lastSectorSize : this->m_sectorSize;
|
||||
|
||||
if (next - previous != sectorSize) {
|
||||
break;
|
||||
}
|
||||
|
||||
sector++;
|
||||
previous = next;
|
||||
} while (sector < end);
|
||||
}
|
||||
|
||||
return sector - first;
|
||||
}
|
||||
|
||||
// VERIFY: 15ce3f88 manual
|
||||
// OFFSET: 0x0045B4E0
|
||||
bool IOMpqReadUnit::DecompressRun(uint32_t first, uint32_t count, uint8_t** dest, uint8_t** scratch, uint32_t* scratchLeft) {
|
||||
uint32_t start = this->m_sectorOffsets.m_data[first];
|
||||
uint32_t size = this->m_sectorOffsets.m_data[first + count] - start;
|
||||
uint32_t lastSize = first + count - 1 >= this->m_sectorOffsets.m_count - 3 ? this->m_lastSectorSize : this->m_sectorSize;
|
||||
uint32_t total = lastSize + this->m_sectorSize * (count - 1);
|
||||
|
||||
if (*scratchLeft < size) {
|
||||
if (!DecompressBlocks(this, start, size, *dest + total - size, first, count, *dest)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
*dest += total;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (!DecompressBlocks(this, start, size, *scratch, first, count, *dest)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
*scratch += size;
|
||||
*scratchLeft -= size;
|
||||
*dest += total;
|
||||
return true;
|
||||
}
|
||||
|
||||
// VERIFY: d7e23bc5 manual
|
||||
// OFFSET: 0x00459A00
|
||||
bool IOMpqReadUnit::LoadSectorTable() {
|
||||
uint32_t entries = this->m_sectorOffsets.m_count - 1;
|
||||
uint32_t tableSize = entries * 4;
|
||||
uint32_t compressedSize = this->m_sectorOffsets.m_data[1];
|
||||
uint32_t bytesRead = 0;
|
||||
|
||||
if (!this->m_next->Read(this->m_sectorOffsets.m_data, 0, tableSize + 4, &bytesRead) || bytesRead < tableSize) {
|
||||
this->m_sectorOffsets.m_data[1] = compressedSize;
|
||||
return false;
|
||||
}
|
||||
|
||||
bytesRead &= ~3u;
|
||||
|
||||
if (this->m_flags & 0xF0000) {
|
||||
System_MPQEncrypt::Decrypt(this->m_sectorOffsets.m_data, bytesRead, this->m_key - 1);
|
||||
}
|
||||
|
||||
for (uint32_t i = 1; i < entries; i++) {
|
||||
if (this->m_sectorOffsets.m_data[i] <= this->m_sectorOffsets.m_data[i - 1] || this->m_sectorOffsets.m_data[i] > compressedSize) {
|
||||
this->m_sectorOffsets.m_data[1] = compressedSize;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t* offsets = this->m_sectorOffsets.m_data;
|
||||
|
||||
if (offsets[0] - tableSize >= 4) {
|
||||
uint32_t checksumOffset = offsets[entries - 1];
|
||||
uint32_t checksumSize = offsets[entries] - checksumOffset;
|
||||
uint32_t expected = tableSize - 4;
|
||||
|
||||
if (checksumSize) {
|
||||
if (checksumSize > expected) {
|
||||
this->m_sectorOffsets.m_data[1] = compressedSize;
|
||||
return false;
|
||||
}
|
||||
|
||||
this->m_checksums.Resize(entries - 1);
|
||||
|
||||
if (!this->m_next->Read(this->m_checksums.m_data, checksumOffset, checksumSize, nullptr)) {
|
||||
this->m_sectorOffsets.m_data[1] = compressedSize;
|
||||
return false;
|
||||
}
|
||||
|
||||
uint32_t outSize = expected;
|
||||
|
||||
if (!System_SComp::Decompress(this->m_checksums.m_data, &outSize, this->m_checksums.m_data, checksumSize) || expected != outSize) {
|
||||
this->m_sectorOffsets.m_data[1] = compressedSize;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// VERIFY: 78cbfb13 manual
|
||||
// OFFSET: 0x0042FBC0
|
||||
bool IOMpqReadUnit::ReadRun(uint32_t first, uint32_t count, uint8_t** dest, uint8_t** scratch, uint32_t* scratchLeft) {
|
||||
uint32_t start = this->m_sectorOffsets.m_data[first];
|
||||
uint32_t size = this->m_sectorOffsets.m_data[first + count] - start;
|
||||
uint32_t lastSize = first + count - 1 >= this->m_sectorOffsets.m_count - 3 ? this->m_lastSectorSize : this->m_sectorSize;
|
||||
uint32_t total = lastSize + this->m_sectorSize * (count - 1);
|
||||
|
||||
if (*scratchLeft < size) {
|
||||
if (!this->m_next->Read(*dest + total - size, start, size, nullptr)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
*dest += total;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (!this->m_next->Read(*scratch, start, size, nullptr)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
*scratch += size;
|
||||
*scratchLeft -= size;
|
||||
*dest += total;
|
||||
return true;
|
||||
}
|
||||
|
||||
// VERIFY: ce01556e manual
|
||||
// OFFSET: 0x0042FCC0
|
||||
bool IOMpqReadUnit::VerifyRun(uint32_t first, uint32_t count, uint8_t** dest, uint8_t** scratch, uint32_t* scratchLeft) {
|
||||
uint32_t start = this->m_sectorOffsets.m_data[first];
|
||||
uint32_t size = this->m_sectorOffsets.m_data[first + count] - start;
|
||||
uint32_t lastSize = first + count - 1 >= this->m_sectorOffsets.m_count - 3 ? this->m_lastSectorSize : this->m_sectorSize;
|
||||
uint32_t total = lastSize + this->m_sectorSize * (count - 1);
|
||||
|
||||
if (*scratchLeft < size) {
|
||||
if (!VerifyBlocks(this, start, size, *dest + total - size, first, count, *dest)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
*dest += total;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (!VerifyBlocks(this, start, size, *scratch, first, count, *dest)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
*scratch += size;
|
||||
*scratchLeft -= size;
|
||||
*dest += total;
|
||||
return true;
|
||||
}
|
||||
@@ -0,0 +1,142 @@
|
||||
#ifndef ENGINE_SOURCE_BLIZZARDCORE_SOURCE_PACKAGES_MOPAQ_IOMPQUNIT_H
|
||||
#define ENGINE_SOURCE_BLIZZARDCORE_SOURCE_PACKAGES_MOPAQ_IOMPQUNIT_H
|
||||
|
||||
#include <cstdint>
|
||||
#include "Engine/Source/BlizzardCore/Include/Blizzard/Util/Digest.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/iounit/IOUnit.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/Mopaq/SFileArchives.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/Memory/TempBuffer.h"
|
||||
|
||||
class IOMpqUnit : public IOUnit {
|
||||
public:
|
||||
/* 0010 */ uint32_t unk_0010;
|
||||
/* 0014 */ System_SFile::ARCHIVEREC* m_archive;
|
||||
/* 0018 */ Blizzard::Memory::TempBuffer<char, 260> m_name;
|
||||
|
||||
virtual uint32_t GetType();
|
||||
virtual ~IOMpqUnit();
|
||||
virtual bool Close();
|
||||
virtual System_SFile::ARCHIVEREC* GetArchive();
|
||||
virtual const char* GetName();
|
||||
virtual const char* GetPath() = 0;
|
||||
virtual bool GetCompressedSize(int64_t* size) = 0;
|
||||
virtual IOUnit* GetBaseUnit() = 0;
|
||||
virtual int64_t GetOffset() = 0;
|
||||
virtual uint64_t GetFileTime() = 0;
|
||||
virtual uint32_t GetCrc() = 0;
|
||||
virtual const Blizzard::Util::Digest<16>* GetMd5() = 0;
|
||||
virtual bool HasMd5Check() = 0;
|
||||
virtual void DisableMd5Check() = 0;
|
||||
virtual uint32_t GetFlags() = 0;
|
||||
virtual bool MarkDeleted() = 0;
|
||||
virtual bool IsEncrypted() = 0;
|
||||
|
||||
IOMpqUnit(System_SFile::ARCHIVEREC* archive, const char* name, bool ownsMemory, IOUnit* next);
|
||||
};
|
||||
|
||||
class IOMpqArchiveUnit : public IOMpqUnit {
|
||||
public:
|
||||
/* 0124 */ uint32_t m_blockIndex;
|
||||
/* 0128 */ System_SFile::BLOCKENTRY m_blockEntry;
|
||||
|
||||
virtual bool GetFileSize(int64_t* size);
|
||||
virtual bool SetFileSize(int64_t size);
|
||||
virtual ~IOMpqArchiveUnit();
|
||||
virtual const char* GetPath();
|
||||
virtual bool GetCompressedSize(int64_t* size);
|
||||
virtual IOUnit* GetBaseUnit();
|
||||
virtual int64_t GetOffset();
|
||||
virtual uint64_t GetFileTime();
|
||||
virtual uint32_t GetCrc();
|
||||
virtual const Blizzard::Util::Digest<16>* GetMd5();
|
||||
virtual bool HasMd5Check();
|
||||
virtual void DisableMd5Check();
|
||||
virtual uint32_t GetFlags();
|
||||
virtual bool MarkDeleted();
|
||||
virtual bool IsEncrypted();
|
||||
|
||||
IOMpqArchiveUnit(System_SFile::ARCHIVEREC* archive, const char* name, uint32_t blockIndex, bool ownsMemory, IOUnit* next);
|
||||
};
|
||||
|
||||
class IOMpqArchiveReadUnit : public IOMpqArchiveUnit {
|
||||
public:
|
||||
static IOMpqArchiveReadUnit* Create(IOUnitContainer* container, System_SFile::ARCHIVEREC* archive, const char* name, uint32_t blockIndex, IOUnit* next);
|
||||
|
||||
virtual bool Write(const void* buffer, int64_t offset, uint32_t count);
|
||||
|
||||
IOMpqArchiveReadUnit(System_SFile::ARCHIVEREC* archive, const char* name, uint32_t blockIndex, bool ownsMemory, IOUnit* next);
|
||||
};
|
||||
|
||||
class IOMpqDiskUnit : public IOMpqUnit {
|
||||
public:
|
||||
static IOMpqDiskUnit* Create(IOUnitContainer* container, System_SFile::ARCHIVEREC* archive, const char* name, const char* path, IOUnit* next);
|
||||
|
||||
/* 0124 */ Blizzard::Memory::TempBuffer<char, 260> m_path;
|
||||
|
||||
virtual ~IOMpqDiskUnit();
|
||||
virtual const char* GetPath();
|
||||
virtual bool GetCompressedSize(int64_t* size);
|
||||
virtual IOUnit* GetBaseUnit();
|
||||
virtual int64_t GetOffset();
|
||||
virtual uint64_t GetFileTime();
|
||||
virtual uint32_t GetCrc();
|
||||
virtual const Blizzard::Util::Digest<16>* GetMd5();
|
||||
virtual bool HasMd5Check();
|
||||
virtual void DisableMd5Check();
|
||||
virtual uint32_t GetFlags();
|
||||
virtual bool MarkDeleted();
|
||||
virtual bool IsEncrypted();
|
||||
|
||||
IOMpqDiskUnit(System_SFile::ARCHIVEREC* archive, const char* name, const char* path, bool ownsMemory, IOUnit* next);
|
||||
};
|
||||
|
||||
class IOMpqReadUnit : public IOUnit {
|
||||
public:
|
||||
struct SectorJob {
|
||||
/* 0000 */ IOMpqReadUnit* m_unit;
|
||||
/* 0004 */ uint32_t m_first;
|
||||
/* 0008 */ uint32_t m_end;
|
||||
/* 000C */ uint8_t* m_scratch;
|
||||
/* 0010 */ uint32_t m_scratchSize;
|
||||
/* 0014 */ uint8_t* m_dest;
|
||||
/* 0018 */ uint32_t m_scratchLeft;
|
||||
/* 001C */ uint8_t* m_destCursor;
|
||||
/* 0020 */ bool m_success;
|
||||
/* 0021 */ uint8_t unk_0021[3];
|
||||
};
|
||||
|
||||
static IOUnit* Create(IOUnitContainer* container, uint32_t fileSize, uint32_t compressedSize, uint32_t sectorSize, uint32_t flags, uint32_t key, IOUnit* next);
|
||||
static IOUnit* CreateSingle(IOUnitContainer* container, uint32_t fileSize, uint32_t compressedSize, uint32_t flags, uint32_t key, IOUnit* next);
|
||||
static bool DecompressBlocks(IOMpqReadUnit* unit, uint32_t offset, uint32_t size, uint8_t* source, uint32_t first, uint32_t count, uint8_t* dest);
|
||||
static void DecompressSectors(void* param);
|
||||
static void ReadSectors(SectorJob* job);
|
||||
static bool VerifyBlocks(IOMpqReadUnit* unit, uint32_t offset, uint32_t size, uint8_t* source, uint32_t first, uint32_t count, uint8_t* dest);
|
||||
|
||||
/* 0010 */ Blizzard::Memory::TempBuffer<uint32_t, 10> m_sectorOffsets;
|
||||
/* 0040 */ Blizzard::Memory::TempBuffer<uint32_t, 8> m_checksums;
|
||||
/* 0068 */ uint32_t m_sectorSize;
|
||||
/* 006C */ uint32_t m_lastSectorSize;
|
||||
/* 0070 */ uint32_t m_flags;
|
||||
/* 0074 */ uint32_t m_key;
|
||||
/* 0078 */ uint32_t m_fileSize;
|
||||
|
||||
virtual uint32_t GetType();
|
||||
virtual bool Read(void* buffer, int64_t offset, uint32_t count, uint32_t* bytesRead);
|
||||
virtual bool Write(const void* buffer, int64_t offset, uint32_t count);
|
||||
virtual bool Flush();
|
||||
virtual bool GetFileSize(int64_t* size);
|
||||
virtual bool SetFileSize(int64_t size);
|
||||
virtual ~IOMpqReadUnit();
|
||||
virtual bool Close();
|
||||
|
||||
IOMpqReadUnit(uint32_t fileSize, uint32_t compressedSize, uint32_t sectorCount, uint32_t sectorSize, uint32_t flags, uint32_t key, bool ownsMemory, IOUnit* next);
|
||||
IOMpqReadUnit(uint32_t fileSize, uint32_t compressedSize, uint32_t flags, uint32_t key, bool ownsMemory, IOUnit* next);
|
||||
uint32_t CountCompressed(uint32_t first, uint32_t end);
|
||||
uint32_t CountUncompressed(uint32_t first, uint32_t end);
|
||||
bool DecompressRun(uint32_t first, uint32_t count, uint8_t** dest, uint8_t** scratch, uint32_t* scratchLeft);
|
||||
bool LoadSectorTable();
|
||||
bool ReadRun(uint32_t first, uint32_t count, uint8_t** dest, uint8_t** scratch, uint32_t* scratchLeft);
|
||||
bool VerifyRun(uint32_t first, uint32_t count, uint8_t** dest, uint8_t** scratch, uint32_t* scratchLeft);
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -15,7 +15,7 @@ bool System_MPQGlobals::ArchiveLess::operator()(const System_SFile::ARCHIVEREC*
|
||||
return a->m_priority > b->m_priority;
|
||||
}
|
||||
|
||||
// VERIFY: df235665 manual
|
||||
// VERIFY: 4886183c manual
|
||||
// OFFSET: 0x0044FFF0
|
||||
System_MPQGlobals::Globals::Globals() {
|
||||
this->m_mopaq.m_directAccess = 0;
|
||||
@@ -24,9 +24,9 @@ System_MPQGlobals::Globals::Globals() {
|
||||
this->m_mopaq.m_basePath[0] = '\0';
|
||||
}
|
||||
|
||||
this->m_mopaq.unk_0108 = 0;
|
||||
this->m_mopaq.unk_010C = 0;
|
||||
this->m_mopaq.unk_0110 = 0;
|
||||
this->m_mopaq.m_openCallback = nullptr;
|
||||
this->m_mopaq.m_openCallbackParam = nullptr;
|
||||
this->m_mopaq.m_md5Mode = 0;
|
||||
}
|
||||
|
||||
// VERIFY: e5b01062 manual
|
||||
@@ -58,3 +58,68 @@ Blizzard::Lock::RMutex* System_MPQGlobals::GetMopaqGlobalsLock() {
|
||||
System_MPQGlobals::WorkerPool* System_MPQGlobals::GetWorkerPool() {
|
||||
return &s_globals.Get()->m_workerPool;
|
||||
}
|
||||
|
||||
// VERIFY: af26db8a manual
|
||||
// OFFSET: 0x0042BA60
|
||||
uint32_t System_MPQGlobals::Worker::ThreadProc(void* param) {
|
||||
Worker* worker = static_cast<Worker*>(param);
|
||||
|
||||
Blizzard::Lock::EventWaitForever(worker->m_start.m_event);
|
||||
|
||||
while (worker->m_proc) {
|
||||
worker->m_proc(worker->m_param);
|
||||
worker->m_proc = nullptr;
|
||||
worker->m_param = nullptr;
|
||||
Blizzard::Lock::EventSet(worker->m_done.m_event);
|
||||
Blizzard::Lock::EventWaitForever(worker->m_start.m_event);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// VERIFY: ab9a819e manual
|
||||
// OFFSET: 0x00451200
|
||||
System_MPQGlobals::Worker::Worker() {
|
||||
this->m_proc = nullptr;
|
||||
this->m_param = nullptr;
|
||||
Blizzard::Thread::Create(ThreadProc, this, &this->m_thread, "", 0, 0x40000);
|
||||
}
|
||||
|
||||
// VERIFY: 7d61b910 manual
|
||||
// OFFSET: 0x00451A30
|
||||
void System_MPQGlobals::WorkerPool::Acquire(uint32_t count, Worker** workers) {
|
||||
uint32_t i = 0;
|
||||
|
||||
if (!count) {
|
||||
return;
|
||||
}
|
||||
|
||||
Blizzard::Lock::MutexEnter(this->m_mutex.m_mutex);
|
||||
|
||||
for (; i < count && !this->m_workers.empty(); i++) {
|
||||
workers[i] = this->m_workers.back();
|
||||
this->m_workers.pop_back();
|
||||
}
|
||||
|
||||
for (; i < count; i++) {
|
||||
workers[i] = new Worker();
|
||||
}
|
||||
|
||||
Blizzard::Lock::MutexLeave(this->m_mutex.m_mutex);
|
||||
}
|
||||
|
||||
// VERIFY: d764e194 manual
|
||||
// OFFSET: 0x00446060
|
||||
void System_MPQGlobals::WorkerPool::Release(uint32_t count, Worker** workers) {
|
||||
if (!count) {
|
||||
return;
|
||||
}
|
||||
|
||||
Blizzard::Lock::MutexEnter(this->m_mutex.m_mutex);
|
||||
|
||||
do {
|
||||
this->m_workers.push_back(*workers++);
|
||||
} while (--count);
|
||||
|
||||
Blizzard::Lock::MutexLeave(this->m_mutex.m_mutex);
|
||||
}
|
||||
|
||||
@@ -8,6 +8,7 @@
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/Mopaq/SFileArchives.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/Lock/Lock.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/Memory/AllocSTL.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/Thread/Thread.h"
|
||||
|
||||
namespace System_MPQGlobals {
|
||||
|
||||
@@ -20,15 +21,32 @@ typedef std::set<System_SFile::ARCHIVEREC*, ArchiveLess, Blizzard::Memory::Alloc
|
||||
struct MopaqGlobals {
|
||||
/* 0000 */ uint32_t m_directAccess;
|
||||
/* 0004 */ char m_basePath[260];
|
||||
/* 0108 */ uint32_t unk_0108;
|
||||
/* 010C */ uint32_t unk_010C;
|
||||
/* 0110 */ uint32_t unk_0110;
|
||||
/* 0114 */ uint32_t unk_0114;
|
||||
/* 0108 */ void (*m_openCallback)(const char* name, void* param);
|
||||
/* 010C */ void* m_openCallbackParam;
|
||||
/* 0110 */ uint32_t m_md5Mode;
|
||||
/* 0114 */ bool (*m_md5Callback)(void* context, const uint8_t* md5);
|
||||
};
|
||||
|
||||
struct WorkerPool {
|
||||
class Worker {
|
||||
public:
|
||||
static uint32_t ThreadProc(void* param);
|
||||
|
||||
/* 0000 */ Blizzard::Thread::ThreadRecord* m_thread;
|
||||
/* 0004 */ Blizzard::Lock::EventObject m_start;
|
||||
/* 0008 */ Blizzard::Lock::EventObject m_done;
|
||||
/* 000C */ void (*m_proc)(void* param);
|
||||
/* 0010 */ void* m_param;
|
||||
|
||||
Worker();
|
||||
};
|
||||
|
||||
class WorkerPool {
|
||||
public:
|
||||
/* 0000 */ Blizzard::Lock::RMutex m_mutex;
|
||||
/* 0018 */ std::vector<void*> m_workers;
|
||||
/* 0018 */ std::vector<Worker*> m_workers;
|
||||
|
||||
void Acquire(uint32_t count, Worker** workers);
|
||||
void Release(uint32_t count, Worker** workers);
|
||||
};
|
||||
|
||||
class Globals {
|
||||
|
||||
@@ -1,10 +1,26 @@
|
||||
#include <cstdint>
|
||||
#include "Engine/Source/BlizzardCore/SFile2-Core.h"
|
||||
#include "Engine/Source/Storm/H/storm.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/iounit/IOAlignUnit.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/iounit/IOChecksumUnit.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/iounit/IOFileUnit.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/iounit/IOUnit.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/iounit/IOUnitContainer.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/Mopaq/IOMpqUnit.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/Mopaq/MPQEncrypt.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/Mopaq/MPQGlobals.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/Mopaq/SFile.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/Mopaq/SFileArchives.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/Lock/Lock.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/Log/Log.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/String/Path.h"
|
||||
#include "Engine/Source/Storm/H/storm.h"
|
||||
|
||||
// STATIC: 0x00B38344
|
||||
Blizzard::Thread::LocalObject<System_SFile::RawReadInfo> System_SFile::s_rawReadInfo;
|
||||
|
||||
// STATIC: 0x00B3858C
|
||||
uint32_t System_SFile::s_threadingMode;
|
||||
|
||||
// INLINED
|
||||
System_SFile::RawReadInfo::RawReadInfo() {
|
||||
this->m_retryNative = false;
|
||||
@@ -15,3 +31,209 @@ void STORMAPI SFile::CreateOverlapped(SOVERLAPPED* overlapped) {
|
||||
|
||||
void STORMAPI SFile::DestroyOverlapped(SOVERLAPPED* overlapped) {
|
||||
}
|
||||
|
||||
// VERIFY: 65f10e31 auto
|
||||
// OFFSET: 0x00426E20
|
||||
bool System_SFile::CheckCrc(void* context, uint32_t crc) {
|
||||
return crc == static_cast<IOMpqArchiveUnit*>(context)->m_blockEntry.m_crc;
|
||||
}
|
||||
|
||||
// VERIFY: dc1be6b1 auto
|
||||
// OFFSET: 0x00426FD0
|
||||
void Blizzard::Mopaq::SFileSetThreadingMode(uint32_t mode) {
|
||||
System_SFile::s_threadingMode = mode;
|
||||
}
|
||||
|
||||
// VERIFY: 94d8b66b manual
|
||||
// OFFSET: 0x0042ED90
|
||||
IOUnit* System_SFile::GetLockedUnit(IOUnit* file) {
|
||||
if (!file || file->GetType() != 'mpq ') {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
IOUnit* lock = file->m_next;
|
||||
|
||||
if (!lock || lock->GetType() != 'lock') {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return lock->m_next;
|
||||
}
|
||||
|
||||
// VERIFY: df584044 auto
|
||||
// OFFSET: 0x0042EDD0
|
||||
bool System_SFile::InsertLockedUnit(IOUnit* file, IOUnit* unit) {
|
||||
if (!file || !unit || file->GetType() != 'mpq ') {
|
||||
return false;
|
||||
}
|
||||
|
||||
return IOLockUnit::ReplaceNext(file->m_next, unit);
|
||||
}
|
||||
|
||||
// VERIFY: 07c1b49c manual
|
||||
// OFFSET: 0x00437310
|
||||
IOUnit* System_SFile::OpenFileUnit(IOUnitContainer* container, const char* path, int32_t mode) {
|
||||
if (mode & 0x40) {
|
||||
return System_Mopaq::OpenDiskFile(container, path, mode);
|
||||
}
|
||||
|
||||
return IOFileUnit::Create(container, path, mode);
|
||||
}
|
||||
|
||||
// VERIFY: 66befaed auto
|
||||
// OFFSET: 0x00437340
|
||||
IOUnit* System_SFile::CreateRangeUnit(IOUnitContainer* container, int64_t start, int64_t end, IOUnit* next) {
|
||||
return IORangeUnit::Create(container, start, end, next);
|
||||
}
|
||||
|
||||
// VERIFY: ed823991 manual
|
||||
// OFFSET: 0x004609B0
|
||||
int32_t Blizzard::Mopaq::SFileOpenFileEx(System_SFile::ARCHIVEREC* handle, const char* name, const Blizzard::Util::Digest<16>& md5, uint32_t flags, IOMpqUnit** result) {
|
||||
IOMpqUnit* file = nullptr;
|
||||
*result = nullptr;
|
||||
System_SFile::ARCHIVEREC* archive = nullptr;
|
||||
uint32_t error = 104;
|
||||
uint32_t blockIndex;
|
||||
char path[260];
|
||||
int32_t found = GetFileBlockEntry(handle, name, md5, flags, nullptr, &archive, &blockIndex, nullptr, path);
|
||||
|
||||
Blizzard::Log::Printf(3, "Logs/Profiling_File_SFileOpenFileEx.log", "%s\n", name);
|
||||
|
||||
switch (found) {
|
||||
case 0:
|
||||
case 4: {
|
||||
error = 2;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
case 1: {
|
||||
System_SFile::BLOCKENTRY entry = archive->GetBlockEntry(blockIndex);
|
||||
|
||||
if (!(entry.m_flags & 0x80000000)) {
|
||||
error = 1006;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
IOChecksumUnit* checksum = nullptr;
|
||||
|
||||
if (entry.m_flags & 0xFFF00) {
|
||||
uint32_t fileSize = entry.m_fileSize;
|
||||
uint32_t key = 0;
|
||||
|
||||
if (entry.m_flags & 0xF0000) {
|
||||
key = System_MPQEncrypt::Hash(Blizzard::String::FindFilename(name), 3);
|
||||
|
||||
if (entry.m_flags & 0x20000) {
|
||||
key = fileSize ^ (key + static_cast<uint32_t>(entry.m_offset) - static_cast<uint32_t>(archive->m_archiveOffset));
|
||||
}
|
||||
}
|
||||
|
||||
archive->m_file->m_refCount.Increment();
|
||||
|
||||
if (entry.m_flags & 0x1000000) {
|
||||
IOUnitContainer container(sizeof(IOMpqArchiveReadUnit), sizeof(IOCrcUnit), sizeof(IOAlignUnit), sizeof(IOLockUnit), sizeof(IOMpqReadUnit), sizeof(IORangeUnit), 0);
|
||||
IOUnit* range = System_SFile::CreateRangeUnit(&container, entry.m_offset, entry.m_offset + entry.m_compressedSize, archive->m_file);
|
||||
IOUnit* read = IOMpqReadUnit::CreateSingle(&container, fileSize, entry.m_compressedSize, entry.m_flags, key, range);
|
||||
IOUnit* crc = IOCrcUnit::Create(&container, fileSize, entry.m_crc ? System_SFile::CheckCrc : nullptr, false, &checksum, read);
|
||||
IOUnit* align = IOAlignUnit::Create(&container, 0, fileSize, 1, false, false, 1, crc);
|
||||
IOUnit* lock = IOLockUnit::Create(&container, align);
|
||||
file = IOMpqArchiveReadUnit::Create(&container, archive, name, blockIndex, lock);
|
||||
} else {
|
||||
bool checkCrc = !(entry.m_flags & 0x4000000) && entry.m_crc;
|
||||
IOUnitContainer container(sizeof(IOMpqArchiveReadUnit), sizeof(IOCrcUnit), sizeof(IOAlignUnit), sizeof(IOLockUnit), sizeof(IOMpqReadUnit), sizeof(IORangeUnit), 0);
|
||||
IOUnit* range = System_SFile::CreateRangeUnit(&container, entry.m_offset, entry.m_offset + entry.m_compressedSize, archive->m_file);
|
||||
IOUnit* read = IOMpqReadUnit::Create(&container, fileSize, entry.m_compressedSize, archive->m_sectorSize, entry.m_flags, key, range);
|
||||
IOUnit* crc = IOCrcUnit::Create(&container, fileSize, checkCrc ? System_SFile::CheckCrc : nullptr, false, &checksum, read);
|
||||
IOUnit* align = IOAlignUnit::Create(&container, 0, archive->m_sectorSize, 1, true, true, 1, crc);
|
||||
IOUnit* lock = IOLockUnit::Create(&container, align);
|
||||
file = IOMpqArchiveReadUnit::Create(&container, archive, name, blockIndex, lock);
|
||||
}
|
||||
} else {
|
||||
if (entry.m_compressedSize != entry.m_fileSize) {
|
||||
error = 1006;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
archive->m_file->m_refCount.Increment();
|
||||
|
||||
IOUnitContainer container(sizeof(IOMpqArchiveReadUnit), sizeof(IOCrcUnit), sizeof(IOLockUnit), sizeof(IORangeUnit), 0);
|
||||
IOUnit* range = System_SFile::CreateRangeUnit(&container, entry.m_offset, entry.m_offset + entry.m_fileSize, archive->m_file);
|
||||
IOUnit* crc = IOCrcUnit::Create(&container, entry.m_fileSize, entry.m_crc ? System_SFile::CheckCrc : nullptr, false, &checksum, range);
|
||||
IOUnit* lock = IOLockUnit::Create(&container, crc);
|
||||
file = IOMpqArchiveReadUnit::Create(&container, archive, name, blockIndex, lock);
|
||||
}
|
||||
|
||||
if (checksum) {
|
||||
checksum->SetContext(file);
|
||||
}
|
||||
|
||||
found = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
case 2:
|
||||
case 3: {
|
||||
IOUnitContainer container(sizeof(IOMpqDiskUnit), sizeof(IOUnbufferedFileUnit), 0);
|
||||
IOUnit* disk = System_SFile::OpenFileUnit(&container, path, (((flags & 4) | 2) >> 1) | 0x1004);
|
||||
file = IOMpqDiskUnit::Create(&container, archive, name, path, disk);
|
||||
found = 2;
|
||||
break;
|
||||
}
|
||||
|
||||
default: {
|
||||
goto fail;
|
||||
}
|
||||
}
|
||||
|
||||
if (!file || (archive && !archive->RemoveInternalArchiveRef())) {
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if (found) {
|
||||
void (*callback)(const char* name, void* param);
|
||||
void* param;
|
||||
|
||||
{
|
||||
Blizzard::Lock::ScopedMutex lock(System_MPQGlobals::GetMopaqGlobalsLock()->m_mutex);
|
||||
System_MPQGlobals::MopaqGlobals* globals = System_MPQGlobals::GetMopaqGlobals();
|
||||
callback = globals->m_openCallback;
|
||||
param = globals->m_openCallbackParam;
|
||||
}
|
||||
|
||||
if (callback) {
|
||||
callback(name, param);
|
||||
}
|
||||
|
||||
if (System_MPQGlobals::GetMopaqGlobals()->m_md5Mode == 1 && file->HasMd5Check()) {
|
||||
int64_t size;
|
||||
file->GetFileSize(&size);
|
||||
|
||||
IOUnit* inner = System_SFile::GetLockedUnit(file);
|
||||
IOUnit* md5Unit = IOMd5Unit::Create(nullptr, size, System_MPQGlobals::GetMopaqGlobals()->m_md5Callback, true, nullptr, inner);
|
||||
static_cast<IOChecksumUnit*>(md5Unit)->SetContext(file);
|
||||
|
||||
bool inserted = System_SFile::InsertLockedUnit(file, md5Unit);
|
||||
|
||||
if (!inner || !inserted) {
|
||||
inner->m_refCount.Increment();
|
||||
md5Unit->Release();
|
||||
found = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
*result = file;
|
||||
return found;
|
||||
|
||||
fail:
|
||||
System_SFile::s_lastError = error;
|
||||
found = 0;
|
||||
|
||||
if (file) {
|
||||
file->Release();
|
||||
file = nullptr;
|
||||
}
|
||||
|
||||
*result = file;
|
||||
return found;
|
||||
}
|
||||
|
||||
@@ -1,10 +1,18 @@
|
||||
#ifndef ENGINE_SOURCE_BLIZZARDCORE_SOURCE_PACKAGES_MOPAQ_SFILE_H
|
||||
#define ENGINE_SOURCE_BLIZZARDCORE_SOURCE_PACKAGES_MOPAQ_SFILE_H
|
||||
|
||||
#include <cstdint>
|
||||
#include "Engine/Source/BlizzardCore/Include/Blizzard/Util/Digest.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/Thread/ThreadLocalStorage.h"
|
||||
|
||||
class IOMpqUnit;
|
||||
class IOUnit;
|
||||
class IOUnitContainer;
|
||||
|
||||
namespace System_SFile {
|
||||
|
||||
class ARCHIVEREC;
|
||||
|
||||
struct RawReadInfo {
|
||||
/* 0000 */ bool m_retryNative;
|
||||
|
||||
@@ -12,7 +20,23 @@ struct RawReadInfo {
|
||||
};
|
||||
|
||||
extern Blizzard::Thread::LocalObject<RawReadInfo> s_rawReadInfo;
|
||||
extern uint32_t s_threadingMode;
|
||||
|
||||
bool CheckCrc(void* context, uint32_t crc);
|
||||
IOUnit* CreateRangeUnit(IOUnitContainer* container, int64_t start, int64_t end, IOUnit* next);
|
||||
IOUnit* GetLockedUnit(IOUnit* file);
|
||||
bool InsertLockedUnit(IOUnit* file, IOUnit* unit);
|
||||
IOUnit* OpenFileUnit(IOUnitContainer* container, const char* path, int32_t mode);
|
||||
|
||||
}
|
||||
|
||||
namespace Blizzard {
|
||||
namespace Mopaq {
|
||||
|
||||
int32_t SFileOpenFileEx(System_SFile::ARCHIVEREC* handle, const char* name, const Blizzard::Util::Digest<16>& md5, uint32_t flags, IOMpqUnit** result);
|
||||
void SFileSetThreadingMode(uint32_t mode);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1213,3 +1213,361 @@ hashError:
|
||||
|
||||
InitEmptyTables(this, 1);
|
||||
}
|
||||
|
||||
// VERIFY: 30fc5178 manual
|
||||
// OFFSET: 0x0042C3F0
|
||||
System_SFile::BLOCKENTRY System_SFile::ARCHIVEREC::GetBlockEntry(uint32_t index) {
|
||||
BlockEntryTable* blocks = this->m_blockEntryTable;
|
||||
|
||||
if (!blocks) {
|
||||
return this->m_blockTable[index];
|
||||
}
|
||||
|
||||
BLOCKENTRY entry;
|
||||
blocks->UnpackEntry(index, &entry);
|
||||
|
||||
if (this->m_flags & 0x80) {
|
||||
entry.m_crc = this->m_blockEntryTable->m_crcs[index];
|
||||
}
|
||||
|
||||
if (this->m_flags & 0x40) {
|
||||
entry.m_md5 = this->m_blockEntryTable->m_md5s[index];
|
||||
}
|
||||
|
||||
if (this->m_flags & 0x100) {
|
||||
entry.m_fileTime = this->m_blockEntryTable->m_fileTimes[index];
|
||||
}
|
||||
|
||||
return entry;
|
||||
}
|
||||
|
||||
// VERIFY: 913cd4bd manual
|
||||
// OFFSET: 0x0042C7E0
|
||||
uint32_t System_SFile::SearchHashTable(ARCHIVEREC* archive, const char* name, bool matchNeutral, bool* deleted) {
|
||||
archive->InitializeTables();
|
||||
|
||||
uint16_t locale = archive->m_locale;
|
||||
uint8_t platform = archive->m_platform;
|
||||
std::vector<HASHENTRY>& table = archive->m_hashTable;
|
||||
uint32_t mask = static_cast<uint32_t>(table.size()) - 1;
|
||||
uint32_t index = System_MPQEncrypt::Hash(name, 0) & mask;
|
||||
uint32_t found = -1;
|
||||
HASHENTRY* entry = &table[index];
|
||||
|
||||
if (entry->m_blockIndex == -1) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
uint32_t hashA = System_MPQEncrypt::Hash(name, 1);
|
||||
uint32_t hashB = System_MPQEncrypt::Hash(name, 2);
|
||||
uint32_t start = index;
|
||||
|
||||
while (true) {
|
||||
if (entry->m_hashA == hashA && entry->m_hashB == hashB && entry->m_blockIndex != -2) {
|
||||
if (entry->m_locale == locale && entry->m_platform == platform) {
|
||||
found = index;
|
||||
break;
|
||||
}
|
||||
|
||||
if (matchNeutral && (!entry->m_locale || entry->m_locale == locale) && (!entry->m_platform || entry->m_platform == platform)) {
|
||||
found = index;
|
||||
}
|
||||
}
|
||||
|
||||
index = (index + 1) & mask;
|
||||
|
||||
if (index == start) {
|
||||
break;
|
||||
}
|
||||
|
||||
entry = &table[index];
|
||||
|
||||
if (entry->m_blockIndex == -1) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (found != -1 && deleted) {
|
||||
*deleted = (archive->GetBlockEntry(table[found].m_blockIndex).m_flags & 0x2000000) != 0;
|
||||
}
|
||||
|
||||
return found;
|
||||
}
|
||||
|
||||
// VERIFY: a62931d4 manual
|
||||
// OFFSET: 0x00454120
|
||||
bool System_SFile::CheckFileExistsOnDisk(const char* name, uint32_t flags, char* result) {
|
||||
char buffer[260];
|
||||
|
||||
if (!(flags & 3)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!result) {
|
||||
result = buffer;
|
||||
}
|
||||
|
||||
if (flags & 2) {
|
||||
ConvertRelativePathName(Blizzard::String::FindFilename(name), result);
|
||||
|
||||
if (Blizzard::File::Exists(result) == 1) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (!(flags & 1)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (Blizzard::File::GetRootChars(name)) {
|
||||
Blizzard::String::Copy(result, name, 260);
|
||||
} else {
|
||||
ConvertRelativePathName(name, result);
|
||||
}
|
||||
|
||||
return Blizzard::File::Exists(result) == 1;
|
||||
}
|
||||
|
||||
// VERIFY: 138e567c manual
|
||||
// OFFSET: 0x0045BED0
|
||||
void System_SFile::ARCHIVEREC::BuildBlockKeys() {
|
||||
if (!this->m_tablesInitialized) {
|
||||
this->InitializeTables();
|
||||
}
|
||||
|
||||
if (this->m_blockKeysBuilt) {
|
||||
return;
|
||||
}
|
||||
|
||||
ArchivePtr archive(GetArchivePtr(this, true));
|
||||
|
||||
if (this->m_blockKeys.empty()) {
|
||||
for (uint32_t i = 0; i < this->m_header.m_blockTableSize; i++) {
|
||||
this->m_blockKeys.insert(std::make_pair(this->m_blockTable[i].m_md5, i));
|
||||
}
|
||||
|
||||
this->m_blockKeysBuilt = true;
|
||||
}
|
||||
}
|
||||
|
||||
// VERIFY: 520c5718 manual
|
||||
// OFFSET: 0x0045C880
|
||||
uint32_t System_SFile::FindBlockEntry(ARCHIVEREC* archive, const Blizzard::Util::Digest<16>& md5, bool* deleted) {
|
||||
archive->BuildBlockKeys();
|
||||
|
||||
std::map<Blizzard::Util::Digest<16>, uint32_t>::iterator it = archive->m_blockKeys.find(md5);
|
||||
|
||||
if (it == archive->m_blockKeys.end()) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
*deleted = (archive->GetBlockEntry(it->second).m_flags & 0x2000000) != 0;
|
||||
|
||||
return it->second;
|
||||
}
|
||||
|
||||
// VERIFY: 962c3879 manual
|
||||
// OFFSET: 0x0045F7D0
|
||||
int32_t FindFileInOneArchive(System_SFile::ARCHIVEREC* archive, const char* name, const uint64_t& hash, const Blizzard::Util::Digest<16>& md5, uint32_t flags, System_SFile::FileLookup* lookup) {
|
||||
if (!(flags & 0x10) && (archive->m_externalRefs.m_value <= 0 || archive->unk_0200 > 0)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool deleted = false;
|
||||
|
||||
if (md5 != System_SFile::s_emptyMd5) {
|
||||
lookup->m_blockIndex = System_SFile::FindBlockEntry(archive, md5, &deleted);
|
||||
}
|
||||
|
||||
if (name && lookup->m_blockIndex == -1 && md5 == System_SFile::s_emptyMd5) {
|
||||
char path[260];
|
||||
uint32_t prefix;
|
||||
bool prefixed = false;
|
||||
|
||||
if (archive->m_directPath.empty()) {
|
||||
prefix = 0;
|
||||
} else {
|
||||
prefix = Blizzard::String::Copy(path, archive->m_directPath.c_str(), 260);
|
||||
Blizzard::String::Copy(&path[prefix], name, 260 - prefix);
|
||||
name = path;
|
||||
prefixed = true;
|
||||
}
|
||||
|
||||
if (!archive->m_file) {
|
||||
if (!lookup->m_checkedDisk || prefix) {
|
||||
if (System_SFile::CheckFileExistsOnDisk(name, 1, lookup->m_path)) {
|
||||
lookup->m_archive = archive;
|
||||
return 2;
|
||||
}
|
||||
|
||||
if (!prefix) {
|
||||
lookup->m_checkedDisk = true;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (archive->m_parent) {
|
||||
archive = archive->m_parent;
|
||||
}
|
||||
|
||||
if (prefix && (flags & 1)) {
|
||||
if (System_SFile::CheckFileExistsOnDisk(name, 1, lookup->m_path)) {
|
||||
return 3;
|
||||
}
|
||||
}
|
||||
|
||||
archive->InitializeTables();
|
||||
|
||||
if (archive->m_hashTable.empty()) {
|
||||
uint64_t key = prefixed ? System_SFile::HashEntryTable::CalculateHash(name) : hash;
|
||||
lookup->m_blockIndex = archive->m_hashEntryTable->GetEntry(key, archive->m_blockEntryTable);
|
||||
|
||||
if (lookup->m_blockIndex == -1) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
deleted = (archive->GetBlockEntry(lookup->m_blockIndex).m_flags & 0x2000000) != 0;
|
||||
} else {
|
||||
lookup->m_hashIndex = System_SFile::SearchHashTable(archive, name, true, &deleted);
|
||||
|
||||
if (lookup->m_hashIndex != -1) {
|
||||
lookup->m_blockIndex = archive->m_hashTable[lookup->m_hashIndex].m_blockIndex;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (deleted) {
|
||||
return 4;
|
||||
}
|
||||
|
||||
if (lookup->m_blockIndex == -1) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
lookup->m_archive = archive;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// VERIFY: b9bc5aa5 manual
|
||||
// OFFSET: 0x0045FA10
|
||||
int32_t GetFileBlockEntry(System_SFile::ARCHIVEREC* handle, const char* name, const Blizzard::Util::Digest<16>& md5, uint32_t flags, System_SFile::ARCHIVEREC** archiveOut, System_SFile::ARCHIVEREC** recordOut, uint32_t* blockIndex, uint32_t* hashIndex, char* path) {
|
||||
if (archiveOut) {
|
||||
*archiveOut = nullptr;
|
||||
}
|
||||
|
||||
if (recordOut) {
|
||||
*recordOut = nullptr;
|
||||
}
|
||||
|
||||
if (blockIndex) {
|
||||
*blockIndex = 0;
|
||||
}
|
||||
|
||||
if (hashIndex) {
|
||||
*hashIndex = -1;
|
||||
}
|
||||
|
||||
System_SFile::ArchivePtr archive(System_SFile::GetArchivePtr(handle, true));
|
||||
|
||||
if (handle && !archive.m_archive) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
System_SFile::FileLookup lookup;
|
||||
lookup.m_hashIndex = -1;
|
||||
lookup.m_blockIndex = -1;
|
||||
int32_t result = 0;
|
||||
lookup.m_checkedDisk = false;
|
||||
lookup.m_archive = nullptr;
|
||||
lookup.m_path = path;
|
||||
|
||||
if (flags & 3) {
|
||||
lookup.m_checkedDisk = true;
|
||||
|
||||
if (System_SFile::CheckFileExistsOnDisk(name, flags, path)) {
|
||||
result = 3;
|
||||
}
|
||||
}
|
||||
|
||||
if (!(flags & 8)) {
|
||||
if (!result) {
|
||||
Blizzard::Lock::ScopedMutex lock(System_MPQGlobals::GetArchiveLock()->m_mutex);
|
||||
uint64_t hash = System_SFile::HashEntryTable::CalculateHash(name);
|
||||
|
||||
if (archive.m_archive) {
|
||||
result = FindFileInOneArchive(archive.m_archive, name, hash, md5, flags, &lookup);
|
||||
} else {
|
||||
System_MPQGlobals::ArchiveList* list = System_MPQGlobals::GetArchiveList();
|
||||
|
||||
for (System_MPQGlobals::ArchiveList::iterator it = list->begin(); it != list->end(); ++it) {
|
||||
result = FindFileInOneArchive(*it, name, hash, md5, flags, &lookup);
|
||||
|
||||
if (result) {
|
||||
handle = *it;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (result == 1 || result == 2) {
|
||||
if (recordOut) {
|
||||
lookup.m_archive->m_internalRefs.Increment();
|
||||
*recordOut = lookup.m_archive;
|
||||
}
|
||||
|
||||
if (archiveOut) {
|
||||
*archiveOut = handle;
|
||||
}
|
||||
|
||||
if (result == 1) {
|
||||
if (hashIndex) {
|
||||
*hashIndex = lookup.m_hashIndex;
|
||||
}
|
||||
|
||||
if (blockIndex) {
|
||||
*blockIndex = lookup.m_blockIndex;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// VERIFY: adbb7274 manual
|
||||
// OFFSET: 0x00460EA0
|
||||
int32_t Blizzard::Mopaq::SFileFileExists(System_SFile::ARCHIVEREC* handle, const char* name, uint32_t flags, System_SFile::ARCHIVEREC** archiveOut) {
|
||||
Blizzard::Util::Digest<16> md5 = System_SFile::s_emptyMd5;
|
||||
int32_t result = GetFileBlockEntry(handle, name, md5, flags, archiveOut, nullptr, nullptr, nullptr, nullptr);
|
||||
|
||||
if (result == 4) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// VERIFY: 2e816731 manual
|
||||
// OFFSET: 0x0042C680
|
||||
void System_SFile::ARCHIVEREC::SetMD5Check(uint32_t index, bool enabled) {
|
||||
BlockEntryTable* blocks = this->m_blockEntryTable;
|
||||
|
||||
if (blocks) {
|
||||
if ((this->m_flags & 0x200) && (blocks->m_tableFlags & 0x200)) {
|
||||
uint8_t bit = enabled;
|
||||
blocks->m_entries->WriteBits(blocks->m_md5Bit + index * blocks->m_entryBits, blocks->m_md5Bits, &bit, 1);
|
||||
}
|
||||
} else {
|
||||
this->m_blockTable[index].m_md5Check = enabled;
|
||||
}
|
||||
}
|
||||
|
||||
// VERIFY: 42f50f1a manual
|
||||
// OFFSET: 0x00431A20
|
||||
void System_SFile::ARCHIVEREC::SetBlockEntry(uint32_t index, const BLOCKENTRY& entry) {
|
||||
this->m_blockTable[index] = entry;
|
||||
}
|
||||
|
||||
@@ -19,8 +19,8 @@ struct BLOCKENTRY {
|
||||
/* 0008 */ uint32_t m_compressedSize;
|
||||
/* 000C */ uint32_t m_fileSize;
|
||||
/* 0010 */ uint32_t m_flags;
|
||||
/* 0014 */ uint32_t m_crc;
|
||||
/* 0018 */ uint64_t m_fileTime;
|
||||
/* 0014 */ uint64_t m_fileTime;
|
||||
/* 001C */ uint32_t m_crc;
|
||||
/* 0020 */ Blizzard::Util::Digest<16> m_md5;
|
||||
/* 0030 */ bool m_md5Check;
|
||||
};
|
||||
@@ -156,7 +156,9 @@ class ARCHIVEREC {
|
||||
/* 01CC */ std::map<Blizzard::Util::Digest<16>, uint32_t> m_blockKeys;
|
||||
/* 01D8 */ bool m_blockKeysBuilt;
|
||||
/* 01D9 */ bool m_tablesInitialized;
|
||||
/* 01DA */ uint8_t unk_01DA[6];
|
||||
/* 01DA */ uint16_t m_locale;
|
||||
/* 01DC */ uint8_t m_platform;
|
||||
/* 01DD */ uint8_t unk_01DD[3];
|
||||
/* 01E0 */ uint32_t unk_01E0;
|
||||
/* 01E4 */ std::vector<uint16_t> unk_01E4;
|
||||
/* 01F4 */ uint32_t unk_01F4;
|
||||
@@ -174,13 +176,26 @@ class ARCHIVEREC {
|
||||
|
||||
ARCHIVEREC();
|
||||
~ARCHIVEREC();
|
||||
void BuildBlockKeys();
|
||||
void BuildBlockTable();
|
||||
void ConvertToNewHashTableFormat();
|
||||
bool FillNewHashTable(int32_t hashBits);
|
||||
BLOCKENTRY GetBlockEntry(uint32_t index);
|
||||
void InitializeTables();
|
||||
void PackBlockTable();
|
||||
bool ReadAdditionalAttributes();
|
||||
bool RemoveInternalArchiveRef();
|
||||
void SetBlockEntry(uint32_t index, const BLOCKENTRY& entry);
|
||||
void SetMD5Check(uint32_t index, bool enabled);
|
||||
};
|
||||
|
||||
struct FileLookup {
|
||||
/* 0000 */ bool m_checkedDisk;
|
||||
/* 0001 */ uint8_t unk_0001[3];
|
||||
/* 0004 */ ARCHIVEREC* m_archive;
|
||||
/* 0008 */ uint32_t m_hashIndex;
|
||||
/* 000C */ uint32_t m_blockIndex;
|
||||
/* 0010 */ char* m_path;
|
||||
};
|
||||
|
||||
class ArchivePtr {
|
||||
@@ -207,19 +222,26 @@ extern Blizzard::Util::Digest<16> s_emptyMd5;
|
||||
extern Blizzard::Lock::Atomic s_nextArchiveId;
|
||||
extern uint32_t s_lastError;
|
||||
|
||||
bool CheckFileExistsOnDisk(const char* name, uint32_t flags, char* result);
|
||||
void ConvertRelativePathName(const char* path, char* result);
|
||||
uint32_t FindBlockEntry(ARCHIVEREC* archive, const Blizzard::Util::Digest<16>& md5, bool* deleted);
|
||||
ARCHIVEREC* GetArchivePtr(ARCHIVEREC* handle, bool addRef);
|
||||
bool InitEmptyTables(ARCHIVEREC* archive, uint32_t hashCount);
|
||||
bool OpenDirectPathAsArchive(const char* path, int32_t priority, uint32_t flags, ARCHIVEREC** result);
|
||||
bool s_OpenArchive(ARCHIVEREC* archive, uint32_t flags, ARCHIVEREC** result);
|
||||
uint32_t SearchHashTable(ARCHIVEREC* archive, const char* name, bool matchNeutral, bool* deleted);
|
||||
|
||||
}
|
||||
|
||||
int32_t FindFileInOneArchive(System_SFile::ARCHIVEREC* archive, const char* name, const uint64_t& hash, const Blizzard::Util::Digest<16>& md5, uint32_t flags, System_SFile::FileLookup* lookup);
|
||||
int32_t GetFileBlockEntry(System_SFile::ARCHIVEREC* handle, const char* name, const Blizzard::Util::Digest<16>& md5, uint32_t flags, System_SFile::ARCHIVEREC** archiveOut, System_SFile::ARCHIVEREC** recordOut, uint32_t* blockIndex, uint32_t* hashIndex, char* path);
|
||||
|
||||
namespace Blizzard {
|
||||
namespace Mopaq {
|
||||
|
||||
bool SFileCloseArchive(System_SFile::ARCHIVEREC* handle);
|
||||
bool SFileEnableDirectAccess(uint32_t enable);
|
||||
int32_t SFileFileExists(System_SFile::ARCHIVEREC* handle, const char* name, uint32_t flags, System_SFile::ARCHIVEREC** archiveOut);
|
||||
uint32_t SFileGetLastError();
|
||||
bool SFileOpenArchive(const char* path, int32_t priority, uint32_t flags, System_SFile::ARCHIVEREC** result);
|
||||
bool SFileOpenArchive(IOUnit* file, const char* name, int32_t priority, uint32_t flags, System_SFile::ARCHIVEREC** result);
|
||||
|
||||
@@ -0,0 +1,40 @@
|
||||
#include <cctype>
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/Mopaq/SFileSignatures.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/Util/Hash.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/String/String.h"
|
||||
|
||||
// STATIC: 0x00B38338
|
||||
System_SFile::SignatureTable System_SFile::s_signatures;
|
||||
|
||||
// VERIFY: 2da0c4e0 manual
|
||||
// OFFSET: 0x0042ECC0
|
||||
System_SFile::SignatureKey::SignatureKey(const char* name) {
|
||||
uint32_t pc = 2;
|
||||
uint32_t pb = 1;
|
||||
Blizzard::Util::hashlittle2(name, name ? strlen(name) : 0, &pc, &pb);
|
||||
|
||||
uint64_t hash = pc + (static_cast<uint64_t>(pb) << 32);
|
||||
this->m_lo = static_cast<uint32_t>(hash) | 0x3F;
|
||||
this->m_hi = static_cast<uint32_t>(hash >> 32);
|
||||
}
|
||||
|
||||
// VERIFY: 7f796dd8 manual
|
||||
// OFFSET: 0x00437470
|
||||
bool System_SFile::SignatureTable::GetSignature(const char* name, Blizzard::Util::Digest<16>* md5) {
|
||||
if (!md5) {
|
||||
return false;
|
||||
}
|
||||
|
||||
char lower[260];
|
||||
Blizzard::String::Copy(lower, name, sizeof(lower));
|
||||
|
||||
for (char* p = lower; *p; p++) {
|
||||
*p = static_cast<char>(tolower(*p));
|
||||
}
|
||||
|
||||
SignatureKey key(lower);
|
||||
|
||||
return this->Get(key, md5);
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
#ifndef ENGINE_SOURCE_BLIZZARDCORE_SOURCE_PACKAGES_MOPAQ_SFILESIGNATURES_H
|
||||
#define ENGINE_SOURCE_BLIZZARDCORE_SOURCE_PACKAGES_MOPAQ_SFILESIGNATURES_H
|
||||
|
||||
#include <cstdint>
|
||||
#include "Engine/Source/BlizzardCore/Include/Blizzard/Util/Digest.h"
|
||||
#include "Engine/Source/BlizzardCore/Include/Blizzard/Util/HashMap.h"
|
||||
|
||||
namespace System_SFile {
|
||||
|
||||
struct SignatureKey {
|
||||
/* 0000 */ uint32_t m_lo;
|
||||
/* 0004 */ uint32_t m_hi;
|
||||
|
||||
SignatureKey(const char* name);
|
||||
};
|
||||
|
||||
class SignatureTable : public Blizzard::Util::HashMap<SignatureKey, Blizzard::Util::Digest<16>> {
|
||||
public:
|
||||
bool GetSignature(const char* name, Blizzard::Util::Digest<16>* md5);
|
||||
};
|
||||
|
||||
extern SignatureTable s_signatures;
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,173 @@
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include "Engine/Source/BlizzardCore/Include/Blizzard/Util/MD5.h"
|
||||
|
||||
#define MD5_ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
|
||||
#define MD5_F(x, y, z) (((x) & (y)) | (~(x) & (z)))
|
||||
#define MD5_G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
|
||||
#define MD5_H(x, y, z) ((x) ^ (y) ^ (z))
|
||||
#define MD5_I(x, y, z) ((y) ^ ((x) | ~(z)))
|
||||
#define MD5_STEP(f, a, b, c, d, k, s, ti) t = a + f(b, c, d) + x[k] + (ti); a = MD5_ROTATE_LEFT(t, s) + b
|
||||
|
||||
// STATIC: 0x00A505D8
|
||||
static const uint8_t s_padding[64] = { 0x80 };
|
||||
|
||||
// INLINED
|
||||
Blizzard::Util::MD5::MD5() {
|
||||
this->m_count[0] = 0;
|
||||
this->m_count[1] = 0;
|
||||
this->m_state[0] = 0x67452301;
|
||||
this->m_state[1] = 0xEFCDAB89;
|
||||
this->m_state[2] = 0x98BADCFE;
|
||||
this->m_state[3] = 0x10325476;
|
||||
}
|
||||
|
||||
// VERIFY: 488235a5 manual
|
||||
// OFFSET: 0x0042B280
|
||||
void Blizzard::Util::MD5::Finish(uint8_t* digest) {
|
||||
uint8_t length[8];
|
||||
|
||||
for (int32_t i = 0; i < 8; i++) {
|
||||
length[i] = static_cast<uint8_t>(this->m_count[i >> 2] >> ((i & 3) << 3));
|
||||
}
|
||||
|
||||
this->Process(s_padding, ((55 - (this->m_count[0] >> 3)) & 63) + 1);
|
||||
this->Process(length, 8);
|
||||
|
||||
for (int32_t i = 0; i < 16; i++) {
|
||||
digest[i] = static_cast<uint8_t>(this->m_state[i >> 2] >> ((i & 3) << 3));
|
||||
}
|
||||
}
|
||||
|
||||
// VERIFY: cf6eed7b manual
|
||||
// OFFSET: 0x004250D0
|
||||
void Blizzard::Util::MD5::Process(const uint8_t* block) {
|
||||
uint32_t a = this->m_state[0];
|
||||
uint32_t b = this->m_state[1];
|
||||
uint32_t c = this->m_state[2];
|
||||
uint32_t d = this->m_state[3];
|
||||
uint32_t t;
|
||||
const uint32_t* x;
|
||||
uint32_t buffer[16];
|
||||
|
||||
if (!(reinterpret_cast<uintptr_t>(block) & 3)) {
|
||||
x = reinterpret_cast<const uint32_t*>(block);
|
||||
} else {
|
||||
memcpy(buffer, block, sizeof(buffer));
|
||||
x = buffer;
|
||||
}
|
||||
|
||||
MD5_STEP(MD5_F, a, b, c, d, 0, 7, 0xD76AA478);
|
||||
MD5_STEP(MD5_F, d, a, b, c, 1, 12, 0xE8C7B756);
|
||||
MD5_STEP(MD5_F, c, d, a, b, 2, 17, 0x242070DB);
|
||||
MD5_STEP(MD5_F, b, c, d, a, 3, 22, 0xC1BDCEEE);
|
||||
MD5_STEP(MD5_F, a, b, c, d, 4, 7, 0xF57C0FAF);
|
||||
MD5_STEP(MD5_F, d, a, b, c, 5, 12, 0x4787C62A);
|
||||
MD5_STEP(MD5_F, c, d, a, b, 6, 17, 0xA8304613);
|
||||
MD5_STEP(MD5_F, b, c, d, a, 7, 22, 0xFD469501);
|
||||
MD5_STEP(MD5_F, a, b, c, d, 8, 7, 0x698098D8);
|
||||
MD5_STEP(MD5_F, d, a, b, c, 9, 12, 0x8B44F7AF);
|
||||
MD5_STEP(MD5_F, c, d, a, b, 10, 17, 0xFFFF5BB1);
|
||||
MD5_STEP(MD5_F, b, c, d, a, 11, 22, 0x895CD7BE);
|
||||
MD5_STEP(MD5_F, a, b, c, d, 12, 7, 0x6B901122);
|
||||
MD5_STEP(MD5_F, d, a, b, c, 13, 12, 0xFD987193);
|
||||
MD5_STEP(MD5_F, c, d, a, b, 14, 17, 0xA679438E);
|
||||
MD5_STEP(MD5_F, b, c, d, a, 15, 22, 0x49B40821);
|
||||
|
||||
MD5_STEP(MD5_G, a, b, c, d, 1, 5, 0xF61E2562);
|
||||
MD5_STEP(MD5_G, d, a, b, c, 6, 9, 0xC040B340);
|
||||
MD5_STEP(MD5_G, c, d, a, b, 11, 14, 0x265E5A51);
|
||||
MD5_STEP(MD5_G, b, c, d, a, 0, 20, 0xE9B6C7AA);
|
||||
MD5_STEP(MD5_G, a, b, c, d, 5, 5, 0xD62F105D);
|
||||
MD5_STEP(MD5_G, d, a, b, c, 10, 9, 0x02441453);
|
||||
MD5_STEP(MD5_G, c, d, a, b, 15, 14, 0xD8A1E681);
|
||||
MD5_STEP(MD5_G, b, c, d, a, 4, 20, 0xE7D3FBC8);
|
||||
MD5_STEP(MD5_G, a, b, c, d, 9, 5, 0x21E1CDE6);
|
||||
MD5_STEP(MD5_G, d, a, b, c, 14, 9, 0xC33707D6);
|
||||
MD5_STEP(MD5_G, c, d, a, b, 3, 14, 0xF4D50D87);
|
||||
MD5_STEP(MD5_G, b, c, d, a, 8, 20, 0x455A14ED);
|
||||
MD5_STEP(MD5_G, a, b, c, d, 13, 5, 0xA9E3E905);
|
||||
MD5_STEP(MD5_G, d, a, b, c, 2, 9, 0xFCEFA3F8);
|
||||
MD5_STEP(MD5_G, c, d, a, b, 7, 14, 0x676F02D9);
|
||||
MD5_STEP(MD5_G, b, c, d, a, 12, 20, 0x8D2A4C8A);
|
||||
|
||||
MD5_STEP(MD5_H, a, b, c, d, 5, 4, 0xFFFA3942);
|
||||
MD5_STEP(MD5_H, d, a, b, c, 8, 11, 0x8771F681);
|
||||
MD5_STEP(MD5_H, c, d, a, b, 11, 16, 0x6D9D6122);
|
||||
MD5_STEP(MD5_H, b, c, d, a, 14, 23, 0xFDE5380C);
|
||||
MD5_STEP(MD5_H, a, b, c, d, 1, 4, 0xA4BEEA44);
|
||||
MD5_STEP(MD5_H, d, a, b, c, 4, 11, 0x4BDECFA9);
|
||||
MD5_STEP(MD5_H, c, d, a, b, 7, 16, 0xF6BB4B60);
|
||||
MD5_STEP(MD5_H, b, c, d, a, 10, 23, 0xBEBFBC70);
|
||||
MD5_STEP(MD5_H, a, b, c, d, 13, 4, 0x289B7EC6);
|
||||
MD5_STEP(MD5_H, d, a, b, c, 0, 11, 0xEAA127FA);
|
||||
MD5_STEP(MD5_H, c, d, a, b, 3, 16, 0xD4EF3085);
|
||||
MD5_STEP(MD5_H, b, c, d, a, 6, 23, 0x04881D05);
|
||||
MD5_STEP(MD5_H, a, b, c, d, 9, 4, 0xD9D4D039);
|
||||
MD5_STEP(MD5_H, d, a, b, c, 12, 11, 0xE6DB99E5);
|
||||
MD5_STEP(MD5_H, c, d, a, b, 15, 16, 0x1FA27CF8);
|
||||
MD5_STEP(MD5_H, b, c, d, a, 2, 23, 0xC4AC5665);
|
||||
|
||||
MD5_STEP(MD5_I, a, b, c, d, 0, 6, 0xF4292244);
|
||||
MD5_STEP(MD5_I, d, a, b, c, 7, 10, 0x432AFF97);
|
||||
MD5_STEP(MD5_I, c, d, a, b, 14, 15, 0xAB9423A7);
|
||||
MD5_STEP(MD5_I, b, c, d, a, 5, 21, 0xFC93A039);
|
||||
MD5_STEP(MD5_I, a, b, c, d, 12, 6, 0x655B59C3);
|
||||
MD5_STEP(MD5_I, d, a, b, c, 3, 10, 0x8F0CCC92);
|
||||
MD5_STEP(MD5_I, c, d, a, b, 10, 15, 0xFFEFF47D);
|
||||
MD5_STEP(MD5_I, b, c, d, a, 1, 21, 0x85845DD1);
|
||||
MD5_STEP(MD5_I, a, b, c, d, 8, 6, 0x6FA87E4F);
|
||||
MD5_STEP(MD5_I, d, a, b, c, 15, 10, 0xFE2CE6E0);
|
||||
MD5_STEP(MD5_I, c, d, a, b, 6, 15, 0xA3014314);
|
||||
MD5_STEP(MD5_I, b, c, d, a, 13, 21, 0x4E0811A1);
|
||||
MD5_STEP(MD5_I, a, b, c, d, 4, 6, 0xF7537E82);
|
||||
MD5_STEP(MD5_I, d, a, b, c, 11, 10, 0xBD3AF235);
|
||||
MD5_STEP(MD5_I, c, d, a, b, 2, 15, 0x2AD7D2BB);
|
||||
MD5_STEP(MD5_I, b, c, d, a, 9, 21, 0xEB86D391);
|
||||
|
||||
this->m_state[0] += a;
|
||||
this->m_state[1] += b;
|
||||
this->m_state[2] += c;
|
||||
this->m_state[3] += d;
|
||||
}
|
||||
|
||||
// VERIFY: d4e30e4c manual
|
||||
// OFFSET: 0x0042B150
|
||||
void Blizzard::Util::MD5::Process(const void* data, uint32_t size) {
|
||||
const uint8_t* p = static_cast<const uint8_t*>(data);
|
||||
uint32_t left = size;
|
||||
uint32_t offset = (this->m_count[0] >> 3) & 63;
|
||||
uint32_t bits = size << 3;
|
||||
|
||||
if (!size) {
|
||||
return;
|
||||
}
|
||||
|
||||
this->m_count[1] += size >> 29;
|
||||
this->m_count[0] += bits;
|
||||
|
||||
if (this->m_count[0] < bits) {
|
||||
this->m_count[1]++;
|
||||
}
|
||||
|
||||
if (offset) {
|
||||
uint32_t copy = offset + size > 64 ? 64 - offset : size;
|
||||
memcpy(this->m_buffer + offset, p, copy);
|
||||
|
||||
if (offset + copy < 64) {
|
||||
return;
|
||||
}
|
||||
|
||||
p += copy;
|
||||
left -= copy;
|
||||
this->Process(this->m_buffer);
|
||||
}
|
||||
|
||||
for (; left >= 64; p += 64, left -= 64) {
|
||||
this->Process(p);
|
||||
}
|
||||
|
||||
if (left) {
|
||||
memcpy(this->m_buffer, p, left);
|
||||
}
|
||||
}
|
||||
@@ -1,7 +1,9 @@
|
||||
#include <algorithm>
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <new>
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/iounit/IOAlignUnit.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/iounit/IOUnitContainer.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/File/File.h"
|
||||
#include "Engine/Source/Storm/H/storm.h"
|
||||
|
||||
@@ -407,3 +409,37 @@ bool IOAlignUnit::Close() {
|
||||
SMemFree(this->m_buffer, __FILE__, __LINE__, 0);
|
||||
return result;
|
||||
}
|
||||
|
||||
// VERIFY: c897ffe8 manual
|
||||
// OFFSET: 0x00434B90
|
||||
IOAlignUnit* IOAlignUnit::Create(IOUnitContainer* container, int64_t base, uint32_t blockSize, uint32_t blockCount, bool largeTransfers, bool exactSize, uint32_t bufferAlign, bool skipCleanOnWrite, IOUnit* next) {
|
||||
if (!next) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
int64_t size;
|
||||
|
||||
if (!next->GetFileSize(&size)) {
|
||||
next->Release();
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (!blockSize) {
|
||||
blockSize = 1;
|
||||
}
|
||||
|
||||
bool ownsMemory;
|
||||
void* memory = IOUnitContainer::Alloc(container, sizeof(IOAlignUnit), &ownsMemory);
|
||||
|
||||
if (!memory) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return new (memory) IOAlignUnit(base, blockSize, blockCount, largeTransfers, exactSize, bufferAlign, skipCleanOnWrite, size, ownsMemory, next);
|
||||
}
|
||||
|
||||
// VERIFY: 5e8cfd60 auto
|
||||
// OFFSET: 0x00434C60
|
||||
IOAlignUnit* IOAlignUnit::Create(IOUnitContainer* container, int64_t base, uint32_t blockSize, uint32_t blockCount, bool largeTransfers, bool exactSize, uint32_t bufferAlign, IOUnit* next) {
|
||||
return IOAlignUnit::Create(container, base, blockSize, blockCount, largeTransfers, exactSize, bufferAlign, true, next);
|
||||
}
|
||||
|
||||
@@ -40,6 +40,9 @@ class IOAlignUnit : public IOUnit {
|
||||
virtual ~IOAlignUnit();
|
||||
virtual bool Close();
|
||||
|
||||
static IOAlignUnit* Create(IOUnitContainer* container, int64_t base, uint32_t blockSize, uint32_t blockCount, bool largeTransfers, bool exactSize, uint32_t bufferAlign, bool skipCleanOnWrite, IOUnit* next);
|
||||
static IOAlignUnit* Create(IOUnitContainer* container, int64_t base, uint32_t blockSize, uint32_t blockCount, bool largeTransfers, bool exactSize, uint32_t bufferAlign, IOUnit* next);
|
||||
|
||||
IOAlignUnit(int64_t base, uint32_t blockSize, uint32_t blockCount, bool largeTransfers, bool exactSize, uint32_t bufferAlign, bool skipCleanOnWrite, int64_t size, bool ownsMemory, IOUnit* next);
|
||||
void AllocateBuffer();
|
||||
bool CleanCache();
|
||||
|
||||
@@ -0,0 +1,263 @@
|
||||
#include <cstdint>
|
||||
#include <new>
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/iounit/IOChecksumUnit.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/iounit/IOUnitContainer.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/Mopaq/MPQGlobals.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/File/File.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/System/Lock/Lock.h"
|
||||
#include "ThirdParty/zlib/zlib.h"
|
||||
|
||||
// VERIFY: 759a2ec7 manual
|
||||
// OFFSET: 0x00426820
|
||||
void IOChecksumUnit::ChecksumJob(void* param) {
|
||||
Job* job = static_cast<Job*>(param);
|
||||
job->m_unit->Checksum(job->m_data, job->m_count);
|
||||
job->m_unit->m_position += job->m_count;
|
||||
}
|
||||
|
||||
// INLINED
|
||||
IOChecksumUnit::IOChecksumUnit(int64_t size, bool readToEnd, IOChecksumUnit** self, bool ownsMemory, IOUnit* next) : IOUnit(next, ownsMemory) {
|
||||
this->m_position = 0;
|
||||
this->m_size = size;
|
||||
this->m_context = nullptr;
|
||||
this->m_readToEnd = readToEnd;
|
||||
|
||||
if (self) {
|
||||
*self = this;
|
||||
}
|
||||
}
|
||||
|
||||
// VERIFY: b072b424 auto
|
||||
// OFFSET: 0x00429620
|
||||
uint32_t IOChecksumUnit::GetType() {
|
||||
return 'crc ';
|
||||
}
|
||||
|
||||
// VERIFY: 875dcaaa manual
|
||||
// OFFSET: 0x00457ED0
|
||||
bool IOChecksumUnit::Read(void* buffer, int64_t offset, uint32_t count, uint32_t* bytesRead) {
|
||||
if (!this->Clamp(offset, &count, bytesRead) || !this->m_next->Read(buffer, offset, count, bytesRead)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return this->Update(static_cast<const uint8_t*>(buffer), offset, bytesRead ? *bytesRead : count);
|
||||
}
|
||||
|
||||
// VERIFY: 750c7f6b manual
|
||||
// OFFSET: 0x00457F40
|
||||
bool IOChecksumUnit::Write(const void* buffer, int64_t offset, uint32_t count) {
|
||||
if (!this->Clamp(offset, &count, nullptr)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
bool result;
|
||||
Job job;
|
||||
job.m_unit = this;
|
||||
|
||||
if (this->GetRange(static_cast<const uint8_t*>(buffer), offset, count, &job.m_data, &job.m_count)) {
|
||||
System_MPQGlobals::Worker* worker;
|
||||
System_MPQGlobals::GetWorkerPool()->Acquire(1, &worker);
|
||||
|
||||
if (!worker->m_proc) {
|
||||
worker->m_proc = ChecksumJob;
|
||||
worker->m_param = &job;
|
||||
Blizzard::Lock::EventSet(worker->m_start.m_event);
|
||||
}
|
||||
|
||||
result = this->m_next->Write(buffer, offset, count);
|
||||
Blizzard::Lock::EventWaitForever(worker->m_done.m_event);
|
||||
System_MPQGlobals::GetWorkerPool()->Release(1, &worker);
|
||||
} else {
|
||||
result = this->m_next->Write(buffer, offset, count);
|
||||
}
|
||||
|
||||
if (!result) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (this->m_position == this->m_size) {
|
||||
return this->Finish();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// VERIFY: d6c9da29 manual
|
||||
// OFFSET: 0x00426850
|
||||
bool IOChecksumUnit::SetFileSize(int64_t size) {
|
||||
if (size <= this->m_size) {
|
||||
return this->m_next->SetFileSize(size);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// INLINED
|
||||
IOChecksumUnit::~IOChecksumUnit() {
|
||||
}
|
||||
|
||||
// VERIFY: 6d8f8a39 manual
|
||||
// OFFSET: 0x00430E00
|
||||
bool IOChecksumUnit::Close() {
|
||||
if (!this->m_readToEnd) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (this->m_position >= this->m_size) {
|
||||
return true;
|
||||
}
|
||||
|
||||
uint32_t count = static_cast<uint32_t>(this->m_size - this->m_position);
|
||||
uint8_t* buffer = count ? new uint8_t[count] : nullptr;
|
||||
bool result = this->Read(buffer, this->m_position, count, nullptr);
|
||||
|
||||
if (buffer) {
|
||||
delete[] buffer;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void IOChecksumUnit::SetContext(void* context) {
|
||||
this->m_context = context;
|
||||
}
|
||||
|
||||
// VERIFY: 80e5336f manual
|
||||
// OFFSET: 0x00457E50
|
||||
bool IOChecksumUnit::Clamp(int64_t offset, uint32_t* count, uint32_t* bytesRead) {
|
||||
if (offset + *count > this->m_size) {
|
||||
if (offset >= this->m_size) {
|
||||
Blizzard::File::SetLastError(10);
|
||||
Blizzard::File::AddToLastErrorStack(10, "IOChecksumUnit::Clamp - Range Error", 1);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!bytesRead) {
|
||||
return false;
|
||||
}
|
||||
|
||||
*count = static_cast<uint32_t>(this->m_size - offset);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// VERIFY: 7f568e1b manual
|
||||
// OFFSET: 0x00426740
|
||||
bool IOChecksumUnit::GetRange(const uint8_t* data, int64_t offset, uint32_t count, const uint8_t** rangeData, uint32_t* rangeCount) {
|
||||
if (offset > this->m_position) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (offset + count <= this->m_position) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (offset < this->m_position) {
|
||||
uint32_t skip = static_cast<uint32_t>(this->m_position - offset);
|
||||
data += skip;
|
||||
count -= skip;
|
||||
}
|
||||
|
||||
*rangeData = data;
|
||||
*rangeCount = count;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// VERIFY: 1fd2bcd5 manual
|
||||
// OFFSET: 0x004267B0
|
||||
bool IOChecksumUnit::Update(const uint8_t* data, int64_t offset, uint32_t count) {
|
||||
if (this->GetRange(data, offset, count, &data, &count)) {
|
||||
this->Checksum(data, count);
|
||||
this->m_position += count;
|
||||
|
||||
if (this->m_position == this->m_size) {
|
||||
return this->Finish();
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// VERIFY: d67d5826 manual
|
||||
// OFFSET: 0x004350C0
|
||||
IOUnit* IOCrcUnit::Create(IOUnitContainer* container, int64_t size, Callback callback, bool readToEnd, IOChecksumUnit** self, IOUnit* next) {
|
||||
if (!next) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (!callback) {
|
||||
return next;
|
||||
}
|
||||
|
||||
bool ownsMemory;
|
||||
void* memory = IOUnitContainer::Alloc(container, sizeof(IOCrcUnit), &ownsMemory);
|
||||
|
||||
if (!memory) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return new (memory) IOCrcUnit(size, callback, readToEnd, self, ownsMemory, next);
|
||||
}
|
||||
|
||||
// VERIFY: 543472ca manual
|
||||
// OFFSET: 0x00430C90
|
||||
IOCrcUnit::IOCrcUnit(int64_t size, Callback callback, bool readToEnd, IOChecksumUnit** self, bool ownsMemory, IOUnit* next) : IOChecksumUnit(size, readToEnd, self, ownsMemory, next) {
|
||||
this->m_callback = callback;
|
||||
this->m_crc = 0;
|
||||
}
|
||||
|
||||
// VERIFY: 81fee3cc auto
|
||||
// OFFSET: 0x00430CF0
|
||||
void IOCrcUnit::Checksum(const uint8_t* data, uint32_t count) {
|
||||
this->m_crc = crc32(this->m_crc, data, count);
|
||||
}
|
||||
|
||||
// VERIFY: 83438dc2 auto
|
||||
// OFFSET: 0x00430D20
|
||||
bool IOCrcUnit::Finish() {
|
||||
return this->m_callback(this->m_context, this->m_crc);
|
||||
}
|
||||
|
||||
// VERIFY: 16498305 manual
|
||||
// OFFSET: 0x00435180
|
||||
IOUnit* IOMd5Unit::Create(IOUnitContainer* container, int64_t size, Callback callback, bool readToEnd, IOChecksumUnit** self, IOUnit* next) {
|
||||
if (!next) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (!callback) {
|
||||
return next;
|
||||
}
|
||||
|
||||
bool ownsMemory;
|
||||
void* memory = IOUnitContainer::Alloc(container, sizeof(IOMd5Unit), &ownsMemory);
|
||||
|
||||
if (!memory) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return new (memory) IOMd5Unit(size, callback, readToEnd, self, ownsMemory, next);
|
||||
}
|
||||
|
||||
// VERIFY: 71e51316 manual
|
||||
// OFFSET: 0x00430D40
|
||||
IOMd5Unit::IOMd5Unit(int64_t size, Callback callback, bool readToEnd, IOChecksumUnit** self, bool ownsMemory, IOUnit* next) : IOChecksumUnit(size, readToEnd, self, ownsMemory, next) {
|
||||
this->m_callback = callback;
|
||||
}
|
||||
|
||||
// VERIFY: 0e82453d auto
|
||||
// OFFSET: 0x00430DC0
|
||||
void IOMd5Unit::Checksum(const uint8_t* data, uint32_t count) {
|
||||
this->m_md5.Process(data, count);
|
||||
}
|
||||
|
||||
// VERIFY: 7776d404 auto
|
||||
// OFFSET: 0x00430DD0
|
||||
bool IOMd5Unit::Finish() {
|
||||
uint8_t digest[16];
|
||||
this->m_md5.Finish(digest);
|
||||
|
||||
return this->m_callback(this->m_context, digest);
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
#ifndef ENGINE_SOURCE_BLIZZARDCORE_SOURCE_PACKAGES_IOUNIT_IOCHECKSUMUNIT_H
|
||||
#define ENGINE_SOURCE_BLIZZARDCORE_SOURCE_PACKAGES_IOUNIT_IOCHECKSUMUNIT_H
|
||||
|
||||
#include <cstdint>
|
||||
#include "Engine/Source/BlizzardCore/Include/Blizzard/Util/MD5.h"
|
||||
#include "Engine/Source/BlizzardCore/Source/Packages/iounit/IOUnit.h"
|
||||
|
||||
class IOChecksumUnit : public IOUnit {
|
||||
public:
|
||||
struct Job {
|
||||
/* 0000 */ IOChecksumUnit* m_unit;
|
||||
/* 0004 */ const uint8_t* m_data;
|
||||
/* 0008 */ uint32_t m_count;
|
||||
};
|
||||
|
||||
static void ChecksumJob(void* param);
|
||||
|
||||
/* 0010 */ int64_t m_position;
|
||||
/* 0018 */ int64_t m_size;
|
||||
/* 0020 */ void* m_context;
|
||||
/* 0024 */ bool m_readToEnd;
|
||||
/* 0025 */ uint8_t unk_0025[3];
|
||||
|
||||
virtual uint32_t GetType();
|
||||
virtual bool Read(void* buffer, int64_t offset, uint32_t count, uint32_t* bytesRead);
|
||||
virtual bool Write(const void* buffer, int64_t offset, uint32_t count);
|
||||
virtual bool SetFileSize(int64_t size);
|
||||
virtual ~IOChecksumUnit();
|
||||
virtual bool Close();
|
||||
virtual void SetContext(void* context);
|
||||
virtual void Checksum(const uint8_t* data, uint32_t count) = 0;
|
||||
virtual bool Finish() = 0;
|
||||
|
||||
IOChecksumUnit(int64_t size, bool readToEnd, IOChecksumUnit** self, bool ownsMemory, IOUnit* next);
|
||||
bool Clamp(int64_t offset, uint32_t* count, uint32_t* bytesRead);
|
||||
bool GetRange(const uint8_t* data, int64_t offset, uint32_t count, const uint8_t** rangeData, uint32_t* rangeCount);
|
||||
bool Update(const uint8_t* data, int64_t offset, uint32_t count);
|
||||
};
|
||||
|
||||
class IOCrcUnit : public IOChecksumUnit {
|
||||
public:
|
||||
typedef bool (*Callback)(void* context, uint32_t crc);
|
||||
|
||||
static IOUnit* Create(IOUnitContainer* container, int64_t size, Callback callback, bool readToEnd, IOChecksumUnit** self, IOUnit* next);
|
||||
|
||||
/* 0028 */ Callback m_callback;
|
||||
/* 002C */ uint32_t m_crc;
|
||||
|
||||
virtual void Checksum(const uint8_t* data, uint32_t count);
|
||||
virtual bool Finish();
|
||||
|
||||
IOCrcUnit(int64_t size, Callback callback, bool readToEnd, IOChecksumUnit** self, bool ownsMemory, IOUnit* next);
|
||||
};
|
||||
|
||||
class IOMd5Unit : public IOChecksumUnit {
|
||||
public:
|
||||
typedef bool (*Callback)(void* context, const uint8_t* md5);
|
||||
|
||||
static IOUnit* Create(IOUnitContainer* container, int64_t size, Callback callback, bool readToEnd, IOChecksumUnit** self, IOUnit* next);
|
||||
|
||||
/* 0028 */ Callback m_callback;
|
||||
/* 002C */ Blizzard::Util::MD5 m_md5;
|
||||
|
||||
virtual void Checksum(const uint8_t* data, uint32_t count);
|
||||
virtual bool Finish();
|
||||
|
||||
IOMd5Unit(int64_t size, Callback callback, bool readToEnd, IOChecksumUnit** self, bool ownsMemory, IOUnit* next);
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -250,3 +250,37 @@ void* IOLockUnit::Win32Handle() {
|
||||
Blizzard::Lock::ScopedMutex lock(*this->m_mutex);
|
||||
return this->m_next->Win32Handle();
|
||||
}
|
||||
|
||||
// VERIFY: 4926450f manual
|
||||
// OFFSET: 0x00435050
|
||||
IORangeUnit* IORangeUnit::Create(IOUnitContainer* container, int64_t start, int64_t end, IOUnit* next) {
|
||||
if (!next) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (start > end) {
|
||||
next->Release();
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool ownsMemory;
|
||||
void* memory = IOUnitContainer::Alloc(container, sizeof(IORangeUnit), &ownsMemory);
|
||||
|
||||
if (!memory) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return new (memory) IORangeUnit(start, end, ownsMemory, next);
|
||||
}
|
||||
|
||||
// VERIFY: dfd9ee20 manual
|
||||
// OFFSET: 0x00429A20
|
||||
bool IOLockUnit::ReplaceNext(IOUnit* lock, IOUnit* next) {
|
||||
if (!lock || !next || lock->GetType() != 'lock' || next->m_next != lock->m_next) {
|
||||
return false;
|
||||
}
|
||||
|
||||
lock->m_next = next;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -29,6 +29,8 @@ class IOUnit {
|
||||
|
||||
class IORangeUnit : public IOUnit {
|
||||
public:
|
||||
static IORangeUnit* Create(IOUnitContainer* container, int64_t start, int64_t end, IOUnit* next);
|
||||
|
||||
/* 0010 */ int64_t m_start;
|
||||
/* 0018 */ int64_t m_end;
|
||||
|
||||
@@ -46,6 +48,7 @@ class IOLockUnit : public IOUnit {
|
||||
public:
|
||||
static IOLockUnit* Create(IOUnitContainer* container, uint32_t flags, IOUnit* next);
|
||||
static IOLockUnit* Create(IOUnitContainer* container, IOUnit* next);
|
||||
static bool ReplaceNext(IOUnit* lock, IOUnit* next);
|
||||
|
||||
/* 0010 */ Blizzard::Lock::Mutex* m_mutex;
|
||||
/* 0014 */ Blizzard::Lock::Mutex m_ownMutex;
|
||||
|
||||
@@ -38,7 +38,7 @@ Blizzard::Memory::TempBuffer<T, N>::~TempBuffer() {
|
||||
}
|
||||
|
||||
// VERIFY: 019cc2c0 manual
|
||||
// OFFSET: 0x0042EC20
|
||||
// OFFSET: [0x0042EC20, 0x0042EAF0]
|
||||
template <class T, uint32_t N>
|
||||
void Blizzard::Memory::TempBuffer<T, N>::Resize(uint32_t count) {
|
||||
if (count > N) {
|
||||
|
||||
Reference in New Issue
Block a user