diff options
72 files changed, 12996 insertions, 14089 deletions
diff --git a/dep/CascLib/CMakeLists.txt b/dep/CascLib/CMakeLists.txt index 0efe93771f1..a78d0508f0c 100644 --- a/dep/CascLib/CMakeLists.txt +++ b/dep/CascLib/CMakeLists.txt @@ -1,10 +1,12 @@ set(HEADER_FILES src/CascCommon.h src/CascLib.h - src/CascMndx.h src/CascPort.h + src/common/Array.h src/common/Common.h + src/common/Csv.h src/common/FileStream.h + src/common/FileTree.h src/common/ListFile.h src/common/Map.h src/jenkins/lookup.h @@ -13,11 +15,10 @@ set(HEADER_FILES set(SRC_FILES src/common/Common.cpp src/common/Directory.cpp - src/common/DumpContext.cpp - src/common/DynamicArray.cpp + src/common/Csv.cpp src/common/FileStream.cpp + src/common/FileTree.cpp src/common/ListFile.cpp - src/common/Map.cpp src/common/RootHandler.cpp src/jenkins/lookup3.c src/CascCommon.cpp @@ -26,26 +27,24 @@ set(SRC_FILES src/CascDumpData.cpp src/CascFiles.cpp src/CascFindFile.cpp + src/CascIndexFiles.cpp src/CascOpenFile.cpp src/CascOpenStorage.cpp src/CascReadFile.cpp src/CascRootFile_Diablo3.cpp - src/CascRootFile_Mndx.cpp - src/CascRootFile_Ovr.cpp - src/CascRootFile_SC1.cpp - src/CascRootFile_WoW6.cpp + src/CascRootFile_Install.cpp + src/CascRootFile_MNDX.cpp + src/CascRootFile_Text.cpp + src/CascRootFile_TVFS.cpp + src/CascRootFile_OW.cpp + src/CascRootFile_WoW.cpp ) -set(TOMCRYPT_FILES - src/libtomcrypt/src/hashes/hash_memory.c - src/libtomcrypt/src/hashes/md5.c - src/libtomcrypt/src/misc/crypt_argchk.c - src/libtomcrypt/src/misc/crypt_hash_descriptor.c - src/libtomcrypt/src/misc/crypt_hash_is_valid.c - src/libtomcrypt/src/misc/crypt_libc.c +set(MD5_FILES + src/md5/md5.cpp ) -add_library(casc STATIC ${SRC_FILES} ${TOMCRYPT_FILES}) +add_library(casc STATIC ${SRC_FILES} ${HEADER_FILES} ${MD5_FILES}) target_include_directories(casc PUBLIC @@ -53,6 +52,8 @@ target_include_directories(casc PRIVATE ${CMAKE_SOURCE_DIR}/dep) +target_compile_definitions(casc PUBLIC -D__SYS_ZLIB) + target_link_libraries(casc PRIVATE trinity-dependency-interface diff --git a/dep/CascLib/src/CascCommon.cpp b/dep/CascLib/src/CascCommon.cpp index 34c3df66b5c..f5e346ec14c 100644 --- a/dep/CascLib/src/CascCommon.cpp +++ b/dep/CascLib/src/CascCommon.cpp @@ -13,78 +13,132 @@ #include "CascCommon.h" //----------------------------------------------------------------------------- -// Conversion of big-endian to integer +// Functions -// Read the 24-bit big-endian offset into ULONGLONG -DWORD ConvertBytesToInteger_3(LPBYTE ValueAsBytes) +LPBYTE LoadInternalFileToMemory(TCascStorage * hs, PCASC_CKEY_ENTRY pCKeyEntry, DWORD * pcbFileData) { - DWORD Value = 0; - - Value = (Value << 0x08) | ValueAsBytes[0]; - Value = (Value << 0x08) | ValueAsBytes[1]; - Value = (Value << 0x08) | ValueAsBytes[2]; - - return Value; -} - -// Read the 32-bit big-endian offset into ULONGLONG -DWORD ConvertBytesToInteger_4(LPBYTE ValueAsBytes) -{ - DWORD Value = 0; - - Value = (Value << 0x08) | ValueAsBytes[0]; - Value = (Value << 0x08) | ValueAsBytes[1]; - Value = (Value << 0x08) | ValueAsBytes[2]; - Value = (Value << 0x08) | ValueAsBytes[3]; - - return Value; -} + LPBYTE pbFileData = NULL; + HANDLE hFile = NULL; + DWORD cbFileData = pcbFileData[0]; + DWORD dwBytesRead = 0; + int nError = ERROR_SUCCESS; + + // Open the file either by CKey or by EKey + if(OpenFileByCKeyEntry(hs, pCKeyEntry, CASC_STRICT_DATA_CHECK, &hFile)) + { + // Retrieve the size of the file. Note that the caller might specify + // the real size of the file, in case the file size is not retrievable + // or if the size is wrong. Example: ENCODING file has size specified in BUILD + if(cbFileData == 0 || cbFileData == CASC_INVALID_SIZE) + { + cbFileData = CascGetFileSize(hFile, NULL); + if(cbFileData == 0 || cbFileData == CASC_INVALID_SIZE) + nError = ERROR_FILE_CORRUPT; + } + + // Retrieve the size of the ENCODING file + if(nError == ERROR_SUCCESS) + { + // Allocate space for the ENCODING file + pbFileData = CASC_ALLOC(BYTE, cbFileData); + if(pbFileData != NULL) + { + // Read the entire file to memory + CascReadFile(hFile, pbFileData, cbFileData, &dwBytesRead); + if(dwBytesRead != cbFileData) + { + nError = ERROR_FILE_CORRUPT; + } + } + else + { + nError = ERROR_NOT_ENOUGH_MEMORY; + } + } + + // Close the file + CascCloseFile(hFile); + } + else + { + nError = GetLastError(); + } -DWORD ConvertBytesToInteger_4_LE(LPBYTE ValueAsBytes) -{ - DWORD Value = 0; + // Handle errors + if(nError != ERROR_SUCCESS) + { + // Free the file data + CASC_FREE(pbFileData); + cbFileData = 0; - Value = (Value << 0x08) | ValueAsBytes[3]; - Value = (Value << 0x08) | ValueAsBytes[2]; - Value = (Value << 0x08) | ValueAsBytes[1]; - Value = (Value << 0x08) | ValueAsBytes[0]; + // Set the last error + SetLastError(nError); + } - return Value; + // Give the loaded file length + if(pcbFileData != NULL) + *pcbFileData = cbFileData; + return pbFileData; } -// Read the 40-bit big-endian offset into ULONGLONG -ULONGLONG ConvertBytesToInteger_5(LPBYTE ValueAsBytes) +LPBYTE LoadFileToMemory(const TCHAR * szFileName, DWORD * pcbFileData) { - ULONGLONG Value = 0; - - Value = (Value << 0x08) | ValueAsBytes[0]; - Value = (Value << 0x08) | ValueAsBytes[1]; - Value = (Value << 0x08) | ValueAsBytes[2]; - Value = (Value << 0x08) | ValueAsBytes[3]; - Value = (Value << 0x08) | ValueAsBytes[4]; - - return Value; -} + TFileStream * pStream; + ULONGLONG FileSize = 0; + LPBYTE pbFileData = NULL; + DWORD cbFileData = 0; + + // Open the stream for read-only access and read the file + // Note that this fails when the game is running (sharing violation). + pStream = FileStream_OpenFile(szFileName, STREAM_FLAG_READ_ONLY | STREAM_PROVIDER_FLAT | BASE_PROVIDER_FILE); + if(pStream != NULL) + { + // Retrieve the file size + FileStream_GetSize(pStream, &FileSize); + cbFileData = (DWORD)FileSize; + + // Do not load zero files or too larget files + if(0 < FileSize && FileSize <= 0x2000000) + { + // Allocate file data buffer. Make it 1 byte longer + // so string functions can put '\0' there + pbFileData = CASC_ALLOC(BYTE, cbFileData + 1); + if(pbFileData != NULL) + { + if(!FileStream_Read(pStream, NULL, pbFileData, cbFileData)) + { + CASC_FREE(pbFileData); + cbFileData = 0; + } + } + else + { + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + cbFileData = 0; + } + } + else + { + SetLastError(ERROR_BAD_FORMAT); + cbFileData = 0; + assert(false); + } + + // Close the file stream + FileStream_Close(pStream); + } -void ConvertIntegerToBytes_4(DWORD Value, LPBYTE ValueAsBytes) -{ - ValueAsBytes[0] = (Value >> 0x18) & 0xFF; - ValueAsBytes[1] = (Value >> 0x10) & 0xFF; - ValueAsBytes[2] = (Value >> 0x08) & 0xFF; - ValueAsBytes[3] = (Value >> 0x00) & 0xFF; + // Give out values + if(pcbFileData != NULL) + pcbFileData[0] = cbFileData; + return pbFileData; } -//----------------------------------------------------------------------------- -// Common fre routine of a CASC blob - void FreeCascBlob(PQUERY_KEY pBlob) { if(pBlob != NULL) { - if(pBlob->pbData != NULL) - CASC_FREE(pBlob->pbData); - - pBlob->pbData = NULL; + CASC_FREE(pBlob->pbData); pBlob->cbData = 0; } } diff --git a/dep/CascLib/src/CascCommon.h b/dep/CascLib/src/CascCommon.h index e38094171b8..3ce527061c2 100644 --- a/dep/CascLib/src/CascCommon.h +++ b/dep/CascLib/src/CascCommon.h @@ -23,341 +23,441 @@ #include "CascPort.h" #include "common/Common.h" -#include "common/DynamicArray.h" +#include "common/Array.h" #include "common/Map.h" +#include "common/FileTree.h" #include "common/FileStream.h" #include "common/Directory.h" #include "common/ListFile.h" -#include "common/DumpContext.h" +#include "common/Csv.h" #include "common/RootHandler.h" -// Headers from LibTomCrypt -#include "libtomcrypt/src/headers/tomcrypt.h" +// Headers from Alexander Peslyak's MD5 implementation +#include "md5/md5.h" // For HashStringJenkins #include "jenkins/lookup.h" +// On-disk CASC structures +#include "CascStructs.h" + //----------------------------------------------------------------------------- // CascLib private defines -#define CASC_GAME_HOTS 0x00010000 // Heroes of the Storm -#define CASC_GAME_WOW6 0x00020000 // World of Warcraft - Warlords of Draenor -#define CASC_GAME_DIABLO3 0x00030000 // Diablo 3 since PTR 2.2.0 -#define CASC_GAME_OVERWATCH 0x00040000 // Overwatch since PTR 24919 -#define CASC_GAME_STARCRAFT2 0x00050000 // Starcraft II - Legacy of the Void, since build 38996 -#define CASC_GAME_STARCRAFT1 0x00060000 // Starcraft 1 (remastered) -#define CASC_GAME_MASK 0xFFFF0000 // Mask for getting game ID - -#define CASC_INDEX_COUNT 0x10 -#define CASC_FILE_KEY_SIZE 0x09 // Size of the file key -#define CASC_MAX_DATA_FILES 0x100 -#define CASC_EXTRA_FILES 0x20 // Number of extra entries to be reserved for additionally inserted files - -#define CASC_SEARCH_HAVE_NAME 0x0001 // Indicated that previous search found a name - -#define BLTE_HEADER_SIGNATURE 0x45544C42 // 'BLTE' header in the data files -#define BLTE_HEADER_DELTA 0x1E // Distance of BLTE header from begin of the header area -#define MAX_HEADER_AREA_SIZE 0x2A // Length of the file header area - -// File header area in the data.nnn: -// BYTE HeaderHash[MD5_HASH_SIZE]; // MD5 of the frame array -// DWORD dwFileSize; // Size of the file (see comment before CascGetFileSize for details) -// BYTE SomeSize[4]; // Some size (big endian) -// BYTE Padding[6]; // Padding (?) -// DWORD dwSignature; // Must be "BLTE" -// BYTE HeaderSizeAsBytes[4]; // Header size in bytes (big endian) -// BYTE MustBe0F; // Must be 0x0F. Optional, only if HeaderSizeAsBytes != 0 -// BYTE FrameCount[3]; // Frame count (big endian). Optional, only if HeaderSizeAsBytes != 0 - -// Prevent problems with CRT "min" and "max" functions, -// as they are not defined on all platforms -#define CASCLIB_MIN(a, b) ((a < b) ? a : b) -#define CASCLIB_MAX(a, b) ((a > b) ? a : b) -#define CASCLIB_UNUSED(p) ((void)(p)) - -#define CASC_PACKAGE_BUFFER 0x1000 - -#ifndef _maxchars -#define _maxchars(buff) ((sizeof(buff) / sizeof(buff[0])) - 1) +#ifdef _DEBUG +#define BREAK_ON_XKEY3(CKey, v0, v1, v2) if(CKey[0] == v0 && CKey[1] == v1 && CKey[2] == v2) { __debugbreak(); } +#define BREAKIF(condition) if(condition) { __debugbreak(); } +#else +#define BREAK_ON_XKEY3(CKey, v0, v1, v2) { /* NOTHING */ } +#define BREAKIF(condition) { /* NOTHING */ } #endif //----------------------------------------------------------------------------- // In-memory structures -// See http://pxr.dk/wowdev/wiki/index.php?title=CASC for more information - -struct TFileStream; typedef enum _CBLD_TYPE { CascBuildNone = 0, // No build type found CascBuildInfo, // .build.info CascBuildDb, // .build.db (older storages) + CascVersionsDb // versions (downloaded online) } CBLD_TYPE, *PCBLD_TYPE; -typedef struct _ENCODING_KEY +// Tag file entry, loaded from the DOWNLOAD file +typedef struct _CASC_TAG_ENTRY { - BYTE Value[MD5_HASH_SIZE]; // MD5 of the file + USHORT HashType; // Hash type + char TagName[1]; // Tag name. Variable length. +} CASC_TAG_ENTRY, *PCASC_TAG_ENTRY; -} ENCODING_KEY, *PENCODING_KEY; - -typedef struct _CASC_INDEX_ENTRY +// Normalized header of the index files. +// Both version 1 and version 2 are converted to this structure +typedef struct _CASC_INDEX_HEADER { - BYTE IndexKey[CASC_FILE_KEY_SIZE]; // The first 9 bytes of the encoding key - BYTE FileOffsetBE[5]; // Index of data file and offset within (big endian). - BYTE FileSizeLE[4]; // Size occupied in the storage file (data.###). See comment before CascGetFileSize for details -} CASC_INDEX_ENTRY, *PCASC_INDEX_ENTRY; - -typedef struct _CASC_MAPPING_TABLE + USHORT IndexVersion; // 5 for index v 1.0, 7 for index version 2.0 + BYTE BucketIndex; // Should be the same as the first byte of the hex filename. + BYTE StorageOffsetLength; // Length, in bytes, of the StorageOffset field in the EKey entry + BYTE EncodedSizeLength; // Length, in bytes, of the EncodedSize in the EKey entry + BYTE EKeyLength; // Length, in bytes, of the (trimmed) EKey in the EKey entry + BYTE FileOffsetBits; // Number of bits of the archive file offset in StorageOffset field. Rest is data segment index + BYTE Alignment; + ULONGLONG SegmentSize; // Size of one data segment (aka data.### file) + size_t HeaderLength; // Length of the on-disk header structure, in bytes + size_t HeaderPadding; // Length of padding after the header + size_t EntryLength; // Length of the on-disk EKey entry structure, in bytes + size_t EKeyCount; // Number of EKey entries. Only supplied for index files version 1. + +} CASC_INDEX_HEADER, *PCASC_INDEX_HEADER; + +// Normalized footer of the archive index files (md5.index) +typedef struct _CASC_ARCINDEX_FOOTER { - TCHAR * szFileName; // Name of the key mapping file - LPBYTE pbFileData; // Pointer to the file data - DWORD cbFileData; // Length of the file data - BYTE ExtraBytes; // (?) Extra bytes in the key record - BYTE SpanSizeBytes; // Size of field with file size - BYTE SpanOffsBytes; // Size of field with file offset - BYTE KeyBytes; // Size of the file key - BYTE SegmentBits; // Number of bits for the file offset (rest is archive index) - ULONGLONG MaxFileOffset; - - PCASC_INDEX_ENTRY pIndexEntries; // Sorted array of index entries - DWORD nIndexEntries; // Number of index entries - -} CASC_MAPPING_TABLE, *PCASC_MAPPING_TABLE; - -typedef struct _CASC_FILE_FRAME + BYTE TocHash[MD5_HASH_SIZE]; // Hash of the structure + BYTE FooterHash[MD5_HASH_SIZE]; // MD5 hash of the footer, possibly shortened + BYTE Version; // Version of the index footer + BYTE OffsetBytes; // Length, in bytes, of the file offset field + BYTE SizeBytes; // Length, in bytes, of the file size field + BYTE EKeyBytes; // Length, in bytes, of the EKey field + BYTE FooterHashBytes; // Length, in bytes, of the hash and checksum + BYTE Alignment[3]; + size_t ElementCount; // total number of elements in the index file + size_t PageLength; // Length, in bytes, of the index page + size_t ItemLength; // Length, in bytes, of the single item + size_t FooterLength; // Length, in bytes, of the index footer structure + +} CASC_ARCINDEX_FOOTER, *PCASC_ARCINDEX_FOOTER; + +// Normalized structure for archive index entry +typedef struct _CASC_ARCINDEX_ENTRY { - DWORD FrameArchiveOffset; // Archive file pointer corresponding to the begin of the frame - DWORD FrameFileOffset; // File pointer corresponding to the begin of the frame - DWORD CompressedSize; // Compressed size of the file - DWORD FrameSize; // Size of the frame - BYTE md5[MD5_HASH_SIZE]; // MD5 hash of the file sector -} CASC_FILE_FRAME, *PCASC_FILE_FRAME; + BYTE IndexHash[MD5_HASH_SIZE]; + BYTE EKey[MD5_HASH_SIZE]; + DWORD ArchiveOffset; + DWORD EncodedSize; +} CASC_ARCINDEX_ENTRY, *PCASC_ARCINDEX_ENTRY; -// The encoding file is in the form of: -// * File header -// * String block #1 -// * Table A header -// * Table A entries -// * Table B header -// * Table B entries -// * String block #2 -// http://pxr.dk/wowdev/wiki/index.php?title=CASC#Key_CASC_Files +// Normalized header of the ENCODING file typedef struct _CASC_ENCODING_HEADER { - BYTE Magic[2]; // "EN" - BYTE Version; // Expected to be 1 by CascLib - BYTE ChecksumSizeA; // The length of the checksums in Encoding Table - BYTE ChecksumSizeB; // The length of the checksums in Encoding Layout Table - BYTE Flags_TableA[2]; // Flags for Encoding Table - BYTE Flags_TableB[2]; // Flags for Encoding Layout Table - BYTE Entries_TableA[4]; // Number of segments in Encoding Table (big endian) - BYTE Entries_TableB[4]; // Number of segments in Encoding Layout Table (big endian) - BYTE field_11; - BYTE Size_StringTable1[4]; // Size of the string block #1 - + USHORT Magic; // FILE_MAGIC_ENCODING ('EN') + USHORT Version; // Expected to be 1 by CascLib + BYTE CKeyLength; // The content key length in ENCODING file. Usually 0x10 + BYTE EKeyLength; // The encoded key length in ENCODING file. Usually 0x10 + DWORD CKeyPageSize; // Size of the CKey page in bytes + DWORD EKeyPageSize; // Size of the CKey page in bytes + DWORD CKeyPageCount; // Number of CKey pages in the page table + DWORD EKeyPageCount; // Number of EKey pages in the page table + DWORD ESpecBlockSize; // Size of the ESpec string block, in bytes } CASC_ENCODING_HEADER, *PCASC_ENCODING_HEADER; -typedef struct _CASC_ENCODING_ENTRY +typedef struct _CASC_DOWNLOAD_HEADER { - USHORT KeyCount; // Number of index keys - BYTE FileSizeBE[4]; // Compressed file size (header area + frame headers + compressed frames), in bytes - BYTE EncodingKey[MD5_HASH_SIZE]; // File encoding key + USHORT Magic; // FILE_MAGIC_DOWNLOAD ('DL') + USHORT Version; // Version + USHORT EKeyLength; // Length of the EKey + USHORT EntryHasChecksum; // If nonzero, then the entry has checksum + DWORD EntryCount; + DWORD TagCount; + USHORT FlagByteSize; + USHORT BasePriority; - // Followed by the index keys - // (number of items = KeyCount) - // Followed by the index keys (number of items = KeyCount) -} CASC_ENCODING_ENTRY, *PCASC_ENCODING_ENTRY; + size_t HeaderLength; // Length of the on-disk header, in bytes + size_t EntryLength; // Length of the on-disk entry, in bytes + +} CASC_DOWNLOAD_HEADER, *PCASC_DOWNLOAD_HEADER; + +typedef struct _CASC_DOWNLOAD_ENTRY +{ + BYTE EKey[MD5_HASH_SIZE]; + ULONGLONG EncodedSize; + DWORD Checksum; + DWORD Flags; + BYTE Priority; +} CASC_DOWNLOAD_ENTRY, *PCASC_DOWNLOAD_ENTRY; + +// Capturable tag structure for loading from DOWNLOAD manifest +typedef struct _CASC_TAG_ENTRY1 +{ + const char * szTagName; // Tag name + LPBYTE Bitmap; // Bitmap + size_t BitmapLength; // Length of the bitmap, in bytes + size_t NameLength; // Length of the tag name, in bytes, not including '\0' + size_t TagLength; // Length of the on-disk tag, in bytes + DWORD TagValue; // Tag value +} CASC_TAG_ENTRY1, *PCASC_TAG_ENTRY1; + +// Tag structure for storing in arrays +typedef struct _CASC_TAG_ENTRY2 +{ + size_t NameLength; // Length of the on-disk tag, in bytes + DWORD TagValue; // Tag value + char szTagName[0x08]; // Tag string. This member can be longer than declared. Aligned to 8 bytes. +} CASC_TAG_ENTRY2, *PCASC_TAG_ENTRY2; -// A version of CASC_ENCODING_ENTRY with one index key -typedef struct _CASC_ENCODING_ENTRY_1 +typedef struct _CASC_INSTALL_HEADER { - USHORT KeyCount; // Number of index keys - BYTE FileSizeBE[4]; // Compressed file size (header area + frame headers + compressed frames), in bytes - BYTE EncodingKey[MD5_HASH_SIZE]; // File encoding key - BYTE IndexKey[MD5_HASH_SIZE]; // File index key + USHORT Magic; // FILE_MAGIC_DOWNLOAD ('DL') + BYTE Version; // Version + BYTE EKeyLength; // Length of the EKey + DWORD EntryCount; + DWORD TagCount; -} CASC_ENCODING_ENTRY_1, *PCASC_ENCODING_ENTRY_1; + size_t HeaderLength; // Length of the on-disk header, in bytes +} CASC_INSTALL_HEADER, *PCASC_INSTALL_HEADER; -#define GET_INDEX_KEY(pEncodingEntry) (pEncodingEntry->EncodingKey + MD5_HASH_SIZE) -#define FAKE_ENCODING_ENTRY_SIZE (sizeof(CASC_ENCODING_ENTRY) + MD5_HASH_SIZE) +typedef struct _CASC_FILE_FRAME +{ + CONTENT_KEY FrameHash; // MD5 hash of the file frame + DWORD DataFileOffset; // Offset in the data file (data.###) + DWORD FileOffset; // File offset of this frame + DWORD EncodedSize; // Encoded size of the frame + DWORD ContentSize; // Content size of the frame +} CASC_FILE_FRAME, *PCASC_FILE_FRAME; //----------------------------------------------------------------------------- // Structures for CASC storage and CASC file -typedef struct _TCascStorage +struct TCascStorage { - const char * szClassName; // "TCascStorage" + TCascStorage(); + ~TCascStorage(); + TCascStorage * AddRef(); + TCascStorage * Release(); + + static TCascStorage * IsValid(HANDLE hStorage); + + PFNPROGRESSCALLBACK PfnCallback; // Callback to be called during CascOpen(Online)Storage + void * PtrCallbackParam; + const TCHAR * szIndexFormat; // Format of the index file name - TCHAR * szRootPath; // This is the game directory + const char * szClassName; // "TCascStorage" + const char * szProductName; // String representation of the product name + TCHAR * szRootPath; // Path where the build file is TCHAR * szDataPath; // This is the directory where data files are - TCHAR * szBuildFile; // Build file name (.build.info or .build.db) TCHAR * szIndexPath; // This is the directory where index files are - TCHAR * szUrlPath; // URL to the Blizzard servers + TCHAR * szBuildFile; // Build file name (.build.info or .build.db) + TCHAR * szCdnServers; // Multi-SZ list of CDN servers + TCHAR * szCdnPath; // Remote CDN sub path for the product + TCHAR * szCodeName; // Product code name. Only for online storages + char * szRegion; // Product region. Only when "versions" is used as storage root file + CASC_PRODUCT Product; // Product enum value (see CASC_PRODUCT) + DWORD dwBuildNumber; // Product build number DWORD dwRefCount; // Number of references - DWORD dwGameInfo; // Game type - DWORD dwBuildNumber; // Game build number - DWORD dwFileBeginDelta; // This is number of bytes to shift back from archive offset (from index entry) to actual begin of file data DWORD dwDefaultLocale; // Default locale, read from ".build.info" + DWORD dwFeatures; // List of CASC features. See CASC_FEATURE_XXX + bool bAllowOrphans; // If TRUE, then orphaned items are allowed CBLD_TYPE BuildFileType; // Type of the build file - QUERY_KEY CdnConfigKey; - QUERY_KEY CdnBuildKey; - QUERY_KEY ArchivesGroup; // Key array of the "archive-group" + QUERY_KEY CdnConfigKey; // Currently selected CDN config file. Points to "config\%02X\%02X\%s + QUERY_KEY CdnBuildKey; // Currently selected CDN build file. Points to "config\%02X\%02X\%s + + QUERY_KEY ArchiveGroup; // Key array of the "archive-group" QUERY_KEY ArchivesKey; // Key array of the "archives" QUERY_KEY PatchArchivesKey; // Key array of the "patch-archives" QUERY_KEY PatchArchivesGroup; // Key array of the "patch-archive-group" - QUERY_KEY RootKey; - QUERY_KEY PatchKey; - QUERY_KEY DownloadKey; - QUERY_KEY InstallKey; - QUERY_KEY EncodingKey; - - TFileStream * DataFileArray[CASC_MAX_DATA_FILES]; // Data file handles + QUERY_KEY BuildFiles; // List of supported build files - CASC_MAPPING_TABLE KeyMapping[CASC_INDEX_COUNT]; // Key mapping - PCASC_MAP pIndexEntryMap; // Map of index entries + TFileStream * DataFiles[CASC_MAX_DATA_FILES]; // Array of open data files - QUERY_KEY EncodingFile; // Content of the ENCODING file - PCASC_MAP pEncodingMap; // Map of encoding entries - DYNAMIC_ARRAY ExtraEntries; // Extra encoding entries + CASC_CKEY_ENTRY EncodingCKey; // Information about ENCODING file + CASC_CKEY_ENTRY DownloadCKey; // Information about DOWNLOAD file + CASC_CKEY_ENTRY InstallCKey; // Information about INSTALL file + CASC_CKEY_ENTRY PatchFile; // Information about PATCH file + CASC_CKEY_ENTRY RootFile; // Information about ROOT file + CASC_CKEY_ENTRY SizeFile; // Information about SIZE file + CASC_CKEY_ENTRY VfsRoot; // The main VFS root file + CASC_ARRAY VfsRootList; // List of CASC_EKEY_ENTRY for each TVFS sub-root TRootHandler * pRootHandler; // Common handler for various ROOT file formats - -} TCascStorage; - -typedef struct _TCascFile + CASC_ARRAY ArcIndexArray; // Array of CASC_ARCINDEX_ENTRY, loaded from archive indexes + CASC_ARRAY IndexArray; // Array of CASC_CKEY_ENTRY loaded from local index files + CASC_ARRAY CKeyArray; // Array of CASC_CKEY_ENTRY, one entry for each physical file + CASC_ARRAY TagsArray; // Array of CASC_DOWNLOAD_TAG2 + CASC_MAP ArcIndexMap; // Map of EKey -> CASC_ARCINDEX_ENTRY + CASC_MAP CKeyMap; // Map of CKey -> CASC_CKEY_ENTRY + CASC_MAP EKeyMap; // Map of EKey -> CASC_EKEY_ENTRY + size_t LocalFiles; // Number of files that are present locally + size_t TotalFiles; // Total number of files in the storage, some may not be present locally + size_t EKeyEntries; // Number of CKeyEntry-ies loaded from text build file + size_t OrphanItems; // Number of EKey entries in indexes that do not have their counterpart in ENCODING + size_t SkippedItems; // Number of EKey entries in indexes that were ignored due to insufficient capacity of CKeyArray + size_t EKeyLength; // EKey length from the index files + DWORD FileOffsetBits; // Nimber of bits in the storage offset which mean data segent offset + + CASC_ARRAY ExtraKeysList; // List additional encryption keys + CASC_MAP EncryptionKeys; // Map of encryption keys + +}; + +struct TCascFile { + TCascFile(TCascStorage * ahs, PCASC_CKEY_ENTRY apCKeyEntry) + { + ULONGLONG StorageOffset; + ULONGLONG FileOffsMask; + + // Reference the storage handle + hs = ahs->AddRef(); + szClassName = "TCascFile"; + + // Init class variables + pCKeyEntry = apCKeyEntry; + pFrames = NULL; + pbFileCache = NULL; + cbFileCache = 0; + + // Supply the sizes + StorageOffset = pCKeyEntry->StorageOffset; + FileOffsMask = ((ULONGLONG)1 << hs->FileOffsetBits) - 1; + ArchiveIndex = (DWORD)(StorageOffset >> hs->FileOffsetBits); + ArchiveOffset = (DWORD)(StorageOffset & FileOffsMask); + EncodedSize = pCKeyEntry->EncodedSize; + ContentSize = pCKeyEntry->ContentSize; + FilePointer = 0; + FrameCount = 0; + bVerifyIntegrity = false; + bDownloadFileIf = false; + bLocalFileStream = false; + } + + ~TCascFile() + { + // Close (dereference) the archive handle + hs = hs->Release(); + szClassName = NULL; + + // Free the file cache and frame array + CASC_FREE(pbFileCache); + CASC_FREE(pFrames); + + // If we are supposed to close the file stream, do it + if (pStream && bLocalFileStream) + FileStream_Close(pStream); + } + + static TCascFile * IsValid(HANDLE hFile) + { + TCascFile * hf = (TCascFile *)hFile; + + return (hf != INVALID_HANDLE_VALUE && + hf != NULL && + hf->hs != NULL && + hf->szClassName != NULL && + hf->pCKeyEntry != NULL) ? hf : NULL; + } + TCascStorage * hs; // Pointer to storage structure TFileStream * pStream; // An open data stream const char * szClassName; // "TCascFile" - DWORD FilePointer; // Current file pointer - - DWORD ArchiveIndex; // Index of the archive (data.###) - DWORD HeaderOffset; // Offset of the BLTE header, relative to the begin of the archive - DWORD HeaderSize; // Length of the BLTE header - DWORD FramesOffset; // Offset of the frame data, relative to the begin of the archive - DWORD CompressedSize; // Compressed size of the file (in bytes) - DWORD FileSize; // Size of file, in bytes - BYTE FrameArrayHash[MD5_HASH_SIZE]; // MD5 hash of the frame array - + PCASC_CKEY_ENTRY pCKeyEntry; PCASC_FILE_FRAME pFrames; // Array of file frames + DWORD ArchiveIndex; // Index of the archive (data.###) + DWORD ArchiveOffset; // Offset in the archive (data.###) + DWORD FilePointer; // Current file pointer + DWORD EncodedSize; // Encoded size. This is the size of encoded header, all file frame headers and all file frames + DWORD ContentSize; // Content size. This is the size of the file content, aka the file size DWORD FrameCount; // Number of the file frames + DWORD bVerifyIntegrity:1; // If true, then the data are validated more strictly when read + DWORD bDownloadFileIf:1; // If true, then the data will be downloaded from the online storage if missing + DWORD bLocalFileStream:1; // If true, then the file stream is a local file LPBYTE pbFileCache; // Pointer to file cache DWORD cbFileCache; // Size of the file cache - DWORD CacheStart; // Starting offset in the cache - DWORD CacheEnd; // Ending offset in the cache - -#ifdef CASCLIB_TEST // Extra fields for analyzing the file size problem - DWORD FileSize_RootEntry; // File size, from the root entry - DWORD FileSize_EncEntry; // File size, from the encoding entry - DWORD FileSize_IdxEntry; // File size, from the index entry - DWORD FileSize_HdrArea; // File size, as stated in the file header area - DWORD FileSize_FrameSum; // File size as sum of frame sizes -#endif -} TCascFile; +}; -typedef struct _TCascSearch +struct TCascSearch { + TCascSearch(TCascStorage * ahs, LPCTSTR aszListFile, const char * aszMask) + { + // Init the class + szClassName = "TCascSearch"; + hs = ahs->AddRef(); + + // Init provider-specific data + pCache = NULL; + nFileIndex = 0; + nSearchState = 0; + bListFileUsed = false; + + // Allocate mask + szListFile = CascNewStr(aszListFile); + szMask = CascNewStr((aszMask != NULL) ? aszMask : "*"); + } + + ~TCascSearch() + { + // Dereference the CASC storage + hs = hs->Release(); + szClassName = NULL; + + // Free the rest of the members + CASC_FREE(szMask); + CASC_FREE(szListFile); + CASC_FREE(pCache); + } + + static TCascSearch * IsValid(HANDLE hFind) + { + TCascSearch * pSearch = (TCascSearch *)hFind; + + return (hFind != INVALID_HANDLE_VALUE && + hFind != NULL && + pSearch->szClassName != NULL && + !strcmp(pSearch->szClassName, "TCascSearch") && + pSearch->szMask != NULL) ? pSearch : NULL; + } + TCascStorage * hs; // Pointer to the storage handle const char * szClassName; // Contains "TCascSearch" TCHAR * szListFile; // Name of the listfile void * pCache; // Listfile cache char * szMask; // Search mask - char szFileName[MAX_PATH]; // Buffer for the file name // Provider-specific data - void * pRootContext; // Root-specific search context - size_t IndexLevel1; // Root-specific search context - size_t IndexLevel2; // Root-specific search context - DWORD dwState; // Pointer to the search state (0 = listfile, 1 = nameless, 2 = done) - - BYTE BitArray[1]; // Bit array of encoding keys. Set for each entry that has already been reported - -} TCascSearch; + size_t nFileIndex; // Root-specific search context + DWORD nSearchState:8; // The current search state (0 = listfile, 1 = nameless, 2 = done) + DWORD bListFileUsed:1; // TRUE: The listfile has already been loaded +}; //----------------------------------------------------------------------------- -// Memory management -// -// We use our own macros for allocating/freeing memory. If you want -// to redefine them, please keep the following rules: -// -// - The memory allocation must return NULL if not enough memory -// (i.e not to throw exception) -// - The allocating function does not need to fill the allocated buffer with zeros -// - The reallocating function must support NULL as the previous block -// - Memory freeing function doesn't have to test the pointer to NULL -// - -#if defined(_MSC_VER) && defined(_DEBUG) - -#define CASC_REALLOC(type, ptr, count) (type *)HeapReAlloc(GetProcessHeap(), 0, ptr, ((count) * sizeof(type))) -#define CASC_ALLOC(type, count) (type *)HeapAlloc(GetProcessHeap(), 0, ((count) * sizeof(type))) -#define CASC_FREE(ptr) HeapFree(GetProcessHeap(), 0, ptr) - -#else - -#define CASC_REALLOC(type, ptr, count) (type *)realloc(ptr, (count) * sizeof(type)) -#define CASC_ALLOC(type, count) (type *)malloc((count) * sizeof(type)) -#define CASC_FREE(ptr) free(ptr) +// Common functions (CascCommon.cpp) -#endif - -//----------------------------------------------------------------------------- -// Big endian number manipulation - -DWORD ConvertBytesToInteger_3(LPBYTE ValueAsBytes); -DWORD ConvertBytesToInteger_4(LPBYTE ValueAsBytes); -DWORD ConvertBytesToInteger_4_LE(LPBYTE ValueAsBytes); -ULONGLONG ConvertBytesToInteger_5(LPBYTE ValueAsBytes); - -void ConvertIntegerToBytes_4(DWORD Value, LPBYTE ValueAsBytes); +bool OpenFileByCKeyEntry(TCascStorage * hs, PCASC_CKEY_ENTRY pCKeyEntry, DWORD dwOpenFlags, HANDLE * PtrFileHandle); +LPBYTE LoadInternalFileToMemory(TCascStorage * hs, PCASC_CKEY_ENTRY pCKeyEntry, DWORD * pcbFileData); +LPBYTE LoadFileToMemory(const TCHAR * szFileName, DWORD * pcbFileData); void FreeCascBlob(PQUERY_KEY pQueryKey); //----------------------------------------------------------------------------- // Text file parsing (CascFiles.cpp) -int LoadBuildInfo(TCascStorage * hs); +int DownloadFileFromCDN(TCascStorage * hs, const TCHAR * szSubDir, LPBYTE pbEKey, const TCHAR * szExtension, TCHAR * szOutLocalPath, size_t cchOutLocalPath); int CheckGameDirectory(TCascStorage * hs, TCHAR * szDirectory); - -int GetRootVariableIndex(const char * szLinePtr, const char * szLineEnd, const char * szVariableName, int * PtrIndex); -int ParseRootFileLine(const char * szLinePtr, const char * szLineEnd, int nFileNameIndex, PQUERY_KEY pEncodingKey, char * szFileName, size_t nMaxChars); +int LoadCdnsInfo(TCascStorage * hs); +int LoadBuildInfo(TCascStorage * hs); +int LoadCdnConfigFile(TCascStorage * hs); +int LoadCdnBuildFile(TCascStorage * hs); //----------------------------------------------------------------------------- // Internal file functions -TCascStorage * IsValidStorageHandle(HANDLE hStorage); -TCascFile * IsValidFileHandle(HANDLE hFile); +void * ProbeOutputBuffer(void * pvBuffer, size_t cbLength, size_t cbMinLength, size_t * pcbLengthNeeded); + +PCASC_CKEY_ENTRY FindCKeyEntry_CKey(TCascStorage * hs, LPBYTE pbCKey, PDWORD PtrIndex = NULL); +PCASC_CKEY_ENTRY FindCKeyEntry_EKey(TCascStorage * hs, LPBYTE pbEKey, PDWORD PtrIndex = NULL); -PCASC_ENCODING_ENTRY FindEncodingEntry(TCascStorage * hs, PQUERY_KEY pEncodingKey, PDWORD PtrIndex); -PCASC_INDEX_ENTRY FindIndexEntry(TCascStorage * hs, PQUERY_KEY pIndexKey); +size_t GetTagBitmapLength(LPBYTE pbFilePtr, LPBYTE pbFileEnd, DWORD EntryCount); int CascDecompress(LPBYTE pvOutBuffer, PDWORD pcbOutBuffer, LPBYTE pvInBuffer, DWORD cbInBuffer); -int CascDecrypt (LPBYTE pbOutBuffer, PDWORD pcbOutBuffer, LPBYTE pbInBuffer, DWORD cbInBuffer, DWORD dwFrameIndex); int CascDirectCopy(LPBYTE pbOutBuffer, PDWORD pcbOutBuffer, LPBYTE pbInBuffer, DWORD cbInBuffer); +int CascLoadEncryptionKeys(TCascStorage * hs); +int CascDecrypt(TCascStorage * hs, LPBYTE pbOutBuffer, PDWORD pcbOutBuffer, LPBYTE pbInBuffer, DWORD cbInBuffer, DWORD dwFrameIndex); + +//----------------------------------------------------------------------------- +// Support for index files + +int LoadIndexFiles(TCascStorage * hs); + //----------------------------------------------------------------------------- // Support for ROOT file int RootHandler_CreateMNDX(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile); +int RootHandler_CreateTVFS(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile); int RootHandler_CreateDiablo3(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile); +int RootHandler_CreateWoW(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile, DWORD dwLocaleMask); int RootHandler_CreateOverwatch(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile); -int RootHandler_CreateWoW6(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile, DWORD dwLocaleMask); -int RootHandler_CreateSC1(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile); +int RootHandler_CreateStarcraft1(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile); +int RootHandler_CreateInstall(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile); //----------------------------------------------------------------------------- -// Dumping CASC data structures +// Dumpers (CascDumpData.cpp) #ifdef _DEBUG -void CascDumpSparseArray(const char * szFileName, void * pvSparseArray); -void CascDumpNameFragTable(const char * szFileName, void * pvMarFile); -void CascDumpFileNames(const char * szFileName, void * pvMarFile); -void CascDumpIndexEntries(const char * szFileName, TCascStorage * hs); -void CascDumpEncodingEntry(TCascStorage * hs, TDumpContext * dc, PCASC_ENCODING_ENTRY pEncodingEntry, int nDumpLevel); -void CascDumpFile(const char * szFileName, HANDLE hFile); -#endif // _DEBUG +void CascDumpFile(HANDLE hFile, const char * szDumpFile = NULL); +void CascDumpStorage(HANDLE hStorage, const char * szDumpFile = NULL); +#endif #endif // __CASCCOMMON_H__ diff --git a/dep/CascLib/src/CascDecompress.cpp b/dep/CascLib/src/CascDecompress.cpp index e60adb8f97b..3262c59ddf7 100644 --- a/dep/CascLib/src/CascDecompress.cpp +++ b/dep/CascLib/src/CascDecompress.cpp @@ -18,29 +18,39 @@ int CascDecompress(LPBYTE pbOutBuffer, PDWORD pcbOutBuffer, LPBYTE pbInBuffer, DWORD cbInBuffer) { z_stream z; // Stream information for zlib + uInt cbOutBuffer = *pcbOutBuffer; int nResult; + int nError = ERROR_FILE_CORRUPT; // Fill the stream structure for zlib z.next_in = pbInBuffer; z.avail_in = cbInBuffer; z.total_in = cbInBuffer; z.next_out = pbOutBuffer; - z.avail_out = *pcbOutBuffer; + z.avail_out = cbOutBuffer; z.total_out = 0; z.zalloc = NULL; z.zfree = NULL; + // Reset the total number of output bytes + cbOutBuffer = 0; + // Initialize the decompression structure if((nResult = inflateInit(&z)) == Z_OK) { // Call zlib to decompress the data nResult = inflate(&z, Z_NO_FLUSH); - inflateEnd(&z); + if (nResult == Z_OK || nResult == Z_STREAM_END) + { + // Give the size of the uncompressed data + cbOutBuffer = z.total_out; + nError = ERROR_SUCCESS; + } - // Give the size of the uncompressed data - *pcbOutBuffer = z.total_out; + inflateEnd(&z); } - // Return an error code - return (nResult == Z_OK || nResult == Z_STREAM_END) ? ERROR_SUCCESS : ERROR_FILE_CORRUPT; + // Give the caller the number of bytes needed + pcbOutBuffer[0] = cbOutBuffer; + return nError; } diff --git a/dep/CascLib/src/CascDecrypt.cpp b/dep/CascLib/src/CascDecrypt.cpp index 57040dd21fb..81e098ca178 100644 --- a/dep/CascLib/src/CascDecrypt.cpp +++ b/dep/CascLib/src/CascDecrypt.cpp @@ -15,6 +15,8 @@ //----------------------------------------------------------------------------- // Local structures +#define CASC_EXTRA_KEYS 0x80 + typedef struct _CASC_ENCRYPTION_KEY { ULONGLONG KeyName; // "Name" of the key @@ -31,125 +33,196 @@ typedef struct _CASC_SALSA20 //----------------------------------------------------------------------------- // Known encryption keys. See https://wowdev.wiki/CASC for updates +static const char * szKeyConstant16 = "expand 16-byte k"; +static const char * szKeyConstant32 = "expand 32-byte k"; + static CASC_ENCRYPTION_KEY CascKeys[] = { - // Key Name Encryption key Seen in - // ---------------------- ------------------------------------------------------------------------------------------------ ----------- - - // Battle.net app - { 0x2C547F26A2613E01ULL, { 0x37, 0xC5, 0x0C, 0x10, 0x2D, 0x4C, 0x9E, 0x3A, 0x5A, 0xC0, 0x69, 0xF0, 0x72, 0xB1, 0x41, 0x7D } }, // Battle.net App Alpha 1.5.0 - - // Overwatch - { 0xFB680CB6A8BF81F3ULL, { 0x62, 0xD9, 0x0E, 0xFA, 0x7F, 0x36, 0xD7, 0x1C, 0x39, 0x8A, 0xE2, 0xF1, 0xFE, 0x37, 0xBD, 0xB9 } }, // 0.8.0.24919_retailx64 (hardcoded) - { 0x402CD9D8D6BFED98ULL, { 0xAE, 0xB0, 0xEA, 0xDE, 0xA4, 0x76, 0x12, 0xFE, 0x6C, 0x04, 0x1A, 0x03, 0x95, 0x8D, 0xF2, 0x41 } }, // 0.8.0.24919_retailx64 (hardcoded) - { 0xDBD3371554F60306ULL, { 0x34, 0xE3, 0x97, 0xAC, 0xE6, 0xDD, 0x30, 0xEE, 0xFD, 0xC9, 0x8A, 0x2A, 0xB0, 0x93, 0xCD, 0x3C } }, // 0.8.0.24919_retailx64 (streamed from server) - { 0x11A9203C9881710AULL, { 0x2E, 0x2C, 0xB8, 0xC3, 0x97, 0xC2, 0xF2, 0x4E, 0xD0, 0xB5, 0xE4, 0x52, 0xF1, 0x8D, 0xC2, 0x67 } }, // 0.8.0.24919_retailx64 (streamed from server) - { 0xA19C4F859F6EFA54ULL, { 0x01, 0x96, 0xCB, 0x6F, 0x5E, 0xCB, 0xAD, 0x7C, 0xB5, 0x28, 0x38, 0x91, 0xB9, 0x71, 0x2B, 0x4B } }, // 0.8.0.24919_retailx64 (streamed from server) - { 0x87AEBBC9C4E6B601ULL, { 0x68, 0x5E, 0x86, 0xC6, 0x06, 0x3D, 0xFD, 0xA6, 0xC9, 0xE8, 0x52, 0x98, 0x07, 0x6B, 0x3D, 0x42 } }, // 0.8.0.24919_retailx64 (streamed from server) - { 0xDEE3A0521EFF6F03ULL, { 0xAD, 0x74, 0x0C, 0xE3, 0xFF, 0xFF, 0x92, 0x31, 0x46, 0x81, 0x26, 0x98, 0x57, 0x08, 0xE1, 0xB9 } }, // 0.8.0.24919_retailx64 (streamed from server) - { 0x8C9106108AA84F07ULL, { 0x53, 0xD8, 0x59, 0xDD, 0xA2, 0x63, 0x5A, 0x38, 0xDC, 0x32, 0xE7, 0x2B, 0x11, 0xB3, 0x2F, 0x29 } }, // 0.8.0.24919_retailx64 (streamed from server) - { 0x49166D358A34D815ULL, { 0x66, 0x78, 0x68, 0xCD, 0x94, 0xEA, 0x01, 0x35, 0xB9, 0xB1, 0x6C, 0x93, 0xB1, 0x12, 0x4A, 0xBA } }, // 0.8.0.24919_retailx64 (streamed from server) - { 0x1463A87356778D14ULL, { 0x69, 0xBD, 0x2A, 0x78, 0xD0, 0x5C, 0x50, 0x3E, 0x93, 0x99, 0x49, 0x59, 0xB3, 0x0E, 0x5A, 0xEC } }, // ? 1.0.3.0 (streamed from server) - { 0x5E152DE44DFBEE01ULL, { 0xE4, 0x5A, 0x17, 0x93, 0xB3, 0x7E, 0xE3, 0x1A, 0x8E, 0xB8, 0x5C, 0xEE, 0x0E, 0xEE, 0x1B, 0x68 } }, // ? 1.0.3.0 (streamed from server) - { 0x9B1F39EE592CA415ULL, { 0x54, 0xA9, 0x9F, 0x08, 0x1C, 0xAD, 0x0D, 0x08, 0xF7, 0xE3, 0x36, 0xF4, 0x36, 0x8E, 0x89, 0x4C } }, // ? 1.0.3.0 (streamed from server) - { 0x24C8B75890AD5917ULL, { 0x31, 0x10, 0x0C, 0x00, 0xFD, 0xE0, 0xCE, 0x18, 0xBB, 0xB3, 0x3F, 0x3A, 0xC1, 0x5B, 0x30, 0x9F } }, // ? 1.0.3.0 (included in game) - { 0xEA658B75FDD4890FULL, { 0xDE, 0xC7, 0xA4, 0xE7, 0x21, 0xF4, 0x25, 0xD1, 0x33, 0x03, 0x98, 0x95, 0xC3, 0x60, 0x36, 0xF8 } }, // ? 1.0.3.0 (included in game) - { 0x026FDCDF8C5C7105ULL, { 0x8F, 0x41, 0x80, 0x9D, 0xA5, 0x53, 0x66, 0xAD, 0x41, 0x6D, 0x3C, 0x33, 0x74, 0x59, 0xEE, 0xE3 } }, // (included in game) - { 0xCAE3FAC925F20402ULL, { 0x98, 0xB7, 0x8E, 0x87, 0x74, 0xBF, 0x27, 0x50, 0x93, 0xCB, 0x1B, 0x5F, 0xC7, 0x14, 0x51, 0x1B } }, // (included in game) - { 0x061581CA8496C80CULL, { 0xDA, 0x2E, 0xF5, 0x05, 0x2D, 0xB9, 0x17, 0x38, 0x0B, 0x8A, 0xA6, 0xEF, 0x7A, 0x5F, 0x8E, 0x6A } }, // - { 0xBE2CB0FAD3698123ULL, { 0x90, 0x2A, 0x12, 0x85, 0x83, 0x6C, 0xE6, 0xDA, 0x58, 0x95, 0x02, 0x0D, 0xD6, 0x03, 0xB0, 0x65 } }, // - { 0x57A5A33B226B8E0AULL, { 0xFD, 0xFC, 0x35, 0xC9, 0x9B, 0x9D, 0xB1, 0x1A, 0x32, 0x62, 0x60, 0xCA, 0x24, 0x6A, 0xCB, 0x41 } }, // 1.1.0.0.30200 Ana - { 0x42B9AB1AF5015920ULL, { 0xC6, 0x87, 0x78, 0x82, 0x3C, 0x96, 0x4C, 0x6F, 0x24, 0x7A, 0xCC, 0x0F, 0x4A, 0x25, 0x84, 0xF8 } }, // 1.2.0.1.30684 Summer Games - { 0x4F0FE18E9FA1AC1AULL, { 0x89, 0x38, 0x1C, 0x74, 0x8F, 0x65, 0x31, 0xBB, 0xFC, 0xD9, 0x77, 0x53, 0xD0, 0x6C, 0xC3, 0xCD } }, // 1.2.0.1.30684 - { 0x7758B2CF1E4E3E1BULL, { 0x3D, 0xE6, 0x0D, 0x37, 0xC6, 0x64, 0x72, 0x35, 0x95, 0xF2, 0x7C, 0x5C, 0xDB, 0xF0, 0x8B, 0xFA } }, // 1.2.0.1.30684 - { 0xE5317801B3561125ULL, { 0x7D, 0xD0, 0x51, 0x19, 0x9F, 0x84, 0x01, 0xF9, 0x5E, 0x4C, 0x03, 0xC8, 0x84, 0xDC, 0xEA, 0x33 } }, // 1.4.0.2.32143 Halloween Terror - { 0x16B866D7BA3A8036ULL, { 0x13, 0x95, 0xE8, 0x82, 0xBF, 0x25, 0xB4, 0x81, 0xF6, 0x1A, 0x4D, 0x62, 0x11, 0x41, 0xDA, 0x6E } }, // 1.4.1.0.31804 Bastion Blizzcon 2016 skin - { 0x11131FFDA0D18D30ULL, { 0xC3, 0x2A, 0xD1, 0xB8, 0x25, 0x28, 0xE0, 0xA4, 0x56, 0x89, 0x7B, 0x3C, 0xE1, 0xC2, 0xD2, 0x7E } }, // 1.5.0.1.32795 Sombra - { 0xCAC6B95B2724144AULL, { 0x73, 0xE4, 0xBE, 0xA1, 0x45, 0xDF, 0x2B, 0x89, 0xB6, 0x5A, 0xEF, 0x02, 0xF8, 0x3F, 0xA2, 0x60 } }, // 1.5.0.1.32795 Ecopoint: Antarctica - { 0xB7DBC693758A5C36ULL, { 0xBC, 0x3A, 0x92, 0xBF, 0xE3, 0x02, 0x51, 0x8D, 0x91, 0xCC, 0x30, 0x79, 0x06, 0x71, 0xBF, 0x10 } }, // 1.5.0.1.32795 Genji Oni skin - { 0x90CA73B2CDE3164BULL, { 0x5C, 0xBF, 0xF1, 0x1F, 0x22, 0x72, 0x0B, 0xAC, 0xC2, 0xAE, 0x6A, 0xAD, 0x8F, 0xE5, 0x33, 0x17 } }, // 1.6.1.0.33236 Oasis map - { 0x6DD3212FB942714AULL, { 0xE0, 0x2C, 0x16, 0x43, 0x60, 0x2E, 0xC1, 0x6C, 0x3A, 0xE2, 0xA4, 0xD2, 0x54, 0xA0, 0x8F, 0xD9 } }, // 1.6.1.0.33236 - { 0x11DDB470ABCBA130ULL, { 0x66, 0x19, 0x87, 0x66, 0xB1, 0xC4, 0xAF, 0x75, 0x89, 0xEF, 0xD1, 0x3A, 0xD4, 0xDD, 0x66, 0x7A } }, // 1.6.1.0.33236 Winter Wonderland - { 0x5BEF27EEE95E0B4BULL, { 0x36, 0xBC, 0xD2, 0xB5, 0x51, 0xFF, 0x1C, 0x84, 0xAA, 0x3A, 0x39, 0x94, 0xCC, 0xEB, 0x03, 0x3E } }, // - { 0x9359B46E49D2DA42ULL, { 0x17, 0x3D, 0x65, 0xE7, 0xFC, 0xAE, 0x29, 0x8A, 0x93, 0x63, 0xBD, 0x6A, 0xA1, 0x89, 0xF2, 0x00 } }, // Diablo's 20th anniversary - { 0x1A46302EF8896F34ULL, { 0x80, 0x29, 0xAD, 0x54, 0x51, 0xD4, 0xBC, 0x18, 0xE9, 0xD0, 0xF5, 0xAC, 0x44, 0x9D, 0xC0, 0x55 } }, // 1.7.0.2.34156 Year of the Rooster - { 0x693529F7D40A064CULL, { 0xCE, 0x54, 0x87, 0x3C, 0x62, 0xDA, 0xA4, 0x8E, 0xFF, 0x27, 0xFC, 0xC0, 0x32, 0xBD, 0x07, 0xE3 } }, // 1.8.0.0.34470 CTF Maps - { 0x388B85AEEDCB685DULL, { 0xD9, 0x26, 0xE6, 0x59, 0xD0, 0x4A, 0x09, 0x6B, 0x24, 0xC1, 0x91, 0x51, 0x07, 0x6D, 0x37, 0x9A } }, // 1.8.0.0.34470 Numbani Update (Doomfist teaser) - { 0xE218F69AAC6C104DULL, { 0xF4, 0x3D, 0x12, 0xC9, 0x4A, 0x9A, 0x52, 0x84, 0x97, 0x97, 0x1F, 0x1C, 0xBE, 0x41, 0xAD, 0x4D } }, // 1.9.0.0.34986 Orisa - { 0xF432F0425363F250ULL, { 0xBA, 0x69, 0xF2, 0xB3, 0x3C, 0x27, 0x68, 0xF5, 0xF2, 0x9B, 0xFE, 0x78, 0xA5, 0xA1, 0xFA, 0xD5 } }, // 1.10.0.0.35455 Uprising - { 0x061D52F86830B35DULL, { 0xD7, 0x79, 0xF9, 0xC6, 0xCC, 0x9A, 0x4B, 0xE1, 0x03, 0xA4, 0xE9, 0x0A, 0x73, 0x38, 0xF7, 0x93 } }, // 1.10.0.0.35455 D.Va Officer Skin (HotS Nexus Challenge 2) - { 0x1275C84CF113EF65ULL, { 0xCF, 0x58, 0xB6, 0x93, 0x3E, 0xAF, 0x98, 0xAF, 0x53, 0xE7, 0x6F, 0x84, 0x26, 0xCC, 0x7E, 0x6C } }, // - { 0xD9C7C7AC0F14C868ULL, { 0x3A, 0xFD, 0xF6, 0x8E, 0x3A, 0x5D, 0x63, 0xBA, 0xBA, 0x1E, 0x68, 0x21, 0x88, 0x3F, 0x06, 0x7D } }, // - { 0xBD4E42661A432951ULL, { 0x6D, 0xE8, 0xE2, 0x8C, 0x85, 0x11, 0x64, 0x4D, 0x55, 0x95, 0xFC, 0x45, 0xE5, 0x35, 0x14, 0x72 } }, // 1.11.0.0.36376 Anniversary event - { 0xC43CB14355249451ULL, { 0x0E, 0xA2, 0xB4, 0x4F, 0x96, 0xA2, 0x69, 0xA3, 0x86, 0x85, 0x6D, 0x04, 0x9A, 0x3D, 0xEC, 0x86 } }, // 1.12.0.0.37104 Horizon Lunar Colony - { 0xE6D914F8E4744953ULL, { 0xC8, 0x47, 0x7C, 0x28, 0x9D, 0xCE, 0x66, 0xD9, 0x13, 0x65, 0x07, 0xA3, 0x3A, 0xA3, 0x33, 0x01 } }, // 1.13.0.0.37646 Doomfist - { 0x5694C503F8C80178ULL, { 0x7F, 0x4C, 0xF1, 0xC1, 0xFB, 0xBA, 0xD9, 0x2B, 0x18, 0x43, 0x36, 0xD6, 0x77, 0xEB, 0xF9, 0x37 } }, // 1.13.0.0.37646 Doomfist - { 0x21DBFD65F3E54269ULL, { 0xAB, 0x58, 0x0C, 0x38, 0x37, 0xCA, 0xF8, 0xA4, 0x61, 0xF2, 0x43, 0xA5, 0x66, 0xB2, 0xAE, 0x4D } }, // 1.13.0.0.37646 Summer Games 2017 - // { 0x27ABA5F88DD8D078ULL, {0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??}}, // 1.13.0.0.37646 - { 0x21E1F90E71D33C71ULL, { 0x32, 0x87, 0x42, 0x33, 0x91, 0x62, 0xB3, 0x26, 0x76, 0xC8, 0x03, 0xC2, 0x25, 0x59, 0x31, 0xA6 } }, // 1.14.1.0.39083 Deathmatch - { 0xD9CB055BCDD40B6EULL, { 0x49, 0xFB, 0x44, 0x77, 0xA4, 0xA0, 0x82, 0x53, 0x27, 0xE9, 0xA7, 0x36, 0x82, 0xBE, 0xCD, 0x0C } }, // 1.15.0.0.????? Junkertown - { 0x8175CE3C694C6659ULL, { 0xE3, 0xF3, 0xFA, 0x77, 0x26, 0xC7, 0x0D, 0x26, 0xAE, 0x13, 0x0D, 0x96, 0x9D, 0xDD, 0xF3, 0x99 } }, // 1.16.0.0.40011 Halloween 2017 - { 0xB8DE51690075435AULL, { 0xC0, 0x7E, 0x92, 0x60, 0xBB, 0x71, 0x12, 0x17, 0xE7, 0xDE, 0x6F, 0xED, 0x91, 0x1F, 0x42, 0x96 } }, // 1.16.0.0.????? Winston Blizzcon 2017 skin - { 0xF6CF23955B5D437DULL, { 0xAE, 0xBA, 0x22, 0x73, 0x28, 0xA5, 0xB0, 0xAA, 0x9F, 0x51, 0xDA, 0xE3, 0xF6, 0xA7, 0xDF, 0xE4 } }, // 1.17.0.2.41350 Moira - - // Streamed WoW keys - { 0xFA505078126ACB3EULL, { 0xBD, 0xC5, 0x18, 0x62, 0xAB, 0xED, 0x79, 0xB2, 0xDE, 0x48, 0xC8, 0xE7, 0xE6, 0x6C, 0x62, 0x00 } }, // 15 WOW-20740patch7.0.1_Beta - { 0xFF813F7D062AC0BCULL, { 0xAA, 0x0B, 0x5C, 0x77, 0xF0, 0x88, 0xCC, 0xC2, 0xD3, 0x90, 0x49, 0xBD, 0x26, 0x7F, 0x06, 0x6D } }, // 25 WOW-20740patch7.0.1_Beta - { 0xD1E9B5EDF9283668ULL, { 0x8E, 0x4A, 0x25, 0x79, 0x89, 0x4E, 0x38, 0xB4, 0xAB, 0x90, 0x58, 0xBA, 0x5C, 0x73, 0x28, 0xEE } }, // 39 WOW-20740patch7.0.1_Beta Enchanted Torch pet - { 0xB76729641141CB34ULL, { 0x98, 0x49, 0xD1, 0xAA, 0x7B, 0x1F, 0xD0, 0x98, 0x19, 0xC5, 0xC6, 0x62, 0x83, 0xA3, 0x26, 0xEC } }, // 40 WOW-20740patch7.0.1_Beta Enchanted Pen pet - { 0xFFB9469FF16E6BF8ULL, { 0xD5, 0x14, 0xBD, 0x19, 0x09, 0xA9, 0xE5, 0xDC, 0x87, 0x03, 0xF4, 0xB8, 0xBB, 0x1D, 0xFD, 0x9A } }, // 41 WOW-20740patch7.0.1_Beta - { 0x23C5B5DF837A226CULL, { 0x14, 0x06, 0xE2, 0xD8, 0x73, 0xB6, 0xFC, 0x99, 0x21, 0x7A, 0x18, 0x08, 0x81, 0xDA, 0x8D, 0x62 } }, // 42 WOW-20740patch7.0.1_Beta Enchanted Cauldron pet - // {0x3AE403EF40AC3037ULL, {0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??}}, // 51 WOW-21249patch7.0.3_Beta - { 0xE2854509C471C554ULL, { 0x43, 0x32, 0x65, 0xF0, 0xCD, 0xEB, 0x2F, 0x4E, 0x65, 0xC0, 0xEE, 0x70, 0x08, 0x71, 0x4D, 0x9E } }, // 52 WOW-21249patch7.0.3_Beta Warcraft movie items - { 0x8EE2CB82178C995AULL, { 0xDA, 0x6A, 0xFC, 0x98, 0x9E, 0xD6, 0xCA, 0xD2, 0x79, 0x88, 0x59, 0x92, 0xC0, 0x37, 0xA8, 0xEE } }, // 55 WOW-21531patch7.0.3_Beta BlizzCon 2016 Murlocs - { 0x5813810F4EC9B005ULL, { 0x01, 0xBE, 0x8B, 0x43, 0x14, 0x2D, 0xD9, 0x9A, 0x9E, 0x69, 0x0F, 0xAD, 0x28, 0x8B, 0x60, 0x82 } }, // 56 WOW-21531patch7.0.3_Beta Fel Kitten - { 0x7F9E217166ED43EAULL, { 0x05, 0xFC, 0x92, 0x7B, 0x9F, 0x4F, 0x5B, 0x05, 0x56, 0x81, 0x42, 0x91, 0x2A, 0x05, 0x2B, 0x0F } }, // 57 WOW-21531patch7.0.3_Beta Legion music - { 0xC4A8D364D23793F7ULL, { 0xD1, 0xAC, 0x20, 0xFD, 0x14, 0x95, 0x7F, 0xAB, 0xC2, 0x71, 0x96, 0xE9, 0xF6, 0xE7, 0x02, 0x4A } }, // 58 WOW-21691patch7.0.3_Beta Demon Hunter #1 cinematic (legion_dh1) - { 0x40A234AEBCF2C6E5ULL, { 0xC6, 0xC5, 0xF6, 0xC7, 0xF7, 0x35, 0xD7, 0xD9, 0x4C, 0x87, 0x26, 0x7F, 0xA4, 0x99, 0x4D, 0x45 } }, // 59 WOW-21691patch7.0.3_Beta Demon Hunter #2 cinematic (legion_dh2) - { 0x9CF7DFCFCBCE4AE5ULL, { 0x72, 0xA9, 0x7A, 0x24, 0xA9, 0x98, 0xE3, 0xA5, 0x50, 0x0F, 0x38, 0x71, 0xF3, 0x76, 0x28, 0xC0 } }, // 60 WOW-21691patch7.0.3_Beta Val'sharah #1 cinematic (legion_val_yd) - { 0x4E4BDECAB8485B4FULL, { 0x38, 0x32, 0xD7, 0xC4, 0x2A, 0xAC, 0x92, 0x68, 0xF0, 0x0B, 0xE7, 0xB6, 0xB4, 0x8E, 0xC9, 0xAF } }, // 61 WOW-21691patch7.0.3_Beta Val'sharah #2 cinematic (legion_val_yx) - { 0x94A50AC54EFF70E4ULL, { 0xC2, 0x50, 0x1A, 0x72, 0x65, 0x4B, 0x96, 0xF8, 0x63, 0x50, 0xC5, 0xA9, 0x27, 0x96, 0x2F, 0x7A } }, // 62 WOW-21691patch7.0.3_Beta Sylvanas warchief cinematic (legion_org_vs) - { 0xBA973B0E01DE1C2CULL, { 0xD8, 0x3B, 0xBC, 0xB4, 0x6C, 0xC4, 0x38, 0xB1, 0x7A, 0x48, 0xE7, 0x6C, 0x4F, 0x56, 0x54, 0xA3 } }, // 63 WOW-21691patch7.0.3_Beta Stormheim Sylvanas vs Greymane cinematic (legion_sth) - { 0x494A6F8E8E108BEFULL, { 0xF0, 0xFD, 0xE1, 0xD2, 0x9B, 0x27, 0x4F, 0x6E, 0x7D, 0xBD, 0xB7, 0xFF, 0x81, 0x5F, 0xE9, 0x10 } }, // 64 WOW-21691patch7.0.3_Beta Harbingers Gul'dan video (legion_hrb_g) - { 0x918D6DD0C3849002ULL, { 0x85, 0x70, 0x90, 0xD9, 0x26, 0xBB, 0x28, 0xAE, 0xDA, 0x4B, 0xF0, 0x28, 0xCA, 0xCC, 0x4B, 0xA3 } }, // 65 WOW-21691patch7.0.3_Beta Harbingers Khadgar video (legion_hrb_k) - { 0x0B5F6957915ADDCAULL, { 0x4D, 0xD0, 0xDC, 0x82, 0xB1, 0x01, 0xC8, 0x0A, 0xBA, 0xC0, 0xA4, 0xD5, 0x7E, 0x67, 0xF8, 0x59 } }, // 66 WOW-21691patch7.0.3_Beta Harbingers Illidan video (legion_hrb_i) - { 0x794F25C6CD8AB62BULL, { 0x76, 0x58, 0x3B, 0xDA, 0xCD, 0x52, 0x57, 0xA3, 0xF7, 0x3D, 0x15, 0x98, 0xA2, 0xCA, 0x2D, 0x99 } }, // 67 WOW-21846patch7.0.3_Beta Suramar cinematic (legion_su_i) - { 0xA9633A54C1673D21ULL, { 0x1F, 0x8D, 0x46, 0x7F, 0x5D, 0x6D, 0x41, 0x1F, 0x8A, 0x54, 0x8B, 0x63, 0x29, 0xA5, 0x08, 0x7E } }, // 68 WOW-21846patch7.0.3_Beta legion_su_r cinematic - { 0x5E5D896B3E163DEAULL, { 0x8A, 0xCE, 0x8D, 0xB1, 0x69, 0xE2, 0xF9, 0x8A, 0xC3, 0x6A, 0xD5, 0x2C, 0x08, 0x8E, 0x77, 0xC1 } }, // 69 WOW-21846patch7.0.3_Beta Broken Shore intro cinematic (legion_bs_i) - { 0x0EBE36B5010DFD7FULL, { 0x9A, 0x89, 0xCC, 0x7E, 0x3A, 0xCB, 0x29, 0xCF, 0x14, 0xC6, 0x0B, 0xC1, 0x3B, 0x1E, 0x46, 0x16 } }, // 70 WOW-21846patch7.0.3_Beta Alliance Broken Shore cinematic (legion_bs_a) - { 0x01E828CFFA450C0FULL, { 0x97, 0x2B, 0x6E, 0x74, 0x42, 0x0E, 0xC5, 0x19, 0xE6, 0xF9, 0xD9, 0x7D, 0x59, 0x4A, 0xA3, 0x7C } }, // 71 WOW-21846patch7.0.3_Beta Horde Broken Shore cinematic (legion_bs_h) - { 0x4A7BD170FE18E6AEULL, { 0xAB, 0x55, 0xAE, 0x1B, 0xF0, 0xC7, 0xC5, 0x19, 0xAF, 0xF0, 0x28, 0xC1, 0x56, 0x10, 0xA4, 0x5B } }, // 72 WOW-21846patch7.0.3_Beta Khadgar & Light's Heart cinematic (legion_iq_lv) - { 0x69549CB975E87C4FULL, { 0x7B, 0x6F, 0xA3, 0x82, 0xE1, 0xFA, 0xD1, 0x46, 0x5C, 0x85, 0x1E, 0x3F, 0x47, 0x34, 0xA1, 0xB3 } }, // 73 WOW-21846patch7.0.3_Beta legion_iq_id cinematic - { 0x460C92C372B2A166ULL, { 0x94, 0x6D, 0x56, 0x59, 0xF2, 0xFA, 0xF3, 0x27, 0xC0, 0xB7, 0xEC, 0x82, 0x8B, 0x74, 0x8A, 0xDB } }, // 74 WOW-21952patch7.0.3_Beta Stormheim Alliance cinematic (legion_g_a_sth) - { 0x8165D801CCA11962ULL, { 0xCD, 0x0C, 0x0F, 0xFA, 0xAD, 0x93, 0x63, 0xEC, 0x14, 0xDD, 0x25, 0xEC, 0xDD, 0x2A, 0x5B, 0x62 } }, // 75 WOW-21952patch7.0.3_Beta Stormheim Horde cinematic (legion_g_h_sth) - { 0xA3F1C999090ADAC9ULL, { 0xB7, 0x2F, 0xEF, 0x4A, 0x01, 0x48, 0x8A, 0x88, 0xFF, 0x02, 0x28, 0x0A, 0xA0, 0x7A, 0x92, 0xBB } }, // 81 WOW-22578patch7.1.0_PTR Firecat Mount - // {0x18AFDF5191923610ULL, {0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 82 WOW-22578patch7.1.0_PTR - // {0x3C258426058FBD93ULL, {0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 91 WOW-23436patch7.2.0_PTR - { 0x094E9A0474876B98ULL, { 0xE5, 0x33, 0xBB, 0x6D, 0x65, 0x72, 0x7A, 0x58, 0x32, 0x68, 0x0D, 0x62, 0x0B, 0x0B, 0xC1, 0x0B } }, // 92 WOW-23910patch7.2.5_PTR - { 0x3DB25CB86A40335EULL, { 0x02, 0x99, 0x0B, 0x12, 0x26, 0x0C, 0x1E, 0x9F, 0xDD, 0x73, 0xFE, 0x47, 0xCB, 0xAB, 0x70, 0x24 } }, // 93 WOW-23789patch7.2.0_PTR - { 0x0DCD81945F4B4686ULL, { 0x1B, 0x78, 0x9B, 0x87, 0xFB, 0x3C, 0x92, 0x38, 0xD5, 0x28, 0x99, 0x7B, 0xFA, 0xB4, 0x41, 0x86 } }, // 94 WOW-23789patch7.2.0_PTR - { 0x486A2A3A2803BE89ULL, { 0x32, 0x67, 0x9E, 0xA7, 0xB0, 0xF9, 0x9E, 0xBF, 0x4F, 0xA1, 0x70, 0xE8, 0x47, 0xEA, 0x43, 0x9A } }, // 95 WOW-23789patch7.2.0_PTR - { 0x71F69446AD848E06ULL, { 0xE7, 0x9A, 0xEB, 0x88, 0xB1, 0x50, 0x9F, 0x62, 0x8F, 0x38, 0x20, 0x82, 0x01, 0x74, 0x1C, 0x30 } }, // 97 WOW-24473patch7.3.0_PTR BlizzCon 2017 Mounts (AllianceShipMount and HordeZeppelinMount) - { 0x211FCD1265A928E9ULL, { 0xA7, 0x36, 0xFB, 0xF5, 0x8D, 0x58, 0x7B, 0x39, 0x72, 0xCE, 0x15, 0x4A, 0x86, 0xAE, 0x45, 0x40 } }, // 98 WOW-24473patch7.3.0_PTR "Shadow" fox pet (store) - { 0x0ADC9E327E42E98CULL, { 0x01, 0x7B, 0x34, 0x72, 0xC1, 0xDE, 0xE3, 0x04, 0xFA, 0x0B, 0x2F, 0xF8, 0xE5, 0x3F, 0xF7, 0xD6 } }, // 99 WOW-23910patch7.2.5_PTR - { 0xBAE9F621B60174F1ULL, { 0x38, 0xC3, 0xFB, 0x39, 0xB4, 0x97, 0x17, 0x60, 0xB4, 0xB9, 0x82, 0xFE, 0x9F, 0x09, 0x50, 0x14 } }, // 100 WOW-24473patch7.3.0_PTR Rejection of the Gift cinematic (legion_73_agi) - { 0x34DE1EEADC97115EULL, { 0x2E, 0x3A, 0x53, 0xD5, 0x9A, 0x49, 0x1E, 0x5C, 0xD1, 0x73, 0xF3, 0x37, 0xF7, 0xCD, 0x8C, 0x61 } }, // 101 WOW-24473patch7.3.0_PTR Resurrection of Alleria Windrunner cinematic (legion_73_avt) - // { 0xE07E107F1390A3DFULL, {0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 102 WOW-25079patch7.3.2_PTR Tottle battle pet, Raptor mount, Horse mount (104 files) - { 0x32690BF74DE12530ULL, { 0xA2, 0x55, 0x62, 0x10, 0xAE, 0x54, 0x22, 0xE6, 0xD6, 0x1E, 0xDA, 0xAF, 0x12, 0x2C, 0xB6, 0x37 } }, // 103 WOW-24781patch7.3.0_PTR legion_73_pan - { 0xBF3734B1DCB04696ULL, { 0x48, 0x94, 0x61, 0x23, 0x05, 0x0B, 0x00, 0xA7, 0xEF, 0xB1, 0xC0, 0x29, 0xEE, 0x6C, 0xC4, 0x38 } }, // 104 WOW-25079patch7.3.2_PTR legion_73_afn - { 0x74F4F78002A5A1BEULL, { 0xC1, 0x4E, 0xEC, 0x8D, 0x5A, 0xEE, 0xF9, 0x3F, 0xA8, 0x11, 0xD4, 0x50, 0xB4, 0xE4, 0x6E, 0x91 } }, // 105 WOW-25079patch7.3.2_PTR SilithusPhase01 map - // { 0x423F07656CA27D23ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // WOW-25600patch7.3.5_PTR - // { 0x0691678F83E8A75DULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // WOW-25600patch7.3.5_PTR - // { 0xC02C78F40BEF5998ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // WOW-25600patch7.3.5_PTR - // { 0x324498590F550556ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // WOW-25600patch7.3.5_PTR - // { 0x8E00C6F405873583ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // WOW-25600patch7.3.5_PTR - // { 0x78482170E4CFD4A6ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // WOW-25600patch7.3.5_PTR - // { 0xB1EB52A64BFAF7BFULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // WOW-25600patch7.3.5_PTR - { 0, { 0 } } + // Key Name Encryption key Seen in + // ---------------------- ------------------------------------------------------------------------------------------------ ----------- + + // Battle.net app + { 0x2C547F26A2613E01ULL, { 0x37, 0xC5, 0x0C, 0x10, 0x2D, 0x4C, 0x9E, 0x3A, 0x5A, 0xC0, 0x69, 0xF0, 0x72, 0xB1, 0x41, 0x7D } }, // Battle.net App Alpha 1.5.0 + + // Starcraft +// { 0xD0CAE11366CEEA83ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? }}, // 1.12.3.2609 (build 45364) + + // Overwatch + { 0xFB680CB6A8BF81F3ULL, { 0x62, 0xD9, 0x0E, 0xFA, 0x7F, 0x36, 0xD7, 0x1C, 0x39, 0x8A, 0xE2, 0xF1, 0xFE, 0x37, 0xBD, 0xB9 } }, // 0.8.0.24919_retailx64 (hardcoded) + { 0x402CD9D8D6BFED98ULL, { 0xAE, 0xB0, 0xEA, 0xDE, 0xA4, 0x76, 0x12, 0xFE, 0x6C, 0x04, 0x1A, 0x03, 0x95, 0x8D, 0xF2, 0x41 } }, // 0.8.0.24919_retailx64 (hardcoded) + { 0xDBD3371554F60306ULL, { 0x34, 0xE3, 0x97, 0xAC, 0xE6, 0xDD, 0x30, 0xEE, 0xFD, 0xC9, 0x8A, 0x2A, 0xB0, 0x93, 0xCD, 0x3C } }, // 0.8.0.24919_retailx64 (streamed from server) + { 0x11A9203C9881710AULL, { 0x2E, 0x2C, 0xB8, 0xC3, 0x97, 0xC2, 0xF2, 0x4E, 0xD0, 0xB5, 0xE4, 0x52, 0xF1, 0x8D, 0xC2, 0x67 } }, // 0.8.0.24919_retailx64 (streamed from server) + { 0xA19C4F859F6EFA54ULL, { 0x01, 0x96, 0xCB, 0x6F, 0x5E, 0xCB, 0xAD, 0x7C, 0xB5, 0x28, 0x38, 0x91, 0xB9, 0x71, 0x2B, 0x4B } }, // 0.8.0.24919_retailx64 (streamed from server) + { 0x87AEBBC9C4E6B601ULL, { 0x68, 0x5E, 0x86, 0xC6, 0x06, 0x3D, 0xFD, 0xA6, 0xC9, 0xE8, 0x52, 0x98, 0x07, 0x6B, 0x3D, 0x42 } }, // 0.8.0.24919_retailx64 (streamed from server) + { 0xDEE3A0521EFF6F03ULL, { 0xAD, 0x74, 0x0C, 0xE3, 0xFF, 0xFF, 0x92, 0x31, 0x46, 0x81, 0x26, 0x98, 0x57, 0x08, 0xE1, 0xB9 } }, // 0.8.0.24919_retailx64 (streamed from server) + { 0x8C9106108AA84F07ULL, { 0x53, 0xD8, 0x59, 0xDD, 0xA2, 0x63, 0x5A, 0x38, 0xDC, 0x32, 0xE7, 0x2B, 0x11, 0xB3, 0x2F, 0x29 } }, // 0.8.0.24919_retailx64 (streamed from server) + { 0x49166D358A34D815ULL, { 0x66, 0x78, 0x68, 0xCD, 0x94, 0xEA, 0x01, 0x35, 0xB9, 0xB1, 0x6C, 0x93, 0xB1, 0x12, 0x4A, 0xBA } }, // 0.8.0.24919_retailx64 (streamed from server) + { 0x1463A87356778D14ULL, { 0x69, 0xBD, 0x2A, 0x78, 0xD0, 0x5C, 0x50, 0x3E, 0x93, 0x99, 0x49, 0x59, 0xB3, 0x0E, 0x5A, 0xEC } }, // ? 1.0.3.0 (streamed from server) + { 0x5E152DE44DFBEE01ULL, { 0xE4, 0x5A, 0x17, 0x93, 0xB3, 0x7E, 0xE3, 0x1A, 0x8E, 0xB8, 0x5C, 0xEE, 0x0E, 0xEE, 0x1B, 0x68 } }, // ? 1.0.3.0 (streamed from server) + { 0x9B1F39EE592CA415ULL, { 0x54, 0xA9, 0x9F, 0x08, 0x1C, 0xAD, 0x0D, 0x08, 0xF7, 0xE3, 0x36, 0xF4, 0x36, 0x8E, 0x89, 0x4C } }, // ? 1.0.3.0 (streamed from server) + { 0x24C8B75890AD5917ULL, { 0x31, 0x10, 0x0C, 0x00, 0xFD, 0xE0, 0xCE, 0x18, 0xBB, 0xB3, 0x3F, 0x3A, 0xC1, 0x5B, 0x30, 0x9F } }, // ? 1.0.3.0 (included in game) + { 0xEA658B75FDD4890FULL, { 0xDE, 0xC7, 0xA4, 0xE7, 0x21, 0xF4, 0x25, 0xD1, 0x33, 0x03, 0x98, 0x95, 0xC3, 0x60, 0x36, 0xF8 } }, // ? 1.0.3.0 (included in game) + { 0x026FDCDF8C5C7105ULL, { 0x8F, 0x41, 0x80, 0x9D, 0xA5, 0x53, 0x66, 0xAD, 0x41, 0x6D, 0x3C, 0x33, 0x74, 0x59, 0xEE, 0xE3 } }, // (included in game) + { 0xCAE3FAC925F20402ULL, { 0x98, 0xB7, 0x8E, 0x87, 0x74, 0xBF, 0x27, 0x50, 0x93, 0xCB, 0x1B, 0x5F, 0xC7, 0x14, 0x51, 0x1B } }, // (included in game) + { 0x061581CA8496C80CULL, { 0xDA, 0x2E, 0xF5, 0x05, 0x2D, 0xB9, 0x17, 0x38, 0x0B, 0x8A, 0xA6, 0xEF, 0x7A, 0x5F, 0x8E, 0x6A } }, // + { 0xBE2CB0FAD3698123ULL, { 0x90, 0x2A, 0x12, 0x85, 0x83, 0x6C, 0xE6, 0xDA, 0x58, 0x95, 0x02, 0x0D, 0xD6, 0x03, 0xB0, 0x65 } }, // + { 0x57A5A33B226B8E0AULL, { 0xFD, 0xFC, 0x35, 0xC9, 0x9B, 0x9D, 0xB1, 0x1A, 0x32, 0x62, 0x60, 0xCA, 0x24, 0x6A, 0xCB, 0x41 } }, // 1.1.0.0.30200 Ana + { 0x42B9AB1AF5015920ULL, { 0xC6, 0x87, 0x78, 0x82, 0x3C, 0x96, 0x4C, 0x6F, 0x24, 0x7A, 0xCC, 0x0F, 0x4A, 0x25, 0x84, 0xF8 } }, // 1.2.0.1.30684 Summer Games + { 0x4F0FE18E9FA1AC1AULL, { 0x89, 0x38, 0x1C, 0x74, 0x8F, 0x65, 0x31, 0xBB, 0xFC, 0xD9, 0x77, 0x53, 0xD0, 0x6C, 0xC3, 0xCD } }, // 1.2.0.1.30684 + { 0x7758B2CF1E4E3E1BULL, { 0x3D, 0xE6, 0x0D, 0x37, 0xC6, 0x64, 0x72, 0x35, 0x95, 0xF2, 0x7C, 0x5C, 0xDB, 0xF0, 0x8B, 0xFA } }, // 1.2.0.1.30684 + { 0xE5317801B3561125ULL, { 0x7D, 0xD0, 0x51, 0x19, 0x9F, 0x84, 0x01, 0xF9, 0x5E, 0x4C, 0x03, 0xC8, 0x84, 0xDC, 0xEA, 0x33 } }, // 1.4.0.2.32143 Halloween Terror + { 0x16B866D7BA3A8036ULL, { 0x13, 0x95, 0xE8, 0x82, 0xBF, 0x25, 0xB4, 0x81, 0xF6, 0x1A, 0x4D, 0x62, 0x11, 0x41, 0xDA, 0x6E } }, // 1.4.1.0.31804 Bastion Blizzcon 2016 skin + { 0x11131FFDA0D18D30ULL, { 0xC3, 0x2A, 0xD1, 0xB8, 0x25, 0x28, 0xE0, 0xA4, 0x56, 0x89, 0x7B, 0x3C, 0xE1, 0xC2, 0xD2, 0x7E } }, // 1.5.0.1.32795 Sombra + { 0xCAC6B95B2724144AULL, { 0x73, 0xE4, 0xBE, 0xA1, 0x45, 0xDF, 0x2B, 0x89, 0xB6, 0x5A, 0xEF, 0x02, 0xF8, 0x3F, 0xA2, 0x60 } }, // 1.5.0.1.32795 Ecopoint: Antarctica + { 0xB7DBC693758A5C36ULL, { 0xBC, 0x3A, 0x92, 0xBF, 0xE3, 0x02, 0x51, 0x8D, 0x91, 0xCC, 0x30, 0x79, 0x06, 0x71, 0xBF, 0x10 } }, // 1.5.0.1.32795 Genji Oni skin + { 0x90CA73B2CDE3164BULL, { 0x5C, 0xBF, 0xF1, 0x1F, 0x22, 0x72, 0x0B, 0xAC, 0xC2, 0xAE, 0x6A, 0xAD, 0x8F, 0xE5, 0x33, 0x17 } }, // 1.6.1.0.33236 Oasis map + { 0x6DD3212FB942714AULL, { 0xE0, 0x2C, 0x16, 0x43, 0x60, 0x2E, 0xC1, 0x6C, 0x3A, 0xE2, 0xA4, 0xD2, 0x54, 0xA0, 0x8F, 0xD9 } }, // 1.6.1.0.33236 + { 0x11DDB470ABCBA130ULL, { 0x66, 0x19, 0x87, 0x66, 0xB1, 0xC4, 0xAF, 0x75, 0x89, 0xEF, 0xD1, 0x3A, 0xD4, 0xDD, 0x66, 0x7A } }, // 1.6.1.0.33236 Winter Wonderland + { 0x5BEF27EEE95E0B4BULL, { 0x36, 0xBC, 0xD2, 0xB5, 0x51, 0xFF, 0x1C, 0x84, 0xAA, 0x3A, 0x39, 0x94, 0xCC, 0xEB, 0x03, 0x3E } }, // + { 0x9359B46E49D2DA42ULL, { 0x17, 0x3D, 0x65, 0xE7, 0xFC, 0xAE, 0x29, 0x8A, 0x93, 0x63, 0xBD, 0x6A, 0xA1, 0x89, 0xF2, 0x00 } }, // Diablo's 20th anniversary + { 0x1A46302EF8896F34ULL, { 0x80, 0x29, 0xAD, 0x54, 0x51, 0xD4, 0xBC, 0x18, 0xE9, 0xD0, 0xF5, 0xAC, 0x44, 0x9D, 0xC0, 0x55 } }, // 1.7.0.2.34156 Year of the Rooster + { 0x693529F7D40A064CULL, { 0xCE, 0x54, 0x87, 0x3C, 0x62, 0xDA, 0xA4, 0x8E, 0xFF, 0x27, 0xFC, 0xC0, 0x32, 0xBD, 0x07, 0xE3 } }, // 1.8.0.0.34470 CTF Maps + { 0x388B85AEEDCB685DULL, { 0xD9, 0x26, 0xE6, 0x59, 0xD0, 0x4A, 0x09, 0x6B, 0x24, 0xC1, 0x91, 0x51, 0x07, 0x6D, 0x37, 0x9A } }, // 1.8.0.0.34470 Numbani Update (Doomfist teaser) + { 0xE218F69AAC6C104DULL, { 0xF4, 0x3D, 0x12, 0xC9, 0x4A, 0x9A, 0x52, 0x84, 0x97, 0x97, 0x1F, 0x1C, 0xBE, 0x41, 0xAD, 0x4D } }, // 1.9.0.0.34986 Orisa + { 0xF432F0425363F250ULL, { 0xBA, 0x69, 0xF2, 0xB3, 0x3C, 0x27, 0x68, 0xF5, 0xF2, 0x9B, 0xFE, 0x78, 0xA5, 0xA1, 0xFA, 0xD5 } }, // 1.10.0.0.35455 Uprising + { 0x061D52F86830B35DULL, { 0xD7, 0x79, 0xF9, 0xC6, 0xCC, 0x9A, 0x4B, 0xE1, 0x03, 0xA4, 0xE9, 0x0A, 0x73, 0x38, 0xF7, 0x93 } }, // 1.10.0.0.35455 D.Va Officer Skin (HotS Nexus Challenge 2) + { 0x1275C84CF113EF65ULL, { 0xCF, 0x58, 0xB6, 0x93, 0x3E, 0xAF, 0x98, 0xAF, 0x53, 0xE7, 0x6F, 0x84, 0x26, 0xCC, 0x7E, 0x6C } }, // + { 0xD9C7C7AC0F14C868ULL, { 0x3A, 0xFD, 0xF6, 0x8E, 0x3A, 0x5D, 0x63, 0xBA, 0xBA, 0x1E, 0x68, 0x21, 0x88, 0x3F, 0x06, 0x7D } }, // + { 0xBD4E42661A432951ULL, { 0x6D, 0xE8, 0xE2, 0x8C, 0x85, 0x11, 0x64, 0x4D, 0x55, 0x95, 0xFC, 0x45, 0xE5, 0x35, 0x14, 0x72 } }, // 1.11.0.0.36376 Anniversary event + { 0xC43CB14355249451ULL, { 0x0E, 0xA2, 0xB4, 0x4F, 0x96, 0xA2, 0x69, 0xA3, 0x86, 0x85, 0x6D, 0x04, 0x9A, 0x3D, 0xEC, 0x86 } }, // 1.12.0.0.37104 Horizon Lunar Colony + { 0xE6D914F8E4744953ULL, { 0xC8, 0x47, 0x7C, 0x28, 0x9D, 0xCE, 0x66, 0xD9, 0x13, 0x65, 0x07, 0xA3, 0x3A, 0xA3, 0x33, 0x01 } }, // 1.13.0.0.37646 Doomfist + { 0x5694C503F8C80178ULL, { 0x7F, 0x4C, 0xF1, 0xC1, 0xFB, 0xBA, 0xD9, 0x2B, 0x18, 0x43, 0x36, 0xD6, 0x77, 0xEB, 0xF9, 0x37 } }, // 1.13.0.0.37646 Doomfist + { 0x21DBFD65F3E54269ULL, { 0xAB, 0x58, 0x0C, 0x38, 0x37, 0xCA, 0xF8, 0xA4, 0x61, 0xF2, 0x43, 0xA5, 0x66, 0xB2, 0xAE, 0x4D } }, // 1.13.0.0.37646 Summer Games 2017 +// { 0x27ABA5F88DD8D078ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 1.13.0.0.37646 + { 0x21E1F90E71D33C71ULL, { 0x32, 0x87, 0x42, 0x33, 0x91, 0x62, 0xB3, 0x26, 0x76, 0xC8, 0x03, 0xC2, 0x25, 0x59, 0x31, 0xA6 } }, // 1.14.1.0.39083 Deathmatch + { 0xD9CB055BCDD40B6EULL, { 0x49, 0xFB, 0x44, 0x77, 0xA4, 0xA0, 0x82, 0x53, 0x27, 0xE9, 0xA7, 0x36, 0x82, 0xBE, 0xCD, 0x0C } }, // 1.15.0.0.????? Junkertown + { 0x8175CE3C694C6659ULL, { 0xE3, 0xF3, 0xFA, 0x77, 0x26, 0xC7, 0x0D, 0x26, 0xAE, 0x13, 0x0D, 0x96, 0x9D, 0xDD, 0xF3, 0x99 } }, // 1.16.0.0.40011 Halloween 2017 + { 0xB8DE51690075435AULL, { 0xC0, 0x7E, 0x92, 0x60, 0xBB, 0x71, 0x12, 0x17, 0xE7, 0xDE, 0x6F, 0xED, 0x91, 0x1F, 0x42, 0x96 } }, // 1.16.0.0.????? Winston Blizzcon 2017 skin + { 0xF6CF23955B5D437DULL, { 0xAE, 0xBA, 0x22, 0x73, 0x28, 0xA5, 0xB0, 0xAA, 0x9F, 0x51, 0xDA, 0xE3, 0xF6, 0xA7, 0xDF, 0xE4 } }, // 1.17.0.2.41350 Moira + { 0x0E4D9426F2891F5CULL, { 0x9F, 0xF0, 0x64, 0xC3, 0x8B, 0xE5, 0x2C, 0xCD, 0xF7, 0x37, 0x48, 0x18, 0x0F, 0x62, 0x82, 0x05 } }, // 1.18.1.2.42076 Winter Wonderland 2017 + { 0x9240BA6A2A0CF684ULL, { 0xDF, 0x2E, 0x37, 0xD7, 0x8B, 0x43, 0x10, 0x8F, 0xA6, 0x24, 0x20, 0x68, 0xB7, 0x0D, 0x1F, 0x65 } }, // 1.19.1.3.42563 Overwatch League + { 0x82297FBAB7F5EB80ULL, { 0xB5, 0x34, 0xC2, 0x09, 0x65, 0x85, 0x2F, 0xB1, 0x5A, 0xEC, 0xAC, 0x17, 0xE3, 0x81, 0xB4, 0x17 } }, // 1.19.1.3.42563 Jan 2017 Lootbox Update + { 0x9ADF00AA1A174A69ULL, { 0x9A, 0x4A, 0xC8, 0x99, 0x26, 0x1A, 0x2F, 0x1C, 0x69, 0x69, 0xF3, 0x93, 0x97, 0xC3, 0x58, 0xE7 } }, // 1.19.1.3.42563 Blizzard World + { 0xCFA05AA76B49F881ULL, { 0x52, 0x6D, 0xDD, 0xEF, 0x19, 0xBF, 0x37, 0x3C, 0x25, 0xB6, 0x29, 0xA3, 0x34, 0xCD, 0x72, 0x37 } }, // 1.19.1.3.42563 WoW's Battle For Azeroth Preorder + { 0x493455579DA0B18EULL, { 0xC0, 0xBA, 0xBF, 0x72, 0xAD, 0x2C, 0x05, 0xDF, 0xC1, 0x40, 0x17, 0xD1, 0xAD, 0xBF, 0x59, 0x77 } }, // 1.19.3.1.43036 Inaugural Season Spray/Icon ?? + { 0x6362C5AD65DAE686ULL, { 0x62, 0xF6, 0x03, 0xD5, 0x39, 0x0F, 0x76, 0x3E, 0xD5, 0x17, 0x73, 0xF0, 0x16, 0x4F, 0xED, 0xB5 } }, // 1.19.3.1.43036 White/Gray OWL Skins ?? + { 0x8162E5313A9C135DULL, { 0xF4, 0x07, 0x83, 0x4D, 0x95, 0x21, 0x58, 0x7C, 0x50, 0x12, 0xB0, 0xA5, 0x9D, 0x7E, 0x06, 0x4B } }, // 1.20.0.2.43435 Lunar New Year 2018 (Dog) / Ayutthaya / Comp CTF +// { 0x68EAE8FDC008C381ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 1.20.0.2.43435 + { 0xF412C6327C4BF091ULL, { 0x6F, 0xAF, 0xC6, 0x48, 0xCB, 0xF1, 0xC2, 0x11, 0x5B, 0x76, 0x95, 0x93, 0xC1, 0x70, 0xE7, 0x32 } }, // 1.20.0.2.43435 SC2 20th Anniversary (Kerrigan Skin) + { 0x3B3ED0874091B174ULL, { 0x5D, 0x09, 0xC2, 0x68, 0x8B, 0x1D, 0x9F, 0x1A, 0x4D, 0xB6, 0x46, 0x02, 0xC1, 0x66, 0x1D, 0x24 } }, // 1.21.?.?.????? Brigitte + { 0x37FD04E05D2A6292ULL, { 0xF0, 0x64, 0x55, 0xE5, 0x6C, 0xD1, 0x44, 0x91, 0x42, 0x95, 0xF2, 0xEF, 0x15, 0x3D, 0x23, 0xBA } }, // 1.21.?.?.????? Brigitte Cosmetics + { 0xC0DDC77552BE5794ULL, { 0xF2, 0xBB, 0x7F, 0x35, 0x99, 0x0E, 0x29, 0x00, 0xCB, 0xD8, 0x77, 0xB4, 0xD3, 0xA7, 0x13, 0x9C } }, // 1.22.?.?.????? OWL away skins + { 0x68D8EB839DC15D75ULL, { 0x29, 0xAF, 0xFE, 0xCA, 0x52, 0x99, 0xC4, 0x14, 0x0A, 0x12, 0xA6, 0x6F, 0x95, 0x4E, 0xF1, 0xE3 } }, // 1.22.?.?.????? Archives 2018 (Retribution) + { 0x209F33BBAC9D1295ULL, { 0xBD, 0x53, 0x54, 0x38, 0xD0, 0xCD, 0xEE, 0x0E, 0x95, 0x67, 0xE0, 0xEF, 0x67, 0x1C, 0x80, 0x9F } }, // 1.23.?.?.????? Rialto + { 0xA55F8C6F20454D94ULL, { 0x42, 0xD7, 0x62, 0x85, 0x41, 0x24, 0x61, 0xB0, 0xC7, 0x5A, 0xB7, 0x5F, 0xB5, 0x2F, 0x59, 0x6E } }, // 1.23.?.?.????? Mercy BCRF Items + { 0x3EEEDB8E7C29A09BULL, { 0x83, 0x7A, 0xC7, 0x93, 0x05, 0xE4, 0xBF, 0xBA, 0x3B, 0x22, 0x26, 0xF1, 0xB9, 0x82, 0x00, 0xBF } }, // 1.24.?.?.????? Anniversary 2018 Map/Items + { 0x22C1AF6758F8449EULL, { 0x28, 0xAA, 0x1B, 0xD2, 0xB9, 0xA1, 0xE3, 0x63, 0x39, 0x89, 0xB1, 0xBB, 0xF6, 0x4A, 0xEA, 0xC4 } }, // 1.26.?.?.????? Emily / Comp Season 11 / Comp 3v3 Items + { 0x11B2E01B9331799EULL, { 0x9A, 0x1C, 0x99, 0x30, 0x3D, 0x6A, 0x58, 0x97, 0x8E, 0x29, 0xC9, 0x88, 0x73, 0x32, 0x7A, 0x6A } }, // 1.26.?.?.????? Wrecking Ball + { 0x8498337C740329B3ULL, { 0xEC, 0x73, 0xD6, 0x63, 0xE3, 0xFC, 0x72, 0x41, 0x6B, 0x3E, 0x46, 0x79, 0x15, 0x70, 0x8B, 0x4F } }, // 1.26.?.?.????? Wrecking Ball Cosmetics + { 0xE6E8BCABE3CC96C1ULL, { 0x57, 0x72, 0x7E, 0x52, 0x60, 0x06, 0x65, 0xEA, 0xC0, 0x2B, 0xD8, 0x7F, 0x06, 0x92, 0x89, 0x8F } }, // 1.26.?.?.????? OWL Grand Finals Unlocks / Lucio Emote + { 0x5D4AC0DC6F3113BAULL, { 0xD1, 0xC9, 0xF1, 0xFF, 0x69, 0x58, 0x5D, 0x13, 0x98, 0xEB, 0xA0, 0x46, 0x34, 0x81, 0xF5, 0xCF } }, // 1.27.?.?.????? Summer Games 2018 + { 0x27F9D85973DCD5AFULL, { 0xC5, 0xFE, 0x10, 0x15, 0xBC, 0xE0, 0xB7, 0x84, 0x8F, 0x02, 0x28, 0x68, 0xAF, 0xF6, 0x54, 0xD1 } }, // 1.27.?.?.????? Summer Games 2018 + { 0x67AAD845CC0F03BDULL, { 0x6C, 0xD8, 0xAD, 0x3F, 0x37, 0xF5, 0x4A, 0xBE, 0xC7, 0x63, 0x02, 0x94, 0xD4, 0x90, 0x41, 0xBF } }, // 1.27.?.?.????? D.Va Nano Cola Challenge + { 0xCA13F0C79042A1A0ULL, { 0xFC, 0xD8, 0x9C, 0xE8, 0x81, 0x2E, 0x63, 0x46, 0x07, 0x6F, 0xC8, 0x2D, 0xD7, 0xA9, 0x24, 0x87 } }, // 1.28.?.?.????? Busan + { 0xC4D84093A32684BDULL, { 0x38, 0xE1, 0x82, 0x42, 0x3E, 0xED, 0xD8, 0xE3, 0xF5, 0x7A, 0xC1, 0xD4, 0x07, 0xB4, 0x70, 0xD0 } }, // 1.28.?.?.????? Blizzcon 2018 Sombra Demon Hunter Skin + { 0x0BFE5A2B3C606BA1ULL, { 0xD6, 0x41, 0x9B, 0x8E, 0x42, 0x82, 0x0B, 0x0B, 0x24, 0xE0, 0x8D, 0xA4, 0x44, 0xA0, 0x68, 0x22 } }, // 1.29.?.?.????? Halloween Terror 2018 + { 0x402CD9D8D6BFED98ULL, { 0xAE, 0xB0, 0xEA, 0xDE, 0xA4, 0x76, 0x12, 0xFE, 0x6C, 0x04, 0x1A, 0x03, 0x95, 0x8D, 0xF2, 0x41 } }, // 1.29.?.?.????? + { 0xF1CBDF48147D26C6ULL, { 0x4B, 0x69, 0x44, 0x69, 0x51, 0x57, 0xD4, 0x3D, 0x33, 0xE4, 0x0B, 0x56, 0x92, 0x44, 0x5A, 0xDB } }, // 1.30.?.?.????? 1.30 + World Cup Viewer + { 0x01A48CFAE25F85CDULL, { 0x60, 0xD7, 0x7A, 0x58, 0x06, 0x2D, 0x03, 0xDC, 0x69, 0x3C, 0x01, 0x95, 0x4D, 0xD1, 0x80, 0x21 } }, // 1.30.?.?.????? 1.30 + World Cup Viewer + { 0xFEBBF66DAEF6C9BEULL, { 0x4A, 0x22, 0x0A, 0xE3, 0xA6, 0x80, 0x8E, 0xD2, 0x69, 0x74, 0x10, 0xC9, 0x4C, 0x1C, 0xE9, 0x70 } }, // 1.30.0.1.????? Ashe + { 0x2AD4834DAB3986ABULL, { 0xEA, 0x69, 0x71, 0xF7, 0x8A, 0xBE, 0xBD, 0x2A, 0xF8, 0x83, 0xD4, 0x6A, 0x54, 0x86, 0xF3, 0x9F } }, // 1.31.?.?.????? Winter 2018 + { 0xD89B24D62F00A04EULL, { 0xC3, 0xA4, 0xD0, 0x10, 0xAA, 0xA7, 0x28, 0x7A, 0x3E, 0xAC, 0xCD, 0x45, 0xED, 0x47, 0x13, 0x45 } }, // 1.31.?.?.????? Bastet Challenge + { 0x32DDC40236DAEA7BULL, { 0x2D, 0xBD, 0xE4, 0xFB, 0x9F, 0xDA, 0x77, 0x6A, 0xA2, 0x94, 0x87, 0x08, 0x54, 0xFE, 0x9B, 0x02 } }, // 1.31.?.?.????? Lunar New Year 2019 (Pig) + { 0xF481EFC2302EE415ULL, { 0x37, 0xA7, 0xF2, 0xB8, 0x7D, 0x0B, 0x8B, 0x70, 0x04, 0x56, 0xC6, 0xA9, 0x2C, 0x71, 0xD6, 0xDD } }, // 1.33.?.?.????? Paris Map + { 0xD1AC8C1903524D9AULL, { 0xD7, 0x81, 0xD0, 0xAA, 0x35, 0xE5, 0xC1, 0x06, 0xBC, 0xA7, 0xCF, 0x01, 0xDE, 0xBD, 0x14, 0x94 } }, // 1.34.0.1.55918 Baptiste + { 0x71EEBE93590AA903ULL, { 0x0C, 0xCD, 0x10, 0xD4, 0x55, 0x3E, 0xEC, 0x7E, 0x97, 0xFD, 0x36, 0xA9, 0xE8, 0xAD, 0xF0, 0xFF } }, // 1.34.0.1.55918 Baptiste Cosmetics + + // Streamed WoW keys + { 0xFA505078126ACB3EULL, { 0xBD, 0xC5, 0x18, 0x62, 0xAB, 0xED, 0x79, 0xB2, 0xDE, 0x48, 0xC8, 0xE7, 0xE6, 0x6C, 0x62, 0x00 } }, // 15 WOW-20740patch7.0.1_Beta <not used between 7.0 and 7.3> + { 0xFF813F7D062AC0BCULL, { 0xAA, 0x0B, 0x5C, 0x77, 0xF0, 0x88, 0xCC, 0xC2, 0xD3, 0x90, 0x49, 0xBD, 0x26, 0x7F, 0x06, 0x6D } }, // 25 WOW-20740patch7.0.1_Beta <not used between 7.0 and 7.3> + { 0xD1E9B5EDF9283668ULL, { 0x8E, 0x4A, 0x25, 0x79, 0x89, 0x4E, 0x38, 0xB4, 0xAB, 0x90, 0x58, 0xBA, 0x5C, 0x73, 0x28, 0xEE } }, // 39 WOW-20740patch7.0.1_Beta Enchanted Torch pet + { 0xB76729641141CB34ULL, { 0x98, 0x49, 0xD1, 0xAA, 0x7B, 0x1F, 0xD0, 0x98, 0x19, 0xC5, 0xC6, 0x62, 0x83, 0xA3, 0x26, 0xEC } }, // 40 WOW-20740patch7.0.1_Beta Enchanted Pen pet + { 0xFFB9469FF16E6BF8ULL, { 0xD5, 0x14, 0xBD, 0x19, 0x09, 0xA9, 0xE5, 0xDC, 0x87, 0x03, 0xF4, 0xB8, 0xBB, 0x1D, 0xFD, 0x9A } }, // 41 WOW-20740patch7.0.1_Beta <not used between 7.0 and 7.3> + { 0x23C5B5DF837A226CULL, { 0x14, 0x06, 0xE2, 0xD8, 0x73, 0xB6, 0xFC, 0x99, 0x21, 0x7A, 0x18, 0x08, 0x81, 0xDA, 0x8D, 0x62 } }, // 42 WOW-20740patch7.0.1_Beta Enchanted Cauldron pet +// { 0x3AE403EF40AC3037ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 51 WOW-21249patch7.0.3_Beta <not used between 7.0 and 7.3> + { 0xE2854509C471C554ULL, { 0x43, 0x32, 0x65, 0xF0, 0xCD, 0xEB, 0x2F, 0x4E, 0x65, 0xC0, 0xEE, 0x70, 0x08, 0x71, 0x4D, 0x9E } }, // 52 WOW-21249patch7.0.3_Beta Warcraft movie items + { 0x8EE2CB82178C995AULL, { 0xDA, 0x6A, 0xFC, 0x98, 0x9E, 0xD6, 0xCA, 0xD2, 0x79, 0x88, 0x59, 0x92, 0xC0, 0x37, 0xA8, 0xEE } }, // 55 WOW-21531patch7.0.3_Beta BlizzCon 2016 Murlocs + { 0x5813810F4EC9B005ULL, { 0x01, 0xBE, 0x8B, 0x43, 0x14, 0x2D, 0xD9, 0x9A, 0x9E, 0x69, 0x0F, 0xAD, 0x28, 0x8B, 0x60, 0x82 } }, // 56 WOW-21531patch7.0.3_Beta Fel Kitten + { 0x7F9E217166ED43EAULL, { 0x05, 0xFC, 0x92, 0x7B, 0x9F, 0x4F, 0x5B, 0x05, 0x56, 0x81, 0x42, 0x91, 0x2A, 0x05, 0x2B, 0x0F } }, // 57 WOW-21531patch7.0.3_Beta Legion music <not used in 7.3> + { 0xC4A8D364D23793F7ULL, { 0xD1, 0xAC, 0x20, 0xFD, 0x14, 0x95, 0x7F, 0xAB, 0xC2, 0x71, 0x96, 0xE9, 0xF6, 0xE7, 0x02, 0x4A } }, // 58 WOW-21691patch7.0.3_Beta Demon Hunter #1 cinematic (legion_dh1) + { 0x40A234AEBCF2C6E5ULL, { 0xC6, 0xC5, 0xF6, 0xC7, 0xF7, 0x35, 0xD7, 0xD9, 0x4C, 0x87, 0x26, 0x7F, 0xA4, 0x99, 0x4D, 0x45 } }, // 59 WOW-21691patch7.0.3_Beta Demon Hunter #2 cinematic (legion_dh2) + { 0x9CF7DFCFCBCE4AE5ULL, { 0x72, 0xA9, 0x7A, 0x24, 0xA9, 0x98, 0xE3, 0xA5, 0x50, 0x0F, 0x38, 0x71, 0xF3, 0x76, 0x28, 0xC0 } }, // 60 WOW-21691patch7.0.3_Beta Val'sharah #1 cinematic (legion_val_yd) + { 0x4E4BDECAB8485B4FULL, { 0x38, 0x32, 0xD7, 0xC4, 0x2A, 0xAC, 0x92, 0x68, 0xF0, 0x0B, 0xE7, 0xB6, 0xB4, 0x8E, 0xC9, 0xAF } }, // 61 WOW-21691patch7.0.3_Beta Val'sharah #2 cinematic (legion_val_yx) + { 0x94A50AC54EFF70E4ULL, { 0xC2, 0x50, 0x1A, 0x72, 0x65, 0x4B, 0x96, 0xF8, 0x63, 0x50, 0xC5, 0xA9, 0x27, 0x96, 0x2F, 0x7A } }, // 62 WOW-21691patch7.0.3_Beta Sylvanas warchief cinematic (legion_org_vs) + { 0xBA973B0E01DE1C2CULL, { 0xD8, 0x3B, 0xBC, 0xB4, 0x6C, 0xC4, 0x38, 0xB1, 0x7A, 0x48, 0xE7, 0x6C, 0x4F, 0x56, 0x54, 0xA3 } }, // 63 WOW-21691patch7.0.3_Beta Stormheim Sylvanas vs Greymane cinematic (legion_sth) + { 0x494A6F8E8E108BEFULL, { 0xF0, 0xFD, 0xE1, 0xD2, 0x9B, 0x27, 0x4F, 0x6E, 0x7D, 0xBD, 0xB7, 0xFF, 0x81, 0x5F, 0xE9, 0x10 } }, // 64 WOW-21691patch7.0.3_Beta Harbingers Gul'dan video (legion_hrb_g) + { 0x918D6DD0C3849002ULL, { 0x85, 0x70, 0x90, 0xD9, 0x26, 0xBB, 0x28, 0xAE, 0xDA, 0x4B, 0xF0, 0x28, 0xCA, 0xCC, 0x4B, 0xA3 } }, // 65 WOW-21691patch7.0.3_Beta Harbingers Khadgar video (legion_hrb_k) + { 0x0B5F6957915ADDCAULL, { 0x4D, 0xD0, 0xDC, 0x82, 0xB1, 0x01, 0xC8, 0x0A, 0xBA, 0xC0, 0xA4, 0xD5, 0x7E, 0x67, 0xF8, 0x59 } }, // 66 WOW-21691patch7.0.3_Beta Harbingers Illidan video (legion_hrb_i) + { 0x794F25C6CD8AB62BULL, { 0x76, 0x58, 0x3B, 0xDA, 0xCD, 0x52, 0x57, 0xA3, 0xF7, 0x3D, 0x15, 0x98, 0xA2, 0xCA, 0x2D, 0x99 } }, // 67 WOW-21846patch7.0.3_Beta Suramar cinematic (legion_su_i) + { 0xA9633A54C1673D21ULL, { 0x1F, 0x8D, 0x46, 0x7F, 0x5D, 0x6D, 0x41, 0x1F, 0x8A, 0x54, 0x8B, 0x63, 0x29, 0xA5, 0x08, 0x7E } }, // 68 WOW-21846patch7.0.3_Beta legion_su_r cinematic + { 0x5E5D896B3E163DEAULL, { 0x8A, 0xCE, 0x8D, 0xB1, 0x69, 0xE2, 0xF9, 0x8A, 0xC3, 0x6A, 0xD5, 0x2C, 0x08, 0x8E, 0x77, 0xC1 } }, // 69 WOW-21846patch7.0.3_Beta Broken Shore intro cinematic (legion_bs_i) + { 0x0EBE36B5010DFD7FULL, { 0x9A, 0x89, 0xCC, 0x7E, 0x3A, 0xCB, 0x29, 0xCF, 0x14, 0xC6, 0x0B, 0xC1, 0x3B, 0x1E, 0x46, 0x16 } }, // 70 WOW-21846patch7.0.3_Beta Alliance Broken Shore cinematic (legion_bs_a) + { 0x01E828CFFA450C0FULL, { 0x97, 0x2B, 0x6E, 0x74, 0x42, 0x0E, 0xC5, 0x19, 0xE6, 0xF9, 0xD9, 0x7D, 0x59, 0x4A, 0xA3, 0x7C } }, // 71 WOW-21846patch7.0.3_Beta Horde Broken Shore cinematic (legion_bs_h) + { 0x4A7BD170FE18E6AEULL, { 0xAB, 0x55, 0xAE, 0x1B, 0xF0, 0xC7, 0xC5, 0x19, 0xAF, 0xF0, 0x28, 0xC1, 0x56, 0x10, 0xA4, 0x5B } }, // 72 WOW-21846patch7.0.3_Beta Khadgar & Light's Heart cinematic (legion_iq_lv) + { 0x69549CB975E87C4FULL, { 0x7B, 0x6F, 0xA3, 0x82, 0xE1, 0xFA, 0xD1, 0x46, 0x5C, 0x85, 0x1E, 0x3F, 0x47, 0x34, 0xA1, 0xB3 } }, // 73 WOW-21846patch7.0.3_Beta legion_iq_id cinematic + { 0x460C92C372B2A166ULL, { 0x94, 0x6D, 0x56, 0x59, 0xF2, 0xFA, 0xF3, 0x27, 0xC0, 0xB7, 0xEC, 0x82, 0x8B, 0x74, 0x8A, 0xDB } }, // 74 WOW-21952patch7.0.3_Beta Stormheim Alliance cinematic (legion_g_a_sth) + { 0x8165D801CCA11962ULL, { 0xCD, 0x0C, 0x0F, 0xFA, 0xAD, 0x93, 0x63, 0xEC, 0x14, 0xDD, 0x25, 0xEC, 0xDD, 0x2A, 0x5B, 0x62 } }, // 75 WOW-21952patch7.0.3_Beta Stormheim Horde cinematic (legion_g_h_sth) + { 0xA3F1C999090ADAC9ULL, { 0xB7, 0x2F, 0xEF, 0x4A, 0x01, 0x48, 0x8A, 0x88, 0xFF, 0x02, 0x28, 0x0A, 0xA0, 0x7A, 0x92, 0xBB } }, // 81 WOW-22578patch7.1.0_PTR Firecat Mount +// { 0x18AFDF5191923610ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 82 WOW-22578patch7.1.0_PTR <not used between 7.1 and 7.3> +// { 0x3C258426058FBD93ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 91 WOW-23436patch7.2.0_PTR <not used between 7.2 and 7.3> + { 0x094E9A0474876B98ULL, { 0xE5, 0x33, 0xBB, 0x6D, 0x65, 0x72, 0x7A, 0x58, 0x32, 0x68, 0x0D, 0x62, 0x0B, 0x0B, 0xC1, 0x0B } }, // 92 WOW-23910patch7.2.5_PTR shadowstalkerpanthermount, shadowstalkerpantherpet + { 0x3DB25CB86A40335EULL, { 0x02, 0x99, 0x0B, 0x12, 0x26, 0x0C, 0x1E, 0x9F, 0xDD, 0x73, 0xFE, 0x47, 0xCB, 0xAB, 0x70, 0x24 } }, // 93 WOW-23789patch7.2.0_PTR legion_72_ots + { 0x0DCD81945F4B4686ULL, { 0x1B, 0x78, 0x9B, 0x87, 0xFB, 0x3C, 0x92, 0x38, 0xD5, 0x28, 0x99, 0x7B, 0xFA, 0xB4, 0x41, 0x86 } }, // 94 WOW-23789patch7.2.0_PTR legion_72_tst + { 0x486A2A3A2803BE89ULL, { 0x32, 0x67, 0x9E, 0xA7, 0xB0, 0xF9, 0x9E, 0xBF, 0x4F, 0xA1, 0x70, 0xE8, 0x47, 0xEA, 0x43, 0x9A } }, // 95 WOW-23789patch7.2.0_PTR legion_72_ars + { 0x71F69446AD848E06ULL, { 0xE7, 0x9A, 0xEB, 0x88, 0xB1, 0x50, 0x9F, 0x62, 0x8F, 0x38, 0x20, 0x82, 0x01, 0x74, 0x1C, 0x30 } }, // 97 WOW-24473patch7.3.0_PTR BlizzCon 2017 Mounts (AllianceShipMount and HordeZeppelinMount) + { 0x211FCD1265A928E9ULL, { 0xA7, 0x36, 0xFB, 0xF5, 0x8D, 0x58, 0x7B, 0x39, 0x72, 0xCE, 0x15, 0x4A, 0x86, 0xAE, 0x45, 0x40 } }, // 98 WOW-24473patch7.3.0_PTR "Shadow" fox pet (store) + { 0x0ADC9E327E42E98CULL, { 0x01, 0x7B, 0x34, 0x72, 0xC1, 0xDE, 0xE3, 0x04, 0xFA, 0x0B, 0x2F, 0xF8, 0xE5, 0x3F, 0xF7, 0xD6 } }, // 99 WOW-23910patch7.2.5_PTR legion_72_tsf + { 0xBAE9F621B60174F1ULL, { 0x38, 0xC3, 0xFB, 0x39, 0xB4, 0x97, 0x17, 0x60, 0xB4, 0xB9, 0x82, 0xFE, 0x9F, 0x09, 0x50, 0x14 } }, // 100 WOW-24727patch7.3.0_PTR Rejection of the Gift cinematic (legion_73_agi) + { 0x34DE1EEADC97115EULL, { 0x2E, 0x3A, 0x53, 0xD5, 0x9A, 0x49, 0x1E, 0x5C, 0xD1, 0x73, 0xF3, 0x37, 0xF7, 0xCD, 0x8C, 0x61 } }, // 101 WOW-24727patch7.3.0_PTR Resurrection of Alleria Windrunner cinematic (legion_73_avt) + { 0xE07E107F1390A3DFULL, { 0x29, 0x0D, 0x27, 0xB0, 0xE8, 0x71, 0xF8, 0xC5, 0xB1, 0x4A, 0x14, 0xE5, 0x14, 0xD0, 0xF0, 0xD9 } }, // 102 WOW-25079patch7.3.2_PTR Tottle battle pet, Raptor mount, Horse mount (104 files) + { 0x32690BF74DE12530ULL, { 0xA2, 0x55, 0x62, 0x10, 0xAE, 0x54, 0x22, 0xE6, 0xD6, 0x1E, 0xDA, 0xAF, 0x12, 0x2C, 0xB6, 0x37 } }, // 103 WOW-24781patch7.3.0_PTR legion_73_pan + { 0xBF3734B1DCB04696ULL, { 0x48, 0x94, 0x61, 0x23, 0x05, 0x0B, 0x00, 0xA7, 0xEF, 0xB1, 0xC0, 0x29, 0xEE, 0x6C, 0xC4, 0x38 } }, // 104 WOW-25079patch7.3.2_PTR legion_73_afn + { 0x74F4F78002A5A1BEULL, { 0xC1, 0x4E, 0xEC, 0x8D, 0x5A, 0xEE, 0xF9, 0x3F, 0xA8, 0x11, 0xD4, 0x50, 0xB4, 0xE4, 0x6E, 0x91 } }, // 105 WOW-25079patch7.3.2_PTR SilithusPhase01 map +// { 0x423F07656CA27D23ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 107 WOW-25600patch7.3.5_PTR bltestmap +// { 0x0691678F83E8A75DULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 108 WOW-25600patch7.3.5_PTR filedataid 1782602-1782603 +// { 0x324498590F550556ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 109 WOW-25600patch7.3.5_PTR filedataid 1782615-1782619 +// { 0xC02C78F40BEF5998ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 110 WOW-25600patch7.3.5_PTR test/testtexture.blp (fdid 1782613) +// { 0x47011412CCAAB541ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 111 WOW-25600patch7.3.5_PTR unused in 25600 +// { 0x23B6F5764CE2DDD6ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 112 WOW-25600patch7.3.5_PTR unused in 25600 +// { 0x8E00C6F405873583ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 113 WOW-25600patch7.3.5_PTR filedataid 1783470-1783472 + { 0x78482170E4CFD4A6ULL, { 0x76, 0x85, 0x40, 0xC2, 0x0A, 0x5B, 0x15, 0x35, 0x83, 0xAD, 0x7F, 0x53, 0x13, 0x0C, 0x58, 0xFE } }, // 114 WOW-25600patch7.3.5_PTR Magni Bronzebeard VO + { 0xB1EB52A64BFAF7BFULL, { 0x45, 0x81, 0x33, 0xAA, 0x43, 0x94, 0x9A, 0x14, 0x16, 0x32, 0xC4, 0xF8, 0x59, 0x6D, 0xE2, 0xB0 } }, // 115 WOW-25600patch7.3.5_PTR dogmount, 50 files + { 0xFC6F20EE98D208F6ULL, { 0x57, 0x79, 0x0E, 0x48, 0xD3, 0x55, 0x00, 0xE7, 0x0D, 0xF8, 0x12, 0x59, 0x4F, 0x50, 0x7B, 0xE7 } }, // 117 WOW-25632patch7.3.5_PTR shop stuff + { 0x402CFABF2020D9B7ULL, { 0x67, 0x19, 0x7B, 0xCD, 0x9D, 0x0E, 0xF0, 0xC4, 0x08, 0x53, 0x78, 0xFA, 0xA6, 0x9A, 0x32, 0x64 } }, // 118 WOW-25678patch7.3.5_PTR filedataid 1854762 + { 0x6FA0420E902B4FBEULL, { 0x27, 0xB7, 0x50, 0x18, 0x4E, 0x53, 0x29, 0xC4, 0xE4, 0x45, 0x5C, 0xBD, 0x3E, 0x1F, 0xD5, 0xAB } }, // 119 WOW-25744patch7.3.5_PTR legion_735_epa / legion_735_eph + { 0x1076074F2B350A2DULL, { 0x88, 0xBF, 0x0C, 0xD0, 0xD5, 0xBA, 0x15, 0x9A, 0xE7, 0xCB, 0x91, 0x6A, 0xFB, 0xE1, 0x38, 0x65 } }, // 121 WOW-26287patch8.0.1_Beta skiff + { 0x816F00C1322CDF52ULL, { 0x6F, 0x83, 0x22, 0x99, 0xA7, 0x57, 0x89, 0x57, 0xEE, 0x86, 0xB7, 0xF9, 0xF1, 0x5B, 0x01, 0x88 } }, // 122 WOW-26287patch8.0.1_Beta snowkid + { 0xDDD295C82E60DB3CULL, { 0x34, 0x29, 0xCC, 0x59, 0x27, 0xD1, 0x62, 0x97, 0x65, 0x97, 0x4F, 0xD9, 0xAF, 0xAB, 0x75, 0x80 } }, // 123 WOW-26287patch8.0.1_Beta redbird + { 0x83E96F07F259F799ULL, { 0x91, 0xF7, 0xD0, 0xE7, 0xA0, 0x2C, 0xDE, 0x0D, 0xE0, 0xBD, 0x36, 0x7F, 0xAB, 0xCB, 0x8A, 0x6E } }, // 124 WOW-26522patch8.0.1_Beta BlizzCon 2018 (Alliance and Horde banners and cloaks) + { 0x49FBFE8A717F03D5ULL, { 0xC7, 0x43, 0x77, 0x70, 0xCF, 0x15, 0x3A, 0x31, 0x35, 0xFA, 0x6D, 0xC5, 0xE4, 0xC8, 0x5E, 0x65 } }, // 225 WOW-27826patch8.1.0_PTR Meatwagon mount (Warcraft 3: Reforged) + { 0xC1E5D7408A7D4484ULL, { 0xA7, 0xD8, 0x8E, 0x52, 0x74, 0x9F, 0xA5, 0x45, 0x9D, 0x64, 0x45, 0x23, 0xF8, 0x35, 0x96, 0x51 } }, // 226 WOW-26871patch8.0.1_Beta Sylvanas Warbringer cinematic + { 0xE46276EB9E1A9854ULL, { 0xCC, 0xCA, 0x36, 0xE3, 0x02, 0xF9, 0x45, 0x9B, 0x1D, 0x60, 0x52, 0x6A, 0x31, 0xBE, 0x77, 0xC8 } }, // 227 WOW-26871patch8.0.1_Beta ltc_a, ltc_h and ltt cinematics + { 0xD245B671DD78648CULL, { 0x19, 0xDC, 0xB4, 0xD4, 0x5A, 0x65, 0x8B, 0x54, 0x35, 0x1D, 0xB7, 0xDD, 0xC8, 0x1D, 0xE7, 0x9E } }, // 228 WOW-26871patch8.0.1_Beta stz, zia, kta, jnm & ja cinematics + { 0x4C596E12D36DDFC3ULL, { 0xB8, 0x73, 0x19, 0x26, 0x38, 0x94, 0x99, 0xCB, 0xD4, 0xAD, 0xBF, 0x50, 0x06, 0xCA, 0x03, 0x91 } }, // 229 WOW-26871patch8.0.1_Beta bar cinematic + { 0x0C9ABD5081C06411ULL, { 0x25, 0xA7, 0x7C, 0xD8, 0x00, 0x19, 0x7E, 0xE6, 0xA3, 0x2D, 0xD6, 0x3F, 0x04, 0xE1, 0x15, 0xFA } }, // 230 WOW-26871patch8.0.1_Beta zcf cinematic + { 0x3C6243057F3D9B24ULL, { 0x58, 0xAE, 0x3E, 0x06, 0x42, 0x10, 0xE3, 0xED, 0xF9, 0xC1, 0x25, 0x9C, 0xDE, 0x91, 0x4C, 0x5D } }, // 231 WOW-26871patch8.0.1_Beta ktf cinematic + { 0x7827FBE24427E27DULL, { 0x34, 0xA4, 0x32, 0x04, 0x20, 0x73, 0xCD, 0x0B, 0x51, 0x62, 0x70, 0x68, 0xD2, 0xE0, 0xBD, 0x3E } }, // 232 WOW-26871patch8.0.1_Beta rot cinematic + { 0xFAF9237E1186CF66ULL, { 0xAE, 0x78, 0x78, 0x40, 0x04, 0x1E, 0x9B, 0x41, 0x98, 0xF4, 0x79, 0x71, 0x4D, 0xAD, 0x56, 0x2C } }, // 233 WOW-28048patch8.1.0_PTR encrypted db2 sections (battle pet?) +// { 0x5DD92EE32BBF9ABDULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 234 WOW-27004patch8.0.1_Subm filedataid 2238294 + { 0x0B68A7AF5F85F7EEULL, { 0x27, 0xAA, 0x01, 0x10, 0x82, 0xF5, 0xE8, 0xBB, 0xBD, 0x71, 0xD1, 0xBA, 0x04, 0xF6, 0xAB, 0xA4 } }, // 236 WOW-28151patch8.1.0_PTR encrypted06 Flying pig mount +// { 0x01531713C83FCC39ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 237 WOW-28151patch8.1.0_PTR fdid 2460009, 2460732 +// { 0x76E4F6739A35E8D7ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 238 WOW-28294patch8.1.0_PTR starts at fdid 2492654, total of 12 fdids + { 0x66033F28DC01923CULL, { 0x9F, 0x95, 0x19, 0x86, 0x14, 0x90, 0xC5, 0xA9, 0xFF, 0xD4, 0xD8, 0x2A, 0x6D, 0x00, 0x67, 0xDB } }, // 239 WOW-28294patch8.1.0_PTR vulpine familiar mount + { 0xFCF34A9B05AE7E6AULL, { 0xE7, 0xC2, 0xC8, 0xF7, 0x7E, 0x30, 0xAC, 0x24, 0x0F, 0x39, 0xEC, 0x23, 0x97, 0x12, 0x96, 0xE5 } }, // 240 WOW-28151patch8.1.0_PTR fdid 2468985, 2471011, 2471012, 2471014, 2471016, 2471018, 2530045 + { 0xE2F6BD41298A2AB9ULL, { 0xC5, 0xDC, 0x1B, 0xB4, 0x3B, 0x8C, 0xF3, 0xF0, 0x85, 0xD6, 0x98, 0x68, 0x26, 0xB9, 0x28, 0xEC } }, // 241 WOW-28151patch8.1.0_PTR fdid 2468988, 2471019, 2471020, 2471021, 2471022, 2471023 + { 0x14C4257E557B49A1ULL, { 0x06, 0x4A, 0x97, 0x09, 0xF4, 0x2D, 0x50, 0xCB, 0x5F, 0x8B, 0x94, 0xBC, 0x1A, 0xCF, 0xDD, 0x5D } }, // 242 WOW-28440patch8.1.0_PTR dor cinematic + { 0x1254E65319C6EEFFULL, { 0x79, 0xD2, 0xB3, 0xD1, 0xCC, 0xB0, 0x15, 0x47, 0x4E, 0x71, 0x58, 0x81, 0x38, 0x64, 0xB8, 0xE6 } }, // 243 WOW-28440patch8.1.0_PTR akt cinematic +// { 0xC8753773ADF1174CULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 244 WOW-28938patch8.1.5_PTR starts at fdid 2615771, total of 14 fdids +// { 0x2170BCAA9FA96E22ULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 245 WOW-28938patch8.1.5_PTR alpaca mount +// { 0x75485627AA225F4DULL, { 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x??, 0x?? } }, // 246 WOW-28938patch8.1.5_PTR fdid 2741546, 2741548, 2741549 + { 0x08717B15BF3C7955ULL, { 0x4B, 0x06, 0xBF, 0x9D, 0x17, 0x66, 0x3C, 0xEB, 0x33, 0x12, 0xEA, 0x3C, 0x69, 0xFB, 0xC5, 0xDD } }, // 248 WOW-29220patch8.1.5_PTR fdid 2823166 + { 0x9FD609902B4B2E07ULL, { 0xAB, 0xE0, 0xC5, 0xF9, 0xC1, 0x23, 0xE6, 0xE2, 0x4E, 0x7B, 0xEA, 0x43, 0xC2, 0xBF, 0x00, 0xAC } }, // 250 WOW-29418patch8.1.5_PTR dpr cinematic }; - -static const char * szKeyConstant16 = "expand 16-byte k"; -static const char * szKeyConstant32 = "expand 32-byte k"; //----------------------------------------------------------------------------- // Local functions @@ -159,19 +232,6 @@ static DWORD Rol32(DWORD dwValue, DWORD dwRolCount) return (dwValue << dwRolCount) | (dwValue >> (32 - dwRolCount)); } -static LPBYTE FindCascKey(ULONGLONG KeyName) -{ - // Search the known keys - for(size_t i = 0; CascKeys[i].KeyName != 0; i++) - { - if(CascKeys[i].KeyName == KeyName) - return CascKeys[i].Key; - } - - // Key not found - return NULL; -} - static void Initialize(PCASC_SALSA20 pState, LPBYTE pbKey, DWORD cbKeyLength, LPBYTE pbVector) { const char * szConstants = (cbKeyLength == 32) ? szKeyConstant32 : szKeyConstant16; @@ -296,7 +356,35 @@ static int Decrypt_Salsa20(LPBYTE pbOutBuffer, LPBYTE pbInBuffer, size_t cbInBuf //----------------------------------------------------------------------------- // Public functions -int CascDecrypt(LPBYTE pbOutBuffer, PDWORD pcbOutBuffer, LPBYTE pbInBuffer, DWORD cbInBuffer, DWORD dwFrameIndex) +int CascLoadEncryptionKeys(TCascStorage * hs) +{ + size_t nKeyCount = (sizeof(CascKeys) / sizeof(CASC_ENCRYPTION_KEY)); + size_t nMaxItems = nKeyCount + CASC_EXTRA_KEYS; + int nError; + + // Create fast map of KeyName -> Key + nError = hs->EncryptionKeys.Create(nMaxItems, sizeof(ULONGLONG), FIELD_OFFSET(CASC_ENCRYPTION_KEY, KeyName)); + if(nError != ERROR_SUCCESS) + return nError; + + // Insert all static keys + for (size_t i = 0; i < nKeyCount; i++) + hs->EncryptionKeys.InsertObject(&CascKeys[i], &CascKeys[i].KeyName); + + // Create array for extra keys + nError = hs->ExtraKeysList.Create<CASC_ENCRYPTION_KEY>(CASC_EXTRA_KEYS); + return nError; +} + +LPBYTE CascFindKey(TCascStorage * hs, ULONGLONG KeyName) +{ + PCASC_ENCRYPTION_KEY pKey; + + pKey = (PCASC_ENCRYPTION_KEY)hs->EncryptionKeys.FindObject(&KeyName); + return (pKey != NULL) ? pKey->Key : NULL; +} + +int CascDecrypt(TCascStorage * hs, LPBYTE pbOutBuffer, PDWORD pcbOutBuffer, LPBYTE pbInBuffer, DWORD cbInBuffer, DWORD dwFrameIndex) { ULONGLONG KeyName = 0; LPBYTE pbBufferEnd = pbInBuffer + cbInBuffer; @@ -347,14 +435,14 @@ int CascDecrypt(LPBYTE pbOutBuffer, PDWORD pcbOutBuffer, LPBYTE pbInBuffer, DWOR return ERROR_INSUFFICIENT_BUFFER; // Check if we know the key - pbKey = FindCascKey(KeyName); + pbKey = CascFindKey(hs, KeyName); if(pbKey == NULL) return ERROR_FILE_ENCRYPTED; // Shuffle the Vector with the block index // Note that there's no point to go beyond 32 bits, unless the file has // more than 0xFFFFFFFF frames. - for(int i = 0; i < sizeof(dwFrameIndex); i++) + for(size_t i = 0; i < sizeof(dwFrameIndex); i++) { Vector[i] = Vector[i] ^ (BYTE)((dwFrameIndex >> dwShift) & 0xFF); dwShift += 8; @@ -392,3 +480,38 @@ int CascDirectCopy(LPBYTE pbOutBuffer, PDWORD pcbOutBuffer, LPBYTE pbInBuffer, D return ERROR_SUCCESS; } +bool WINAPI CascAddEncryptionKey(HANDLE hStorage, ULONGLONG KeyName, LPBYTE Key) +{ + PCASC_ENCRYPTION_KEY pEncKey; + TCascStorage * hs; + + // Validate the storage handle + hs = TCascStorage::IsValid(hStorage); + if (hs == NULL) + { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + // Don't allow more than CASC_EXTRA_KEYS keys + if (hs->ExtraKeysList.ItemCount() >= CASC_EXTRA_KEYS) + { + SetLastError(ERROR_INSUFFICIENT_BUFFER); + return false; + } + + // Insert the key to the array + pEncKey = (PCASC_ENCRYPTION_KEY)hs->ExtraKeysList.Insert(1); + if (pEncKey == NULL) + { + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + return false; + } + + // Fill the key + memcpy(pEncKey->Key, Key, sizeof(pEncKey->Key)); + pEncKey->KeyName = KeyName; + + // Also insert the key to the map + return hs->EncryptionKeys.InsertObject(pEncKey, &pEncKey->KeyName); +} diff --git a/dep/CascLib/src/CascDumpData.cpp b/dep/CascLib/src/CascDumpData.cpp index e6b4265d76b..40e791f7a15 100644 --- a/dep/CascLib/src/CascDumpData.cpp +++ b/dep/CascLib/src/CascDumpData.cpp @@ -11,47 +11,80 @@ #define __CASCLIB_SELF__ #include "CascLib.h" #include "CascCommon.h" -#include "CascMndx.h" #ifdef _DEBUG // The entire feature is only valid for debug purposes //----------------------------------------------------------------------------- // Forward definitions -//LPBYTE VerifyLocaleBlock(PROOT_BLOCK_INFO pBlockInfo, LPBYTE pbFilePointer, LPBYTE pbFileEnd); +int CaptureEncodingHeader(CASC_ENCODING_HEADER & EnHeader, LPBYTE pbFileData, size_t cbFileData); +int CaptureDownloadHeader(CASC_DOWNLOAD_HEADER & DlHeader, LPBYTE pbFileData, size_t cbFileData); +int CaptureDownloadEntry(CASC_DOWNLOAD_HEADER & DlHeader, CASC_DOWNLOAD_ENTRY & DlEntry, LPBYTE pbFilePtr, LPBYTE pbFileEnd); +int CaptureDownloadTag(CASC_DOWNLOAD_HEADER & DlHeader, CASC_TAG_ENTRY1 & DlTag, LPBYTE pbFilePtr, LPBYTE pbFileEnd); //----------------------------------------------------------------------------- -// Sort compare functions +// Local functions -static int CompareIndexEntries_FilePos(const void *, const void * pvIndexEntry1, const void * pvIndexEntry2) +static char * StringFromLPTSTR(const TCHAR * szString, char * szBuffer, size_t cchBuffer) { - PCASC_INDEX_ENTRY pIndexEntry1 = (PCASC_INDEX_ENTRY)pvIndexEntry1; - PCASC_INDEX_ENTRY pIndexEntry2 = (PCASC_INDEX_ENTRY)pvIndexEntry2; - ULONGLONG FileOffset1 = ConvertBytesToInteger_5(pIndexEntry1->FileOffsetBE); - ULONGLONG FileOffset2 = ConvertBytesToInteger_5(pIndexEntry2->FileOffsetBE); - DWORD ArchIndex1 = (DWORD)(FileOffset1 >> 0x1E); - DWORD ArchIndex2 = (DWORD)(FileOffset2 >> 0x1E); - - // First, compare the archive index - if(ArchIndex1 < ArchIndex2) - return -1; - if(ArchIndex1 > ArchIndex2) - return +1; - - // Second, compare the archive offset - FileOffset1 &= 0x3FFFFFFF; - FileOffset2 &= 0x3FFFFFFF; - if(FileOffset1 < FileOffset2) - return -1; - if(FileOffset1 > FileOffset2) - return +1; - - return 0; + char * szSaveBuffer = szBuffer; + char * szBufferEnd = szBuffer + cchBuffer - 1; + + while (szBuffer < szBufferEnd && szString[0] != 0) + *szBuffer++ = (char)*szString++; + szBuffer[0] = 0; + + return szSaveBuffer; } -//----------------------------------------------------------------------------- -// Public functions +// Either opens a dump file or returns "stdout" +static FILE * OpenDumpFile(const char * szDumpFile) +{ + if(szDumpFile != NULL) + { + return fopen(szDumpFile, "wt"); + } + else + { + return stdout; + } +} + +// Closes the dump file if it was open by OpenDumpFile +static void CloseDumpFile(const char * szDumpFile, FILE * fp) +{ + if(szDumpFile != NULL && fp != NULL) + fclose(fp); +} + +static void DumpKey(FILE * fp, const char * szInFormat, LPBYTE pbData, size_t cbData) +{ + const char * szFormatSpec; + LPBYTE pbDataEnd = pbData + cbData; + char szFormat[0x100]; + char szKey[MD5_STRING_SIZE + 1]; + + // First line: Copy the line with the complete format + CascStrCopy(szFormat, _countof(szFormat), szInFormat); + szFormatSpec = strstr(szFormat, "%s"); + // Dump all keys, every one on a new line + while(pbData < pbDataEnd) + { + // Fump the line + StringFromBinary(pbData, MD5_HASH_SIZE, szKey); + fprintf(fp, szFormat, szKey); + + // If there will be more lines, then we clear the entire part until "%s" + if(szFormatSpec != NULL) + memset(szFormat, ' ', (szFormatSpec - szFormat)); + + // Move pointers + pbData += MD5_HASH_SIZE; + } +} + +/* void CascDumpSparseArray(const char * szFileName, void * pvSparseArray) { TSparseArray * pSparseArray = (TSparseArray *)pvSparseArray; @@ -93,8 +126,8 @@ void CascDumpNameFragTable(const char * szFileName, void * pMarFile) fp = fopen(szFileName, "wt"); if(fp != NULL) { - PNAME_FRAG pNameTable = pDB->NameFragTable.NameFragArray; - const char * szNames = pDB->IndexStruct_174.NameFragments.CharArray; + PNAME_FRAG pNameTable = pDB->NameFragTable.ItemArray; + const char * szNames = pDB->IndexStruct_174.ItemArray; const char * szLastEntry; char szMatchType[0x100]; @@ -114,9 +147,9 @@ void CascDumpNameFragTable(const char * szFileName, void * pMarFile) { // Prepare the entry if(IS_SINGLE_CHAR_MATCH(pDB->NameFragTable, i)) - sprintf(szMatchType, "SINGLE_CHAR (\'%c\')", (pNameTable->FragOffs & 0xFF)); + CascStrPrintf(szMatchType, _countof(szMatchType), "SINGLE_CHAR (\'%c\')", (pNameTable->FragOffs & 0xFF)); else - sprintf(szMatchType, "NAME_FRAGMT (\"%s\")", szNames + pNameTable->FragOffs); + CascStrPrintf(szMatchType, _countof(szMatchType), "NAME_FRAGMT (\"%s\")", szNames + pNameTable->FragOffs); } // Dump the entry @@ -169,147 +202,269 @@ void CascDumpFileNames(const char * szFileName, void * pvMarFile) Struct1C.FreeStruct40(); } -void CascDumpIndexEntry( - TCascStorage * /* hs */, - TDumpContext * dc, - PCASC_INDEX_ENTRY pIndexEntry, - int /* nDumpLevel */) + +void DumpEKeyEntries(TCascStorage * hs, FILE * fp) { - if(pIndexEntry != NULL) + // Dump header + fprintf(fp, "=== Ekey Entries ============================================================\n"); + + // Dump index entries from all index files + for(int file = 0; file < CASC_INDEX_COUNT; file++) { - ULONGLONG FileOffset = ConvertBytesToInteger_5(pIndexEntry->FileOffsetBE); - DWORD ArchIndex = (DWORD)(FileOffset >> 0x1E); - DWORD FileSize = ConvertBytesToInteger_4_LE(pIndexEntry->FileSizeLE); - - // Mask the file offset - FileOffset &= 0x3FFFFFFF; - dump_print(dc, " data.%03u at 0x%08x (0x%lx bytes)\n", - ArchIndex, - (DWORD)FileOffset, - FileSize); - - //if(nDumpLevel > 2) - //{ - // QueryKey.pbData = pIndexEntry->IndexKey; - // QueryKey.cbData = MD5_HASH_SIZE; - // if(CascOpenFileByIndexKey((HANDLE)hs, &QueryKey, 0, &hFile)) - // { - // // Make sure that the data file is open and frame header loaded - // CascGetFileSize(hFile, NULL); - // hf = IsValidFileHandle(hFile); - // assert(hf->pStream != NULL); - - // // Read the header area - // FileOffset = hf->HeaderOffset - BLTE_HEADER_DELTA; - // FileStream_Read(hf->pStream, &FileOffset, HeaderArea, sizeof(HeaderArea)); - // CascCloseFile(hFile); - - // // Dump the header area - // dump_print(dc, " FileSize: %X Rest: %s\n", - // ConvertBytesToInteger_4_LE(&HeaderArea[0x10]), - // StringFromBinary(&HeaderArea[0x14], 10, szBuffer)); - // } - //} + PCASC_EKEY_ENTRY pEKeyEntry = hs->IndexFile[file].pEKeyEntries; + DWORD nEKeyEntries = hs->IndexFile[file].nEKeyEntries; + + // Only if they are present + if(pEKeyEntry && nEKeyEntries) + { +// fprintf(fp, "--- Index: %03u --------------------------------------------------------------\n", file); + for(DWORD entry = 0; entry < nEKeyEntries; entry++, pEKeyEntry++) + DumpEKeyEntry(fp, pEKeyEntry->EKey, CASC_EKEY_SIZE, pEKeyEntry->StorageOffset, ConvertBytesToInteger_4_LE(pEKeyEntry->EncodedSize)); + } } - else + + // Dump tail + fprintf(fp, "=============================================================================\n\n"); +} +*/ + +//----------------------------------------------------------------------------- +// Dumping the ENCODING manifest +/* +static void DumpESpecEntries(FILE * fp, LPBYTE pbDataPtr, LPBYTE pbDataEnd) +{ + fprintf(fp, "--- ESpec Entries -----------------------------------------------------------\n"); + + while(pbDataPtr < pbDataEnd) { - dump_print(dc, " NO INDEX ENTRY\n"); + const char * szESpecEntry = (const char *)pbDataPtr; + + // Find the end of the entry + while((pbDataPtr < pbDataEnd) && (pbDataPtr[0] != 0)) + { + pbDataPtr++; + } + + // Dump the entry + if(pbDataPtr[0] == 0) + { + fprintf(fp, "%s\n", szESpecEntry); + pbDataPtr++; + } } } -void CascDumpEncodingEntry( - TCascStorage * hs, - TDumpContext * dc, - PCASC_ENCODING_ENTRY pEncodingEntry, - int nDumpLevel) +static void DumpCKeyEntry(PCASC_CKEY_ENTRY pCKeyEntry, FILE * fp, DWORD nIndex) { - PCASC_INDEX_ENTRY pIndexEntry; - QUERY_KEY QueryKey; - LPBYTE pbIndexKey; - char szMd5[MD5_STRING_SIZE+1]; + LPBYTE pbEKey; + char szStringBuff[MD5_STRING_SIZE + 1]; - // If the encoding key exists - if(pEncodingEntry != NULL) + // Print the CKey and number of EKeys + fprintf(fp, "[0x%02X] %s (EKeys: %02u): ", nIndex, StringFromBinary(pCKeyEntry->CKey, MD5_HASH_SIZE, szStringBuff), pCKeyEntry->EKeyCount); + pbEKey = pCKeyEntry->EKey; + + // Print the EKeys + for(USHORT i = 0; i < pCKeyEntry->EKeyCount; i++, pbEKey += MD5_HASH_SIZE) + fprintf(fp, " %s ", StringFromBinary(pbEKey, MD5_HASH_SIZE, szStringBuff)); + fprintf(fp, "\n"); +} + +static void DumpCKeyPages(FILE * fp, CASC_ENCODING_HEADER & EnHeader, LPBYTE pbDataPtr, LPBYTE pbDataEnd) +{ + // Get the CKey page header and the page itself + PFILE_CKEY_PAGE pPageHeader = (PFILE_CKEY_PAGE)pbDataPtr; + LPBYTE pbPageEntry = (LPBYTE)(pPageHeader + EnHeader.CKeyPageCount); + + fprintf(fp, "--- CKey Pages --------------------------------------------------------------\n"); + for(DWORD i = 0; i < EnHeader.CKeyPageCount; i++, pPageHeader++) { - dump_print(dc, " Size %lx Key Count: %u\n", - ConvertBytesToInteger_4(pEncodingEntry->FileSizeBE), - pEncodingEntry->KeyCount); + LPBYTE pbCKeyEntry = pbPageEntry; + LPBYTE pbEndOfPage = pbPageEntry + EnHeader.CKeyPageSize; + DWORD nCKeyIndex = 0; + + // Check if there is enough space in the buffer + if((pbPageEntry + EnHeader.CKeyPageSize) > pbDataEnd) + break; - // Dump all index keys - pbIndexKey = pEncodingEntry->EncodingKey + MD5_HASH_SIZE; - for(DWORD j = 0; j < pEncodingEntry->KeyCount; j++, pbIndexKey += MD5_HASH_SIZE) + DumpKey(fp, "First CKey: %s\n", pPageHeader->FirstKey, EnHeader.CKeyLength); + DumpKey(fp, "Page hash: %s\n", pPageHeader->SegmentHash, MD5_HASH_SIZE); + fprintf(fp, "\n"); + + // Parse all CKey entries + while(pbCKeyEntry <= pbEndOfPage) { - // Dump the index key - dump_print(dc, " %s\n", StringFromMD5(pbIndexKey, szMd5)); + PCASC_CKEY_ENTRY pCKeyEntry = (PCASC_CKEY_ENTRY)pbCKeyEntry; - // Dump the index entry as well - if(nDumpLevel >= DUMP_LEVEL_INDEX_ENTRIES) - { - QueryKey.pbData = pbIndexKey; - QueryKey.cbData = MD5_HASH_SIZE; - pIndexEntry = FindIndexEntry(hs, &QueryKey); - CascDumpIndexEntry(hs, dc, pIndexEntry, nDumpLevel); - } + // Get pointer to the encoding entry + if(pCKeyEntry->EKeyCount == 0) + break; + + // Dump this encoding entry + DumpCKeyEntry(pCKeyEntry, fp, nCKeyIndex++); + + // Move to the next encoding entry + pbCKeyEntry += sizeof(FILE_CKEY_ENTRY) + ((pCKeyEntry->EKeyCount - 1) * EnHeader.CKeyLength); + } + + // Move to the next segment + pbPageEntry += EnHeader.CKeyPageSize; + fprintf(fp, "\n"); + } +} + +void DumpEncodingManifest(TCascStorage * hs, LPBYTE pbData, ULONG cbData, FILE * fp) +{ + // Dump header + fprintf(fp, "=== ENCODING Manifest =======================================================\n"); + + // Dump the encoding file + if(hs->EncodingManifest.pbData && hs->EncodingManifest.cbData) + { + CASC_ENCODING_HEADER EnHeader; + LPBYTE pbFilePtr = hs->EncodingManifest.pbData; + DWORD cbDataSize; + + // Capture the header of the ENCODING file + if(CaptureEncodingHeader(EnHeader, hs->EncodingManifest.pbData, hs->EncodingManifest.cbData) == ERROR_SUCCESS) + { + // Dump the ENCODING file info + fprintf(fp, "Magic: %u\n", EnHeader.Magic); + fprintf(fp, "Version: %u\n", EnHeader.Version); + fprintf(fp, "CKey Length: %02X\n", EnHeader.CKeyLength); + fprintf(fp, "EKey Length: %02X\n", EnHeader.EKeyLength); + fprintf(fp, "CKey page size: %08X\n", EnHeader.CKeyPageSize); + fprintf(fp, "CKey page count: %08X\n", EnHeader.CKeyPageCount); + fprintf(fp, "EKey page size: %08X\n", EnHeader.EKeyPageSize); + fprintf(fp, "EKey page count: %08X\n", EnHeader.EKeyPageCount); + fprintf(fp, "ESpec block size: %08X\n", EnHeader.ESpecBlockSize); + pbFilePtr += sizeof(FILE_ENCODING_HEADER); + + // Dump all ESpec entries + DumpESpecEntries(fp, pbFilePtr, pbFilePtr + EnHeader.ESpecBlockSize); + pbFilePtr += EnHeader.ESpecBlockSize; + + // Parse all CKey pages and dump them + cbDataSize = EnHeader.CKeyPageCount * (sizeof(FILE_CKEY_PAGE) + EnHeader.CKeyPageSize); + DumpCKeyPages(fp, EnHeader, pbFilePtr, pbFilePtr + cbDataSize); + pbFilePtr += cbDataSize; } } else { - dump_print(dc, " NO ENCODING KEYS\n"); + fprintf(fp, "(empty)\n"); } -} -void CascDumpIndexEntries(const char * szFileName, TCascStorage * hs) + // Dump tail + fprintf(fp, "=============================================================================\n\n"); +} +*/ +//----------------------------------------------------------------------------- +// Dumping the DOWNLOAD manifest +/* +static void DumpDownloadEntries(FILE * fp, CASC_DOWNLOAD_HEADER & DlHeader, LPBYTE pbDownloadPtr, LPBYTE pbDownloadEnd) { - PCASC_INDEX_ENTRY * ppIndexEntries; - FILE * fp; - size_t nIndexEntries = hs->pIndexEntryMap->ItemCount; - char szIndexKey[0x40]; + fprintf(fp, "--- DOWNLOAD Entries --------------------------------------------------------\n"); + fprintf(fp, "Index EKey FileSize Checksum Flags Prio\n"); + fprintf(fp, "-------- -------------------------------- ---------- -------- -------- ----\n"); - // Create the dump file - fp = fopen(szFileName, "wt"); - if(fp != NULL) + for(DWORD i = 0; i < DlHeader.EntryCount; i++) { - // Create linear aray - ppIndexEntries = CASC_ALLOC(PCASC_INDEX_ENTRY, nIndexEntries); - if(ppIndexEntries != NULL) - { - // Obtain the linear array of index entries - Map_EnumObjects(hs->pIndexEntryMap, (void **)ppIndexEntries); + CASC_DOWNLOAD_ENTRY DlEntry; + char szEKey[MD5_STRING_SIZE+1]; + char szChksum[0x40]; + char szFlags[0x40]; + + if(CaptureDownloadEntry(DlHeader, DlEntry, pbDownloadPtr, pbDownloadEnd) != ERROR_SUCCESS) + break; + + // Dump the entry + StringFromBinary(DlEntry.EKey, DlHeader.EKeyLength, szEKey); + CascStrPrintf(szChksum, _countof(szChksum), (DlHeader.EntryHasChecksum ? "%08X" : "<none> "), DlEntry.Checksum); + CascStrPrintf(szFlags, _countof(szFlags), (DlHeader.FlagByteSize ? "%08X" : "<none> "), DlEntry.Flags); + fprintf(fp, "[%06X] %-16s %010I64X %s %s %04X\n", i, szEKey, DlEntry.FileSize, szChksum, szFlags, DlEntry.Priority); + + // Move to the next entry + pbDownloadPtr += DlHeader.EntryLength; + } - // Sort the array by archive number and archive offset - qsort_pointer_array((void **)ppIndexEntries, nIndexEntries, CompareIndexEntries_FilePos, NULL); + fprintf(fp, "\n"); +} - // Parse the array - fprintf(fp, "ArNo ArOffset FileSize IndexKey\n==== ======== ======== ================================\n"); - for(size_t i = 0; i < nIndexEntries; i++) - { - PCASC_INDEX_ENTRY pIndexEntry = ppIndexEntries[i]; - ULONGLONG ArchOffset = ConvertBytesToInteger_5(pIndexEntry->FileOffsetBE); - DWORD ArchIndex = (DWORD)(ArchOffset >> 0x1E); - DWORD FileSize; +static void DumpDownloadTags(FILE * fp, CASC_DOWNLOAD_HEADER & DlHeader, LPBYTE pbFilePtr, LPBYTE pbFileEnd) +{ + CASC_TAG_ENTRY1 DlTag; - FileSize = ConvertBytesToInteger_4_LE(pIndexEntry->FileSizeLE); - ArchOffset &= 0x3FFFFFFF; + fprintf(fp, "--- DOWNLOAD Tags ---------------------------------------------------------\n"); + for(DWORD i = 0; i < DlHeader.TagCount; i++) + { + // Capture the download tag + if(CaptureDownloadTag(DlHeader, DlTag, pbFilePtr, pbFileEnd) != ERROR_SUCCESS) + break; - fprintf(fp, " %02X %08X %08X %s\n", ArchIndex, (DWORD)ArchOffset, FileSize, StringFromBinary(pIndexEntry->IndexKey, CASC_FILE_KEY_SIZE, szIndexKey)); - } + // Dump the tag + fprintf(fp, "[%02X]: %08X = %s\n", i, DlTag.TagValue, DlTag.szTagName); + pbFilePtr += DlTag.TagLength; + } +} - CASC_FREE(ppIndexEntries); - } +void DumpDownloadManifest(TCascStorage * hs, FILE * fp) +{ + // Dump header + fprintf(fp, "=== DOWNLOAD Manifest =======================================================\n"); - fclose(fp); + // Dump the encoding file + if(hs->DownloadManifest.pbData && hs->DownloadManifest.cbData) + { + CASC_DOWNLOAD_HEADER DlHeader; + LPBYTE pbFileEnd = hs->DownloadManifest.pbData + hs->DownloadManifest.cbData; + LPBYTE pbFilePtr = hs->DownloadManifest.pbData; + + // Capture the header of the ENCODING file + if(CaptureDownloadHeader(DlHeader, hs->DownloadManifest.pbData, hs->DownloadManifest.cbData) == ERROR_SUCCESS) + { + // Dump the DOWNLOAD header + fprintf(fp, "Magic: %u\n", DlHeader.Magic); + fprintf(fp, "Version: %u\n", DlHeader.Version); + fprintf(fp, "EKey Length: %02X\n", DlHeader.EKeyLength); + fprintf(fp, "Checksum present: %s\n", DlHeader.EntryHasChecksum ? "Yes" : "No"); + fprintf(fp, "Entry Count: %08X\n", DlHeader.EntryCount); + fprintf(fp, "Tag Count: %08X\n", DlHeader.TagCount); + fprintf(fp, "Flag byte size: %08X\n", DlHeader.FlagByteSize); + fprintf(fp, "Base priority: %08X\n", DlHeader.BasePriority); + fprintf(fp, "Header length: %08X\n", (DWORD)DlHeader.HeaderLength); + fprintf(fp, "Entry length: %08X\n", (DWORD)DlHeader.EntryLength); + fprintf(fp, "\n"); + pbFilePtr += DlHeader.HeaderLength; + + // Dump all download entries + DumpDownloadEntries(fp, DlHeader, pbFilePtr, pbFileEnd); + pbFilePtr += DlHeader.EntryLength * DlHeader.EntryCount; + + // Dump all tags + DumpDownloadTags(fp, DlHeader, pbFilePtr, pbFileEnd); + } + } + else + { + fprintf(fp, "(empty)\n"); } + + // Dump tail + fprintf(fp, "=============================================================================\n\n"); } +*/ +//----------------------------------------------------------------------------- +// Public dumping functions -void CascDumpFile(const char * szFileName, HANDLE hFile) +void CascDumpFile(const char * szDumpFile, HANDLE hFile) { FILE * fp; DWORD dwBytesRead = 1; DWORD dwFilePos = CascSetFilePointer(hFile, 0, NULL, FILE_BEGIN); BYTE Buffer[0x1000]; - // Create the dump file - fp = fopen(szFileName, "wb"); + // Create/open the dump file + fp = OpenDumpFile(szDumpFile); if(fp != NULL) { // Read data as long as we can, write as long as we can @@ -324,11 +479,54 @@ void CascDumpFile(const char * szFileName, HANDLE hFile) break; } - // Close the local file - fclose(fp); - // Restore the file pointer CascSetFilePointer(hFile, dwFilePos, NULL, FILE_BEGIN); + + // Close the dump file + CloseDumpFile(szDumpFile, fp); + } +} + +void CascDumpStorage(HANDLE hStorage, const char * szDumpFile) +{ + TCascStorage * hs; + FILE * fp = stdout; + char szStringBuff[0x800]; + + // Verify the storage handle + hs = TCascStorage::IsValid(hStorage); + if(hs == NULL) + return; + + // Create/open the dump file + fp = OpenDumpFile(szDumpFile); + if(fp != NULL) + { + // Dump the basic storage info + fprintf(fp, "=== Basic Storage Info ======================================================\n"); + fprintf(fp, "DataPath: %s\n", StringFromLPTSTR(hs->szDataPath, szStringBuff, sizeof(szStringBuff))); + fprintf(fp, "IndexPath: %s\n", StringFromLPTSTR(hs->szIndexPath, szStringBuff, sizeof(szStringBuff))); + fprintf(fp, "BuildFile: %s\n", StringFromLPTSTR(hs->szBuildFile, szStringBuff, sizeof(szStringBuff))); + fprintf(fp, "CDN Server: %s\n", StringFromLPTSTR(hs->szCdnServers, szStringBuff, sizeof(szStringBuff))); + fprintf(fp, "CDN Path: %s\n", StringFromLPTSTR(hs->szCdnPath, szStringBuff, sizeof(szStringBuff))); + DumpKey(fp, "CDN Config Key: %s\n", hs->CdnConfigKey.pbData, hs->CdnConfigKey.cbData); + DumpKey(fp, "CDN Build Key: %s\n", hs->CdnBuildKey.pbData, hs->CdnBuildKey.cbData); + DumpKey(fp, "Archives Key: %s\n", hs->ArchivesKey.pbData, hs->ArchivesKey.cbData); + DumpKey(fp, "ROOT file: %s\n", hs->RootFile.CKey, CASC_CKEY_SIZE); + DumpKey(fp, "PATCH file: %s\n", hs->PatchFile.CKey, CASC_CKEY_SIZE); + DumpKey(fp, "ENCODING file: %s\n", hs->EncodingCKey.CKey, CASC_CKEY_SIZE); + DumpKey(fp, "DOWNLOAD file: %s\n", hs->DownloadCKey.CKey, CASC_CKEY_SIZE); + DumpKey(fp, "INSTALL file: %s\n", hs->InstallCKey.CKey, CASC_CKEY_SIZE); + fprintf(fp, "\n"); + + // Dump the complete ENCODING manifest +// DumpEncodingManifest(hs, fp); + + // Dump the complete ENCODING manifest +// DumpDownloadManifest(hs, fp); + + // Close the dump file + CloseDumpFile(szDumpFile, fp); } } diff --git a/dep/CascLib/src/CascFiles.cpp b/dep/CascLib/src/CascFiles.cpp index 3132992db4c..33f065b66d3 100644 --- a/dep/CascLib/src/CascFiles.cpp +++ b/dep/CascLib/src/CascFiles.cpp @@ -14,9 +14,13 @@ #include "CascCommon.h" //----------------------------------------------------------------------------- -// Local functions +// Local defines + +typedef int (*PARSETEXTFILE)(TCascStorage * hs, void * pvListFile); +typedef int (*PARSECSVFILE)(TCascStorage * hs, CASC_CSV & Csv); +typedef int (*PARSE_VARIABLE)(TCascStorage * hs, const char * szVariableName, const char * szDataBegin, const char * szDataEnd, void * pvParam); -typedef int (*PARSEINFOFILE)(TCascStorage * hs, void * pvListFile); +#define MAX_VAR_NAME 80 //----------------------------------------------------------------------------- // Local structures @@ -27,47 +31,62 @@ struct TBuildFileInfo CBLD_TYPE BuildFileType; }; -struct TGameIdString +struct TGameLocaleString { - const char * szGameInfo; - size_t cchGameInfo; - DWORD dwGameInfo; + const char * szLocale; + DWORD dwLocale; }; static const TBuildFileInfo BuildTypes[] = { {_T(".build.info"), CascBuildInfo}, // Since HOTS build 30027, the game uses .build.info file for storage info {_T(".build.db"), CascBuildDb}, // Older CASC storages + {_T("versions"), CascVersionsDb}, // Older CASC storages {NULL, CascBuildNone} }; static const TCHAR * DataDirs[] = { - _T("SC2Data"), // Starcraft II (Legacy of the Void) build 38749 - _T("Data\\Casc"), // Overwatch + _T("data") _T(PATH_SEP_STRING) _T("casc"), // Overwatch + _T("data"), // TACT casc (for Linux systems) _T("Data"), // World of Warcraft, Diablo + _T("SC2Data"), // Starcraft II (Legacy of the Void) build 38749 _T("HeroesData"), // Heroes of the Storm _T("BNTData"), // Heroes of the Storm, until build 30414 NULL, }; -static const TGameIdString GameIds[] = +static const TGameLocaleString LocaleStrings[] = { - {"Hero", 0x04, CASC_GAME_HOTS}, // Alpha build of Heroes of the Storm - {"WoW", 0x03, CASC_GAME_WOW6}, // Alpha build of World of Warcraft - Warlords of Draenor - {"Diablo3", 0x07, CASC_GAME_DIABLO3}, // Diablo III BETA 2.2.0 - {"Prometheus", 0x0A, CASC_GAME_OVERWATCH}, // Overwatch BETA since build 24919 - {"SC2", 0x03, CASC_GAME_STARCRAFT2}, // Starcraft II - Legacy of the Void - {"Starcraft1", 0x0A, CASC_GAME_STARCRAFT1}, // Starcraft 1 (remake) - {NULL, 0, 0}, + {"enUS", CASC_LOCALE_ENUS}, + {"koKR", CASC_LOCALE_KOKR}, + {"frFR", CASC_LOCALE_FRFR}, + {"deDE", CASC_LOCALE_DEDE}, + {"zhCN", CASC_LOCALE_ZHCN}, + {"esES", CASC_LOCALE_ESES}, + {"zhTW", CASC_LOCALE_ZHTW}, + {"enGB", CASC_LOCALE_ENGB}, + {"enCN", CASC_LOCALE_ENCN}, + {"enTW", CASC_LOCALE_ENTW}, + {"esMX", CASC_LOCALE_ESMX}, + {"ruRU", CASC_LOCALE_RURU}, + {"ptBR", CASC_LOCALE_PTBR}, + {"itIT", CASC_LOCALE_ITIT}, + {"ptPT", CASC_LOCALE_PTPT}, + {NULL, 0} }; //----------------------------------------------------------------------------- // Local functions +static bool inline IsWhiteSpace(const char * szVarValue) +{ + return (0 <= szVarValue[0] && szVarValue[0] <= 0x20); +} + static bool inline IsValueSeparator(const char * szVarValue) { - return ((0 <= szVarValue[0] && szVarValue[0] <= 0x20) || (szVarValue[0] == '|')); + return (IsWhiteSpace(szVarValue) || (szVarValue[0] == '|')); } static bool IsCharDigit(BYTE OneByte) @@ -75,597 +94,606 @@ static bool IsCharDigit(BYTE OneByte) return ('0' <= OneByte && OneByte <= '9'); } -static DWORD GetLocaleMask(const char * szTag) +static const char * CaptureDecimalInteger(const char * szDataPtr, const char * szDataEnd, PDWORD PtrValue) { - if(!strcmp(szTag, "enUS")) - return CASC_LOCALE_ENUS; + const char * szSaveDataPtr = szDataPtr; + DWORD TotalValue = 0; + DWORD AddValue = 0; - if(!strcmp(szTag, "koKR")) - return CASC_LOCALE_KOKR; + // Skip all spaces + while (szDataPtr < szDataEnd && szDataPtr[0] == ' ') + szDataPtr++; - if(!strcmp(szTag, "frFR")) - return CASC_LOCALE_FRFR; + // Load the number + while (szDataPtr < szDataEnd && szDataPtr[0] != ' ') + { + // Must only contain decimal digits ('0' - '9') + if (!IsCharDigit(szDataPtr[0])) + break; - if(!strcmp(szTag, "deDE")) - return CASC_LOCALE_DEDE; + // Get the next value and verify overflow + AddValue = szDataPtr[0] - '0'; + if ((TotalValue + AddValue) < TotalValue) + return NULL; - if(!strcmp(szTag, "zhCN")) - return CASC_LOCALE_ZHCN; + TotalValue = (TotalValue * 10) + AddValue; + szDataPtr++; + } - if(!strcmp(szTag, "esES")) - return CASC_LOCALE_ESES; + // If there were no decimal digits, we consider it failure + if(szDataPtr == szSaveDataPtr) + return NULL; - if(!strcmp(szTag, "zhTW")) - return CASC_LOCALE_ZHTW; + // Give the result + PtrValue[0] = TotalValue; + return szDataPtr; +} - if(!strcmp(szTag, "enGB")) - return CASC_LOCALE_ENGB; +static const char * CaptureSingleString(const char * szDataPtr, const char * szDataEnd, char * szBuffer, size_t ccBuffer) +{ + char * szBufferEnd = szBuffer + ccBuffer - 1; - if(!strcmp(szTag, "enCN")) - return CASC_LOCALE_ENCN; + // Skip all whitespaces + while (szDataPtr < szDataEnd && IsWhiteSpace(szDataPtr)) + szDataPtr++; - if(!strcmp(szTag, "enTW")) - return CASC_LOCALE_ENTW; + // Copy the string + while (szDataPtr < szDataEnd && szBuffer < szBufferEnd && !IsWhiteSpace(szDataPtr) && szDataPtr[0] != '=') + *szBuffer++ = *szDataPtr++; - if(!strcmp(szTag, "esMX")) - return CASC_LOCALE_ESMX; + szBuffer[0] = 0; + return szDataPtr; +} - if(!strcmp(szTag, "ruRU")) - return CASC_LOCALE_RURU; +static const char * CaptureSingleHash(const char * szDataPtr, const char * szDataEnd, LPBYTE HashValue, size_t HashLength) +{ + const char * szHashString; + size_t HashStringLength = HashLength * 2; - if(!strcmp(szTag, "ptBR")) - return CASC_LOCALE_PTBR; + // Skip all whitespaces + while (szDataPtr < szDataEnd && IsWhiteSpace(szDataPtr)) + szDataPtr++; + szHashString = szDataPtr; - if(!strcmp(szTag, "itIT")) - return CASC_LOCALE_ITIT; + // Count all hash characters + for (size_t i = 0; i < HashStringLength; i++) + { + if (szDataPtr >= szDataEnd || isxdigit(szDataPtr[0]) == 0) + return NULL; + szDataPtr++; + } - if(!strcmp(szTag, "ptPT")) - return CASC_LOCALE_PTPT; + // There must be a separator or end-of-string + if (szDataPtr > szDataEnd || IsWhiteSpace(szDataPtr) == false) + return NULL; - return 0; + // Give the values + ConvertStringToBinary(szHashString, HashStringLength, HashValue); + return szDataPtr; } -static bool IsInfoVariable(const char * szLineBegin, const char * szLineEnd, const char * szVarName, const char * szVarType) +static const char * CaptureHashCount(const char * szDataPtr, const char * szDataEnd, size_t * PtrHashCount) { - size_t nLength; + BYTE HashValue[MD5_HASH_SIZE]; + size_t HashCount = 0; - // Check the variable name - nLength = strlen(szVarName); - if((size_t)(szLineEnd - szLineBegin) > nLength) + // Capculate the hash count + while (szDataPtr < szDataEnd) { - // Check the variable name - if(!_strnicmp(szLineBegin, szVarName, nLength)) - { - // Skip variable name and the exclamation mark - szLineBegin += nLength; - if(szLineBegin < szLineEnd && szLineBegin[0] == '!') - { - // Skip the exclamation mark - szLineBegin++; + // Check one hash + szDataPtr = CaptureSingleHash(szDataPtr, szDataEnd, HashValue, MD5_HASH_SIZE); + if (szDataPtr == NULL) + return NULL; - // Check the variable type - nLength = strlen(szVarType); - if((size_t)(szLineEnd - szLineBegin) > nLength) - { - // Check the variable name - if(!_strnicmp(szLineBegin, szVarType, nLength)) - { - // Skip variable type and the doublecolon - szLineBegin += nLength; - return (szLineBegin < szLineEnd && szLineBegin[0] == ':'); - } - } - } - } + // Skip all whitespaces + while (szDataPtr < szDataEnd && IsWhiteSpace(szDataPtr)) + szDataPtr++; + + HashCount++; } - return false; + // Give results + PtrHashCount[0] = HashCount; + return szDataPtr; } -static const char * SkipInfoVariable(const char * szLineBegin, const char * szLineEnd) +static DWORD GetLocaleMask(const char * szTag) { - while(szLineBegin < szLineEnd) + for(size_t i = 0; LocaleStrings[i].szLocale != NULL; i++) { - if(szLineBegin[0] == '|') - return szLineBegin + 1; - - szLineBegin++; + if(!strncmp(LocaleStrings[i].szLocale, szTag, 4)) + { + return LocaleStrings[i].dwLocale; + } } - return NULL; + return 0; } -static TCHAR * CheckForIndexDirectory(TCascStorage * hs, const TCHAR * szSubDir) +static bool CheckConfigFileVariable( + TCascStorage * hs, // Pointer to storage structure + const char * szLinePtr, // Pointer to the begin of the line + const char * szLineEnd, // Pointer to the end of the line + const char * szVarName, // Pointer to the variable to check + PARSE_VARIABLE PfnParseProc, // Pointer to the parsing function + void * pvParseParam) // Pointer to the parameter passed to parsing function { - TCHAR * szIndexPath; + char szVariableName[MAX_VAR_NAME]; - // Cpmbine the index path - szIndexPath = CombinePath(hs->szDataPath, szSubDir); - if(DirectoryExists(szIndexPath)) - { - hs->szIndexPath = szIndexPath; - return hs->szIndexPath; - } + // Capture the variable from the line + szLinePtr = CaptureSingleString(szLinePtr, szLineEnd, szVariableName, sizeof(szVariableName)); + if (szLinePtr == NULL) + return false; - CASC_FREE(szIndexPath); - return NULL; -} + // Verify whether this is the variable + if (!CascCheckWildCard(szVariableName, szVarName)) + return false; -TCHAR * AppendBlobText(TCHAR * szBuffer, LPBYTE pbData, DWORD cbData, TCHAR chSeparator) -{ - // Put the separator, if any - if(chSeparator != 0) - *szBuffer++ = chSeparator; - - // Copy the blob data as text - for(DWORD i = 0; i < cbData; i++) - { - *szBuffer++ = IntToHexChar[pbData[0] >> 0x04]; - *szBuffer++ = IntToHexChar[pbData[0] & 0x0F]; - pbData++; - } + // Skip the spaces and '=' + while (szLinePtr < szLineEnd && (IsWhiteSpace(szLinePtr) || szLinePtr[0] == '=')) + szLinePtr++; - // Terminate the string - *szBuffer = 0; + // Call the parsing function only if there is some data + if (szLinePtr >= szLineEnd) + return false; - // Return new buffer position - return szBuffer; + return (PfnParseProc(hs, szVariableName, szLinePtr, szLineEnd, pvParseParam) == ERROR_SUCCESS); } -static const char * CheckLineVariable(const char * szLineBegin, const char * szLineEnd, const char * szVarName) +static int LoadHashArray( + PQUERY_KEY pBlob, + const char * szLinePtr, + const char * szLineEnd, + size_t HashCount) { - size_t nLineLength = (size_t)(szLineEnd - szLineBegin); - size_t nNameLength = strlen(szVarName); + int nError = ERROR_NOT_ENOUGH_MEMORY; - // If the line longer than the variable name? - if(nLineLength > nNameLength) + // Allocate the blob buffer + pBlob->cbData = (DWORD)(HashCount * MD5_HASH_SIZE); + pBlob->pbData = CASC_ALLOC(BYTE, pBlob->cbData); + if (pBlob->pbData != NULL) { - if(!_strnicmp((const char *)szLineBegin, szVarName, nNameLength)) - { - // Skip the variable name - szLineBegin += nNameLength; - - // Skip the separator(s) - while(szLineBegin < szLineEnd && IsValueSeparator(szLineBegin)) - szLineBegin++; - - // Check if there is "=" - if(szLineBegin >= szLineEnd || szLineBegin[0] != '=') - return NULL; - szLineBegin++; - - // Skip the separator(s) - while(szLineBegin < szLineEnd && IsValueSeparator(szLineBegin)) - szLineBegin++; + LPBYTE pbBuffer = pBlob->pbData; - // Check if there is "=" - if(szLineBegin >= szLineEnd) - return NULL; + for (size_t i = 0; i < HashCount; i++) + { + // Capture the hash value + szLinePtr = CaptureSingleHash(szLinePtr, szLineEnd, pbBuffer, MD5_HASH_SIZE); + if (szLinePtr == NULL) + return ERROR_BAD_FORMAT; - // Return the begin of the variable - return szLineBegin; + // Move buffer + pbBuffer += MD5_HASH_SIZE; } + + nError = ERROR_SUCCESS; } - return NULL; + return nError; } -static int LoadInfoVariable(PQUERY_KEY pVarBlob, const char * szLineBegin, const char * szLineEnd, bool bHexaValue) +static int LoadMultipleHashes(PQUERY_KEY pBlob, const char * szLineBegin, const char * szLineEnd) { - const char * szLinePtr = szLineBegin; - - // Sanity checks - assert(pVarBlob->pbData == NULL); - assert(pVarBlob->cbData == 0); + size_t HashCount = 0; + int nError = ERROR_SUCCESS; - // Check length of the variable - while(szLinePtr < szLineEnd && szLinePtr[0] != '|') - szLinePtr++; + // Retrieve the hash count + if (CaptureHashCount(szLineBegin, szLineEnd, &HashCount) == NULL) + return ERROR_BAD_FORMAT; - // Allocate space for the blob - if(bHexaValue) + // Do nothing if there is no data + if(HashCount != 0) { - // Initialize the blob - pVarBlob->pbData = CASC_ALLOC(BYTE, (szLinePtr - szLineBegin) / 2); - pVarBlob->cbData = (DWORD)((szLinePtr - szLineBegin) / 2); - return ConvertStringToBinary(szLineBegin, (size_t)(szLinePtr - szLineBegin), pVarBlob->pbData); + nError = LoadHashArray(pBlob, szLineBegin, szLineEnd, HashCount); } - // Initialize the blob - pVarBlob->pbData = CASC_ALLOC(BYTE, (szLinePtr - szLineBegin) + 1); - pVarBlob->cbData = (DWORD)(szLinePtr - szLineBegin); - - // Check for success - if(pVarBlob->pbData == NULL) - return ERROR_NOT_ENOUGH_MEMORY; + return nError; +} - // Copy the string - memcpy(pVarBlob->pbData, szLineBegin, pVarBlob->cbData); - pVarBlob->pbData[pVarBlob->cbData] = 0; - return ERROR_SUCCESS; +// Loads a query key from the text form +// A QueryKey is an array of "ContentKey EncodedKey1 ... EncodedKeyN" +static int LoadQueryKey(TCascStorage * /* hs */, const char * /* szVariableName */, const char * szDataBegin, const char * szDataEnd, void * pvParam) +{ + return LoadMultipleHashes((PQUERY_KEY)pvParam, szDataBegin, szDataEnd); } -static void AppendConfigFilePath(TCHAR * szFileName, PQUERY_KEY pFileKey) +static int LoadCKeyEntry(TCascStorage * hs, const char * szVariableName, const char * szDataPtr, const char * szDataEnd, void * pvParam) { - size_t nLength = _tcslen(szFileName); + PCASC_CKEY_ENTRY pCKeyEntry = (PCASC_CKEY_ENTRY)pvParam; + size_t nLength = strlen(szVariableName); + size_t HashCount = 0; + + // If the variable ends at "-size", it means we need to capture the size + if((nLength > 5) && !strcmp(szVariableName + nLength - 5, "-size")) + { + DWORD ContentSize = CASC_INVALID_SIZE; + DWORD EncodedSize = CASC_INVALID_SIZE; - // If there is no slash, append if - if(nLength > 0 && szFileName[nLength - 1] != '\\' && szFileName[nLength - 1] != '/') - szFileName[nLength++] = _T('/'); + // Load the content size + szDataPtr = CaptureDecimalInteger(szDataPtr, szDataEnd, &ContentSize); + if(szDataPtr != NULL) + { + CaptureDecimalInteger(szDataPtr, szDataEnd, &EncodedSize); + pCKeyEntry->ContentSize = ContentSize; + pCKeyEntry->EncodedSize = EncodedSize; + return ERROR_SUCCESS; + } + } + else + { + // Get the number of hashes. It is expected to be 1 or 2 + if(CaptureHashCount(szDataPtr, szDataEnd, &HashCount) != NULL) + { + // Capture the CKey + if(HashCount >= 1) + { + // Load the CKey. This should alway be there + szDataPtr = CaptureSingleHash(szDataPtr, szDataEnd, pCKeyEntry->CKey, MD5_HASH_SIZE); + if(szDataPtr == NULL) + return ERROR_BAD_FORMAT; + pCKeyEntry->Flags |= CASC_CE_HAS_CKEY; + } - // Get to the end of the file name - szFileName = szFileName + nLength; + // Capture EKey, if any + if(HashCount == 2) + { + // Load the EKey into the structure + szDataPtr = CaptureSingleHash(szDataPtr, szDataEnd, pCKeyEntry->EKey, MD5_HASH_SIZE); + if(szDataPtr == NULL) + return ERROR_BAD_FORMAT; + pCKeyEntry->Flags |= CASC_CE_HAS_EKEY; + + // Increment the number of EKey entries loaded from text build file + hs->EKeyEntries++; + } - // Append the "config" directory - _tcscpy(szFileName, _T("config")); - szFileName += 6; + return (HashCount == 1 || HashCount == 2) ? ERROR_SUCCESS : ERROR_BAD_FORMAT; + } + } - // Append the first level directory - szFileName = AppendBlobText(szFileName, pFileKey->pbData, 1, _T('/')); - szFileName = AppendBlobText(szFileName, pFileKey->pbData + 1, 1, _T('/')); - szFileName = AppendBlobText(szFileName, pFileKey->pbData, pFileKey->cbData, _T('/')); + // Unrecognized + return ERROR_BAD_FORMAT; } -static DWORD GetBlobCount(const char * szLineBegin, const char * szLineEnd) +static int LoadVfsRootEntry(TCascStorage * hs, const char * szVariableName, const char * szDataPtr, const char * szDataEnd, void * pvParam) { - DWORD dwBlobCount = 0; - - // Until we find an end of the line - while(szLineBegin < szLineEnd) + PCASC_CKEY_ENTRY pCKeyEntry; + CASC_ARRAY * pArray = (CASC_ARRAY *)pvParam; + const char * szVarPtr = szVariableName; + const char * szVarEnd = szVarPtr + strlen(szVarPtr); + DWORD VfsRootIndex = CASC_INVALID_INDEX; + + // Skip the "vfs-" part + if (!strncmp(szVariableName, "vfs-", 4)) { - // Skip the blob - while(szLineBegin < szLineEnd && IsValueSeparator(szLineBegin) == false) - szLineBegin++; + // Then, there must be a decimal number as index + if ((szVarPtr = CaptureDecimalInteger(szVarPtr + 4, szVarEnd, &VfsRootIndex)) != NULL) + { + // We expect the array to be initialized + assert(pArray->IsInitialized()); - // Increment the number of blobs - dwBlobCount++; + // The index of the key must not be NULL + if(VfsRootIndex != 0) + { + // Make sure that he entry is in the array + pCKeyEntry = (PCASC_CKEY_ENTRY)pArray->ItemAt(VfsRootIndex - 1); + if(pCKeyEntry == NULL) + { + // Insert a new entry + pCKeyEntry = (PCASC_CKEY_ENTRY)pArray->InsertAt(VfsRootIndex - 1); + if(pCKeyEntry == NULL) + return ERROR_NOT_ENOUGH_MEMORY; + + // Initialize the new entry + pCKeyEntry->Init(); + } - // Skip the separator - while(szLineBegin < szLineEnd && IsValueSeparator(szLineBegin)) - szLineBegin++; + // Call just a normal parse function + return LoadCKeyEntry(hs, szVariableName, szDataPtr, szDataEnd, pCKeyEntry); + } + } } - return dwBlobCount; + return ERROR_SUCCESS; } -static int LoadBlobArray( - PQUERY_KEY pBlob, - const char * szLineBegin, - const char * szLineEnd, - DWORD dwMaxBlobs) +static int LoadBuildProductId(TCascStorage * hs, const char * /* szVariableName */, const char * szDataBegin, const char * szDataEnd, void * /* pvParam */) { - LPBYTE pbBufferEnd = pBlob->pbData + pBlob->cbData; - LPBYTE pbBuffer = pBlob->pbData; - int nError = ERROR_SUCCESS; + DWORD dwBuildUid = 0; - // Sanity check - assert(pBlob->pbData != NULL); - assert(pBlob->cbData != 0); - - // Until we find an end of the line - while(szLineBegin < szLineEnd && dwMaxBlobs > 0) + // Convert up to 4 chars to DWORD + for(size_t i = 0; i < 4 && szDataBegin < szDataEnd; i++) { - const char * szBlobEnd = szLineBegin; - - // Find the end of the text blob - while(szBlobEnd < szLineEnd && IsValueSeparator(szBlobEnd) == false) - szBlobEnd++; - - // Verify the length of the found blob - if((szBlobEnd - szLineBegin) != MD5_STRING_SIZE) - return ERROR_BAD_FORMAT; - - // Verify if there is enough space in the buffer - if((pbBufferEnd - pbBuffer) < MD5_HASH_SIZE) - return ERROR_NOT_ENOUGH_MEMORY; - - // Perform the conversion - nError = ConvertStringToBinary(szLineBegin, MD5_STRING_SIZE, pbBuffer); - if(nError != ERROR_SUCCESS) - return nError; + dwBuildUid = (dwBuildUid << 0x08) | (BYTE)szDataBegin[0]; + szDataBegin++; + } - // Move pointers - pbBuffer += MD5_HASH_SIZE; - dwMaxBlobs--; + // Product-specific. See https://wowdev.wiki/TACT#Products + switch(dwBuildUid) + { + case 0x00006433: // 'd3' + case 0x00643364: // 'd3b': Diablo 3 Beta (2013) + case 0x6433636e: // 'd3cn': Diablo 3 China + case 0x00643374: // 'd3t': Diablo 3 Test + hs->szProductName = "Diablo 3"; + hs->Product = Diablo3; + break; - // Skip the separator - while(szBlobEnd < szLineEnd && IsValueSeparator(szBlobEnd)) - szBlobEnd++; - szLineBegin = szBlobEnd; - } + case 0x64737432: // 'dst2': + hs->szProductName = "Destiny 2"; + hs->Product = Destiny2; + break; - return nError; -} + case 0x00626e74: // 'bnt': Heroes of the Storm Alpha + case 0x6865726f: // 'hero': Heroes of the Storm Retail + case 0x73746f72: // 'stor': Heroes of the Storm (deprecated) + hs->szProductName = "Heroes Of The Storm"; + hs->Product = HeroesOfTheStorm; + break; -static int LoadMultipleBlobs(PQUERY_KEY pBlob, const char * szLineBegin, const char * szLineEnd, DWORD dwBlobCount) -{ - size_t nLength = (szLineEnd - szLineBegin); + case 0x0070726f: // 'pro': + case 0x70726f63: // 'proc': + case 0x70726f64: // 'prod': "prodev": Overwatch Dev + case 0x70726f65: // 'proe': Not on public CDNs + case 0x70726f74: // 'prot': Overwatch Test + case 0x70726f76: // 'prov': Overwatch Vendor + case 0x70726f6d: // 'prom': "proms": Overwatch World Cup Viewer + hs->szProductName = "Overwatch"; + hs->Product = Overwatch; + break; - // We expect each blob to have length of the encoding key and one space between - if(nLength > (dwBlobCount * MD5_STRING_SIZE) + ((dwBlobCount - 1) * sizeof(char))) - return ERROR_INVALID_PARAMETER; + case 0x00007331: // 's1': StarCraft 1 + case 0x00733161: // 's1a': Starcraft 1 Alpha + case 0x00733174: // 's1t': StarCraft 1 Test + hs->szProductName = "Starcraft 1"; + hs->Product = StarCraft1; + break; - // Allocate the blob buffer - pBlob->pbData = CASC_ALLOC(BYTE, dwBlobCount * MD5_HASH_SIZE); - if(pBlob->pbData == NULL) - return ERROR_NOT_ENOUGH_MEMORY; + case 0x00007332: // 's2': StarCraft 2 + case 0x00733262: // 's2b': Starcraft 2 Beta + case 0x00733274: // 's2t': StarCraft 2 Test + case 0x00736332: // 'sc2': StarCraft 2 (deprecated) + hs->szProductName = "Starcraft 2"; + hs->Product = StarCraft2; + break; - // Set the buffer size and load the blob array - pBlob->cbData = dwBlobCount * MD5_HASH_SIZE; - return LoadBlobArray(pBlob, szLineBegin, szLineEnd, dwBlobCount); -} + case 0x76697065: // "viper", "viperdev", "viperv1": Call of Duty Black Ops 4 + hs->szProductName = "Call Of Duty Black Ops 4"; + hs->Product = CallOfDutyBlackOps4; + break; -static int LoadMultipleBlobs(PQUERY_KEY pBlob, const char * szLineBegin, const char * szLineEnd) -{ - return LoadMultipleBlobs(pBlob, szLineBegin, szLineEnd, GetBlobCount(szLineBegin, szLineEnd)); -} + case 0x00007733: // 'w3': Warcraft III + case 0x00773374: // 'w3t': Warcraft III Public Test + case 0x77617233: // 'war3': Warcraft III (old) + hs->szProductName = "WarCraft 3"; + hs->Product = WarCraft3; + break; -static int LoadSingleBlob(PQUERY_KEY pBlob, const char * szLineBegin, const char * szLineEnd) -{ - return LoadMultipleBlobs(pBlob, szLineBegin, szLineEnd, 1); -} + case 0x00776f77: // 'wow': World of Warcraft + case 0x776f775f: // "wow_beta", "wow_classic", "wow_classic_beta" + case 0x776f7764: // "wowdev", "wowdemo" + case 0x776f7765: // "wowe1", "wowe3", "wowe3" + case 0x776f7774: // 'wowt': World of Warcraft Test + case 0x776f7776: // 'wowv': World of Warcraft Vendor + case 0x776f777a: // 'wowz': World of Warcraft Submission (previously Vendor) + hs->szProductName = "World Of Warcraft"; + hs->Product = WorldOfWarcraft; + break; -static int GetGameType(TCascStorage * hs, const char * szVarBegin, const char * szLineEnd) -{ - // Go through all games that we support - for(size_t i = 0; GameIds[i].szGameInfo != NULL; i++) - { - // Check the length of the variable - if((size_t)(szLineEnd - szVarBegin) == GameIds[i].cchGameInfo) - { - // Check the string - if(!_strnicmp(szVarBegin, GameIds[i].szGameInfo, GameIds[i].cchGameInfo)) - { - hs->dwGameInfo = GameIds[i].dwGameInfo; - return ERROR_SUCCESS; - } - } + default: + hs->szProductName = "Unknown Product"; + hs->Product = UnknownProduct; + break; } - // Unknown/unsupported game - assert(false); - return ERROR_BAD_FORMAT; + return ERROR_SUCCESS; } // "B29049" // "WOW-18125patch6.0.1" // "30013_Win32_2_2_0_Ptr_ptr" // "prometheus-0_8_0_0-24919" -static int GetBuildNumber(TCascStorage * hs, const char * szVarBegin, const char * szLineEnd) +static int LoadBuildNumber(TCascStorage * hs, const char * /* szVariableName */, const char * szDataBegin, const char * szDataEnd, void * /* pvParam */) { DWORD dwBuildNumber = 0; + DWORD dwMaxValue = 0; - // Skip all non-digit characters - while(szVarBegin < szLineEnd) + // Parse the string and take the largest decimal numeric value + // "build-name = 1.21.5.4037-retail" + while(szDataBegin < szDataEnd) { // There must be at least three digits (build 99 anyone?) - if(IsCharDigit(szVarBegin[0]) && IsCharDigit(szVarBegin[1]) && IsCharDigit(szVarBegin[2])) + if(IsCharDigit(szDataBegin[0])) { - // Convert the build number string to value - while(szVarBegin < szLineEnd && IsCharDigit(szVarBegin[0])) - dwBuildNumber = (dwBuildNumber * 10) + (*szVarBegin++ - '0'); - break; + dwBuildNumber = (dwBuildNumber * 10) + (szDataBegin[0] - '0'); + dwMaxValue = CASCLIB_MAX(dwBuildNumber, dwMaxValue); + } + else + { + // Reset build number when we find non-digit char + dwBuildNumber = 0; } // Move to the next - szVarBegin++; + szDataBegin++; } - assert(dwBuildNumber != 0); - hs->dwBuildNumber = dwBuildNumber; - return (dwBuildNumber != 0) ? ERROR_SUCCESS : ERROR_BAD_FORMAT; + // If not there, just take value from build file + if((hs->dwBuildNumber = dwMaxValue) == 0) + hs->dwBuildNumber = hs->CdnBuildKey.pbData[0] % 100; + return ERROR_BAD_FORMAT; } -static int GetDefaultLocaleMask(TCascStorage * hs, PQUERY_KEY pTagsString) +static int LoadQueryKey(const CASC_CSV_COLUMN & Column, QUERY_KEY & Key) { - char * szTagEnd = (char *)pTagsString->pbData + pTagsString->cbData; - char * szTagPtr = (char *)pTagsString->pbData; - char * szNext; + // Check the input data + if (Column.szValue == NULL) + return ERROR_BUFFER_OVERFLOW; + if (Column.nLength != MD5_STRING_SIZE) + return ERROR_BAD_FORMAT; + + return LoadHashArray(&Key, Column.szValue, Column.szValue + Column.nLength, 1); +} + +static int GetDefaultLocaleMask(TCascStorage * hs, const CASC_CSV_COLUMN & Column) +{ + const char * szTagEnd = Column.szValue + Column.nLength; + const char * szTagPtr = Column.szValue; DWORD dwLocaleMask = 0; while(szTagPtr < szTagEnd) { - // Get the next part - szNext = strchr(szTagPtr, ' '); - if(szNext != NULL) - *szNext++ = 0; - - // Check whether the current tag is a language identifier - dwLocaleMask = dwLocaleMask | GetLocaleMask(szTagPtr); - - // Get the next part - if(szNext == NULL) - break; - - // Skip spaces - while(szNext < szTagEnd && szNext[0] == ' ') - szNext++; - szTagPtr = szNext; + // Could this be a locale string? + if((szTagPtr + 4) <= szTagEnd && (szTagPtr[4] == ',' || szTagPtr[4] == ' ')) + { + // Check whether the current tag is a language identifier + dwLocaleMask = dwLocaleMask | GetLocaleMask(szTagPtr); + szTagPtr += 4; + } + else + { + szTagPtr++; + } } hs->dwDefaultLocale = dwLocaleMask; return ERROR_SUCCESS; } -static void * FetchAndVerifyConfigFile(TCascStorage * hs, PQUERY_KEY pFileKey) +static int ParseFile_CDNS(TCascStorage * hs, CASC_CSV & Csv) { - TCHAR * szFileName; - void * pvListFile = NULL; + const char * szWantedRegion = hs->szRegion; + TCHAR szCdnServers[MAX_PATH]; + TCHAR szCdnPath[MAX_PATH]; + size_t nLineCount; - // Construct the local file name - szFileName = CascNewStr(hs->szDataPath, 8 + 3 + 3 + 32); - if(szFileName != NULL) - { - // Add the part where the config file path is - AppendConfigFilePath(szFileName, pFileKey); + // Fix the region + if(szWantedRegion == NULL || !_stricmp(szWantedRegion, "beta") || !_stricmp(szWantedRegion, "xx")) + szWantedRegion = "us"; + + // Determine the row count + nLineCount = Csv.GetLineCount(); - // Load and verify the external listfile - pvListFile = ListFile_OpenExternal(szFileName); - if(pvListFile != NULL) + // Find the active config + for (size_t i = 0; i < nLineCount; i++) + { + // Is it the version we are looking for? + if(!strcmp(Csv[i]["Name!STRING:0"].szValue, szWantedRegion)) { - if(!ListFile_VerifyMD5(pvListFile, pFileKey->pbData)) - { - ListFile_Free(pvListFile); - pvListFile = NULL; - } - } + // Save the list of CDN servers + CascStrCopy(szCdnServers, _countof(szCdnServers), Csv[i]["Hosts!STRING:0"].szValue); + hs->szCdnServers = CascNewStr(szCdnServers); + + // Save the CDN subpath + CascStrCopy(szCdnPath, _countof(szCdnPath), Csv[i]["Path!STRING:0"].szValue); + hs->szCdnPath = CascNewStr(szCdnPath); - // Free the file name - CASC_FREE(szFileName); + // Check and return result + return (hs->szCdnServers && hs->szCdnPath) ? ERROR_SUCCESS : ERROR_BAD_FORMAT; + } } - return pvListFile; + return ERROR_FILE_NOT_FOUND; } -static int ParseFile_BuildInfo(TCascStorage * hs, void * pvListFile) +static int ParseFile_BuildInfo(TCascStorage * hs, CASC_CSV & Csv) { - QUERY_KEY Active = {NULL, 0}; - QUERY_KEY TagString = {NULL, 0}; - QUERY_KEY CdnHost = {NULL, 0}; - QUERY_KEY CdnPath = {NULL, 0}; - const char * szLinePtr1; - const char * szLineEnd1; - const char * szLinePtr2; - const char * szLineEnd2; - size_t nLength1; - size_t nLength2; - int nError = ERROR_BAD_FORMAT; - - // Extract the first line, cotaining the headers - nLength1 = ListFile_GetNextLine(pvListFile, &szLinePtr1, &szLineEnd1); - if(nLength1 == 0) - return ERROR_BAD_FORMAT; + size_t nLineCount = Csv.GetLineCount(); + int nError; - // Now parse the second and the next lines. We are looking for line - // with "Active" set to 1 - for(;;) + // Find the active config + for(size_t i = 0; i < nLineCount; i++) { - // Read the next line - nLength2 = ListFile_GetNextLine(pvListFile, &szLinePtr2, &szLineEnd2); - if(nLength2 == 0) - break; - - // Parse all variables - while(szLinePtr1 < szLineEnd1) + // Is that build config active? + if (!strcmp(Csv[i]["Active!DEC:1"].szValue, "1")) { - // Check for variables we need - if(IsInfoVariable(szLinePtr1, szLineEnd1, "Active", "DEC")) - LoadInfoVariable(&Active, szLinePtr2, szLineEnd2, false); - if(IsInfoVariable(szLinePtr1, szLineEnd1, "Build Key", "HEX")) - LoadInfoVariable(&hs->CdnBuildKey, szLinePtr2, szLineEnd2, true); - if(IsInfoVariable(szLinePtr1, szLineEnd1, "CDN Key", "HEX")) - LoadInfoVariable(&hs->CdnConfigKey, szLinePtr2, szLineEnd2, true); - if(IsInfoVariable(szLinePtr1, szLineEnd1, "CDN Hosts", "STRING")) - LoadInfoVariable(&CdnHost, szLinePtr2, szLineEnd2, false); - if(IsInfoVariable(szLinePtr1, szLineEnd1, "CDN Path", "STRING")) - LoadInfoVariable(&CdnPath, szLinePtr2, szLineEnd2, false); - if(IsInfoVariable(szLinePtr1, szLineEnd1, "Tags", "STRING")) - LoadInfoVariable(&TagString, szLinePtr2, szLineEnd2, false); - - // Move both line pointers - szLinePtr1 = SkipInfoVariable(szLinePtr1, szLineEnd1); - if(szLinePtr1 == NULL) - break; - - szLinePtr2 = SkipInfoVariable(szLinePtr2, szLineEnd2); - if(szLinePtr2 == NULL) - break; - } + // Extract the CDN build key + nError = LoadQueryKey(Csv[i]["Build Key!HEX:16"], hs->CdnBuildKey); + if (nError != ERROR_SUCCESS) + return nError; + + // Extract the CDN config key + nError = LoadQueryKey(Csv[i]["CDN Key!HEX:16"], hs->CdnConfigKey); + if (nError != ERROR_SUCCESS) + return nError; + + // If we found tags, we can extract language build from it + GetDefaultLocaleMask(hs, Csv[i]["Tags!STRING:0"]); + + // If we found version, extract a build number + const CASC_CSV_COLUMN & VerColumn = Csv[i]["Version!STRING:0"]; + if(VerColumn.szValue && VerColumn.nLength) + { + LoadBuildNumber(hs, NULL, VerColumn.szValue, VerColumn.szValue + VerColumn.nLength, NULL); + } - // Stop parsing if found active config - if(Active.pbData != NULL && *Active.pbData == '1') - break; + // Verify all variables + return (hs->CdnBuildKey.pbData != NULL && hs->CdnConfigKey.pbData != NULL) ? ERROR_SUCCESS : ERROR_BAD_FORMAT; + } + } - // Free the blobs - FreeCascBlob(&Active); - FreeCascBlob(&hs->CdnBuildKey); - FreeCascBlob(&hs->CdnConfigKey); - FreeCascBlob(&CdnHost); - FreeCascBlob(&CdnPath); - FreeCascBlob(&TagString); + return ERROR_FILE_NOT_FOUND; +} - // Rewind column names pointer back to start of line - szLinePtr1 = szLineEnd1 - nLength1; - } +static int ParseFile_VersionsDb(TCascStorage * hs, CASC_CSV & Csv) +{ + size_t nLineCount = Csv.GetLineCount(); + int nError; - // All four must be present - if(hs->CdnBuildKey.pbData != NULL && - hs->CdnConfigKey.pbData != NULL && - CdnHost.pbData != NULL && - CdnPath.pbData != NULL) + // Find the active config + for (size_t i = 0; i < nLineCount; i++) { - // Merge the CDN host and CDN path - hs->szUrlPath = CASC_ALLOC(TCHAR, CdnHost.cbData + CdnPath.cbData + 1); - if(hs->szUrlPath != NULL) + // Either take the version required or take the first one + if (hs->szRegion == NULL || !strcmp(Csv[i]["Region!STRING:0"].szValue, hs->szRegion)) { - CopyString(hs->szUrlPath, (char *)CdnHost.pbData, CdnHost.cbData); - CopyString(hs->szUrlPath + CdnHost.cbData, (char *)CdnPath.pbData, CdnPath.cbData); - nError = ERROR_SUCCESS; + // Extract the CDN build key + nError = LoadQueryKey(Csv[i]["BuildConfig!HEX:16"], hs->CdnBuildKey); + if (nError != ERROR_SUCCESS) + return nError; + + // Extract the CDN config key + nError = LoadQueryKey(Csv[i]["CDNConfig!HEX:16"], hs->CdnConfigKey); + if (nError != ERROR_SUCCESS) + return nError; + + const CASC_CSV_COLUMN & VerColumn = Csv[i]["VersionsName!String:0"]; + if (VerColumn.szValue && VerColumn.nLength) + { + LoadBuildNumber(hs, NULL, VerColumn.szValue, VerColumn.szValue + VerColumn.nLength, NULL); + } + + // Verify all variables + return (hs->CdnBuildKey.pbData != NULL && hs->CdnConfigKey.pbData != NULL) ? ERROR_SUCCESS : ERROR_BAD_FORMAT; } } - // If we found tags, we can extract language build from it - if(TagString.pbData != NULL) - GetDefaultLocaleMask(hs, &TagString); - - FreeCascBlob(&CdnHost); - FreeCascBlob(&CdnPath); - FreeCascBlob(&TagString); - FreeCascBlob(&Active); - return nError; + return ERROR_FILE_NOT_FOUND; } -static int ParseFile_BuildDb(TCascStorage * hs, void * pvListFile) +static int ParseFile_BuildDb(TCascStorage * hs, CASC_CSV & Csv) { - const char * szLinePtr; - const char * szLineEnd; - char szOneLine[0x200]; - size_t nLength; int nError; - // Load the single line from the text file - nLength = ListFile_GetNextLine(pvListFile, szOneLine, _maxchars(szOneLine)); - if(nLength == 0) - return ERROR_BAD_FORMAT; - - // Set the line range - szLinePtr = szOneLine; - szLineEnd = szOneLine + nLength; - // Extract the CDN build key - nError = LoadInfoVariable(&hs->CdnBuildKey, szLinePtr, szLineEnd, true); - if(nError == ERROR_SUCCESS) - { - // Skip the variable - szLinePtr = SkipInfoVariable(szLinePtr, szLineEnd); - - // Load the CDN config hash - nError = LoadInfoVariable(&hs->CdnConfigKey, szLinePtr, szLineEnd, true); - if(nError == ERROR_SUCCESS) - { - // Skip the variable - szLinePtr = SkipInfoVariable(szLinePtr, szLineEnd); + nError = LoadQueryKey(Csv[CSV_ZERO][CSV_ZERO], hs->CdnBuildKey); + if(nError != ERROR_SUCCESS) + return nError; - // Skip the Locale/OS/code variable - szLinePtr = SkipInfoVariable(szLinePtr, szLineEnd); + // Extract the CDN config key + nError = LoadQueryKey(Csv[CSV_ZERO][1], hs->CdnConfigKey); + if (nError != ERROR_SUCCESS) + return nError; - // Load the URL - hs->szUrlPath = CascNewStrFromAnsi(szLinePtr, szLineEnd); - if(hs->szUrlPath == NULL) - nError = ERROR_NOT_ENOUGH_MEMORY; - } - } + // Load the the tags + GetDefaultLocaleMask(hs, Csv[CSV_ZERO][2]); // Verify all variables - if(hs->CdnBuildKey.pbData == NULL || hs->CdnConfigKey.pbData == NULL || hs->szUrlPath == NULL) - nError = ERROR_BAD_FORMAT; - return nError; + return (hs->CdnBuildKey.pbData != NULL && hs->CdnConfigKey.pbData != NULL) ? ERROR_SUCCESS : ERROR_BAD_FORMAT; } -static int LoadCdnConfigFile(TCascStorage * hs, void * pvListFile) +static int ParseFile_CdnConfig(TCascStorage * hs, void * pvListFile) { const char * szLineBegin; - const char * szVarBegin; const char * szLineEnd; int nError = ERROR_SUCCESS; @@ -676,37 +704,28 @@ static int LoadCdnConfigFile(TCascStorage * hs, void * pvListFile) if(!ListFile_GetNextLine(pvListFile, &szLineBegin, &szLineEnd)) break; - // Archive group - szVarBegin = CheckLineVariable(szLineBegin, szLineEnd, "archive-group"); - if(szVarBegin != NULL) - { - nError = LoadSingleBlob(&hs->ArchivesGroup, szVarBegin, szLineEnd); + // CDN key of ARCHIVE-GROUP. Archive-group is actually a very special '.index' file. + // It is essentially a merger of all .index files, with a structure change + // When ".index" added after the ARCHIVE-GROUP, we get file name in "indices" folder + if(CheckConfigFileVariable(hs, szLineBegin, szLineEnd, "archive-group", LoadQueryKey, &hs->ArchiveGroup)) continue; - } - // Archives - szVarBegin = CheckLineVariable(szLineBegin, szLineEnd, "archives"); - if(szVarBegin != NULL) - { - nError = LoadMultipleBlobs(&hs->ArchivesKey, szVarBegin, szLineEnd); + // CDN key of all archives. When ".index" added to the string, we get file name in "indices" folder + if(CheckConfigFileVariable(hs, szLineBegin, szLineEnd, "archives", LoadQueryKey, &hs->ArchivesKey)) continue; - } - // Patch archive group - szVarBegin = CheckLineVariable(szLineBegin, szLineEnd, "patch-archive-group"); - if(szVarBegin != NULL) - { - LoadSingleBlob(&hs->PatchArchivesGroup, szVarBegin, szLineEnd); + // CDN keys of patch archives (needs research) + if(CheckConfigFileVariable(hs, szLineBegin, szLineEnd, "patch-archives", LoadQueryKey, &hs->PatchArchivesKey)) continue; - } - // Patch archives - szVarBegin = CheckLineVariable(szLineBegin, szLineEnd, "patch-archives"); - if(szVarBegin != NULL) - { - nError = LoadMultipleBlobs(&hs->PatchArchivesKey, szVarBegin, szLineEnd); + // CDN key of probably the combined patch index file (needs research) + if(CheckConfigFileVariable(hs, szLineBegin, szLineEnd, "patch-archive-group", LoadQueryKey, &hs->PatchArchivesGroup)) + continue; + + // List of build configs this config supports (optional) + // Points to file: "data\config\%02X\%02X\%s + if(CheckConfigFileVariable(hs, szLineBegin, szLineEnd, "builds", LoadQueryKey, &hs->BuildFiles)) continue; - } } // Check if all required fields are present @@ -716,78 +735,79 @@ static int LoadCdnConfigFile(TCascStorage * hs, void * pvListFile) return nError; } -static int LoadCdnBuildFile(TCascStorage * hs, void * pvListFile) +static int ParseFile_CdnBuild(TCascStorage * hs, void * pvListFile) { const char * szLineBegin; - const char * szVarBegin; const char * szLineEnd = NULL; - int nError = ERROR_SUCCESS; + int nError; - for(;;) + // Initialize the empty VFS array + nError = hs->VfsRootList.Create<CASC_CKEY_ENTRY>(0x10); + if (nError != ERROR_SUCCESS) + return nError; + + // Parse all variables + while(ListFile_GetNextLine(pvListFile, &szLineBegin, &szLineEnd) != 0) { - // Get the next line - if(!ListFile_GetNextLine(pvListFile, &szLineBegin, &szLineEnd)) - break; + // Product name and build name + if(CheckConfigFileVariable(hs, szLineBegin, szLineEnd, "build-uid", LoadBuildProductId, NULL)) + continue; + if(CheckConfigFileVariable(hs, szLineBegin, szLineEnd, "build-name", LoadBuildNumber, NULL)) + continue; - // Game name - szVarBegin = CheckLineVariable(szLineBegin, szLineEnd, "build-product"); - if(szVarBegin != NULL) - { - GetGameType(hs, szVarBegin, szLineEnd); + // Content key of the ROOT file. Look this up in ENCODING to get the encoded key + if(CheckConfigFileVariable(hs, szLineBegin, szLineEnd, "root*", LoadCKeyEntry, &hs->RootFile)) continue; - } - // Game build number - szVarBegin = CheckLineVariable(szLineBegin, szLineEnd, "build-name"); - if(szVarBegin != NULL) - { - GetBuildNumber(hs, szVarBegin, szLineEnd); + // Content key [+ encoded key] of the INSTALL file + // If EKey is absent, you need to query the ENCODING file for it + if(CheckConfigFileVariable(hs, szLineBegin, szLineEnd, "install*", LoadCKeyEntry, &hs->InstallCKey)) continue; - } - // Root - szVarBegin = CheckLineVariable(szLineBegin, szLineEnd, "root"); - if(szVarBegin != NULL) - { - LoadSingleBlob(&hs->RootKey, szVarBegin, szLineEnd); + // Content key [+ encoded key] of the DOWNLOAD file + // If EKey is absent, you need to query the ENCODING file for it + if(CheckConfigFileVariable(hs, szLineBegin, szLineEnd, "download*", LoadCKeyEntry, &hs->DownloadCKey)) continue; - } - // Patch - szVarBegin = CheckLineVariable(szLineBegin, szLineEnd, "patch"); - if(szVarBegin != NULL) - { - LoadSingleBlob(&hs->PatchKey, szVarBegin, szLineEnd); + // Content key + encoded key of the ENCODING file. Contains CKey+EKey + // If either none or 1 is found, the game (at least Wow) switches to plain-data(?). Seen in build 20173 + if(CheckConfigFileVariable(hs, szLineBegin, szLineEnd, "encoding*", LoadCKeyEntry, &hs->EncodingCKey)) continue; - } - // Download - szVarBegin = CheckLineVariable(szLineBegin, szLineEnd, "download"); - if(szVarBegin != NULL) - { - LoadSingleBlob(&hs->DownloadKey, szVarBegin, szLineEnd); + // PATCH file + if(CheckConfigFileVariable(hs, szLineBegin, szLineEnd, "patch*", LoadCKeyEntry, &hs->PatchFile)) continue; - } - // Install - szVarBegin = CheckLineVariable(szLineBegin, szLineEnd, "install"); - if(szVarBegin != NULL) - { - LoadSingleBlob(&hs->InstallKey, szVarBegin, szLineEnd); + // SIZE file + if(CheckConfigFileVariable(hs, szLineBegin, szLineEnd, "size*", LoadCKeyEntry, &hs->SizeFile)) continue; - } - // Encoding keys - szVarBegin = CheckLineVariable(szLineBegin, szLineEnd, "encoding"); - if(szVarBegin != NULL) - { - nError = LoadMultipleBlobs(&hs->EncodingKey, szVarBegin, szLineEnd, 2); + // VFS root file (the root file of the storage VFS) + if(CheckConfigFileVariable(hs, szLineBegin, szLineEnd, "vfs-root*", LoadCKeyEntry, &hs->VfsRoot)) + continue; + + // Load a directory entry to the VFS + if(CheckConfigFileVariable(hs, szLineBegin, szLineEnd, "vfs-*", LoadVfsRootEntry, &hs->VfsRootList)) continue; + } + + // Special case: Some builds of WoW (22267) don't have the variable in the build file + if(hs->szProductName == NULL || hs->Product == UnknownProduct) + { + if(hs->szCdnPath != NULL) + { + TCHAR * szPlainName = (TCHAR *)GetPlainFileName(hs->szCdnPath); + + if(szPlainName[0] == 'w' && szPlainName[1] == 'o' && szPlainName[2] == 'w') + { + hs->szProductName = "World Of Warcraft"; + hs->Product = WorldOfWarcraft; + } } } - // Check the encoding keys - if(hs->EncodingKey.pbData == NULL || hs->EncodingKey.cbData != MD5_HASH_SIZE * 2) + // Both CKey and EKey of ENCODING file is required + if((hs->EncodingCKey.Flags & (CASC_CE_HAS_CKEY | CASC_CE_HAS_EKEY)) != (CASC_CE_HAS_CKEY | CASC_CE_HAS_EKEY)) return ERROR_BAD_FORMAT; return nError; } @@ -807,6 +827,7 @@ static int CheckDataDirectory(TCascStorage * hs, TCHAR * szDirectory) // Does that directory exist? if(DirectoryExists(szDataPath)) { + hs->szRootPath = CascNewStr(szDirectory); hs->szDataPath = szDataPath; return ERROR_SUCCESS; } @@ -819,91 +840,328 @@ static int CheckDataDirectory(TCascStorage * hs, TCHAR * szDirectory) return nError; } +static int LoadCsvFile(TCascStorage * hs, const TCHAR * szFileName, PARSECSVFILE PfnParseProc, bool bHasHeader) +{ + CASC_CSV Csv(0x40, bHasHeader); + int nError = Csv.Load(szFileName); -//----------------------------------------------------------------------------- -// Public functions + // Load the external file to memory + if (nError == ERROR_SUCCESS) + nError = PfnParseProc(hs, Csv); + return nError; +} -int LoadBuildInfo(TCascStorage * hs) +static const TCHAR * ExtractCdnServerName(TCHAR * szServerName, size_t cchServerName, const TCHAR * szCdnServers) { - PARSEINFOFILE PfnParseProc = NULL; - void * pvListFile; - int nError = ERROR_SUCCESS; + const TCHAR * szSeparator; - switch(hs->BuildFileType) + if(szCdnServers[0] != 0) { - case CascBuildInfo: - PfnParseProc = ParseFile_BuildInfo; - break; + szSeparator = _tcschr(szCdnServers, _T(' ')); + if(szSeparator != NULL) + { + // Copy one server name + CascStrCopy(szServerName, cchServerName, szCdnServers, (szSeparator - szCdnServers)); - case CascBuildDb: - PfnParseProc = ParseFile_BuildDb; - break; + // Skip all separators + while(szSeparator[0] == ' ' || szSeparator[0] == 0x09) + szSeparator++; + return szSeparator; + } + else + { + CascStrCopy(szServerName, MAX_PATH, szCdnServers); + return szCdnServers + _tcslen(szCdnServers); + } + } - default: - nError = ERROR_NOT_SUPPORTED; - break; + return NULL; +} + +static int ForcePathExist(const TCHAR * szFileName, bool bIsFileName) +{ + TCHAR * szLocalPath; + size_t nIndex; + bool bFirstSeparator = false; + int nError = ERROR_NOT_ENOUGH_MEMORY; + + // Sanity checks + if(szFileName && szFileName[0]) + { + szLocalPath = CascNewStr(szFileName); + if(szLocalPath != NULL) + { + // Get the end of search + if(bIsFileName) + CutLastPathPart(szLocalPath); + + // Check the entire path + if(_taccess(szLocalPath, 0) != 0) + { + // Searth the entire path + for(nIndex = 0; szLocalPath[nIndex] != 0; nIndex++) + { + if(szLocalPath[nIndex] == '\\' || szLocalPath[nIndex] == '/') + { + // Cut the path and verify whether the folder/file exists + szLocalPath[nIndex] = 0; + + // Skip the very first separator + if(bFirstSeparator == true) + { + // Is it there? + if(DirectoryExists(szLocalPath) == false && MakeDirectory(szLocalPath) == false) + { + nError = ERROR_PATH_NOT_FOUND; + break; + } + } + + // Restore the character + szLocalPath[nIndex] = PATH_SEP_CHAR; + bFirstSeparator = true; + nError = ERROR_SUCCESS; + } + } + + // Now check the final path + if(DirectoryExists(szLocalPath) || MakeDirectory(szLocalPath)) + { + nError = ERROR_SUCCESS; + } + } + else + { + nError = ERROR_SUCCESS; + } + + CASC_FREE(szLocalPath); + } } - // Parse the appropriate build file - if(nError == ERROR_SUCCESS) + return nError; +} + +static int DownloadFile( + const TCHAR * szRemoteName, + const TCHAR * szLocalName, + PULONGLONG PtrByteOffset, + DWORD cbReadSize, + DWORD dwPortFlags) +{ + TFileStream * pRemStream; + TFileStream * pLocStream; + LPBYTE pbFileData; + int nError = ERROR_NOT_ENOUGH_MEMORY; + + // Open the remote stream + pRemStream = FileStream_OpenFile(szRemoteName, BASE_PROVIDER_HTTP | STREAM_PROVIDER_FLAT | dwPortFlags); + if (pRemStream != NULL) { - pvListFile = ListFile_OpenExternal(hs->szBuildFile); - if(pvListFile != NULL) + // Will we download the entire file or just a part of it? + if (PtrByteOffset == NULL) { - // Parse the info file - nError = PfnParseProc(hs, pvListFile); - ListFile_Free(pvListFile); + ULONGLONG FileSize = 0; + + // Retrieve the file size + if (FileStream_GetSize(pRemStream, &FileSize) && 0 < FileSize && FileSize < 0x10000000) + { + // Cut the file size down to 32 bits + cbReadSize = (DWORD)FileSize; + } } - else - nError = ERROR_FILE_NOT_FOUND; + + // Shall we read something? + if ((cbReadSize != 0) && (pbFileData = CASC_ALLOC(BYTE, cbReadSize)) != NULL) + { + // Read all required data from the remote file + if (FileStream_Read(pRemStream, PtrByteOffset, pbFileData, cbReadSize)) + { + pLocStream = FileStream_CreateFile(szLocalName, BASE_PROVIDER_FILE | STREAM_PROVIDER_FLAT); + if (pLocStream != NULL) + { + if (FileStream_Write(pLocStream, NULL, pbFileData, cbReadSize)) + nError = ERROR_SUCCESS; + + FileStream_Close(pLocStream); + } + } + + // Free the data buffer + CASC_FREE(pbFileData); + } + + // Close the remote stream + FileStream_Close(pRemStream); + } + else + { + nError = GetLastError(); } - // If the .build.info OR .build.db file has been loaded, - // proceed with loading the CDN config file and CDN build file + return nError; +} + +static int DownloadFile( + TCascStorage * hs, + const TCHAR * szServerName, + const TCHAR * szServerPath1, + const TCHAR * szServerPath2, + const TCHAR * szLocalPath2, + PULONGLONG PtrByteOffset, + DWORD cbReadSize, + TCHAR * szOutLocalPath, + size_t cchOutLocalPath, + DWORD dwPortFlags, + bool bAlwaysDownload, + bool bWowClassicRedirect) +{ + TCHAR szRemotePath[MAX_PATH]; + TCHAR szLocalPath[MAX_PATH]; + size_t nLength; + int nError = ERROR_NOT_ENOUGH_MEMORY; + + // Format the target URL + if(bWowClassicRedirect && !_tcsicmp(szServerPath1, _T("wow_classic_beta"))) + szServerPath1 = _T("wow"); + if (szLocalPath2 == NULL) + szLocalPath2 = szServerPath2; + + // Create remote path + CombineUrlPath(szRemotePath, _countof(szRemotePath), szServerName, szServerPath1, szServerPath2); + CombineFilePath(szLocalPath, _countof(szLocalPath), hs->szRootPath, NULL, szLocalPath2); + + // Make sure that the path exists + ForcePathExist(szLocalPath, true); + + // If we are not forced to download a new one, try if local file exists. + if ((bAlwaysDownload == false) && (_taccess(szLocalPath, 0) == 0)) + { + nError = ERROR_SUCCESS; + } + else + { + nError = DownloadFile(szRemotePath, szLocalPath, PtrByteOffset, cbReadSize, dwPortFlags); + } + + // If succeeded, give the local path if(nError == ERROR_SUCCESS) { - // Load the configuration file. Note that we don't - // need it for anything, really, so we don't care if it fails - pvListFile = FetchAndVerifyConfigFile(hs, &hs->CdnConfigKey); - if(pvListFile != NULL) + // If the caller wanted local path, give it to him + if (szOutLocalPath && cchOutLocalPath) { - nError = LoadCdnConfigFile(hs, pvListFile); - ListFile_Free(pvListFile); + nLength = _tcslen(szLocalPath); + if ((nLength + 1) <= cchOutLocalPath) + { + CascStrCopy(szOutLocalPath, cchOutLocalPath, szLocalPath); + } } } - // Load the build file - if(nError == ERROR_SUCCESS) + return nError; +} + +static int FetchAndLoadConfigFile(TCascStorage * hs, PQUERY_KEY pFileKey, PARSETEXTFILE PfnParseProc) +{ + const TCHAR * szPathType = _T("config"); + TCHAR szLocalPath[MAX_PATH]; + TCHAR szSubDir[0x80] = _T(""); + void * pvListFile = NULL; + int nError = ERROR_CAN_NOT_COMPLETE; + + // If online storage, we download the file. Otherwise, create a local path + if(hs->dwFeatures & CASC_FEATURE_ONLINE) + { + nError = DownloadFileFromCDN(hs, szPathType, pFileKey->pbData, NULL, szLocalPath, _countof(szLocalPath)); + if(nError != ERROR_SUCCESS) + return nError; + } + else { - pvListFile = FetchAndVerifyConfigFile(hs, &hs->CdnBuildKey); - if(pvListFile != NULL) + CreateCascSubdirectoryName(szSubDir, _countof(szSubDir), szPathType, NULL, pFileKey->pbData); + CombineFilePath(szLocalPath, _countof(szLocalPath), hs->szDataPath, szSubDir); + } + + // Load and verify the external listfile + pvListFile = ListFile_OpenExternal(szLocalPath); + if (pvListFile != NULL) + { + if (ListFile_VerifyMD5(pvListFile, pFileKey->pbData)) { - nError = LoadCdnBuildFile(hs, pvListFile); - ListFile_Free(pvListFile); + nError = PfnParseProc(hs, pvListFile); } else - nError = ERROR_FILE_NOT_FOUND; + { + nError = ERROR_FILE_CORRUPT; + } + CASC_FREE(pvListFile); + } + else + { + nError = ERROR_FILE_NOT_FOUND; } - // Fill the index directory - if(nError == ERROR_SUCCESS) + return nError; +} + +//----------------------------------------------------------------------------- +// Public functions + +int DownloadFileFromCDN(TCascStorage * hs, const TCHAR * szSubDir, LPBYTE pbEKey, const TCHAR * szExtension, TCHAR * szOutLocalPath, size_t cchOutLocalPath) +{ + PCASC_ARCINDEX_ENTRY pIndexEntry; + const TCHAR * szCdnServers = hs->szCdnServers; + TCHAR szRemoteFolder[MAX_PATH]; + TCHAR szLocalFolder[MAX_PATH]; + TCHAR szServerName[MAX_PATH]; + int nError = ERROR_CAN_NOT_COMPLETE; + + // Try all download servers + while((szCdnServers = ExtractCdnServerName(szServerName, _countof(szServerName), szCdnServers)) != NULL) { - // First, check for more common "data" subdirectory - if((hs->szIndexPath = CheckForIndexDirectory(hs, _T("data"))) != NULL) - return ERROR_SUCCESS; + // Create the local subdirectory + CreateCascSubdirectoryName(szLocalFolder, _countof(szLocalFolder), szSubDir, szExtension, pbEKey); - // Second, try the "darch" subdirectory (older builds of HOTS - Alpha) - if((hs->szIndexPath = CheckForIndexDirectory(hs, _T("darch"))) != NULL) - return ERROR_SUCCESS; + // If the EKey is in an archive, we need to change the source + if ((pIndexEntry = (PCASC_ARCINDEX_ENTRY)hs->ArcIndexMap.FindObject(pbEKey)) != NULL) + { + ULONGLONG ByteOffset; + + // Change the subpath to an archive + CreateCascSubdirectoryName(szRemoteFolder, _countof(szRemoteFolder), szSubDir, szExtension, pIndexEntry->IndexHash); + ByteOffset = pIndexEntry->ArchiveOffset; + nError = DownloadFile(hs, + szServerName, + hs->szCdnPath, + szRemoteFolder, + szLocalFolder, + &ByteOffset, + pIndexEntry->EncodedSize, + szOutLocalPath, + cchOutLocalPath, 0, false, false); + } + else + { + nError = DownloadFile(hs, + szServerName, + hs->szCdnPath, + szLocalFolder, + szLocalFolder, + NULL, + 0, + szOutLocalPath, + cchOutLocalPath, 0, false, false); + } - nError = ERROR_FILE_NOT_FOUND; + if (nError == ERROR_SUCCESS) + break; } return nError; } // Checks whether there is a ".build.info" or ".build.db". -// If yes, the function sets "szRootPath" and "szDataPath" +// If yes, the function sets "szDataPath" and "szIndexPath" // in the storage structure and returns ERROR_SUCCESS int CheckGameDirectory(TCascStorage * hs, TCHAR * szDirectory) { @@ -912,22 +1170,22 @@ int CheckGameDirectory(TCascStorage * hs, TCHAR * szDirectory) int nError = ERROR_FILE_NOT_FOUND; // Try to find any of the root files used in the history - for(size_t i = 0; BuildTypes[i].szFileName != NULL; i++) + for (size_t i = 0; BuildTypes[i].szFileName != NULL; i++) { // Create the full name of the .agent.db file szBuildFile = CombinePath(szDirectory, BuildTypes[i].szFileName); - if(szBuildFile != NULL) + if (szBuildFile != NULL) { // Attempt to open the file pStream = FileStream_OpenFile(szBuildFile, STREAM_FLAG_READ_ONLY); - if(pStream != NULL) + if (pStream != NULL) { // Free the stream FileStream_Close(pStream); // Check for the data directory nError = CheckDataDirectory(hs, szDirectory); - if(nError == ERROR_SUCCESS) + if (nError == ERROR_SUCCESS) { hs->szBuildFile = szBuildFile; hs->BuildFileType = BuildTypes[i].BuildFileType; @@ -942,76 +1200,95 @@ int CheckGameDirectory(TCascStorage * hs, TCHAR * szDirectory) return nError; } -//----------------------------------------------------------------------------- -// Helpers for a config files that have multiple variables separated by "|" -// The line structure is (Overwatch 24919): "#MD5|CHUNK_ID|FILENAME|INSTALLPATH" -// The line structure is (Overwatch 27759): "#MD5|CHUNK_ID|PRIORITY|MPRIORITY|FILENAME|INSTALLPATH" -// The line has all preceding spaces removed - -// Retrieves the index of a variable from the initial line -int GetRootVariableIndex(const char * szLinePtr, const char * szLineEnd, const char * szVariableName, int * PtrIndex) +int LoadBuildInfo(TCascStorage * hs) { - size_t nLength = strlen(szVariableName); - int nIndex = 0; - - while(szLinePtr < szLineEnd) + PARSECSVFILE PfnParseProc = NULL; + bool bHasHeader = true; + int nError; + + // If the storage is online storage, we need to download "versions" + if(hs->dwFeatures & CASC_FEATURE_ONLINE) { - // Check the variable there - if(!_strnicmp(szLinePtr, szVariableName, nLength)) + // Inform the user about loading the build.info/build.db/versions + if(hs->PfnCallback && hs->PfnCallback(hs->PtrCallbackParam, "Downloading the \"versions\" file", NULL, 0, 0)) + return ERROR_CANCELLED; + + // Attempt to download the "versions" file + nError = DownloadFile(hs, _T("us.patch.battle.net"), hs->szCodeName, _T("versions"), NULL, NULL, 0, NULL, 0, STREAM_FLAG_USE_PORT_1119, true, false); + if(nError != ERROR_SUCCESS) { - // Does the length match? - if(szLinePtr[nLength] == '|' || szLinePtr[nLength] == '0') - { - PtrIndex[0] = nIndex; - return ERROR_SUCCESS; - } + return nError; } + } + + // We support either ".build.info" or ".build.db" + switch (hs->BuildFileType) + { + case CascBuildInfo: + PfnParseProc = ParseFile_BuildInfo; + break; + + case CascVersionsDb: + PfnParseProc = ParseFile_VersionsDb; + break; - // Get the next variable - szLinePtr = SkipInfoVariable(szLinePtr, szLineEnd); - if(szLinePtr == NULL) + case CascBuildDb: + PfnParseProc = ParseFile_BuildDb; + bHasHeader = false; break; - nIndex++; + + default: + return ERROR_NOT_SUPPORTED; } - return ERROR_BAD_FORMAT; + return LoadCsvFile(hs, hs->szBuildFile, PfnParseProc, bHasHeader); } -// Parses single line from Overwatch. -int ParseRootFileLine(const char * szLinePtr, const char * szLineEnd, int nFileNameIndex, PQUERY_KEY PtrEncodingKey, char * szFileName, size_t nMaxChars) +int LoadCdnsInfo(TCascStorage * hs) { - int nIndex = 0; - int nError; - - // Extract the MD5 (aka encoding key) - if(szLinePtr[MD5_STRING_SIZE] != '|') - return ERROR_BAD_FORMAT; + TCHAR szLocalPath[MAX_PATH]; + int nError = ERROR_SUCCESS; - // Convert the encoding key to binary - PtrEncodingKey->cbData = MD5_HASH_SIZE; - nError = ConvertStringToBinary(szLinePtr, MD5_STRING_SIZE, PtrEncodingKey->pbData); - if(nError != ERROR_SUCCESS) - return nError; + // Sanity checks + assert(hs->dwFeatures & CASC_FEATURE_ONLINE); - // Skip the variable - szLinePtr += MD5_STRING_SIZE + 1; - nIndex = 1; + // Inform the user about what we are doing + if(hs->PfnCallback && hs->PfnCallback(hs->PtrCallbackParam, "Downloading the \"cdns\" file", NULL, 0, 0)) + return ERROR_CANCELLED; - // Skip the variables until we find the file name - while(szLinePtr < szLineEnd && nIndex < nFileNameIndex) + // Download file and parse it + nError = DownloadFile(hs, _T("us.patch.battle.net"), hs->szCodeName, _T("cdns"), NULL, NULL, 0, szLocalPath, _countof(szLocalPath), STREAM_FLAG_USE_PORT_1119, false, true); + if(nError == ERROR_SUCCESS) { - if(szLinePtr[0] == '|') - nIndex++; - szLinePtr++; + nError = LoadCsvFile(hs, szLocalPath, ParseFile_CDNS, true); } - // Extract the file name - while(szLinePtr < szLineEnd && szLinePtr[0] != '|' && nMaxChars > 1) - { - *szFileName++ = *szLinePtr++; - nMaxChars--; - } + return nError; +} - *szFileName = 0; - return ERROR_SUCCESS; +int LoadCdnConfigFile(TCascStorage * hs) +{ + // The CKey for the CDN config should have been loaded already + assert(hs->CdnConfigKey.pbData != NULL && hs->CdnConfigKey.cbData == MD5_HASH_SIZE); + + // Inform the user about what we are doing + if(hs->PfnCallback && hs->PfnCallback(hs->PtrCallbackParam, "Downloading CDN config file", NULL, 0, 0)) + return ERROR_CANCELLED; + + // Load the CDN config file + return FetchAndLoadConfigFile(hs, &hs->CdnConfigKey, ParseFile_CdnConfig); +} + +int LoadCdnBuildFile(TCascStorage * hs) +{ + // The CKey for the CDN config should have been loaded already + assert(hs->CdnBuildKey.pbData != NULL && hs->CdnBuildKey.cbData == MD5_HASH_SIZE); + + // Inform the user about what we are doing + if(hs->PfnCallback && hs->PfnCallback(hs->PtrCallbackParam, "Downloading CDN build file", NULL, 0, 0)) + return ERROR_CANCELLED; + + // Load the CDN config file. Note that we don't + // need it for anything, really, so we don't care if it fails + return FetchAndLoadConfigFile(hs, &hs->CdnBuildKey, ParseFile_CdnBuild); } diff --git a/dep/CascLib/src/CascFindFile.cpp b/dep/CascLib/src/CascFindFile.cpp index a5ec5766654..129403188c5 100644 --- a/dep/CascLib/src/CascFindFile.cpp +++ b/dep/CascLib/src/CascFindFile.cpp @@ -15,192 +15,124 @@ //----------------------------------------------------------------------------- // Local functions -static TCascSearch * IsValidSearchHandle(HANDLE hFind) +// Reset the search structure. Called before each search +static void ResetFindData(PCASC_FIND_DATA pFindData) { - TCascSearch * pSearch = (TCascSearch *)hFind; - - return (pSearch != NULL && pSearch->szClassName != NULL && !strcmp(pSearch->szClassName, "TCascSearch") && pSearch->szMask != NULL) ? pSearch : NULL; + // Reset the variables + ZeroMemory16(pFindData->CKey); + ZeroMemory16(pFindData->EKey); + pFindData->szFileName[0] = 0; + pFindData->szPlainName = pFindData->szFileName; + pFindData->TagBitMask = 0; + pFindData->dwFileDataId = CASC_INVALID_ID; + pFindData->dwFileSize = CASC_INVALID_SIZE; + pFindData->dwLocaleFlags = CASC_INVALID_ID; + pFindData->dwContentFlags = CASC_INVALID_ID; + pFindData->NameType = CascNameFull; + pFindData->bFileAvailable = false; + pFindData->bCanOpenByName = false; + pFindData->bCanOpenByDataId = false; + pFindData->bCanOpenByCKey = false; + pFindData->bCanOpenByEKey = false; } -static void FreeSearchHandle(TCascSearch * pSearch) +static void SupplyFakeFileName(PCASC_FIND_DATA pFindData) { - // Only if the storage handle is valid - assert(pSearch != NULL); - - // Close (dereference) the archive handle - if(pSearch->hs != NULL) + // If the file can be open by file data id, create fake file name + if(pFindData->bCanOpenByDataId) { - // Give root handler chance to free their stuff - RootHandler_EndSearch(pSearch->hs->pRootHandler, pSearch); + CascStrPrintf(pFindData->szFileName, _countof(pFindData->szFileName), "FILE%08X.dat", pFindData->dwFileDataId); + pFindData->NameType = CascNameDataId; + return; + } - // Dereference the storage handle - CascCloseStorage((HANDLE)pSearch->hs); - pSearch->hs = NULL; + // If the file can be open by CKey, convert the CKey to file name + if(pFindData->bCanOpenByCKey) + { + StringFromBinary(pFindData->CKey, MD5_HASH_SIZE, pFindData->szFileName); + pFindData->NameType = CascNameCKey; + return; } - // Free the file cache and frame array - if(pSearch->szMask != NULL) - CASC_FREE(pSearch->szMask); - if(pSearch->szListFile != NULL) - CASC_FREE(pSearch->szListFile); -// if(pSearch->pStruct1C != NULL) -// delete pSearch->pStruct1C; - if(pSearch->pCache != NULL) - ListFile_Free(pSearch->pCache); - - // Free the structure itself - pSearch->szClassName = NULL; - CASC_FREE(pSearch); + // CKey should be always present + StringFromBinary(pFindData->EKey, MD5_HASH_SIZE, pFindData->szFileName); + pFindData->NameType = CascNameEKey; + assert(pFindData->bCanOpenByEKey != false); } -static TCascSearch * AllocateSearchHandle(TCascStorage * hs, const TCHAR * szListFile, const char * szMask) +static bool CopyCKeyEntryToFindData(PCASC_FIND_DATA pFindData, PCASC_CKEY_ENTRY pCKeyEntry) { - TCascSearch * pSearch; - size_t cbToAllocate; - - // When using the MNDX info, do not allocate the extra bit array - cbToAllocate = sizeof(TCascSearch) + ((hs->pEncodingMap->TableSize + 7) / 8); - pSearch = (TCascSearch *)CASC_ALLOC(BYTE, cbToAllocate); - if(pSearch != NULL) - { - // Initialize the structure - memset(pSearch, 0, cbToAllocate); - pSearch->szClassName = "TCascSearch"; - - // Save the search handle - pSearch->hs = hs; - hs->dwRefCount++; - - // If the mask was not given, use default - if(szMask == NULL) - szMask = "*"; - - // Save the other variables - if(szListFile != NULL) - { - pSearch->szListFile = CascNewStr(szListFile, 0); - if(pSearch->szListFile == NULL) - { - FreeSearchHandle(pSearch); - return NULL; - } - } - - // Allocate the search mask - pSearch->szMask = CascNewStr(szMask, 0); - if(pSearch->szMask == NULL) - { - FreeSearchHandle(pSearch); - return NULL; - } - } - - return pSearch; + // Supply both keys + CopyMemory16(pFindData->CKey, pCKeyEntry->CKey); + CopyMemory16(pFindData->EKey, pCKeyEntry->EKey); + pFindData->bCanOpenByCKey = (pCKeyEntry->Flags & CASC_CE_HAS_CKEY) ? true : false; + pFindData->bCanOpenByEKey = (pCKeyEntry->Flags & CASC_CE_HAS_EKEY) ? true : false; + + // Supply the tag mask + pFindData->TagBitMask = pCKeyEntry->TagBitMask; + + // Supply the plain name. Only do that if the found name is not a CKey/EKey + if(pFindData->szFileName[0] != 0) + pFindData->szPlainName = (char *)GetPlainFileName(pFindData->szFileName); + + // If we retrieved the file size directly from the root provider, use it + // Otherwise, supply EncodedSize or ContentSize, whichever is available (but ContentSize > EncodedSize) + if(pFindData->dwFileSize == CASC_INVALID_SIZE) + pFindData->dwFileSize = pCKeyEntry->ContentSize; + + // Set flag indicating that the file is locally available + pFindData->bFileAvailable = (pCKeyEntry->Flags & CASC_CE_FILE_IS_LOCAL); + + // Supply a fake file name, if there is none supplied by the root handler + if(pFindData->szFileName[0] == 0) + SupplyFakeFileName(pFindData); + return true; } // Perform searching using root-specific provider. // The provider may need the listfile static bool DoStorageSearch_RootFile(TCascSearch * pSearch, PCASC_FIND_DATA pFindData) { - PCASC_ENCODING_ENTRY pEncodingEntry; - PCASC_INDEX_ENTRY pIndexEntry; - QUERY_KEY EncodingKey; - QUERY_KEY IndexKey; - LPBYTE pbEncodingKey; - DWORD EncodingIndex = 0; - DWORD ByteIndex; - DWORD BitMask; + PCASC_CKEY_ENTRY pCKeyEntry; + TCascStorage * hs = pSearch->hs; + + // Reset the search structure + ResetFindData(pFindData); + // Enumerate over all files for(;;) { - DWORD LocaleFlags = 0; - DWORD FileDataId = CASC_INVALID_ID; - DWORD FileSize = CASC_INVALID_SIZE; - - // Attempt to find (the next) file from the root entry - pbEncodingKey = RootHandler_Search(pSearch->hs->pRootHandler, pSearch, &FileSize, &LocaleFlags, &FileDataId); - if(pbEncodingKey == NULL) + // Attempt to find (the next) file from the root handler + pCKeyEntry = hs->pRootHandler->Search(pSearch, pFindData); + if(pCKeyEntry == NULL) return false; - // Verify whether the encoding key exists in the encoding table - EncodingKey.pbData = pbEncodingKey; - EncodingKey.cbData = MD5_HASH_SIZE; - pEncodingEntry = FindEncodingEntry(pSearch->hs, &EncodingKey, &EncodingIndex); - if(pEncodingEntry != NULL) - { - // Mark the item as already found - // Note: Duplicate items are allowed while we are searching using file names - // Do not exclude items from search if they were found before - ByteIndex = (DWORD)(EncodingIndex / 8); - BitMask = 1 << (EncodingIndex & 0x07); - pSearch->BitArray[ByteIndex] |= BitMask; - - // Locate the index entry - IndexKey.pbData = GET_INDEX_KEY(pEncodingEntry); - IndexKey.cbData = MD5_HASH_SIZE; - pIndexEntry = FindIndexEntry(pSearch->hs, &IndexKey); - if(pIndexEntry == NULL) - continue; - - // If we retrieved the file size directly from the root provider, use it - // Otherwise, we need to retrieve it from the encoding entry - if(FileSize == CASC_INVALID_SIZE) - FileSize = ConvertBytesToInteger_4(pEncodingEntry->FileSizeBE); - - // Fill-in the found file - strcpy(pFindData->szFileName, pSearch->szFileName); - memcpy(pFindData->EncodingKey, pEncodingEntry->EncodingKey, MD5_HASH_SIZE); - pFindData->szPlainName = (char *)GetPlainFileName(pFindData->szFileName); - pFindData->dwLocaleFlags = LocaleFlags; - pFindData->dwFileDataId = FileDataId; - pFindData->dwFileSize = FileSize; - return true; - } + // The entry is expected to be referenced by the root directory + assert(pCKeyEntry->RefCount != 0); + + // Copy the CKey entry to the find data and return it + return CopyCKeyEntryToFindData(pFindData, pCKeyEntry); } } -static bool DoStorageSearch_EncodingKey(TCascSearch * pSearch, PCASC_FIND_DATA pFindData) +static bool DoStorageSearch_CKey(TCascSearch * pSearch, PCASC_FIND_DATA pFindData) { - PCASC_ENCODING_ENTRY pEncodingEntry; - PCASC_INDEX_ENTRY pIndexEntry; + PCASC_CKEY_ENTRY pCKeyEntry; TCascStorage * hs = pSearch->hs; - QUERY_KEY IndexKey; - DWORD ByteIndex; - DWORD BitMask; + size_t nTotalItems = hs->CKeyArray.ItemCount(); - // Check for encoding keys that haven't been found yet - while(pSearch->IndexLevel1 < hs->pEncodingMap->TableSize) + // Reset the find data structure + ResetFindData(pFindData); + + // Check for CKeys that haven't been found yet + while(pSearch->nFileIndex < nTotalItems) { - // Check if that entry has been reported before - ByteIndex = (DWORD)(pSearch->IndexLevel1 / 8); - BitMask = 1 << (pSearch->IndexLevel1 & 0x07); - if((pSearch->BitArray[ByteIndex] & BitMask) == 0) + // Locate the n-th CKey entry. If this entry is not referenced by the root handler, we include it in the search result + pCKeyEntry = (PCASC_CKEY_ENTRY)hs->CKeyArray.ItemAt(pSearch->nFileIndex++); + if((pCKeyEntry->Flags & CASC_CE_FOLDER_ENTRY) == 0 && pCKeyEntry->RefCount == 0) { - // Locate the index entry - pEncodingEntry = (PCASC_ENCODING_ENTRY)hs->pEncodingMap->HashTable[pSearch->IndexLevel1]; - if(pEncodingEntry != NULL) - { - IndexKey.pbData = GET_INDEX_KEY(pEncodingEntry); - IndexKey.cbData = MD5_HASH_SIZE; - pIndexEntry = FindIndexEntry(pSearch->hs, &IndexKey); - if(pIndexEntry != NULL) - { - // Fill-in the found file - memcpy(pFindData->EncodingKey, pEncodingEntry->EncodingKey, MD5_HASH_SIZE); - pFindData->szFileName[0] = 0; - pFindData->szPlainName = pFindData->szFileName; - pFindData->dwLocaleFlags = CASC_LOCALE_NONE; - pFindData->dwFileSize = ConvertBytesToInteger_4(pEncodingEntry->FileSizeBE); - - // Mark the entry as already-found - pSearch->BitArray[ByteIndex] |= BitMask; - return true; - } - } + return CopyCKeyEntryToFindData(pFindData, pCKeyEntry); } - - // Go to the next encoding entry - pSearch->IndexLevel1++; } // Nameless search ended @@ -210,36 +142,37 @@ static bool DoStorageSearch_EncodingKey(TCascSearch * pSearch, PCASC_FIND_DATA p static bool DoStorageSearch(TCascSearch * pSearch, PCASC_FIND_DATA pFindData) { // State 0: No search done yet - if(pSearch->dwState == 0) + if(pSearch->nSearchState == 0) { // Does the search specify listfile? if(pSearch->szListFile != NULL) pSearch->pCache = ListFile_OpenExternal(pSearch->szListFile); // Move the search phase to the listfile searching - pSearch->IndexLevel1 = 0; - pSearch->dwState++; + pSearch->nSearchState = 1; + pSearch->nFileIndex = 0; } // State 1: Searching the list file - if(pSearch->dwState == 1) + if(pSearch->nSearchState == 1) { if(DoStorageSearch_RootFile(pSearch, pFindData)) return true; // Move to the nameless search state - pSearch->IndexLevel1 = 0; - pSearch->dwState++; + pSearch->nSearchState = 2; + pSearch->nFileIndex = 0; } - // State 2: Searching the remaining entries - if(pSearch->dwState == 2 && (pSearch->szMask == NULL || !strcmp(pSearch->szMask, "*"))) + // State 2: Searching the remaining entries by CKey + if(pSearch->nSearchState == 2 && (pSearch->szMask == NULL || !strcmp(pSearch->szMask, "*"))) { - if(DoStorageSearch_EncodingKey(pSearch, pFindData)) + if(DoStorageSearch_CKey(pSearch, pFindData)) return true; // Move to the final search state - pSearch->dwState++; + pSearch->nSearchState++; + pSearch->nFileIndex = 0; } return false; @@ -250,16 +183,16 @@ static bool DoStorageSearch(TCascSearch * pSearch, PCASC_FIND_DATA pFindData) HANDLE WINAPI CascFindFirstFile( HANDLE hStorage, - const char * szMask, + LPCSTR szMask, PCASC_FIND_DATA pFindData, - const TCHAR * szListFile) + LPCTSTR szListFile) { TCascStorage * hs; TCascSearch * pSearch = NULL; int nError = ERROR_SUCCESS; // Check parameters - if((hs = IsValidStorageHandle(hStorage)) == NULL) + if((hs = TCascStorage::IsValid(hStorage)) == NULL) nError = ERROR_INVALID_HANDLE; if(szMask == NULL || pFindData == NULL) nError = ERROR_INVALID_PARAMETER; @@ -267,11 +200,8 @@ HANDLE WINAPI CascFindFirstFile( // Init the search structure and search handle if(nError == ERROR_SUCCESS) { - // Clear the entire search structure - memset(pFindData, 0, sizeof(CASC_FIND_DATA)); - // Allocate the search handle - pSearch = AllocateSearchHandle(hs, szListFile, szMask); + pSearch = new TCascSearch(hs, szListFile, szMask); if(pSearch == NULL) nError = ERROR_NOT_ENOUGH_MEMORY; } @@ -285,8 +215,7 @@ HANDLE WINAPI CascFindFirstFile( if(nError != ERROR_SUCCESS) { - if(pSearch != NULL) - FreeSearchHandle(pSearch); + delete pSearch; pSearch = (TCascSearch *)INVALID_HANDLE_VALUE; } @@ -299,7 +228,7 @@ bool WINAPI CascFindNextFile( { TCascSearch * pSearch; - pSearch = IsValidSearchHandle(hFind); + pSearch = TCascSearch::IsValid(hFind); if(pSearch == NULL || pFindData == NULL) { SetLastError(ERROR_INVALID_PARAMETER); @@ -314,13 +243,13 @@ bool WINAPI CascFindClose(HANDLE hFind) { TCascSearch * pSearch; - pSearch = IsValidSearchHandle(hFind); + pSearch = TCascSearch::IsValid(hFind); if(pSearch == NULL) { SetLastError(ERROR_INVALID_PARAMETER); return false; } - FreeSearchHandle(pSearch); + delete pSearch; return true; } diff --git a/dep/CascLib/src/CascIndexFiles.cpp b/dep/CascLib/src/CascIndexFiles.cpp new file mode 100644 index 00000000000..c54c874ec8c --- /dev/null +++ b/dep/CascLib/src/CascIndexFiles.cpp @@ -0,0 +1,774 @@ +/*****************************************************************************/ +/* CascIndexFiles.cpp Copyright (c) Ladislav Zezula 2019 */ +/*---------------------------------------------------------------------------*/ +/* Index file support */ +/*---------------------------------------------------------------------------*/ +/* Date Ver Who Comment */ +/* -------- ---- --- ------- */ +/* 23.05.19 1.00 Lad Created */ +/*****************************************************************************/ + +#define __CASCLIB_SELF__ +#include "CascLib.h" +#include "CascCommon.h" + +//----------------------------------------------------------------------------- +// Local variables + +static const TCHAR * szAllowedHexChars = _T("0123456789aAbBcCdDeEfF"); +static const TCHAR * szIndexFormat_V1 = _T("data.i%x%x"); +static const TCHAR * szIndexFormat_V2 = _T("%02x%08x.idx"); + +// Limit for "orphaned" items - those that are in index files, but are not in ENCODING manifest +#define CASC_MAX_ORPHANED_ITEMS 0x100 + +//----------------------------------------------------------------------------- +// Local functions + +// "data.iXY" +static bool IsIndexFileName_V1(const TCHAR * szFileName) +{ + // Check if the name looks like a valid index file + return (_tcslen(szFileName) == 8 && + _tcsnicmp(szFileName, _T("data.i"), 6) == 0 && + _tcsspn(szFileName + 6, szAllowedHexChars) == 2); +} + +static bool IsIndexFileName_V2(const TCHAR * szFileName) +{ + // Check if the name looks like a valid index file + return (_tcslen(szFileName) == 14 && + _tcsspn(szFileName, _T("0123456789aAbBcCdDeEfF")) == 0x0A && + _tcsicmp(szFileName + 0x0A, _T(".idx")) == 0); +} + +static bool IndexDirectory_OnFileFound( + const TCHAR * szFileName, + PDWORD IndexArray, + PDWORD OldIndexArray, + void * pvContext) +{ + TCascStorage * hs = (TCascStorage *)pvContext; + DWORD IndexValue = 0; + DWORD IndexVersion = 0; + + // Auto-detect the format of the index file name + if(hs->szIndexFormat == NULL) + { + if(IsIndexFileName_V2(szFileName)) + hs->szIndexFormat = szIndexFormat_V2; + else if(IsIndexFileName_V1(szFileName)) + hs->szIndexFormat = szIndexFormat_V1; + else + return false; + } + + if(hs->szIndexFormat == szIndexFormat_V2) + { + // Check the index file name format + if(!IsIndexFileName_V2(szFileName)) + return false; + + // Get the main index from the first two digits + if(ConvertStringToInt32(szFileName, 2, &IndexValue) != ERROR_SUCCESS) + return false; + if(ConvertStringToInt32(szFileName + 2, 8, &IndexVersion) != ERROR_SUCCESS) + return false; + } + else if(hs->szIndexFormat == szIndexFormat_V1) + { + // Check the index file name format + if(!IsIndexFileName_V1(szFileName)) + return false; + + // Get the main index from the first two digits + if(ConvertDigitToInt32(szFileName + 6, &IndexValue) != ERROR_SUCCESS) + return false; + if(ConvertDigitToInt32(szFileName + 7, &IndexVersion) != ERROR_SUCCESS) + return false; + } + else + { + // Should never happen + assert(false); + return false; + } + + // The index value must not be greater than 0x0F + if(IndexValue >= CASC_INDEX_COUNT) + return false; + + // If the new subindex is greater than the previous one, + // use this one instead + if(IndexVersion > IndexArray[IndexValue]) + { + OldIndexArray[IndexValue] = IndexArray[IndexValue]; + IndexArray[IndexValue] = IndexVersion; + } + else if(IndexVersion > OldIndexArray[IndexValue]) + { + OldIndexArray[IndexValue] = IndexVersion; + } + + // Note: WoW6 only keeps last two index files + // Any additional index files are deleted at this point + return true; +} + +static TCHAR * CreateIndexFileName(TCascStorage * hs, DWORD IndexValue, DWORD IndexVersion) +{ + TCHAR szPlainName[0x40]; + + // Sanity checks + assert(hs->szIndexFormat != NULL); + assert(hs->szIndexPath != NULL); + assert(IndexValue <= 0x0F); + + // Create the full path + CascStrPrintf(szPlainName, _countof(szPlainName), hs->szIndexFormat, IndexValue, IndexVersion); + return CombinePath(hs->szIndexPath, szPlainName); +} + +// Verifies a guarded block - data availability and checksum match +static LPBYTE CaptureGuardedBlock1(LPBYTE pbFileData, LPBYTE pbFileEnd) +{ + PFILE_INDEX_GUARDED_BLOCK pBlock = (PFILE_INDEX_GUARDED_BLOCK)pbFileData; + + // Check the guarded block + if((pbFileData + sizeof(FILE_INDEX_GUARDED_BLOCK)) >= pbFileEnd) + return NULL; + if((pbFileData + sizeof(FILE_INDEX_GUARDED_BLOCK) + pBlock->BlockSize) > pbFileEnd) + return NULL; + + // Verify the hash + if(hashlittle(pbFileData + sizeof(FILE_INDEX_GUARDED_BLOCK), pBlock->BlockSize, 0) != pBlock->BlockHash) + return NULL; + + // Give the output + return (LPBYTE)(pBlock + 1); +} + +// Second method of checking a guarded block; hash is calculated entry-by-entry. +// Unfortunately, due to implementation in hashlittle2(), we cannot calculate the hash of a continuous block +static LPBYTE CaptureGuardedBlock2(LPBYTE pbFileData, LPBYTE pbFileEnd, size_t EntryLength, PDWORD PtrBlockSize = NULL) +{ + PFILE_INDEX_GUARDED_BLOCK pBlock = (PFILE_INDEX_GUARDED_BLOCK)pbFileData; + LPBYTE pbEntryPtr; + size_t EntryCount; + unsigned int HashHigh = 0; + unsigned int HashLow = 0; + + // Check the guarded block. There must be enough bytes to contain FILE_INDEX_GUARDED_BLOCK + // and also the block length must not be NULL + if ((pbFileData + sizeof(FILE_INDEX_GUARDED_BLOCK)) >= pbFileEnd) + return NULL; + if (pBlock->BlockSize == 0 || (pbFileData + sizeof(FILE_INDEX_GUARDED_BLOCK) + pBlock->BlockSize) > pbFileEnd) + return NULL; + + // Compute the hash entry-by-entry + pbEntryPtr = pbFileData + sizeof(FILE_INDEX_GUARDED_BLOCK); + EntryCount = pBlock->BlockSize / EntryLength; + for (size_t i = 0; i < EntryCount; i++) + { + hashlittle2(pbEntryPtr, EntryLength, &HashHigh, &HashLow); + pbEntryPtr += EntryLength; + } + + // Verify hash + if (HashHigh != pBlock->BlockHash) + return NULL; + + // Give the output + if (PtrBlockSize != NULL) + PtrBlockSize[0] = pBlock->BlockSize; + return (LPBYTE)(pBlock + 1); +} + +// Third method of checking a guarded block; There is 32-bit hash, followed by EKey entry +// The hash covers the EKey entry plus one byte +static LPBYTE CaptureGuardedBlock3(LPBYTE pbFileData, LPBYTE pbFileEnd, size_t EntryLength) +{ + PDWORD PtrEntryHash = (PDWORD)pbFileData; + DWORD EntryHash; + + // Check the guarded block. There must be enough bytes to contain single entry and the hash + // Also, the hash must be present + if ((pbFileData + sizeof(DWORD) + EntryLength) >= pbFileEnd) + return NULL; + if (PtrEntryHash[0] == 0) + return NULL; + + EntryHash = hashlittle(pbFileData + sizeof(DWORD), EntryLength+1, 0) | 0x80000000; + if(EntryHash != PtrEntryHash[0]) + return NULL; + + // Give the output + return (LPBYTE)(PtrEntryHash + 1); +} + +static bool CaptureIndexEntry(CASC_INDEX_HEADER & InHeader, PCASC_CKEY_ENTRY pCKeyEntry, LPBYTE pbEKeyEntry) +{ + // Zero both CKey and EKey + ZeroMemory16(pCKeyEntry->CKey); + ZeroMemory16(pCKeyEntry->EKey); + + // Copy the EKey. We assume 9 bytes + pCKeyEntry->EKey[0x00] = pbEKeyEntry[0]; + pCKeyEntry->EKey[0x01] = pbEKeyEntry[1]; + pCKeyEntry->EKey[0x02] = pbEKeyEntry[2]; + pCKeyEntry->EKey[0x03] = pbEKeyEntry[3]; + pCKeyEntry->EKey[0x04] = pbEKeyEntry[4]; + pCKeyEntry->EKey[0x05] = pbEKeyEntry[5]; + pCKeyEntry->EKey[0x06] = pbEKeyEntry[6]; + pCKeyEntry->EKey[0x07] = pbEKeyEntry[7]; + pCKeyEntry->EKey[0x08] = pbEKeyEntry[8]; + pCKeyEntry->EKey[0x09] = pbEKeyEntry[9]; + pbEKeyEntry += InHeader.EKeyLength; + + // Copy the storage offset + pCKeyEntry->StorageOffset = ConvertBytesToInteger_5(pbEKeyEntry); + pbEKeyEntry += InHeader.StorageOffsetLength; + + // Clear the tag bit mask + pCKeyEntry->TagBitMask = 0; + + // Copy the encoded length + pCKeyEntry->EncodedSize = ConvertBytesToInteger_4_LE(pbEKeyEntry); + pCKeyEntry->ContentSize = CASC_INVALID_SIZE; + pCKeyEntry->RefCount = 0; + pCKeyEntry->Priority = 0; + pCKeyEntry->Flags = CASC_CE_FILE_IS_LOCAL | CASC_CE_HAS_EKEY | CASC_CE_HAS_EKEY_PARTIAL; + + // We ignore items that have EncodedSize of 0x1E + return (pCKeyEntry->EncodedSize > FIELD_OFFSET(BLTE_ENCODED_HEADER, Signature)); +} + +static void CheckForEncodingManifestCKey(TCascStorage * hs, PCASC_CKEY_ENTRY pCKeyEntry) +{ + // If the encoding file was not found yet + if(hs->EncodingCKey.StorageOffset == CASC_INVALID_OFFS64) + { + if(!memcmp(pCKeyEntry->EKey, hs->EncodingCKey.EKey, hs->EKeyLength)) + { + hs->EncodingCKey.StorageOffset = pCKeyEntry->StorageOffset; + hs->EncodingCKey.EncodedSize = pCKeyEntry->EncodedSize; + hs->EncodingCKey.Flags |= CASC_CE_FILE_IS_LOCAL; + } + } +} + +static int LoadIndexItems(TCascStorage * hs, CASC_INDEX_HEADER & InHeader, LPBYTE pbEKeyEntry, LPBYTE pbEKeyEnd) +{ + size_t EntryLength = InHeader.EntryLength; + + while((pbEKeyEntry + EntryLength) <= pbEKeyEnd) + { + CASC_CKEY_ENTRY CKeyEntry; + + // Capture the index entry and verify it. + if(CaptureIndexEntry(InHeader, &CKeyEntry, pbEKeyEntry)) + { + // Insert new entry to the array of CKey entries + if(hs->IndexArray.Insert(&CKeyEntry, 1) == NULL) + return ERROR_NOT_ENOUGH_MEMORY; + + // Verify whether the key is not a CKEy entry for ENCODING file + CheckForEncodingManifestCKey(hs, &CKeyEntry); + } + + pbEKeyEntry += EntryLength; + } + + return ERROR_SUCCESS; +} + +static int CaptureIndexHeader_V1(CASC_INDEX_HEADER & InHeader, LPBYTE pbFileData, DWORD cbFileData, DWORD BucketIndex) +{ + PFILE_INDEX_HEADER_V1 pIndexHeader = (PFILE_INDEX_HEADER_V1)pbFileData; + LPBYTE pbKeyEntries; + LPBYTE pbFileEnd = pbFileData + cbFileData; + size_t cbKeyEntries; + DWORD HeaderHash; + + // Check the available size. Note that the index file can be just a header. + if((pbFileData + sizeof(FILE_INDEX_HEADER_V1)) > pbFileEnd) + return ERROR_BAD_FORMAT; + if(pIndexHeader->IndexVersion != 0x05 || pIndexHeader->BucketIndex != (BYTE)BucketIndex || pIndexHeader->field_8 == 0) + return ERROR_BAD_FORMAT; + if(pIndexHeader->EncodedSizeLength != 0x04 || pIndexHeader->StorageOffsetLength != 0x05 || pIndexHeader->EKeyLength != 0x09) + return ERROR_NOT_SUPPORTED; + + // Verify the header hash + HeaderHash = pIndexHeader->HeaderHash; + pIndexHeader->HeaderHash = 0; + if(hashlittle(pbFileData, sizeof(FILE_INDEX_HEADER_V1), 0) != HeaderHash) + return ERROR_BAD_FORMAT; + + // Return the header hash back + pIndexHeader->HeaderHash = HeaderHash; + + // Copy the fields + InHeader.IndexVersion = pIndexHeader->IndexVersion; + InHeader.BucketIndex = pIndexHeader->BucketIndex; + InHeader.StorageOffsetLength = pIndexHeader->StorageOffsetLength; + InHeader.EncodedSizeLength = pIndexHeader->EncodedSizeLength; + InHeader.EKeyLength = pIndexHeader->EKeyLength; + InHeader.FileOffsetBits = pIndexHeader->FileOffsetBits; + InHeader.Alignment = 0; + InHeader.SegmentSize = pIndexHeader->SegmentSize; + + // Determine the size of the header + InHeader.HeaderLength = sizeof(FILE_INDEX_HEADER_V1); + InHeader.HeaderPadding = 0; + InHeader.EntryLength = pIndexHeader->EKeyLength + pIndexHeader->StorageOffsetLength + pIndexHeader->EncodedSizeLength; + InHeader.EKeyCount = pIndexHeader->EKeyCount1 + pIndexHeader->EKeyCount2; + + // Verify the entries hash - 1st block + pbKeyEntries = pbFileData + InHeader.HeaderLength; + cbKeyEntries = pIndexHeader->EKeyCount1 * InHeader.EntryLength; + if((pbKeyEntries + cbKeyEntries) > pbFileEnd) + return ERROR_FILE_CORRUPT; + if(hashlittle(pbKeyEntries, cbKeyEntries, 0) != pIndexHeader->KeysHash1) + return ERROR_FILE_CORRUPT; + + // Verify the entries hash - 2nd block + pbKeyEntries = pbKeyEntries + cbKeyEntries; + cbKeyEntries = pIndexHeader->EKeyCount2 * InHeader.EntryLength; + if((pbKeyEntries + cbKeyEntries) > pbFileEnd) + return ERROR_FILE_CORRUPT; + if(hashlittle(pbKeyEntries, cbKeyEntries, 0) != pIndexHeader->KeysHash2) + return ERROR_FILE_CORRUPT; + + return ERROR_SUCCESS; +} + +static int CaptureIndexHeader_V2(CASC_INDEX_HEADER & InHeader, LPBYTE pbFileData, DWORD cbFileData, DWORD BucketIndex) +{ + PFILE_INDEX_HEADER_V2 pIndexHeader; + LPBYTE pbFileEnd = pbFileData + cbFileData; + + // Check for guarded block + if((pbFileData = CaptureGuardedBlock1(pbFileData, pbFileEnd)) == NULL) + return ERROR_FILE_CORRUPT; + pIndexHeader = (PFILE_INDEX_HEADER_V2)pbFileData; + + // Verify the content of the index header + if(pIndexHeader->IndexVersion != 0x07 || pIndexHeader->BucketIndex != (BYTE)BucketIndex || pIndexHeader->ExtraBytes != 0x00) + return ERROR_BAD_FORMAT; + if(pIndexHeader->EncodedSizeLength != 0x04 || pIndexHeader->StorageOffsetLength != 0x05 || pIndexHeader->EKeyLength != 0x09) + return ERROR_BAD_FORMAT; + + // Capture the values from the index header + InHeader.IndexVersion = pIndexHeader->IndexVersion; + InHeader.BucketIndex = pIndexHeader->BucketIndex; + InHeader.StorageOffsetLength = pIndexHeader->StorageOffsetLength; + InHeader.EncodedSizeLength = pIndexHeader->EncodedSizeLength; + InHeader.EKeyLength = pIndexHeader->EKeyLength; + InHeader.FileOffsetBits = pIndexHeader->FileOffsetBits; + InHeader.Alignment = 0; + InHeader.SegmentSize = pIndexHeader->SegmentSize; + + // Supply the lengths + InHeader.HeaderLength = sizeof(FILE_INDEX_GUARDED_BLOCK) + sizeof(FILE_INDEX_HEADER_V2); + InHeader.HeaderPadding = 8; + InHeader.EntryLength = pIndexHeader->EKeyLength + pIndexHeader->StorageOffsetLength + pIndexHeader->EncodedSizeLength; + InHeader.EKeyCount = 0; + return ERROR_SUCCESS; +} + +static int LoadIndexFile_V1(TCascStorage * hs, CASC_INDEX_HEADER & InHeader, LPBYTE pbFileData, DWORD cbFileData) +{ + LPBYTE pbEKeyEntries = pbFileData + InHeader.HeaderLength + InHeader.HeaderPadding; + + // Remember the values from the index header + hs->FileOffsetBits = InHeader.FileOffsetBits; + hs->EKeyLength = InHeader.EKeyLength; + + // Load the entries from a continuous array + return LoadIndexItems(hs, InHeader, pbEKeyEntries, pbFileData + cbFileData); +} + +static int LoadIndexFile_V2(TCascStorage * hs, CASC_INDEX_HEADER & InHeader, LPBYTE pbFileData, DWORD cbFileData) +{ + LPBYTE pbEKeyEntry; + LPBYTE pbFileEnd = pbFileData + cbFileData; + LPBYTE pbFilePtr = pbFileData + InHeader.HeaderLength + InHeader.HeaderPadding; + size_t EKeyEntriesLength; + DWORD BlockSize = 0; + int nError = ERROR_NOT_SUPPORTED; + + // Remember the values from the index header + hs->FileOffsetBits = InHeader.FileOffsetBits; + hs->EKeyLength = InHeader.EKeyLength; + + // Get the pointer to the first block of EKey entries + if((pbEKeyEntry = CaptureGuardedBlock2(pbFilePtr, pbFileEnd, InHeader.EntryLength, &BlockSize)) != NULL) + { + // Supply the number of EKey entries + InHeader.HeaderPadding += sizeof(FILE_INDEX_GUARDED_BLOCK); + + // Load the continuous array of EKeys + return LoadIndexItems(hs, InHeader, pbEKeyEntry, pbEKeyEntry + BlockSize); + } + + // Get the pointer to the second block of EKey entries. + // They are alway at the position aligned to 4096 + EKeyEntriesLength = pbFileEnd - pbFilePtr; + if(EKeyEntriesLength >= 0x7800) + { + LPBYTE pbStartPage = pbFileData + 0x1000; + LPBYTE pbEndPage = pbStartPage + FILE_INDEX_PAGE_SIZE; + size_t AlignedLength = ALIGN_TO_SIZE(InHeader.EntryLength, 4); + + // Parse the chunks with the EKey entries + while(pbStartPage < pbFileEnd) + { + pbEKeyEntry = pbStartPage; + + while(pbEKeyEntry < pbEndPage) + { + CASC_CKEY_ENTRY CKeyEntry; + + // Check the EKey entry protected by 32-bit hash + if((pbEKeyEntry = CaptureGuardedBlock3(pbEKeyEntry, pbEndPage, InHeader.EntryLength)) == NULL) + break; + + // CASC\\0001: Encoding + //BREAK_ON_XKEY3(pbEKeyEntry, 0xbc, 0xe8, 0x23); + + // Capture the index entry and verify it. + if(CaptureIndexEntry(InHeader, &CKeyEntry, pbEKeyEntry)) + { + // Insert the EKey entry to the array + if(hs->IndexArray.Insert(&CKeyEntry, 1) == NULL) + return ERROR_NOT_ENOUGH_MEMORY; + + // Check whether the CKey entry is an encoding entry + CheckForEncodingManifestCKey(hs, &CKeyEntry); + } + + // Move to the next entry + pbEKeyEntry += AlignedLength; + } + + // Move to the next chunk + pbStartPage += FILE_INDEX_PAGE_SIZE; + } + nError = ERROR_SUCCESS; + } + + return nError; +} + +static int LoadIndexFile(TCascStorage * hs, LPBYTE pbFileData, DWORD cbFileData, DWORD BucketIndex) +{ + CASC_INDEX_HEADER InHeader; + + // Check for CASC version 2 + if(CaptureIndexHeader_V2(InHeader, pbFileData, cbFileData, BucketIndex) == ERROR_SUCCESS) + return LoadIndexFile_V2(hs, InHeader, pbFileData, cbFileData); + + // Check for CASC index version 1 + if(CaptureIndexHeader_V1(InHeader, pbFileData, cbFileData, BucketIndex) == ERROR_SUCCESS) + return LoadIndexFile_V1(hs, InHeader, pbFileData, cbFileData); + + // Should never happen + assert(false); + return ERROR_BAD_FORMAT; +} + +static int LoadIndexFile(TCascStorage * hs, const TCHAR * szFileName, DWORD BucketIndex) +{ + LPBYTE pbFileData; + DWORD cbFileData; + int nError = ERROR_SUCCESS; + + // WoW6 actually reads THE ENTIRE file to memory. Verified on Mac build (x64). + pbFileData = LoadFileToMemory(szFileName, &cbFileData); + if(pbFileData && cbFileData) + { + // Parse and load the index file + nError = LoadIndexFile(hs, pbFileData, cbFileData, BucketIndex); + CASC_FREE(pbFileData); + } + else + { + nError = GetLastError(); + } + + return nError; +} + +static int LoadLocalIndexFiles(TCascStorage * hs) +{ + TCHAR * szFileName; + DWORD OldIndexArray[CASC_INDEX_COUNT]; + DWORD IndexArray[CASC_INDEX_COUNT]; + int nError; + + // Scan all index files and load contained EKEY entries + memset(OldIndexArray, 0, sizeof(OldIndexArray)); + memset(IndexArray, 0, sizeof(IndexArray)); + nError = ScanIndexDirectory(hs->szIndexPath, IndexDirectory_OnFileFound, IndexArray, OldIndexArray, hs); + if(nError == ERROR_SUCCESS) + { + // Initialize the array of index files + if((nError = hs->IndexArray.Create(sizeof(CASC_CKEY_ENTRY), 0x200000)) == ERROR_SUCCESS) + { + // Load each index file + for(DWORD i = 0; i < CASC_INDEX_COUNT; i++) + { + // Create the name of the index file + if((szFileName = CreateIndexFileName(hs, i, IndexArray[i])) != NULL) + { + // Inform the user about what we are doing + if(hs->PfnCallback && hs->PfnCallback(hs->PtrCallbackParam, "Loading index files", NULL, i, CASC_INDEX_COUNT)) + { + nError = ERROR_CANCELLED; + break; + } + + // Load the index file + if((nError = LoadIndexFile(hs, szFileName, i)) != ERROR_SUCCESS) + break; + CASC_FREE(szFileName); + } + } + + // Remember the number of files that are present locally + hs->LocalFiles = hs->IndexArray.ItemCount(); + } + } + + return nError; +} + +//----------------------------------------------------------------------------- +// Online index files + +static int CaptureArcIndexFooter(CASC_ARCINDEX_FOOTER & InFooter, LPBYTE pbIndexFile, DWORD cbIndexFile) +{ + FILE_INDEX_FOOTER<0x08> * pFooter08; + BYTE checksum_data[0x40] = { 0 }; + BYTE md5_hash[MD5_HASH_SIZE]; + DWORD checksum_data_length; + + // Clear the entire structure + memset(&InFooter, 0, sizeof(CASC_ARCINDEX_FOOTER)); + + // Check the variant for checksum == 0x08 + pFooter08 = (FILE_INDEX_FOOTER<0x08> *)(pbIndexFile + cbIndexFile - sizeof(FILE_INDEX_FOOTER<0x08>)); + if (pFooter08->Version == 1 && pFooter08->Reserved[0] == 0 && pFooter08->Reserved[1] == 0 && pFooter08->FooterHashBytes == 8) + { + // Copy the entire structure + memcpy(InFooter.TocHash, pFooter08->TocHash, MD5_HASH_SIZE); + memcpy(InFooter.FooterHash, pFooter08->FooterHash, pFooter08->FooterHashBytes); + InFooter.Version = pFooter08->Version; + InFooter.OffsetBytes = pFooter08->OffsetBytes; + InFooter.SizeBytes = pFooter08->SizeBytes; + InFooter.EKeyBytes = pFooter08->EKeySizeBytes; + InFooter.FooterHashBytes = pFooter08->FooterHashBytes; + InFooter.PageLength = pFooter08->PageSizeKB << 10; + InFooter.ItemLength = pFooter08->EKeySizeBytes + pFooter08->OffsetBytes + pFooter08->SizeBytes; + InFooter.FooterLength = sizeof(FILE_INDEX_FOOTER<0x08>); + InFooter.ElementCount = ConvertBytesToInteger_4_LE(pFooter08->ElementCount); + + // Verify the hash. FooterHash needs to be cleared in order to calculate footer hash properly + checksum_data_length = FIELD_OFFSET(FILE_INDEX_FOOTER<0x08>, FooterHash) - FIELD_OFFSET(FILE_INDEX_FOOTER<0x08>, Version); + memcpy(checksum_data, &pFooter08->Version, checksum_data_length); + CascCalculateDataBlockHash(checksum_data, sizeof(FILE_INDEX_FOOTER<0x08>) - MD5_HASH_SIZE, md5_hash); + if(!memcmp(md5_hash, InFooter.FooterHash, InFooter.FooterHashBytes)) + return ERROR_SUCCESS; + } + + assert(false); + return ERROR_BAD_FORMAT; +} + +static int CaptureArcIndexEntry(CASC_ARCINDEX_FOOTER & InFooter, CASC_ARCINDEX_ENTRY & InEntry, LPBYTE pbIndexPage, LPBYTE pbIndexPageEnd) +{ + // If there enough bytes for one entry/ + if ((pbIndexPage + InFooter.ItemLength) > pbIndexPageEnd) + return ERROR_BAD_FORMAT; + + // Copy the item + memcpy(InEntry.EKey, pbIndexPage, InFooter.EKeyBytes); + pbIndexPage += InFooter.EKeyBytes; + + // Copy the archive offset + InEntry.EncodedSize = ConvertBytesToInteger_X(pbIndexPage, InFooter.OffsetBytes); + pbIndexPage += InFooter.OffsetBytes; + + // Copy thefile encoded size + InEntry.ArchiveOffset = ConvertBytesToInteger_X(pbIndexPage, InFooter.SizeBytes); + if (InEntry.ArchiveOffset >= 0x10000000) + return ERROR_BAD_FORMAT; + + // Is there a valid hash? + return CascIsValidMD5(InEntry.EKey) ? ERROR_SUCCESS : ERROR_BAD_FORMAT; +} + +static int VerifyIndexSize(CASC_ARCINDEX_FOOTER & InFooter, LPBYTE pbIndexFile, size_t cbIndexFile, LPBYTE * PtrIndexEnd) +{ + size_t nPageCount; + + // Set the new length (without the footer) + cbIndexFile = cbIndexFile - InFooter.FooterLength; + nPageCount = cbIndexFile / (InFooter.PageLength + MD5_HASH_SIZE); + + // There must be equal or more pages + if(((InFooter.PageLength + MD5_HASH_SIZE) * nPageCount) > cbIndexFile) + return ERROR_BAD_FORMAT; + + // Return the end-of-index + nPageCount = cbIndexFile / (InFooter.PageLength + MD5_HASH_SIZE); + PtrIndexEnd[0] = pbIndexFile + (nPageCount * InFooter.PageLength); + return ERROR_SUCCESS; +} + +static int LoadArchiveIndexPage(TCascStorage * hs, CASC_ARCINDEX_FOOTER & InFooter, LPBYTE pbIndexHash, LPBYTE pbIndexPage, LPBYTE pbIndexPageEnd) +{ + CASC_ARCINDEX_ENTRY InEntry; + int nError; + + while (pbIndexPage < pbIndexPageEnd) + { + // Capture the index entry + nError = CaptureArcIndexEntry(InFooter, InEntry, pbIndexPage, pbIndexPageEnd); + if (nError != ERROR_SUCCESS) + break; + + // Insert the index entry to the array + memcpy(InEntry.IndexHash, pbIndexHash, MD5_HASH_SIZE); + if (hs->ArcIndexArray.Insert(&InEntry, 1) == NULL) + return ERROR_NOT_ENOUGH_MEMORY; + + // Move to the next entry + pbIndexPage += InFooter.ItemLength; + } + + return ERROR_SUCCESS; +} + +static int LoadArchiveIndexFile(TCascStorage * hs, LPBYTE pbIndexHash, LPBYTE pbIndexFile, DWORD cbIndexFile) +{ + CASC_ARCINDEX_FOOTER InFooter; + LPBYTE pbIndexEnd = NULL; + int nError; + + // Validate and capture the footer + nError = CaptureArcIndexFooter(InFooter, pbIndexFile, cbIndexFile); + if (nError != ERROR_SUCCESS) + return nError; + + // Verify the size of the index file + nError = VerifyIndexSize(InFooter, pbIndexFile, cbIndexFile, &pbIndexEnd); + if (nError != ERROR_SUCCESS) + return nError; + + // Parse all pages + while (pbIndexFile < pbIndexEnd) + { + // Load the entire page + nError = LoadArchiveIndexPage(hs, InFooter, pbIndexHash, pbIndexFile, pbIndexFile + InFooter.PageLength); + if (nError != ERROR_SUCCESS) + break; + + // Move to the next page + pbIndexFile += InFooter.PageLength; + } + + return ERROR_SUCCESS; +} + +static int BuildMapOfArcIndices(TCascStorage * hs) +{ + PCASC_ARCINDEX_ENTRY pEntry; + size_t nItemCount = hs->ArcIndexArray.ItemCount(); + int nError; + + // Create the map + nError = hs->ArcIndexMap.Create(nItemCount, MD5_HASH_SIZE, FIELD_OFFSET(CASC_ARCINDEX_ENTRY, EKey)); + if (nError != ERROR_SUCCESS) + return nError; + + // Insert all items + for(size_t i = 0; i < nItemCount; i++) + { + pEntry = (PCASC_ARCINDEX_ENTRY)hs->ArcIndexArray.ItemAt(i); + if (pEntry != NULL) + { + if (!hs->ArcIndexMap.InsertObject(pEntry, pEntry->EKey)) + { + return ERROR_NOT_ENOUGH_MEMORY; + } + } + } + + return nError; +} + +static int LoadArchiveIndexFiles(TCascStorage * hs) +{ + LPBYTE pbFileData; + TCHAR szLocalPath[MAX_PATH]; + DWORD cbFileData = 0; + size_t nArchiveCount = (hs->ArchivesKey.cbData / MD5_HASH_SIZE); + int nError = ERROR_SUCCESS; + + // Create the array object for the indices + nError = hs->ArcIndexArray.Create(sizeof(CASC_ARCINDEX_ENTRY), 10000); + if (nError != ERROR_SUCCESS) + return nError; + + // Load all the indices + for (size_t i = 0; i < nArchiveCount; i++) + { + LPBYTE pbIndexHash = hs->ArchivesKey.pbData + (i * MD5_HASH_SIZE); + + // Inform the user about what we are doing + if(hs->PfnCallback && hs->PfnCallback(hs->PtrCallbackParam, "Downloading archive indexes", NULL, (DWORD)(i), (DWORD)(nArchiveCount))) + { + nError = ERROR_CANCELLED; + break; + } + + // Make sure that we have local copy of the file + nError = DownloadFileFromCDN(hs, _T("data"), pbIndexHash, _T(".index"), szLocalPath, _countof(szLocalPath)); + if (nError == ERROR_SUCCESS) + { + // Load the index file to memory + pbFileData = LoadFileToMemory(szLocalPath, &cbFileData); + if (pbFileData && cbFileData) + { + nError = LoadArchiveIndexFile(hs, pbIndexHash, pbFileData, cbFileData); + CASC_FREE(pbFileData); + } + } + + // Break if an error + if (nError != ERROR_SUCCESS) + break; + } + + // Build map of EKey -> CASC_ARCINDEX_ENTRY + if (nError == ERROR_SUCCESS) + nError = BuildMapOfArcIndices(hs); + + return nError; +} + +//----------------------------------------------------------------------------- +// Public functions + +int LoadIndexFiles(TCascStorage * hs) +{ + if (hs->dwFeatures & CASC_FEATURE_ONLINE) + { + return LoadArchiveIndexFiles(hs); + } + else + { + return LoadLocalIndexFiles(hs); + } +}
\ No newline at end of file diff --git a/dep/CascLib/src/CascLib.def b/dep/CascLib/src/CascLib.def index cb5f9166e49..12e7904cb84 100644 --- a/dep/CascLib/src/CascLib.def +++ b/dep/CascLib/src/CascLib.def @@ -9,12 +9,13 @@ LIBRARY CascLib.dll EXPORTS CascOpenStorage + CascOpenOnlineStorage CascGetStorageInfo + CascAddEncryptionKey CascCloseStorage - CascOpenFileByIndexKey - CascOpenFileByEncodingKey CascOpenFile + CascGetFileInfo CascGetFileSize CascSetFilePointer CascReadFile diff --git a/dep/CascLib/src/CascLib.h b/dep/CascLib/src/CascLib.h index 272d4b4ad4d..1fb1911eade 100644 --- a/dep/CascLib/src/CascLib.h +++ b/dep/CascLib/src/CascLib.h @@ -29,14 +29,17 @@ extern "C" { //----------------------------------------------------------------------------- // Defines -#define CASCLIB_VERSION 0x0100 // Current version of CascLib (1.0) -#define CASCLIB_VERSION_STRING "1.00" // String version of CascLib version - -// Values for CascOpenStorage -#define CASC_STOR_XXXXX 0x00000001 // Not used +#define CASCLIB_VERSION 0x0132 // Current version of CascLib (1.50) +#define CASCLIB_VERSION_STRING "1.50" // String version of CascLib version // Values for CascOpenFile -#define CASC_OPEN_BY_ENCODING_KEY 0x00000001 // The name is just the encoding key; skip ROOT file processing +#define CASC_OPEN_BY_NAME 0x00000000 // Open the file by name. This is the default value +#define CASC_OPEN_BY_CKEY 0x00000001 // The name is just the content key; skip ROOT file processing +#define CASC_OPEN_BY_EKEY 0x00000002 // The name is just the encoded key; skip ROOT file processing +#define CASC_OPEN_BY_FILEID 0x00000003 // The name is CASC_IDTONAME(FileDataId) +#define CASC_OPEN_TYPE_MASK 0x0000000F // The mask which gets open type from the dwFlags +#define CASC_OPEN_FLAGS_MASK 0xFFFFFFF0 // The mask which gets open type from the dwFlags +#define CASC_STRICT_DATA_CHECK 0x00000010 // Verify all data read from a file #define CASC_LOCALE_ALL 0xFFFFFFFF #define CASC_LOCALE_NONE 0x00000000 @@ -58,25 +61,14 @@ extern "C" { #define CASC_LOCALE_ITIT 0x00008000 #define CASC_LOCALE_PTPT 0x00010000 -#define CASC_LOCALE_BIT_ENUS 0x01 -#define CASC_LOCALE_BIT_KOKR 0x02 -#define CASC_LOCALE_BIT_RESERVED 0x03 -#define CASC_LOCALE_BIT_FRFR 0x04 -#define CASC_LOCALE_BIT_DEDE 0x05 -#define CASC_LOCALE_BIT_ZHCN 0x06 -#define CASC_LOCALE_BIT_ESES 0x07 -#define CASC_LOCALE_BIT_ZHTW 0x08 -#define CASC_LOCALE_BIT_ENGB 0x09 -#define CASC_LOCALE_BIT_ENCN 0x0A -#define CASC_LOCALE_BIT_ENTW 0x0B -#define CASC_LOCALE_BIT_ESMX 0x0C -#define CASC_LOCALE_BIT_RURU 0x0D -#define CASC_LOCALE_BIT_PTBR 0x0E -#define CASC_LOCALE_BIT_ITIT 0x0F -#define CASC_LOCALE_BIT_PTPT 0x10 - - -#define MAX_CASC_KEY_LENGTH 0x10 // Maximum length of the key (equal to MD5 hash) +// Content flags on WoW +#define CASC_CFLAG_LOAD_ON_WINDOWS 0x08 +#define CASC_CFLAG_LOAD_ON_MAC 0x10 +#define CASC_CFLAG_LOW_VIOLENCE 0x80 +#define CASC_CFLAG_DONT_LOAD 0x100 +#define CASC_CFLAG_NO_NAME_HASH 0x10000000 +#define CASC_CFLAG_BUNDLE 0x40000000 +#define CASC_CFLAG_NO_COMPRESSION 0x80000000 #ifndef MD5_HASH_SIZE #define MD5_HASH_SIZE 0x10 @@ -87,79 +79,205 @@ extern "C" { #define SHA1_DIGEST_SIZE 0x14 // 160 bits #endif -#ifndef LANG_NEUTRAL -#define LANG_NEUTRAL 0x00 // Neutral locale -#endif - // Return value for CascGetFileSize and CascSetFilePointer +#define CASC_INVALID_INDEX 0xFFFFFFFF #define CASC_INVALID_SIZE 0xFFFFFFFF #define CASC_INVALID_POS 0xFFFFFFFF #define CASC_INVALID_ID 0xFFFFFFFF - -// Flags for CascGetStorageInfo -#define CASC_FEATURE_LISTFILE 0x00000001 // The storage supports listfile +#define CASC_INVALID_OFFS64 0xFFFFFFFFFFFFFFFF + +// Flags for CASC_STORAGE_FEATURES::dwFeatures +#define CASC_FEATURE_FILE_NAMES 0x00000001 // File names are supported by the storage +#define CASC_FEATURE_ROOT_CKEY 0x00000002 // Present if the storage's ROOT returns CKey +#define CASC_FEATURE_TAGS 0x00000002 // Tags are supported by the storage +#define CASC_FEATURE_FNAME_HASHES 0x00000004 // The storage contains file name hashes on ALL files +#define CASC_FEATURE_FNAME_HASHES_OPTIONAL 0x00000008 // The storage contains file name hashes for SOME files +#define CASC_FEATURE_FILE_DATA_IDS 0x00000010 // The storage indexes files by FileDataId +#define CASC_FEATURE_LOCALE_FLAGS 0x00000020 // Locale flags are supported +#define CASC_FEATURE_CONTENT_FLAGS 0x00000040 // Content flags are supported +#define CASC_FEATURE_ONLINE 0x00000080 // The storage is an online storage + +// Macro to convert FileDataId to the argument of CascOpenFile +#define CASC_FILE_DATA_ID(FileDataId) ((LPCSTR)(size_t)FileDataId) +#define CASC_FILE_DATA_ID_FROM_STRING(szFileName) ((DWORD)(size_t)szFileName) //----------------------------------------------------------------------------- // Structures typedef enum _CASC_STORAGE_INFO_CLASS { - CascStorageFileCount, + // Returns the number of local files in the storage. Note that files + // can exist under different names, so the total number of files in the archive + // can be higher than the value returned by this info class + CascStorageLocalFileCount, + + // Returns the total file count, including the offline files + CascStorageTotalFileCount, + + // Returns the CASC_STORAGE_FEATURES structure. CascStorageFeatures, - CascStorageGameInfo, - CascStorageGameBuild, CascStorageInstalledLocales, + CascStorageProduct, // Gives CASC_STORAGE_PRODUCT + CascStorageTags, // Gives CASC_STORAGE_TAGS structure CascStorageInfoClassMax } CASC_STORAGE_INFO_CLASS, *PCASC_STORAGE_INFO_CLASS; - -typedef struct _QUERY_KEY +typedef enum _CASC_FILE_INFO_CLASS +{ + CascFileContentKey, + CascFileEncodedKey, + CascFileFullInfo, // Gives CASC_FILE_FULL_INFO structure + CascFileInfoClassMax +} CASC_FILE_INFO_CLASS, *PCASC_FILE_INFO_CLASS; + +// See https://wowdev.wiki/TACT#Products +typedef enum _CASC_PRODUCT { - LPBYTE pbData; - DWORD cbData; -} QUERY_KEY, *PQUERY_KEY; + UnknownProduct, + HeroesOfTheStorm, + Diablo3, + Overwatch, + StarCraft1, + StarCraft2, + WorldOfWarcraft, + WarCraft3, + Destiny2, + CallOfDutyBlackOps4, + Odin, + MaxProductValue + +} CASC_PRODUCT, *PCASC_PRODUCT; + +// CascLib may provide a fake name, constructed from file data id, CKey or EKey. +// This enum helps to see what name was actually returned +// Note that any of these names can be passed to CascOpenFile with no extra flags +typedef enum _CASC_NAME_TYPE +{ + CascNameFull, // Fully qualified file name + CascNameDataId, // Name created from file data id (FILE%08X.dat) + CascNameCKey, // Name created as string representation of CKey + CascNameEKey // Name created as string representation of EKey +} CASC_NAME_TYPE, *PCASC_NAME_TYPE; // Structure for SFileFindFirstFile and SFileFindNextFile typedef struct _CASC_FIND_DATA { - char szFileName[MAX_PATH]; // Full name of the found file - char * szPlainName; // Plain name of the found file - BYTE EncodingKey[MD5_HASH_SIZE]; // Encoding key - DWORD dwLocaleFlags; // Locale flags (WoW only) - DWORD dwFileDataId; // File data ID (WoW only) - DWORD dwFileSize; // Size of the file + // Full name of the found file. In case when this is CKey/EKey, + // this will be just string representation of the key stored in 'FileKey' + char szFileName[MAX_PATH]; + + // Content key. This is present if the CASC_FEATURE_ROOT_CKEY is present + BYTE CKey[MD5_HASH_SIZE]; + + // Encoded key. This is always present. + BYTE EKey[MD5_HASH_SIZE]; + + // Tag mask. Only valid if the storage supports tags, otherwise 0 + ULONGLONG TagBitMask; + + // Plain name of the found file. Pointing inside the 'szFileName' array + char * szPlainName; + + // File data ID. Only valid if the storage supports file data IDs, otherwise CASC_INVALID_ID + DWORD dwFileDataId; + + // Size of the file, as retrieved from CKey entry or EKey entry + DWORD dwFileSize; + + // Locale flags. Only valid if the storage supports locale flags, otherwise CASC_INVALID_ID + DWORD dwLocaleFlags; + + // Content flags. Only valid if the storage supports content flags, otherwise CASC_INVALID_ID + DWORD dwContentFlags; + + // Hints as for which open method is suitable + DWORD bFileAvailable:1; // If true the file is available locally + DWORD bCanOpenByName:1; + DWORD bCanOpenByDataId:1; + DWORD bCanOpenByCKey:1; + DWORD bCanOpenByEKey:1; + CASC_NAME_TYPE NameType; } CASC_FIND_DATA, *PCASC_FIND_DATA; -//----------------------------------------------------------------------------- -// Callback functions +typedef struct _CASC_STORAGE_TAG +{ + LPCSTR szTagName; // Tag name (zero terminated, ANSI) + DWORD TagNameLength; // Length of the tag name + DWORD TagValue; // Tag value +} CASC_STORAGE_TAG, *PCASC_STORAGE_TAG; -typedef struct TFileStream TFileStream; -typedef void (WINAPI * STREAM_DOWNLOAD_CALLBACK)(void * pvUserData, ULONGLONG ByteOffset, DWORD dwTotalBytes); +typedef struct _CASC_STORAGE_TAGS +{ + size_t TagCount; // Number of items in the Tags array + size_t Reserved; // Reserved for future use -//----------------------------------------------------------------------------- -// We have our own qsort implementation, optimized for sorting array of pointers + CASC_STORAGE_TAG Tags[1]; // Array of CASC tags + +} CASC_STORAGE_TAGS, *PCASC_STORAGE_TAGS; + +typedef struct _CASC_STORAGE_PRODUCT +{ + LPCSTR szProductName; + DWORD dwBuildNumber; + CASC_PRODUCT Product; + +} CASC_STORAGE_PRODUCT, *PCASC_STORAGE_PRODUCT; -void qsort_pointer_array(void ** base, size_t num, int (*compare)(const void *, const void *, const void *), const void * context); +typedef struct _CASC_FILE_FULL_INFO +{ + BYTE CKey[MD5_HASH_SIZE]; // CKey + BYTE EKey[MD5_HASH_SIZE]; // EKey + char DataFileName[0x10]; // Plain name of the data file where the file is stored + ULONGLONG StorageOffset; // Offset of the file over the entire storage + ULONGLONG SegmentOffset; // Offset of the file in the segment file ("data.###") + ULONGLONG TagBitMask; // Bitmask of tags. Zero if not supported + ULONGLONG FileNameHash; // Hash of the file name. Zero if not supported + DWORD SegmentIndex; // Index of the segment file (aka 0 = "data.000") + DWORD FileDataId; // File data ID. CASC_INVALID_ID if not supported. + DWORD ContentSize; // Content size of the file + DWORD EncodedSize; // Encoded size of the file + DWORD LocaleFlags; // Locale flags. CASC_INVALID_ID if not supported. + DWORD ContentFlags; // Locale flags. CASC_INVALID_ID if not supported + +} CASC_FILE_FULL_INFO, *PCASC_FILE_FULL_INFO; + +//----------------------------------------------------------------------------- +// Some operations (e.g. opening an online storage) may take long time. +// This callback allows an application to be notified about loading progress. +// This callback only works for a single CascOpen(Online)Storage call. + +typedef bool (WINAPI * PFNPROGRESSCALLBACK)( // Return 'true' to cancel the loading process + void * PtrUserParam, // User-specific parameter passed to the callback + LPCSTR szWork, // Text for the current activity (example: "Loading "ENCODING" file") + LPCSTR szObject, // (optional) name of the object tied to the activity (example: index file name) + DWORD nCurrent, // (optional) current object being processed + DWORD nTotal // (optional) If non-zero, this is the total number of objects to process + ); + +void WINAPI CascSetProgressCallback( + PFNPROGRESSCALLBACK PtrUserCallback, // Pointer to the callback function that will be called during opening the storage + void * PtrUserParam // Arbitrary user parameter that will be passed to the callback + ); //----------------------------------------------------------------------------- // Functions for storage manipulation -bool WINAPI CascOpenStorage(const TCHAR * szDataPath, DWORD dwLocaleMask, HANDLE * phStorage); +bool WINAPI CascOpenStorage(LPCTSTR szDataPath, DWORD dwLocaleMask, HANDLE * phStorage); +bool WINAPI CascOpenOnlineStorage(LPCTSTR szLocalCache, LPCSTR szCodeName, LPCSTR szRegion, DWORD dwLocaleMask, HANDLE * phStorage); bool WINAPI CascGetStorageInfo(HANDLE hStorage, CASC_STORAGE_INFO_CLASS InfoClass, void * pvStorageInfo, size_t cbStorageInfo, size_t * pcbLengthNeeded); +bool WINAPI CascAddEncryptionKey(HANDLE hStorage, ULONGLONG KeyName, LPBYTE Key); bool WINAPI CascCloseStorage(HANDLE hStorage); -bool WINAPI CascOpenFileByIndexKey(HANDLE hStorage, PQUERY_KEY pIndexKey, DWORD dwFlags, HANDLE * phFile); -bool WINAPI CascOpenFileByEncodingKey(HANDLE hStorage, PQUERY_KEY pEncodingKey, DWORD dwFlags, HANDLE * phFile); -bool WINAPI CascOpenFile(HANDLE hStorage, const char * szFileName, DWORD dwLocale, DWORD dwFlags, HANDLE * phFile); +bool WINAPI CascOpenFile(HANDLE hStorage, const void * pvFileName, DWORD dwLocaleFlags, DWORD dwOpenFlags, HANDLE * phFile); +bool WINAPI CascGetFileInfo(HANDLE hFile, CASC_FILE_INFO_CLASS InfoClass, void * pvFileInfo, size_t cbFileInfo, size_t * pcbLengthNeeded); DWORD WINAPI CascGetFileSize(HANDLE hFile, PDWORD pdwFileSizeHigh); -DWORD WINAPI CascGetFileId(HANDLE hStorage, const char * szFileName); DWORD WINAPI CascSetFilePointer(HANDLE hFile, LONG lFilePos, LONG * plFilePosHigh, DWORD dwMoveMethod); bool WINAPI CascReadFile(HANDLE hFile, void * lpBuffer, DWORD dwToRead, PDWORD pdwRead); bool WINAPI CascCloseFile(HANDLE hFile); -HANDLE WINAPI CascFindFirstFile(HANDLE hStorage, const char * szMask, PCASC_FIND_DATA pFindData, const TCHAR * szListFile); +HANDLE WINAPI CascFindFirstFile(HANDLE hStorage, LPCSTR szMask, PCASC_FIND_DATA pFindData, LPCTSTR szListFile); bool WINAPI CascFindNextFile(HANDLE hFind, PCASC_FIND_DATA pFindData); bool WINAPI CascFindClose(HANDLE hFind); @@ -168,8 +286,8 @@ bool WINAPI CascFindClose(HANDLE hFind); #ifndef PLATFORM_WINDOWS -int GetLastError(); -void SetLastError(int nError); +DWORD GetLastError(); +void SetLastError(DWORD dwErrCode); #endif // PLATFORM_WINDOWS diff --git a/dep/CascLib/src/CascMndx.h b/dep/CascLib/src/CascMndx.h deleted file mode 100644 index 2ce268e40a6..00000000000 --- a/dep/CascLib/src/CascMndx.h +++ /dev/null @@ -1,359 +0,0 @@ -/*****************************************************************************/ -/* CascMndxRoot.h Copyright (c) Ladislav Zezula 2014 */ -/*---------------------------------------------------------------------------*/ -/* Interface file for MNDX structures */ -/*---------------------------------------------------------------------------*/ -/* Date Ver Who Comment */ -/* -------- ---- --- ------- */ -/* 15.05.14 1.00 Lad Created */ -/*****************************************************************************/ - -#ifndef __CASC_MNDX_ROOT__ -#define __CASC_MNDX_ROOT__ - -class TFileNameDatabase; - -#define CASC_MAX_MAR_FILES 3 // Maximum of 3 MAR files are supported -#define CASC_MNDX_SIGNATURE 0x58444E4D // 'MNDX' - -#define CASC_MAX_ENTRIES(type) (0xFFFFFFFF / sizeof(type)) - -#define CASC_SEARCH_INITIALIZING 0 -#define CASC_SEARCH_SEARCHING 2 -#define CASC_SEARCH_FINISHED 4 - -typedef struct _TRIPLET -{ - DWORD BaseValue; - DWORD Value2; - DWORD Value3; -} TRIPLET, *PTRIPLET; - -typedef struct _NAME_FRAG -{ - DWORD ItemIndex; // Back index to various tables - DWORD NextIndex; // The following item index - DWORD FragOffs; // Higher 24 bits are 0xFFFFFF00 --> A single matching character - // Otherwise --> Offset to the name fragment table -} NAME_FRAG, *PNAME_FRAG; - -typedef struct _PATH_STOP -{ - DWORD ItemIndex; - DWORD field_4; - DWORD field_8; - DWORD field_C; - DWORD field_10; -} PATH_STOP, *PPATH_STOP; - -typedef union _ARRAY_POINTER -{ - LPBYTE Bytes; // Pointer to an octet - char * Chars; // Pointer to a character - PDWORD Uint32s; // Pointer to a DWORD - PTRIPLET Triplets; // Pointer to TRIPLET - PNAME_FRAG NameFrags; // Pointer to name fragment entry - PPATH_STOP PathStopPtr; // Pointer to path checkpoint - PULONGLONG Int64Ptr; // Pointer to 64-bit integer - -} ARRAY_POINTER, *PARRAY_POINTER; - -// Simple access to various tables within TGenericArray -#define ByteArray ArrayPointer.Bytes -#define CharArray ArrayPointer.Chars -#define Uint32Array ArrayPointer.Uint32s -#define TripletArray ArrayPointer.Triplets -#define NameFragArray ArrayPointer.NameFrags - -class TByteStream -{ - public: - - TByteStream(); - - void ExchangeWith(TByteStream & Target); - int GetBytes(DWORD cbByteCount, PARRAY_POINTER PtrArray); - int SkipBytes(DWORD cbByteCount); - int SetByteBuffer(LPBYTE pbNewMarData, DWORD cbNewMarData); - int GetValue_DWORD(DWORD & Value); - int GetValue_ItemCount(DWORD & NumberOfBytes, DWORD & ItemCount, DWORD ItemSize); - int GetArray_DWORDs(PARRAY_POINTER PtrArray, DWORD ItemCount); - int GetArray_Triplets(PARRAY_POINTER PtrArray, DWORD ItemCount); - int GetArray_NameTable(PARRAY_POINTER PtrArray, DWORD ItemCount); - int GetArray_BYTES(PARRAY_POINTER PtrArray, DWORD ItemCount); - - LPBYTE pbByteData; - void * pvMappedFile; - DWORD cbByteData; - DWORD field_C; - HANDLE hFile; - HANDLE hMap; -}; - -class TGenericArray -{ - public: - - TGenericArray(); - ~TGenericArray(); - - int SetArrayValid(); - - void ExchangeWith(TGenericArray & Target); - void CopyFrom(TGenericArray & Source); - - void SetMaxItems_CHARS(DWORD NewMaxItemCount); - void SetMaxItems_PATH_STOP(DWORD NewMaxItemCount); - - void InsertOneItem_CHAR(char OneChar); - void InsertOneItem_PATH_STOP(PATH_STOP & NewItem); - - void sub_19583A0(DWORD NewItemCount); - - int LoadDwordsArray(TByteStream & InStream); - int LoadTripletsArray(TByteStream & InStream); - int LoadByteArray(TByteStream & InStream); - int LoadFragmentInfos(TByteStream & InStream); - int LoadStrings(TByteStream & InStream); - - int LoadDwordsArray_Copy(TByteStream & InStream); - int LoadTripletsArray_Copy(TByteStream & InStream); - int LoadBytes_Copy(TByteStream & InStream); - int LoadFragmentInfos_Copy(TByteStream & InStream); - int LoadStringsWithCopy(TByteStream & InStream); - - ARRAY_POINTER DataBuffer; - ARRAY_POINTER FirstValid; - - ARRAY_POINTER ArrayPointer; - DWORD ItemCount; // Number of items in the array - DWORD MaxItemCount; // Capacity of the array - bool bIsValidArray; -}; - -class TBitEntryArray : public TGenericArray -{ - public: - - TBitEntryArray(); - ~TBitEntryArray(); - - DWORD GetBitEntry(DWORD EntryIndex) - { - DWORD dwItemIndex = (EntryIndex * BitsPerEntry) >> 0x05; - DWORD dwStartBit = (EntryIndex * BitsPerEntry) & 0x1F; - DWORD dwEndBit = dwStartBit + BitsPerEntry; - DWORD dwResult; - - // If the end bit index is greater than 32, - // we also need to load from the next 32-bit item - if(dwEndBit > 0x20) - { - dwResult = (Uint32Array[dwItemIndex + 1] << (0x20 - dwStartBit)) | (Uint32Array[dwItemIndex] >> dwStartBit); - } - else - { - dwResult = Uint32Array[dwItemIndex] >> dwStartBit; - } - - // Now we also need to mask the result by the bit mask - return dwResult & EntryBitMask; - } - - void ExchangeWith(TBitEntryArray & Target); - int LoadFromStream(TByteStream & InStream); - int LoadFromStream_Exchange(TByteStream & InStream); - - DWORD BitsPerEntry; - DWORD EntryBitMask; - DWORD TotalEntries; -}; - -class TStruct40 -{ - public: - - TStruct40(); - - void InitSearchBuffers(); - - TGenericArray array_00; - TGenericArray PathStops; // Array of path checkpoints - DWORD ItemIndex; // Current name fragment: Index to various tables - DWORD CharIndex; - DWORD ItemCount; - DWORD SearchPhase; // 0 = initializing, 2 = searching, 4 = finished -}; - -class TMndxFindResult -{ - public: - - TMndxFindResult(); - ~TMndxFindResult(); - - int CreateStruct40(); - void FreeStruct40(); - - int SetSearchPath(const char * szNewSearchPath, size_t cchNewSearchPath); - - const char * szSearchMask; // Search mask without wildcards - size_t cchSearchMask; // Length of the search mask - DWORD field_8; - const char * szFoundPath; // Found path name - size_t cchFoundPath; // Length of the found path name - DWORD FileNameIndex; // Index of the file name - TStruct40 * pStruct40; -}; - -class TSparseArray -{ - public: - - TSparseArray(); - - void ExchangeWith(TSparseArray & TargetObject); - int LoadFromStream(TByteStream & InStream); - int LoadFromStream_Exchange(TByteStream & InStream); - - // Returns true if the item at n-th position is present - DWORD IsItemPresent(DWORD ItemIndex) - { - return (ItemBits.Uint32Array[ItemIndex >> 0x05] & (1 << (ItemIndex & 0x1F))); - } - - DWORD GetItemValue(DWORD ItemIndex); - - TGenericArray ItemBits; // Bit array for each item (1 = item is present) - DWORD TotalItemCount; // Total number of items in the array - DWORD ValidItemCount; // Number of present items in the array - TGenericArray BaseValues; // Array of base values for item indexes >= 0x200 - TGenericArray ArrayDwords_38; - TGenericArray ArrayDwords_50; -}; - -class TNameIndexStruct -{ - public: - - TNameIndexStruct(); - ~TNameIndexStruct(); - - bool CheckNameFragment(TMndxFindResult * pStruct1C, DWORD dwFragOffs); - bool CheckAndCopyNameFragment(TMndxFindResult * pStruct1C, DWORD dwFragOffs); - void CopyNameFragment(TMndxFindResult * pStruct1C, DWORD dwFragOffs); - - void ExchangeWith(TNameIndexStruct & Target); - int LoadFromStream(TByteStream & InStream); - int LoadFromStream_Exchange(TByteStream & InStream); - - TGenericArray NameFragments; - TSparseArray Struct68; -}; - -class TStruct10 -{ - public: - - TStruct10(); - - void CopyFrom(TStruct10 & Target); - int sub_1956FD0(DWORD dwBitMask); - int sub_1957050(DWORD dwBitMask); - int sub_19572E0(DWORD dwBitMask); - int sub_1957800(DWORD dwBitMask); - - DWORD field_0; - DWORD field_4; - DWORD field_8; - DWORD field_C; -}; - -class TFileNameDatabasePtr -{ - public: - - TFileNameDatabasePtr(); - ~TFileNameDatabasePtr(); - - int FindFileInDatabase(TMndxFindResult * pStruct1C); - int sub_1956CE0(TMndxFindResult * pStruct1C, bool * pbFindResult); - - int GetFileNameCount(PDWORD PtrFileNameCount); - int CreateDatabase(LPBYTE pbMarData, DWORD cbMarData); - int SetDatabase(TFileNameDatabase * pNewDB); - - TFileNameDatabase * pDB; -}; - -class TFileNameDatabase -{ - public: - - TFileNameDatabase(); - - void ExchangeWith(TFileNameDatabase & Target); - int LoadFromStream(TByteStream & InStream); - int LoadFromStream_Exchange(TByteStream & InStream); - - DWORD sub_1959CB0(DWORD dwHashValue); - DWORD sub_1959F50(DWORD arg_0); - - // Retrieves the name fragment distance - // HOTS: 19573D0/inlined - DWORD GetNameFragmentOffsetEx(DWORD LoBitsIndex, DWORD HiBitsIndex) - { - return (FrgmDist_HiBits.GetBitEntry(HiBitsIndex) << 0x08) | FrgmDist_LoBits.ByteArray[LoBitsIndex]; - } - - // HOTS: 1957350, inlined - DWORD GetNameFragmentOffset(DWORD LoBitsIndex) - { - return GetNameFragmentOffsetEx(LoBitsIndex, Struct68_D0.GetItemValue(LoBitsIndex)); - } - - bool sub_1957B80(TMndxFindResult * pStruct1C, DWORD dwKey); - bool CheckNextPathFragment(TMndxFindResult * pStruct1C); - bool FindFileInDatabase(TMndxFindResult * pStruct1C); - - void sub_1958D70(TMndxFindResult * pStruct1C, DWORD arg_4); - bool sub_1959010(TMndxFindResult * pStruct1C, DWORD arg_4); - bool sub_1958B00(TMndxFindResult * pStruct1C); - bool sub_1959460(TMndxFindResult * pStruct1C); - - TSparseArray Struct68_00; - TSparseArray FileNameIndexes; // Array of file name indexes - TSparseArray Struct68_D0; - - // This pair of arrays serves for fast conversion from name hash to fragment offset - TGenericArray FrgmDist_LoBits; // Array of lower 8 bits of name fragment offset - TBitEntryArray FrgmDist_HiBits; // Array of upper x bits of name fragment offset - - TNameIndexStruct IndexStruct_174; - TFileNameDatabasePtr NextDB; - - TGenericArray NameFragTable; - - DWORD NameFragIndexMask; - DWORD field_214; - TStruct10 Struct10; - TByteStream MarStream; -}; - -typedef struct _MAR_FILE -{ - TFileNameDatabasePtr * pDatabasePtr; - LPBYTE pbMarData; - DWORD cbMarData; -} MAR_FILE, *PMAR_FILE; - -//----------------------------------------------------------------------------- -// Macros - -// Returns nonzero if the name fragment match is a single-char match -inline bool IS_SINGLE_CHAR_MATCH(TGenericArray & Table, DWORD ItemIndex) -{ - return ((Table.NameFragArray[ItemIndex].FragOffs & 0xFFFFFF00) == 0xFFFFFF00); -} - -#endif // __CASC_MNDX_ROOT__ diff --git a/dep/CascLib/src/CascOpenFile.cpp b/dep/CascLib/src/CascOpenFile.cpp index 9db3691af48..741ab1e1005 100644 --- a/dep/CascLib/src/CascOpenFile.cpp +++ b/dep/CascLib/src/CascOpenFile.cpp @@ -15,196 +15,63 @@ //----------------------------------------------------------------------------- // Local functions -TCascFile * IsValidFileHandle(HANDLE hFile) +PCASC_CKEY_ENTRY FindCKeyEntry_CKey(TCascStorage * hs, LPBYTE pbCKey, PDWORD PtrIndex) { - TCascFile * hf = (TCascFile *)hFile; - - return (hf != NULL && hf->hs != NULL && hf->szClassName != NULL && !strcmp(hf->szClassName, "TCascFile")) ? hf : NULL; + return (PCASC_CKEY_ENTRY)hs->CKeyMap.FindObject(pbCKey, PtrIndex); } -PCASC_INDEX_ENTRY FindIndexEntry(TCascStorage * hs, PQUERY_KEY pIndexKey) +PCASC_CKEY_ENTRY FindCKeyEntry_EKey(TCascStorage * hs, LPBYTE pbEKey, PDWORD PtrIndex) { - PCASC_INDEX_ENTRY pIndexEntry = NULL; - - if(hs->pIndexEntryMap != NULL) - pIndexEntry = (PCASC_INDEX_ENTRY)Map_FindObject(hs->pIndexEntryMap, pIndexKey->pbData, NULL); - - return pIndexEntry; -} - -PCASC_ENCODING_ENTRY FindEncodingEntry(TCascStorage * hs, PQUERY_KEY pEncodingKey, PDWORD PtrIndex) -{ - PCASC_ENCODING_ENTRY pEncodingEntry = NULL; - - if(hs->pEncodingMap != NULL) - pEncodingEntry = (PCASC_ENCODING_ENTRY)Map_FindObject(hs->pEncodingMap, pEncodingKey->pbData, PtrIndex); - - return pEncodingEntry; + return (PCASC_CKEY_ENTRY)hs->EKeyMap.FindObject(pbEKey, PtrIndex); } -static TCascFile * CreateFileHandle(TCascStorage * hs, PCASC_INDEX_ENTRY pIndexEntry) +bool OpenFileByCKeyEntry(TCascStorage * hs, PCASC_CKEY_ENTRY pCKeyEntry, DWORD dwOpenFlags, HANDLE * PtrFileHandle) { - ULONGLONG FileOffsMask = ((ULONGLONG)1 << hs->KeyMapping[0].SegmentBits) - 1; - ULONGLONG FileOffset = ConvertBytesToInteger_5(pIndexEntry->FileOffsetBE); - TCascFile * hf; + TCascFile * hf = NULL; + int nError = ERROR_FILE_NOT_FOUND; - // Allocate the CASC file structure - hf = (TCascFile *)CASC_ALLOC(TCascFile, 1); - if(hf != NULL) + // If the CKey entry is NULL, we consider the file non-existant + if(pCKeyEntry != NULL) { - // Initialize the structure - memset(hf, 0, sizeof(TCascFile)); - hf->ArchiveIndex = (DWORD)(FileOffset >> hs->KeyMapping[0].SegmentBits); - hf->HeaderOffset = (DWORD)(FileOffset & FileOffsMask); - hf->szClassName = "TCascFile"; - - // Copy the file size. Note that for all files except ENCODING, - // this is the compressed file size - hf->CompressedSize = ConvertBytesToInteger_4_LE(pIndexEntry->FileSizeLE); - - // For now, we set the file size to be equal to compressed size - // This is used when loading the ENCODING file, which does not - // have entry in the encoding table - hf->FileSize = hf->CompressedSize; - - // Increment the number of references to the archive - hs->dwRefCount++; - hf->hs = hs; - } - - return hf; -} - -static bool OpenFileByIndexKey(TCascStorage * hs, PQUERY_KEY pIndexKey, DWORD dwFlags, TCascFile ** ppCascFile) -{ - PCASC_INDEX_ENTRY pIndexEntry; - int nError = ERROR_SUCCESS; - - CASCLIB_UNUSED(dwFlags); - - // Find the key entry in the array of file keys - pIndexEntry = FindIndexEntry(hs, pIndexKey); - if(pIndexEntry == NULL) - nError = ERROR_FILE_NOT_FOUND; - - // Create the file handle structure - if(nError == ERROR_SUCCESS) - { - ppCascFile[0] = CreateFileHandle(hs, pIndexEntry); - if(ppCascFile[0] == NULL) - nError = ERROR_FILE_NOT_FOUND; + // Create the file handle structure + if((hf = new TCascFile(hs, pCKeyEntry)) != NULL) + { + hf->bVerifyIntegrity = (dwOpenFlags & CASC_STRICT_DATA_CHECK) ? true : false; + hf->bDownloadFileIf = (hs->dwFeatures & CASC_FEATURE_ONLINE) ? true : false; + nError = ERROR_SUCCESS; + } + else + { + nError = ERROR_NOT_ENOUGH_MEMORY; + } } -#ifdef CASCLIB_TEST - if(nError == ERROR_SUCCESS && ppCascFile[0] != NULL) - { - ppCascFile[0]->FileSize_IdxEntry = ConvertBytesToInteger_4_LE(pIndexEntry->FileSizeLE); - } -#endif + // Give the output parameter, no matter what + PtrFileHandle[0] = (HANDLE)hf; + // Handle last error if(nError != ERROR_SUCCESS) SetLastError(nError); return (nError == ERROR_SUCCESS); } -static bool OpenFileByEncodingKey(TCascStorage * hs, PQUERY_KEY pEncodingKey, DWORD dwFlags, TCascFile ** ppCascFile) -{ - PCASC_ENCODING_ENTRY pEncodingEntry; - QUERY_KEY IndexKey; - - // Find the encoding entry - pEncodingEntry = FindEncodingEntry(hs, pEncodingKey, NULL); - if(pEncodingEntry == NULL) - { - SetLastError(ERROR_FILE_NOT_FOUND); - return false; - } - - // Prepare the file index and open the file by index - // Note: We don't know what to do if there is more than just one index key - // We always take the first file present. Is that correct? - IndexKey.pbData = GET_INDEX_KEY(pEncodingEntry); - IndexKey.cbData = MD5_HASH_SIZE; - if(OpenFileByIndexKey(hs, &IndexKey, dwFlags, ppCascFile)) - { - // Check if the file handle was created - if(ppCascFile[0] != NULL) - { - // Fill-in the file size. For all files except ENCODING, - // this overrides the value stored in the index entry. - ppCascFile[0]->FileSize = ConvertBytesToInteger_4(pEncodingEntry->FileSizeBE); - -#ifdef CASCLIB_TEST - ppCascFile[0]->FileSize_EncEntry = ConvertBytesToInteger_4(pEncodingEntry->FileSizeBE); -#endif - return true; - } - } - - return false; -} - //----------------------------------------------------------------------------- // Public functions -bool WINAPI CascOpenFileByIndexKey(HANDLE hStorage, PQUERY_KEY pIndexKey, DWORD dwFlags, HANDLE * phFile) -{ - TCascStorage * hs; - - // Validate the storage handle - hs = IsValidStorageHandle(hStorage); - if(hs == NULL) - { - SetLastError(ERROR_INVALID_HANDLE); - return false; - } - - // Validate the other parameters - if(pIndexKey == NULL || pIndexKey->pbData == NULL || pIndexKey->cbData == 0 || phFile == NULL) - { - SetLastError(ERROR_INVALID_PARAMETER); - return false; - } - - // Use the internal function to open the file - return OpenFileByIndexKey(hs, pIndexKey, dwFlags, (TCascFile **)phFile); -} - -bool WINAPI CascOpenFileByEncodingKey(HANDLE hStorage, PQUERY_KEY pEncodingKey, DWORD dwFlags, HANDLE * phFile) +bool WINAPI CascOpenFile(HANDLE hStorage, const void * pvFileName, DWORD dwLocaleFlags, DWORD dwOpenFlags, HANDLE * PtrFileHandle) { + PCASC_CKEY_ENTRY pCKeyEntry = NULL; TCascStorage * hs; - - // Validate the storage handle - hs = IsValidStorageHandle(hStorage); - if(hs == NULL) - { - SetLastError(ERROR_INVALID_HANDLE); - return false; - } - - // Validate the other parameters - if(pEncodingKey == NULL || pEncodingKey->pbData == NULL || pEncodingKey->cbData == 0 || phFile == NULL) - { - SetLastError(ERROR_INVALID_PARAMETER); - return false; - } - - // Use the internal function fo open the file - return OpenFileByEncodingKey(hs, pEncodingKey, dwFlags, (TCascFile **)phFile); -} - -bool WINAPI CascOpenFile(HANDLE hStorage, const char * szFileName, DWORD dwLocale, DWORD dwFlags, HANDLE * phFile) -{ - TCascStorage * hs; - QUERY_KEY EncodingKey; - LPBYTE pbEncodingKey; - BYTE KeyBuffer[MD5_HASH_SIZE]; + const char * szFileName; + DWORD FileDataId = CASC_INVALID_ID; + BYTE CKeyEKeyBuffer[MD5_HASH_SIZE]; int nError = ERROR_SUCCESS; - CASCLIB_UNUSED(dwLocale); + // This parameter is not used + CASCLIB_UNUSED(dwLocaleFlags); // Validate the storage handle - hs = IsValidStorageHandle(hStorage); + hs = TCascStorage::IsValid(hStorage); if(hs == NULL) { SetLastError(ERROR_INVALID_HANDLE); @@ -212,107 +79,104 @@ bool WINAPI CascOpenFile(HANDLE hStorage, const char * szFileName, DWORD dwLocal } // Validate the other parameters - if(szFileName == NULL || szFileName[0] == 0 || phFile == NULL) + if(PtrFileHandle == NULL) { SetLastError(ERROR_INVALID_PARAMETER); return false; } - // If the user is opening the file via encoding key, skip the ROOT file processing - if((dwFlags & CASC_OPEN_BY_ENCODING_KEY) == 0) - { - // Let the root directory provider get us the encoding key - pbEncodingKey = RootHandler_GetKey(hs->pRootHandler, szFileName); - if(pbEncodingKey == NULL) - { + // Retrieve the CKey/EKey from the file name in different modes + switch(dwOpenFlags & CASC_OPEN_TYPE_MASK) + { + case CASC_OPEN_BY_NAME: + + // The 'pvFileName' must be zero terminated ANSI file name + szFileName = (const char *)pvFileName; + if(szFileName == NULL || szFileName[0] == 0) + { + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } + + // The first chance: Try to find the file by name (using the root handler) + pCKeyEntry = hs->pRootHandler->GetFile(hs, szFileName); + if(pCKeyEntry != NULL) + break; + + // Second chance: If the file name is actually a file data id, we convert it to file data ID + if(IsFileDataIdName(szFileName, FileDataId)) + { + pCKeyEntry = hs->pRootHandler->GetFile(hs, FileDataId); + if(pCKeyEntry != NULL) + break; + } + + // Third chance: If the file name is a string representation of CKey/EKey, we try to query for CKey + if(IsFileCKeyEKeyName(szFileName, CKeyEKeyBuffer)) + { + pCKeyEntry = FindCKeyEntry_CKey(hs, CKeyEKeyBuffer); + if(pCKeyEntry != NULL) + break; + + pCKeyEntry = FindCKeyEntry_EKey(hs, CKeyEKeyBuffer); + if(pCKeyEntry != NULL) + break; + } + SetLastError(ERROR_FILE_NOT_FOUND); return false; - } - // Setup the encoding key - EncodingKey.pbData = pbEncodingKey; - EncodingKey.cbData = MD5_HASH_SIZE; - } - else - { - // Check the length of the file name - if(strlen(szFileName) < MD5_STRING_SIZE) - { - SetLastError(ERROR_INVALID_PARAMETER); - return false; - } + case CASC_OPEN_BY_CKEY: - // Convert the file name to binary blob - EncodingKey.pbData = KeyBuffer; - EncodingKey.cbData = MD5_HASH_SIZE; - nError = ConvertStringToBinary(szFileName, MD5_STRING_SIZE, KeyBuffer); - } + // The 'pvFileName' must be a pointer to 16-byte CKey or EKey + if(pvFileName == NULL) + { + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } - // Use the encoding key to find the file in the encoding table entry - if(nError == ERROR_SUCCESS) - { - if(!OpenFileByEncodingKey(hs, &EncodingKey, dwFlags, (TCascFile **)phFile)) - { - assert(GetLastError() != ERROR_SUCCESS); - nError = GetLastError(); - } - } + // Search the CKey map in order to find the CKey entry + pCKeyEntry = FindCKeyEntry_CKey(hs, (LPBYTE)pvFileName); + break; -#ifdef CASCLIB_TEST -// if(phFile[0] != NULL && pRootEntryMndx != NULL) -// { -// ((TCascFile *)(phFile[0]))->FileSize_RootEntry = pRootEntryMndx->FileSize; -// } -#endif + case CASC_OPEN_BY_EKEY: - if(nError != ERROR_SUCCESS) - SetLastError(nError); - return (nError == ERROR_SUCCESS); -} + // The 'pvFileName' must be a pointer to 16-byte CKey or EKey + if(pvFileName == NULL) + { + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } -DWORD WINAPI CascGetFileId(HANDLE hStorage, const char * szFileName) -{ - TCascStorage * hs; + // Search the CKey map in order to find the CKey entry + pCKeyEntry = FindCKeyEntry_EKey(hs, (LPBYTE)pvFileName); + break; - // Validate the storage handle - hs = IsValidStorageHandle(hStorage); - if (hs == NULL) - { - SetLastError(ERROR_INVALID_HANDLE); - return false; - } + case CASC_OPEN_BY_FILEID: - // Validate the other parameters - if (szFileName == NULL || szFileName[0] == 0) - { - SetLastError(ERROR_INVALID_PARAMETER); - return false; + // Retrieve the file CKey/EKey + pCKeyEntry = hs->pRootHandler->GetFile(hs, CASC_FILE_DATA_ID_FROM_STRING(pvFileName)); + break; + + default: + + // Unknown open mode + nError = ERROR_INVALID_PARAMETER; + break; } - return RootHandler_GetFileId(hs->pRootHandler, szFileName); + // Perform the open operation + return OpenFileByCKeyEntry(hs, pCKeyEntry, dwOpenFlags, PtrFileHandle); } bool WINAPI CascCloseFile(HANDLE hFile) { TCascFile * hf; - hf = IsValidFileHandle(hFile); - if(hf != NULL) + hf = TCascFile::IsValid(hFile); + if (hf != NULL) { - // Close (dereference) the archive handle - if(hf->hs != NULL) - CascCloseStorage((HANDLE)hf->hs); - hf->hs = NULL; - - // Free the file cache and frame array - if(hf->pbFileCache != NULL) - CASC_FREE(hf->pbFileCache); - if(hf->pFrames != NULL) - CASC_FREE(hf->pFrames); - - // Free the structure itself - hf->szClassName = NULL; - CASC_FREE(hf); + delete hf; return true; } diff --git a/dep/CascLib/src/CascOpenStorage.cpp b/dep/CascLib/src/CascOpenStorage.cpp index ec277f67c13..53031169cbb 100644 --- a/dep/CascLib/src/CascOpenStorage.cpp +++ b/dep/CascLib/src/CascOpenStorage.cpp @@ -15,1101 +15,1221 @@ #include "CascCommon.h" //----------------------------------------------------------------------------- -// Local structures +// Local defines -// Size of one segment in the ENCODING table -// The segment is filled by entries of type -#define CASC_ENCODING_SEGMENT_SIZE 0x1000 +// Limit for "orphaned" items - those that are in index files, but are not in ENCODING manifest +#define CASC_MAX_ORPHANED_ITEMS 0x100 -typedef struct _BLOCK_SIZE_AND_HASH -{ - DWORD cbBlockSize; - DWORD dwBlockHash; +//----------------------------------------------------------------------------- +// Local variables -} BLOCK_SIZE_AND_HASH, *PBLOCK_SIZE_AND_HASH; +static PFNPROGRESSCALLBACK PfnProgressCallback = NULL; +static void * PtrProgressParam = NULL; -typedef struct _FILE_INDEX_HEADER_V1 -{ - USHORT field_0; - BYTE KeyIndex; // Key index (0 for data.i0x, 1 for data.i1x, 2 for data.i2x etc.) - BYTE align_3; - DWORD field_4; - ULONGLONG field_8; - ULONGLONG MaxFileOffset; - BYTE SpanSizeBytes; - BYTE SpanOffsBytes; - BYTE KeyBytes; - BYTE SegmentBits; // Number of bits for file offset - DWORD KeyCount1; - DWORD KeyCount2; - DWORD KeysHash1; - DWORD KeysHash2; - DWORD dwHeaderHash; -} FILE_INDEX_HEADER_V1, *PFILE_INDEX_HEADER_V1; - -typedef struct _FILE_INDEX_HEADER_V2 -{ - USHORT IndexVersion; // Must be 0x07 - BYTE KeyIndex; // Must be equal to the file key index - BYTE ExtraBytes; // (?) Extra bytes in the key record - BYTE SpanSizeBytes; // Size of field with file size - BYTE SpanOffsBytes; // Size of field with file offset - BYTE KeyBytes; // Size of the file key (bytes) - BYTE SegmentBits; // Number of bits for the file offset (rest is archive index) - ULONGLONG MaxFileOffset; - -} FILE_INDEX_HEADER_V2, *PFILE_INDEX_HEADER_V2; - -typedef struct _FILE_ENCODING_SEGMENT +//----------------------------------------------------------------------------- +// TCascStorage service functions + +TCascStorage::TCascStorage() { - BYTE FirstEncodingKey[MD5_HASH_SIZE]; // The first encoding key in the segment - BYTE SegmentHash[MD5_HASH_SIZE]; // MD5 hash of the entire segment + // Prepare the base storage parameters + szClassName = "TCascStorage"; + pRootHandler = NULL; + dwDefaultLocale = CASC_LOCALE_ENUS | CASC_LOCALE_ENGB; + dwRefCount = 1; + + szRootPath = szDataPath = szIndexPath = szBuildFile = szCdnServers = szCdnPath = szCodeName = NULL; + szProductName = NULL; + szIndexFormat = NULL; + szRegion = NULL; + + memset(DataFiles, 0, sizeof(DataFiles)); + Product = UnknownProduct; + dwBuildNumber = 0; + dwFeatures = 0; + bAllowOrphans = false; + BuildFileType = CascBuildNone; + + LocalFiles = TotalFiles = EKeyEntries = OrphanItems = SkippedItems = EKeyLength = FileOffsetBits = 0; + + // Take the callback param and data. Zero the global pointers + PfnCallback = PfnProgressCallback; + PtrCallbackParam = PtrProgressParam; + PfnProgressCallback = NULL; + PtrProgressParam = NULL; +} -} FILE_ENCODING_SEGMENT, *PFILE_ENCODING_SEGMENT; +TCascStorage::~TCascStorage() +{ + // Free the root handler + if(pRootHandler != NULL) + delete pRootHandler; + pRootHandler = NULL; -//----------------------------------------------------------------------------- -// Local variables + // Close all data files + for(size_t i = 0; i < CASC_MAX_DATA_FILES; i++) + { + FileStream_Close(DataFiles[i]); + DataFiles[i] = NULL; + } -static const TCHAR * szAllowedHexChars = _T("0123456789aAbBcCdDeEfF"); -static const TCHAR * szIndexFormat_V1 = _T("data.i%x%x"); -static const TCHAR * szIndexFormat_V2 = _T("%02x%08x.idx"); + // Free the file paths + CASC_FREE(szDataPath); + CASC_FREE(szRootPath); + CASC_FREE(szBuildFile); + CASC_FREE(szIndexPath); + CASC_FREE(szCdnServers); + CASC_FREE(szCdnPath); + CASC_FREE(szCodeName); + CASC_FREE(szRegion); + + // Free the blobs + FreeCascBlob(&CdnConfigKey); + FreeCascBlob(&CdnBuildKey); + + FreeCascBlob(&ArchiveGroup); + FreeCascBlob(&ArchivesKey); + FreeCascBlob(&PatchArchivesKey); + FreeCascBlob(&PatchArchivesGroup); + FreeCascBlob(&BuildFiles); + szClassName = NULL; +} -//----------------------------------------------------------------------------- -// Local functions +TCascStorage * TCascStorage::AddRef() +{ + dwRefCount++; + return this; +} -inline void CopyFileKey(LPBYTE Trg, LPBYTE Src) +TCascStorage * TCascStorage::Release() { - Trg[0x00] = Src[0x00]; - Trg[0x01] = Src[0x01]; - Trg[0x02] = Src[0x02]; - Trg[0x03] = Src[0x03]; - Trg[0x04] = Src[0x04]; - Trg[0x05] = Src[0x05]; - Trg[0x06] = Src[0x06]; - Trg[0x07] = Src[0x07]; - Trg[0x08] = Src[0x08]; - Trg[0x09] = Src[0x09]; - Trg[0x0A] = Src[0x0A]; - Trg[0x0B] = Src[0x0B]; - Trg[0x0C] = Src[0x0C]; - Trg[0x0D] = Src[0x0D]; - Trg[0x0E] = Src[0x0E]; - Trg[0x0F] = Src[0x0F]; + if (dwRefCount == 1) + { + delete this; + return NULL; + } + + dwRefCount--; + return NULL; } -TCascStorage * IsValidStorageHandle(HANDLE hStorage) +TCascStorage * TCascStorage::IsValid(HANDLE hStorage) { TCascStorage * hs = (TCascStorage *)hStorage; return (hs != NULL && hs->szClassName != NULL && !strcmp(hs->szClassName, "TCascStorage")) ? hs : NULL; } -// "data.iXY" -static bool IsIndexFileName_V1(const TCHAR * szFileName) -{ - // Check if the name looks like a valid index file - return (_tcslen(szFileName) == 8 && - _tcsnicmp(szFileName, _T("data.i"), 6) == 0 && - _tcsspn(szFileName + 6, szAllowedHexChars) == 2); -} +//----------------------------------------------------------------------------- +// Local functions -static bool IsIndexFileName_V2(const TCHAR * szFileName) +void * ProbeOutputBuffer(void * pvBuffer, size_t cbLength, size_t cbMinLength, size_t * pcbLengthNeeded) { - // Check if the name looks like a valid index file - return (_tcslen(szFileName) == 14 && - _tcsspn(szFileName, _T("0123456789aAbBcCdDeEfF")) == 0x0A && - _tcsicmp(szFileName + 0x0A, _T(".idx")) == 0); + // Verify the output length + if(cbLength < cbMinLength) + { + SetLastError(ERROR_INSUFFICIENT_BUFFER); + pvBuffer = NULL; + } + + // Give the output length and return result + if(pcbLengthNeeded != NULL) + pcbLengthNeeded[0] = cbMinLength; + return pvBuffer; } -static bool IsRootFile_Starcraft1(LPBYTE pbFileData, DWORD cbFileData) +static TCHAR * CheckForIndexDirectory(TCascStorage * hs, const TCHAR * szSubDir) { - LPBYTE pbFileEnd = pbFileData + cbFileData; - LPBYTE pbHashName; - LPBYTE pbHashEnd; - - // Skip the file name - while(pbFileData < pbFileEnd && pbFileData[0] != '|') - pbFileData++; - if(pbFileData[0] != '|') - return false; + TCHAR * szIndexPath; - // Then, a MD5 must follow - pbHashName = pbHashEnd = pbFileData + 1; - while(pbHashEnd < pbFileEnd && pbHashEnd[0] != 0x0A) - pbHashEnd++; - if(pbHashEnd[0] != 0x0A) - return false; + // Combine the index path + szIndexPath = CombinePath(hs->szDataPath, szSubDir); + if (!DirectoryExists(szIndexPath)) + { + CASC_FREE(szIndexPath); + } - // The length must be exactly 32 characters - return ((pbHashEnd - pbHashName) == 32); + return szIndexPath; } -static bool IsCascIndexHeader_V1(LPBYTE pbFileData, DWORD cbFileData) +static int CreateCKeyMaps(TCascStorage * hs, CASC_ENCODING_HEADER & EnHeader) { - PFILE_INDEX_HEADER_V1 pIndexHeader = (PFILE_INDEX_HEADER_V1)pbFileData; - DWORD dwHeaderHash; - bool bResult = false; + size_t nEstimatedEntries = (EnHeader.CKeyPageCount * EnHeader.CKeyPageSize) / sizeof(FILE_CKEY_ENTRY); + size_t nIxEntries = hs->IndexArray.ItemCount(); + int nError; - // Check the size - if(cbFileData >= sizeof(FILE_INDEX_HEADER_V1)) + // Orphaned items: These are present in INDEX files (by EKey), but missing in the ENCODING manifest. + // Probably a bug in generator of "2018 - New CASC\00001", but we want to open the storage nontheless. + if(nEstimatedEntries < 0x100) { - // Save the header hash - dwHeaderHash = pIndexHeader->dwHeaderHash; - pIndexHeader->dwHeaderHash = 0; + nEstimatedEntries = nEstimatedEntries + nIxEntries; + hs->bAllowOrphans = true; + } - // Calculate the hash - if(hashlittle(pIndexHeader, sizeof(FILE_INDEX_HEADER_V1), 0) == dwHeaderHash) - bResult = true; + // Allow some room for extra entries + nEstimatedEntries += CASC_MAX_ORPHANED_ITEMS; - // Put the hash back - pIndexHeader->dwHeaderHash = dwHeaderHash; - } + // Create the array of CKey items + nError = hs->CKeyArray.Create(sizeof(CASC_CKEY_ENTRY), nEstimatedEntries); + if(nError != ERROR_SUCCESS) + return nError; + + // Create the map CKey -> CASC_CKEY_ENTRY + nError = hs->CKeyMap.Create(nEstimatedEntries, EnHeader.CKeyLength, FIELD_OFFSET(CASC_CKEY_ENTRY, CKey)); + if(nError != ERROR_SUCCESS) + return nError; + + // Create the map EKey -> CASC_CKEY_ENTRY + nError = hs->EKeyMap.Create(nEstimatedEntries, hs->EKeyLength, FIELD_OFFSET(CASC_CKEY_ENTRY, EKey)); + if(nError != ERROR_SUCCESS) + return nError; - return bResult; + return ERROR_SUCCESS; } -static bool IsCascIndexHeader_V2(LPBYTE pbFileData, DWORD cbFileData) +int CaptureEncodingHeader(CASC_ENCODING_HEADER & EnHeader, LPBYTE pbFileData, size_t cbFileData) { - PBLOCK_SIZE_AND_HASH pSizeAndHash = (PBLOCK_SIZE_AND_HASH)pbFileData; - unsigned int HashHigh = 0; - unsigned int HashLow = 0; + PFILE_ENCODING_HEADER pFileHeader = (PFILE_ENCODING_HEADER)pbFileData; - // Check for the header - if(cbFileData < sizeof(BLOCK_SIZE_AND_HASH) || pSizeAndHash->cbBlockSize < 0x10) - return false; - if(cbFileData < pSizeAndHash->cbBlockSize + sizeof(BLOCK_SIZE_AND_HASH)) - return false; + // Check the signature ('EN') and version + if(cbFileData < sizeof(FILE_ENCODING_HEADER) || pFileHeader->Magic != FILE_MAGIC_ENCODING || pFileHeader->Version != 0x01) + return ERROR_BAD_FORMAT; - // The index header for CASC v 2.0 begins with length and checksum - hashlittle2(pSizeAndHash + 1, pSizeAndHash->cbBlockSize, &HashHigh, &HashLow); - return (HashHigh == pSizeAndHash->dwBlockHash); + // Note that we don't support CKey and EKey sizes other than 0x10 in the ENCODING file + if(pFileHeader->CKeyLength != MD5_HASH_SIZE || pFileHeader->EKeyLength != MD5_HASH_SIZE) + return ERROR_BAD_FORMAT; + + EnHeader.Magic = pFileHeader->Magic; + EnHeader.Version = pFileHeader->Version; + EnHeader.CKeyLength = pFileHeader->CKeyLength; + EnHeader.EKeyLength = pFileHeader->EKeyLength; + EnHeader.CKeyPageCount = ConvertBytesToInteger_4(pFileHeader->CKeyPageCount); + EnHeader.CKeyPageSize = ConvertBytesToInteger_2(pFileHeader->CKeyPageSize) * 1024; + EnHeader.EKeyPageCount = ConvertBytesToInteger_4(pFileHeader->EKeyPageCount); + EnHeader.EKeyPageSize = ConvertBytesToInteger_2(pFileHeader->EKeyPageSize) * 1024; + EnHeader.ESpecBlockSize = ConvertBytesToInteger_4(pFileHeader->ESpecBlockSize); + return ERROR_SUCCESS; } -static bool CutLastPathPart(TCHAR * szWorkPath) +static int LoadEncodingCKeyPage(TCascStorage * hs, CASC_ENCODING_HEADER & EnHeader, LPBYTE pbPageBegin, LPBYTE pbEndOfPage) { - size_t nLength = _tcslen(szWorkPath); + PCASC_CKEY_ENTRY pCKeyEntry; + PFILE_CKEY_ENTRY pFileEntry; + LPBYTE pbFileEntry = pbPageBegin; + + // Sanity checks + assert(hs->CKeyMap.IsInitialized()); + assert(hs->EKeyMap.IsInitialized()); + + // Parse all encoding entries + while(pbFileEntry < pbEndOfPage) + { + // Get pointer to the encoding entry + pFileEntry = (PFILE_CKEY_ENTRY)pbFileEntry; + if(pFileEntry->EKeyCount == 0) + break; + + // Example of a file entry with multiple EKeys: + // Overwatch build 24919, CKey: 0e 90 94 fa d2 cb 85 ac d0 7c ea 09 f9 c5 ba 00 +// BREAKIF(pFileEntry->EKeyCount > 1); - // Go one character back - if(nLength > 0) - nLength--; + // Insert the CKey entry into the array + pCKeyEntry = (PCASC_CKEY_ENTRY)hs->CKeyArray.Insert(1); + if(pCKeyEntry != NULL) + { + // Supply both CKey and EKey. Rewrite EKey regardless, because ENCODING manifest contains a full one + CopyMemory16(pCKeyEntry->CKey, pFileEntry->CKey); + CopyMemory16(pCKeyEntry->EKey, pFileEntry->EKey); + pCKeyEntry->StorageOffset = CASC_INVALID_OFFS64; + pCKeyEntry->TagBitMask = 0; + pCKeyEntry->EncodedSize = CASC_INVALID_SIZE; + pCKeyEntry->ContentSize = ConvertBytesToInteger_4(pFileEntry->ContentSize); + pCKeyEntry->RefCount = 0; + pCKeyEntry->Priority = 0; + pCKeyEntry->Flags = (CASC_CE_HAS_CKEY | CASC_CE_HAS_EKEY | CASC_CE_IN_ENCODING); + + // Insert the item into both maps + hs->CKeyMap.InsertObject(pCKeyEntry, pCKeyEntry->CKey); + hs->EKeyMap.InsertObject(pCKeyEntry, pCKeyEntry->EKey); + } - // Cut ending (back)slashes, if any - while(nLength > 0 && (szWorkPath[nLength] == _T('\\') || szWorkPath[nLength] == _T('/'))) - nLength--; + // Move to the next encoding entry + pbFileEntry = pbFileEntry + 2 + 4 + EnHeader.CKeyLength + (pFileEntry->EKeyCount * EnHeader.EKeyLength); + } + return ERROR_SUCCESS; +} + +static PCASC_CKEY_ENTRY InsertCKeyEntry(TCascStorage * hs, PCASC_CKEY_ENTRY pSourceEntry, bool bAllowOrphans, bool * pbAllocatedNewEntry) +{ + PCASC_CKEY_ENTRY pCKeyEntry = NULL; + bool bAllocatedNewEntry = false; - // Cut the last path part - while(nLength > 0) + if(pSourceEntry->Flags & CASC_CE_HAS_EKEY) { - // End of path? - if(szWorkPath[nLength] == _T('\\') || szWorkPath[nLength] == _T('/')) + // If there is that item already, reuse it + pCKeyEntry = FindCKeyEntry_EKey(hs, pSourceEntry->EKey); + if(pCKeyEntry == NULL) { - szWorkPath[nLength] = 0; - return true; + // Increment number of orphaned index entries + hs->OrphanItems++; + + // Insert the orphan item only of they are allowed and if we won't overflow the array + if(bAllowOrphans && (hs->CKeyArray.ItemCount() + 1) < hs->CKeyArray.ItemCountMax()) + { + // Insert a new entry to the array + pCKeyEntry = (PCASC_CKEY_ENTRY)hs->CKeyArray.Insert(1); + if(pCKeyEntry != NULL) + { + // Copy CKey, EKey and some flags + if(pSourceEntry->Flags & CASC_CE_HAS_CKEY) + CopyMemory16(pCKeyEntry->CKey, pSourceEntry->CKey); + + if(pSourceEntry->Flags & CASC_CE_HAS_EKEY) + CopyMemory16(pCKeyEntry->EKey, pSourceEntry->EKey); + + pCKeyEntry->StorageOffset = CASC_INVALID_OFFS64; + pCKeyEntry->TagBitMask = 0; + pCKeyEntry->RefCount = 0; + pCKeyEntry->Priority = 0; + + pCKeyEntry->EncodedSize = CASC_INVALID_SIZE; + pCKeyEntry->ContentSize = CASC_INVALID_SIZE; + pCKeyEntry->Flags = (pSourceEntry->Flags & (CASC_CE_HAS_CKEY | CASC_CE_HAS_EKEY | CASC_CE_HAS_EKEY_PARTIAL)); + bAllocatedNewEntry = true; + } + } + else + { + hs->SkippedItems++; + } } + } + + if(pbAllocatedNewEntry != NULL) + pbAllocatedNewEntry[0] = bAllocatedNewEntry; + return pCKeyEntry; +} + +static PCASC_CKEY_ENTRY CopyBuildFileItemToCKeyArray(TCascStorage * hs, PCASC_CKEY_ENTRY pSourceEntry) +{ + PCASC_CKEY_ENTRY pCKeyEntry = NULL; + bool bAllocatedNewEntry = false; - // Go one character back - nLength--; + pCKeyEntry = InsertCKeyEntry(hs, pSourceEntry, true, &bAllocatedNewEntry); + if(pCKeyEntry != NULL) + { + // Fill the values that might be known + if(pCKeyEntry->EncodedSize == CASC_INVALID_SIZE) + pCKeyEntry->EncodedSize = pSourceEntry->EncodedSize; + if(pCKeyEntry->ContentSize == CASC_INVALID_SIZE) + pCKeyEntry->ContentSize = pSourceEntry->ContentSize; + + // If this is a new entry, we need to insert it to the maps + if(bAllocatedNewEntry) + { + if(pCKeyEntry->Flags & CASC_CE_HAS_CKEY) + hs->CKeyMap.InsertObject(pCKeyEntry, pCKeyEntry->CKey); + if(pCKeyEntry->Flags & CASC_CE_HAS_EKEY) + hs->EKeyMap.InsertObject(pCKeyEntry, pCKeyEntry->EKey); + } } - return false; + return pCKeyEntry; } -static int InsertExtraFile( - TCascStorage * hs, - const char * szFileName, - PQUERY_KEY pQueryKey) +static int CopyBuildFileItemsToCKeyArray(TCascStorage * hs) { - // If the given key is not encoding key (aka, it's an index key), - // we need to create a fake encoding entry - if(pQueryKey->cbData == MD5_HASH_SIZE * 2) + // Insert the well-known files + CopyBuildFileItemToCKeyArray(hs, &hs->EncodingCKey); + CopyBuildFileItemToCKeyArray(hs, &hs->DownloadCKey); + CopyBuildFileItemToCKeyArray(hs, &hs->InstallCKey); + CopyBuildFileItemToCKeyArray(hs, &hs->PatchFile); + CopyBuildFileItemToCKeyArray(hs, &hs->RootFile); + CopyBuildFileItemToCKeyArray(hs, &hs->SizeFile); + CopyBuildFileItemToCKeyArray(hs, &hs->VfsRoot); + + // Insert all VFS roots + for(size_t i = 0; i < hs->VfsRootList.ItemCount(); i++) { - PCASC_ENCODING_ENTRY pNewEntry; - PCASC_INDEX_ENTRY pIndexEntry; - QUERY_KEY IndexKey; - - // Find the entry in the index table in order to get the file size - IndexKey.pbData = pQueryKey->pbData + MD5_HASH_SIZE; - IndexKey.cbData = MD5_HASH_SIZE; - pIndexEntry = FindIndexEntry(hs, &IndexKey); - if(pIndexEntry == NULL) - return ERROR_FILE_NOT_FOUND; - - // Create a fake entry in the encoding map - pNewEntry = (PCASC_ENCODING_ENTRY)Array_Insert(&hs->ExtraEntries, NULL, 1); - if(pNewEntry == NULL) - return ERROR_NOT_ENOUGH_MEMORY; - - // Fill the encoding entry - pNewEntry->KeyCount = 1; - pNewEntry->FileSizeBE[0] = pIndexEntry->FileSizeLE[3]; - pNewEntry->FileSizeBE[1] = pIndexEntry->FileSizeLE[2]; - pNewEntry->FileSizeBE[2] = pIndexEntry->FileSizeLE[1]; - pNewEntry->FileSizeBE[3] = pIndexEntry->FileSizeLE[0]; - memcpy(pNewEntry->EncodingKey, pQueryKey->pbData, MD5_HASH_SIZE); - memcpy(pNewEntry + 1, pQueryKey->pbData + MD5_HASH_SIZE, MD5_HASH_SIZE); - - // Insert the entry to the map of encoding keys - Map_InsertObject(hs->pEncodingMap, pNewEntry, pNewEntry->EncodingKey); + PCASC_CKEY_ENTRY pCKeyEntry = (PCASC_CKEY_ENTRY)hs->VfsRootList.ItemAt(i); + CopyBuildFileItemToCKeyArray(hs, pCKeyEntry); } - // Now we need to insert the entry to the root handler in order - // to be able to translate file name to encoding key - return RootHandler_Insert(hs->pRootHandler, szFileName, pQueryKey->pbData); + return ERROR_SUCCESS; } -static int InitializeCascDirectories(TCascStorage * hs, const TCHAR * szDataPath) +static int CopyIndexItemsToCKeyArray(TCascStorage * hs) { - TCHAR * szWorkPath; - int nError = ERROR_NOT_ENOUGH_MEMORY; + PCASC_CKEY_ENTRY pIndexEntry; + PCASC_CKEY_ENTRY pCKeyEntry; + size_t nItemCount = hs->IndexArray.ItemCount(); + bool bAllocatedNewEntry = false; - // Find the root directory of the storage. The root directory - // is the one where ".build.info" is. - szWorkPath = CascNewStr(szDataPath, 0); - if(szWorkPath != NULL) + // Iterate over all index items + for(size_t i = 0; i < nItemCount; i++) { - // Get the length and go up until we find the ".build.info" or ".build.db" - for(;;) + // Get the n-th index entry + pIndexEntry = (PCASC_CKEY_ENTRY)hs->IndexArray.ItemAt(i); + + // Sometimes, there are multiple items with the same EKey in the index files + // Example: "2018 - New CASC\00001", EKey 37 89 16 5b 2d cc 71 c1 25 00 00 00 00 00 00 00 + // Positions: 0x2D, 0x2E, 0x2F + //BREAK_ON_XKEY3(pIndexEntry->EKey, 0x37, 0x89, 0x16); + + // Copy the index entry to the central storage + if((pCKeyEntry = InsertCKeyEntry(hs, pIndexEntry, hs->bAllowOrphans, &bAllocatedNewEntry)) != NULL) { - // Is this a game directory? - nError = CheckGameDirectory(hs, szWorkPath); - if(nError == ERROR_SUCCESS) + // Make sure that the CKey is zeroed when not present + if((pCKeyEntry->Flags & CASC_CE_HAS_CKEY) == 0) + ZeroMemory16(pCKeyEntry->CKey); + + // Only copy the storage offset and sizes if not available yet + if(pCKeyEntry->StorageOffset == CASC_INVALID_OFFS64) { - nError = ERROR_SUCCESS; - break; + pCKeyEntry->StorageOffset = pIndexEntry->StorageOffset; + pCKeyEntry->EncodedSize = pIndexEntry->EncodedSize; } - // Cut one path part - if(!CutLastPathPart(szWorkPath)) + if(bAllocatedNewEntry) { - nError = ERROR_FILE_NOT_FOUND; - break; + if(pCKeyEntry->Flags & CASC_CE_HAS_CKEY) + hs->CKeyMap.InsertObject(pCKeyEntry, pCKeyEntry->CKey); + if(pCKeyEntry->Flags & CASC_CE_HAS_EKEY) + hs->EKeyMap.InsertObject(pCKeyEntry, pCKeyEntry->EKey); } - } - // Free the work path buffer - CASC_FREE(szWorkPath); + // Mark the file as available locally + pCKeyEntry->Flags |= CASC_CE_FILE_IS_LOCAL; + } } - return nError; + // We free the index array at this point + hs->IndexArray.Free(); + return ERROR_SUCCESS; } -static bool IndexDirectory_OnFileFound( - const TCHAR * szFileName, - PDWORD IndexArray, - PDWORD OldIndexArray, - void * pvContext) +static int LoadEncodingManifest(TCascStorage * hs) { - TCascStorage * hs = (TCascStorage *)pvContext; - DWORD IndexValue = 0; - DWORD IndexVersion = 0; + LPBYTE pbEncodingFile; + DWORD cbEncodingFile = 0; + int nError = ERROR_SUCCESS; - // Auto-detect the format of the index file name - if(hs->szIndexFormat == NULL) - { - if(IsIndexFileName_V1(szFileName)) - hs->szIndexFormat = szIndexFormat_V1; - else if(IsIndexFileName_V2(szFileName)) - hs->szIndexFormat = szIndexFormat_V2; - else - return false; - } + // Inform the user about what we are doing + if(hs->PfnCallback && hs->PfnCallback(hs->PtrCallbackParam, "Loading ENCODING manifest", NULL, 0, 0)) + return ERROR_CANCELLED; - if(hs->szIndexFormat == szIndexFormat_V1) + // Load the entire encoding file to memory + pbEncodingFile = LoadInternalFileToMemory(hs, &hs->EncodingCKey, &cbEncodingFile); + if(pbEncodingFile != NULL && cbEncodingFile != 0) { - // Check the index file name format - if(!IsIndexFileName_V1(szFileName)) - return false; + CASC_ENCODING_HEADER EnHeader; - // Get the main index from the first two digits - if(ConvertDigitToInt32(szFileName + 6, &IndexValue) != ERROR_SUCCESS) - return false; - if(ConvertDigitToInt32(szFileName + 7, &IndexVersion) != ERROR_SUCCESS) - return false; - } - - else if(hs->szIndexFormat == szIndexFormat_V2) - { - // Check the index file name format - if(!IsIndexFileName_V2(szFileName)) - return false; + // Capture the header of the ENCODING file + nError = CaptureEncodingHeader(EnHeader, pbEncodingFile, cbEncodingFile); + if(nError == ERROR_SUCCESS) + { + // Get the CKey page header and the first page + PFILE_CKEY_PAGE pPageHeader = (PFILE_CKEY_PAGE)(pbEncodingFile + sizeof(FILE_ENCODING_HEADER) + EnHeader.ESpecBlockSize); + LPBYTE pbCKeyPage = (LPBYTE)(pPageHeader + EnHeader.CKeyPageCount); + + // Since ENCODING contains the full list of all files (even those not downloaded), + // we can now make a fair estimate about how large maps shall we create. + // So, we can build the maps CKey and EKey map. + if((nError = CreateCKeyMaps(hs, EnHeader)) == ERROR_SUCCESS) + { + // Go through all CKey pages and verify them + for(DWORD i = 0; i < EnHeader.CKeyPageCount; i++) + { + PFILE_CKEY_ENTRY pCKeyEntry = (PFILE_CKEY_ENTRY)pbCKeyPage; + + // Check if there is enough space in the buffer + if((pbCKeyPage + EnHeader.CKeyPageSize) > (pbEncodingFile + cbEncodingFile)) + { + nError = ERROR_FILE_CORRUPT; + break; + } + + // Check the hash of the entire segment + // Note that verifying takes considerable time of the storage loading +// if(!VerifyDataBlockHash(pbCKeyPage, EnHeader.CKeyPageSize, pEncodingSegment->SegmentHash)) +// { +// nError = ERROR_FILE_CORRUPT; +// break; +// } + + // Check if the CKey matches with the expected first value + if(memcmp(pCKeyEntry->CKey, pPageHeader[i].FirstKey, CASC_CKEY_SIZE)) + { + nError = ERROR_FILE_CORRUPT; + break; + } + + // Load the entire page of CKey entries. + // This operation will never fail, because all memory is already pre-allocated + nError = LoadEncodingCKeyPage(hs, EnHeader, pbCKeyPage, pbCKeyPage + EnHeader.CKeyPageSize); + if(nError != ERROR_SUCCESS) + break; + + // Move to the next CKey page + pbCKeyPage += EnHeader.CKeyPageSize; + } + } + } - // Get the main index from the first two digits - if(ConvertStringToInt32(szFileName, 2, &IndexValue) != ERROR_SUCCESS) - return false; - if(ConvertStringToInt32(szFileName + 2, 8, &IndexVersion) != ERROR_SUCCESS) - return false; - } - else - { - // Should never happen - assert(false); - return false; - } + // All CKey->EKey entries from the text build files need to be copied to the CKey array + // This also includes the ENCODING file itself, which is vital for later loading + if(nError == ERROR_SUCCESS) + { + nError = CopyBuildFileItemsToCKeyArray(hs); + } - // The index value must not be greater than 0x0F - if(IndexValue >= CASC_INDEX_COUNT) - return false; + // Now supply all the entries from the index files + if(nError == ERROR_SUCCESS) + { + nError = CopyIndexItemsToCKeyArray(hs); + } - // If the new subindex is greater than the previous one, - // use this one instead - if(IndexVersion > IndexArray[IndexValue]) - { - OldIndexArray[IndexValue] = IndexArray[IndexValue]; - IndexArray[IndexValue] = IndexVersion; + // Free the loaded ENCODING file + CASC_FREE(pbEncodingFile); } - else if(IndexVersion > OldIndexArray[IndexValue]) + else { - OldIndexArray[IndexValue] = IndexVersion; + nError = GetLastError(); } - // Note: WoW6 only keeps last two index files - // Any additional index files are deleted at this point - return true; + return nError; } -static TCHAR * CreateIndexFileName(TCascStorage * hs, DWORD IndexValue, DWORD IndexVersion) +size_t GetTagBitmapLength(LPBYTE pbFilePtr, LPBYTE pbFileEnd, DWORD EntryCount) { - TCHAR szPlainName[0x40]; - - // Sanity checks - assert(hs->szIndexFormat != NULL); - assert(hs->szIndexPath != NULL); - assert(IndexValue <= 0x0F); - - // Create the full path - _stprintf(szPlainName, hs->szIndexFormat, IndexValue, IndexVersion); - return CombinePath(hs->szIndexPath, szPlainName); -} + size_t nBitmapLength; -static int VerifyAndParseKeyMapping_V1(PCASC_MAPPING_TABLE pKeyMapping, DWORD KeyIndex) -{ - PFILE_INDEX_HEADER_V1 pIndexHeader = (PFILE_INDEX_HEADER_V1)pKeyMapping->pbFileData; - DWORD dwDataHash1; - DWORD dwDataHash2; - - // Verify the format - if(pIndexHeader->field_0 != 0x0005) - return ERROR_NOT_SUPPORTED; - if(pIndexHeader->KeyIndex != KeyIndex) - return ERROR_NOT_SUPPORTED; - if(pIndexHeader->field_8 == 0) - return ERROR_NOT_SUPPORTED; - - // Verofy the bit counts - if(pIndexHeader->SpanSizeBytes != 0x04 || - pIndexHeader->SpanOffsBytes != 0x05 || - pIndexHeader->KeyBytes != 0x09) - return ERROR_NOT_SUPPORTED; - - pKeyMapping->ExtraBytes = 0; - pKeyMapping->SpanSizeBytes = pIndexHeader->SpanSizeBytes; - pKeyMapping->SpanOffsBytes = pIndexHeader->SpanOffsBytes; - pKeyMapping->KeyBytes = pIndexHeader->KeyBytes; - pKeyMapping->SegmentBits = pIndexHeader->SegmentBits; - pKeyMapping->MaxFileOffset = pIndexHeader->MaxFileOffset; - - // Get the pointer to the key entry array - pKeyMapping->nIndexEntries = pIndexHeader->KeyCount1 + pIndexHeader->KeyCount2; - if(pKeyMapping->nIndexEntries != 0) - pKeyMapping->pIndexEntries = (PCASC_INDEX_ENTRY)(pKeyMapping->pbFileData + sizeof(FILE_INDEX_HEADER_V1)); - - // Verify hashes - dwDataHash1 = hashlittle(pKeyMapping->pIndexEntries, pIndexHeader->KeyCount1 * sizeof(CASC_INDEX_ENTRY), 0); - dwDataHash2 = hashlittle(pKeyMapping->pIndexEntries + pIndexHeader->KeyCount1, pIndexHeader->KeyCount2 * sizeof(CASC_INDEX_ENTRY), 0); - if(dwDataHash1 != pIndexHeader->KeysHash1 || dwDataHash2 != pIndexHeader->KeysHash2) - return ERROR_FILE_CORRUPT; + nBitmapLength = (EntryCount / 8) + ((EntryCount & 0x07) ? 1 : 0); + if ((pbFilePtr + nBitmapLength) > pbFileEnd) + nBitmapLength = (pbFileEnd - pbFilePtr); - return ERROR_SUCCESS; + return nBitmapLength; } -static int VerifyAndParseKeyMapping_V2(PCASC_MAPPING_TABLE pKeyMapping, DWORD KeyIndex) +int CaptureDownloadHeader(CASC_DOWNLOAD_HEADER & DlHeader, LPBYTE pbFileData, size_t cbFileData) { - PFILE_INDEX_HEADER_V2 pIndexHeader = (PFILE_INDEX_HEADER_V2)pKeyMapping->pbFileData; - PBLOCK_SIZE_AND_HASH pSizeAndHash; - LPBYTE pbLastPartEnd; - LPBYTE pbLastPart; - DWORD FilePosition; - DWORD LastPartLength; - unsigned int HashHigh = 0; - unsigned int HashLow = 0; - - // The index header v2 begins after the SizeAndHash - pSizeAndHash = (PBLOCK_SIZE_AND_HASH)pKeyMapping->pbFileData; - pIndexHeader = (PFILE_INDEX_HEADER_V2)(pSizeAndHash + 1); - if(pIndexHeader->IndexVersion != 0x07 || pIndexHeader->KeyIndex != KeyIndex) - return ERROR_BAD_FORMAT; + PFILE_DOWNLOAD_HEADER pFileHeader = (PFILE_DOWNLOAD_HEADER)pbFileData; - if(pIndexHeader->ExtraBytes != 0x00 || - pIndexHeader->SpanSizeBytes != 0x04 || - pIndexHeader->SpanOffsBytes != 0x05 || - pIndexHeader->KeyBytes != CASC_FILE_KEY_SIZE) + // Check the signature ('DL') and version + if(cbFileData < sizeof(FILE_DOWNLOAD_HEADER) || pFileHeader->Magic != FILE_MAGIC_DOWNLOAD || pFileHeader->Version > 3) return ERROR_BAD_FORMAT; - // Remember the sizes - pKeyMapping->ExtraBytes = pIndexHeader->ExtraBytes; - pKeyMapping->SpanSizeBytes = pIndexHeader->SpanSizeBytes; - pKeyMapping->SpanOffsBytes = pIndexHeader->SpanOffsBytes; - pKeyMapping->KeyBytes = pIndexHeader->KeyBytes; - pKeyMapping->SegmentBits = pIndexHeader->SegmentBits; - pKeyMapping->MaxFileOffset = pIndexHeader->MaxFileOffset; - - // Get the data position - FilePosition = (sizeof(BLOCK_SIZE_AND_HASH) + pSizeAndHash->cbBlockSize + 0x0F) & 0xFFFFFFF0; - if((FilePosition + 0x08) > pKeyMapping->cbFileData) + // Note that we don't support CKey sizes greater than 0x10 in the DOWNLOAD file + if(pFileHeader->EKeyLength > MD5_HASH_SIZE) return ERROR_BAD_FORMAT; - // Get the pointer to "size+hash" block - pSizeAndHash = (PBLOCK_SIZE_AND_HASH)(pKeyMapping->pbFileData + FilePosition); - FilePosition += 0x08; + // Capture the header version 1 + memset(&DlHeader, 0, sizeof(CASC_DOWNLOAD_HEADER)); + DlHeader.Magic = pFileHeader->Magic; + DlHeader.Version = pFileHeader->Version; + DlHeader.EKeyLength = pFileHeader->EKeyLength; + DlHeader.EntryHasChecksum = pFileHeader->EntryHasChecksum; + DlHeader.EntryCount = ConvertBytesToInteger_4(pFileHeader->EntryCount); + DlHeader.TagCount = ConvertBytesToInteger_2(pFileHeader->TagCount); + DlHeader.HeaderLength = FIELD_OFFSET(FILE_DOWNLOAD_HEADER, FlagByteSize); + DlHeader.EntryLength = DlHeader.EKeyLength + 5 + 1 + (DlHeader.EntryHasChecksum ? 4 : 0); + + // Capture header version 2 + if (pFileHeader->Version >= 2) + { + DlHeader.FlagByteSize = pFileHeader->FlagByteSize; + DlHeader.HeaderLength = FIELD_OFFSET(FILE_DOWNLOAD_HEADER, BasePriority); + DlHeader.EntryLength += DlHeader.FlagByteSize; - if((FilePosition + pSizeAndHash->cbBlockSize) > pKeyMapping->cbFileData) - return ERROR_BAD_FORMAT; - if(pSizeAndHash->cbBlockSize < sizeof(CASC_INDEX_ENTRY)) - return ERROR_BAD_FORMAT; + // Capture header version 3 + if (pFileHeader->Version >= 3) + { + DlHeader.BasePriority = pFileHeader->BasePriority; + DlHeader.HeaderLength = sizeof(FILE_DOWNLOAD_HEADER); + } + } - // Remember the array of file keys - pKeyMapping->pIndexEntries = (PCASC_INDEX_ENTRY)(pKeyMapping->pbFileData + FilePosition); - pKeyMapping->nIndexEntries = pSizeAndHash->cbBlockSize / sizeof(CASC_INDEX_ENTRY); - FilePosition += pSizeAndHash->cbBlockSize; + return ERROR_SUCCESS; +} - // Verify the integrity of the key array - for(DWORD i = 0; i < pKeyMapping->nIndexEntries; i++) - hashlittle2(pKeyMapping->pIndexEntries + i, sizeof(CASC_INDEX_ENTRY), &HashHigh, &HashLow); - if(HashHigh != pSizeAndHash->dwBlockHash) +int CaptureDownloadEntry(CASC_DOWNLOAD_HEADER & DlHeader, CASC_DOWNLOAD_ENTRY & DlEntry, LPBYTE pbFilePtr, LPBYTE pbFileEnd) +{ + // Check the range + if((pbFilePtr + DlHeader.EntryLength) >= pbFileEnd) return ERROR_BAD_FORMAT; + memset(&DlEntry, 0, sizeof(CASC_DOWNLOAD_ENTRY)); - // Align the data position up to next 0x1000 - FilePosition = ALIGN_TO_SIZE(FilePosition, 0x1000); - if(FilePosition > pKeyMapping->cbFileData) - return ERROR_BAD_FORMAT; + // Copy the EKey + memcpy(DlEntry.EKey, pbFilePtr, DlHeader.EKeyLength); + pbFilePtr += DlHeader.EKeyLength; - LastPartLength = pKeyMapping->cbFileData - FilePosition; - if(LastPartLength < 0x7800) - return ERROR_BAD_FORMAT; + // Convert the file size + DlEntry.EncodedSize = ConvertBytesToInteger_5(pbFilePtr); + pbFilePtr += 5; - pbLastPart = pKeyMapping->pbFileData + FilePosition; - pbLastPartEnd = pbLastPart + ((LastPartLength >> 0x09) << 0x09); + // Copy the file priority + DlEntry.Priority = pbFilePtr[0]; + pbFilePtr++; - while(pbLastPart < pbLastPartEnd) + // Copy the checksum + if(DlHeader.EntryHasChecksum) { - for(int i = 0; i < 0x1F8; i += 0x18) - { - PDWORD PtrLastPart = (PDWORD)pbLastPart; - if(PtrLastPart[0] == 0) - return ERROR_SUCCESS; - - HashLow = hashlittle(PtrLastPart + i, 0x13, 0) | 0x80000000; - if(HashLow != PtrLastPart[0]) - return ERROR_BAD_FORMAT; - } - - pbLastPart += 0x200; + DlEntry.Checksum = ConvertBytesToInteger_4(pbFilePtr); + pbFilePtr += 4; } + // Copy the flags + DlEntry.Flags = ConvertBytesToInteger_X(pbFilePtr, DlHeader.FlagByteSize); return ERROR_SUCCESS; } -static int VerifyAndParseKeyMapping(PCASC_MAPPING_TABLE pKeyMapping, DWORD KeyIndex) +int CaptureDownloadTag(CASC_DOWNLOAD_HEADER & DlHeader, CASC_TAG_ENTRY1 & DlTag, LPBYTE pbFilePtr, LPBYTE pbFileEnd) { - // Sanity checks - assert(pKeyMapping->pbFileData != NULL); - assert(pKeyMapping->cbFileData != 0); + LPBYTE pbSaveFilePtr = pbFilePtr; - // Check for CASC version 2 - if(IsCascIndexHeader_V2(pKeyMapping->pbFileData, pKeyMapping->cbFileData)) - return VerifyAndParseKeyMapping_V2(pKeyMapping, KeyIndex); + // Prepare the tag structure + memset(&DlTag, 0, sizeof(CASC_TAG_ENTRY1)); + DlTag.szTagName = (const char *)pbFilePtr; - // Check for CASC version 1 - if(IsCascIndexHeader_V1(pKeyMapping->pbFileData, pKeyMapping->cbFileData)) - return VerifyAndParseKeyMapping_V1(pKeyMapping, KeyIndex); + // Skip the tag string + while(pbFilePtr < pbFileEnd && pbFilePtr[0] != 0) + pbFilePtr++; + if(pbFilePtr >= pbFileEnd) + return ERROR_BAD_FORMAT; + + // Save the length of the tag name + DlTag.NameLength = (pbFilePtr - pbSaveFilePtr); + pbFilePtr++; - // Unknown CASC version - assert(false); - return ERROR_BAD_FORMAT; + // Get the tag value + if((pbFilePtr + sizeof(DWORD)) > pbFileEnd) + return ERROR_BAD_FORMAT; + DlTag.TagValue = ConvertBytesToInteger_2(pbFilePtr); + pbFilePtr += 2; + + // Get the bitmap + DlTag.Bitmap = pbFilePtr; + + // Get the bitmap length. + // If the bitmap is last in the list and it's shorter than declared, we make it shorter + DlTag.BitmapLength = GetTagBitmapLength(pbFilePtr, pbFileEnd, DlHeader.EntryCount); + + // Get the entry length + DlTag.TagLength = (pbFilePtr - pbSaveFilePtr) + DlTag.BitmapLength; + return ERROR_SUCCESS; } -static int LoadKeyMapping(PCASC_MAPPING_TABLE pKeyMapping, DWORD KeyIndex) +static int LoadDownloadManifest(TCascStorage * hs, CASC_DOWNLOAD_HEADER & DlHeader, LPBYTE pbFileData, LPBYTE pbFileEnd) { - TFileStream * pStream; - ULONGLONG FileSize = 0; + PCASC_TAG_ENTRY1 TagArray = NULL; + LPBYTE pbEntries = pbFileData + DlHeader.HeaderLength; + LPBYTE pbEntry = pbEntries; + LPBYTE pbTags = pbEntries + DlHeader.EntryLength * DlHeader.EntryCount; + LPBYTE pbTag = pbTags; + size_t nMaxNameLength = 0; + size_t nTagEntryLengh = 0; int nError = ERROR_SUCCESS; - // Sanity checks - assert(pKeyMapping->szFileName != NULL && pKeyMapping->szFileName[0] != 0); - - // Open the stream for read-only access and read the file - pStream = FileStream_OpenFile(pKeyMapping->szFileName, STREAM_FLAG_READ_ONLY | STREAM_PROVIDER_FLAT | BASE_PROVIDER_FILE); - if(pStream != NULL) + // Does the storage support tags? + if(DlHeader.TagCount != 0) { - // Retrieve the file size - FileStream_GetSize(pStream, &FileSize); - if(0 < FileSize && FileSize <= 0x200000) + // Remember that we support tags + hs->dwFeatures |= CASC_FEATURE_TAGS; + + // Allocate space for the tag array + TagArray = CASC_ALLOC(CASC_TAG_ENTRY1, DlHeader.TagCount); + if(TagArray != NULL) { - // WoW6 actually reads THE ENTIRE file to memory - // Verified on Mac build (x64) - pKeyMapping->pbFileData = CASC_ALLOC(BYTE, (DWORD)FileSize); - pKeyMapping->cbFileData = (DWORD)FileSize; + // Get the longest tag name + for(DWORD i = 0; i < DlHeader.TagCount; i++) + { + if(CaptureDownloadTag(DlHeader, TagArray[i], pbTag, pbFileEnd) == ERROR_SUCCESS) + nMaxNameLength = CASCLIB_MAX(nMaxNameLength, TagArray[i].NameLength); + pbTag = pbTag + TagArray[i].TagLength; + } + + // Determine the tag entry length + nTagEntryLengh = FIELD_OFFSET(CASC_TAG_ENTRY2, szTagName) + nMaxNameLength; + nTagEntryLengh = ALIGN_TO_SIZE(nTagEntryLengh, 8); - // Load the data to memory and parse it - if(pKeyMapping->pbFileData != NULL) + // Load the tags into array in the storage structure + nError = hs->TagsArray.Create(nTagEntryLengh, DlHeader.TagCount); + if(nError == ERROR_SUCCESS) { - if(FileStream_Read(pStream, NULL, pKeyMapping->pbFileData, pKeyMapping->cbFileData)) + // Convert the array of CASC_DOWNLOAD_TAG1 to array of CASC_DOWNLOAD_TAG2 + for(DWORD i = 0; i < DlHeader.TagCount; i++) { - nError = VerifyAndParseKeyMapping(pKeyMapping, KeyIndex); + PCASC_TAG_ENTRY1 pSourceTag = &TagArray[i]; + PCASC_TAG_ENTRY2 pTargetTag; + + // Insert the tag to the array + pTargetTag = (PCASC_TAG_ENTRY2)hs->TagsArray.Insert(1); + if(pTargetTag == NULL) + { + nError = ERROR_NOT_ENOUGH_MEMORY; + break; + } + + // Copy the tag structure + memset(pTargetTag, 0, nTagEntryLengh); + memcpy(pTargetTag->szTagName, pSourceTag->szTagName, pSourceTag->NameLength); + pTargetTag->NameLength = pSourceTag->NameLength; + pTargetTag->TagValue = pSourceTag->TagValue; } } - else - nError = ERROR_NOT_ENOUGH_MEMORY; } else { - assert(false); - nError = ERROR_BAD_FORMAT; + nError = ERROR_NOT_ENOUGH_MEMORY; } - - // Close the file stream - FileStream_Close(pStream); } - else - nError = GetLastError(); - - return ERROR_SUCCESS; -} -static int CreateArrayOfIndexEntries(TCascStorage * hs) -{ - PCASC_MAP pMap; - DWORD TotalCount = 0; - int nError = ERROR_NOT_ENOUGH_MEMORY; + // Now parse all entries. For each entry, mark the corresponding tag bit in the EKey table + for(DWORD i = 0; i < DlHeader.EntryCount; i++) + { + CASC_DOWNLOAD_ENTRY DlEntry; + PCASC_CKEY_ENTRY pCKeyEntry; + size_t BitMaskOffset = (i / 8); + BYTE BitMaskBit = 0x80 >> (i % 8); - // Count the total number of files in the storage - for(size_t i = 0; i < CASC_INDEX_COUNT; i++) - TotalCount += hs->KeyMapping[i].nIndexEntries; + // Capture the download entry + if(CaptureDownloadEntry(DlHeader, DlEntry, pbEntry, pbFileEnd) != ERROR_SUCCESS) + break; - // Create the map of all index entries - pMap = Map_Create(TotalCount, CASC_FILE_KEY_SIZE, FIELD_OFFSET(CASC_INDEX_ENTRY, IndexKey)); - if(pMap != NULL) - { - // Put all index entries in the map - for(size_t i = 0; i < CASC_INDEX_COUNT; i++) + // Make sure we have the entry in CKey table + pCKeyEntry = FindCKeyEntry_EKey(hs, DlEntry.EKey); + if(pCKeyEntry != NULL) { - PCASC_INDEX_ENTRY pIndexEntry = hs->KeyMapping[i].pIndexEntries; - DWORD nIndexEntries = hs->KeyMapping[i].nIndexEntries; + ULONGLONG TagBit = 1; + size_t TagItemCount = hs->TagsArray.ItemCount(); - for(DWORD j = 0; j < nIndexEntries; j++) + // Supply the tag bits + for(size_t j = 0; j < TagItemCount; j++) { - // Insert the index entry to the map - // Note that duplicate entries will not be inserted to the map - // - // Duplicate entries in WoW-WOD build 18179: - // 9e dc a7 8f e2 09 ad d8 b7 (encoding file) - // f3 5e bb fb d1 2b 3f ef 8b - // c8 69 9f 18 a2 5e df 7e 52 - Map_InsertObject(pMap, pIndexEntry, pIndexEntry->IndexKey); - - // Move to the next entry - pIndexEntry++; + // Set the bit in the entry, if the tag for it is present + if((BitMaskOffset < TagArray[j].BitmapLength) && (TagArray[j].Bitmap[BitMaskOffset] & BitMaskBit)) + pCKeyEntry->TagBitMask |= TagBit; + + // Move to the next bit + TagBit <<= 1; } + + // If the EKey has partial EKey only, fix that + if(pCKeyEntry->Flags & CASC_CE_HAS_EKEY_PARTIAL) + { + CopyMemory16(pCKeyEntry->EKey, DlEntry.EKey); + pCKeyEntry->Flags &= ~CASC_CE_HAS_EKEY_PARTIAL; + } + + // Supply the priority + pCKeyEntry->Priority = DlEntry.Priority; + pCKeyEntry->Flags |= CASC_CE_IN_DOWNLOAD; } - // Store the map to the storage handle - hs->pIndexEntryMap = pMap; - nError = ERROR_SUCCESS; + // Move to the next entry + pbEntry += DlHeader.EntryLength; } + // Free the tag array, if any + CASC_FREE(TagArray); + + // Remember the total file count + hs->TotalFiles = hs->CKeyArray.ItemCount(); return nError; } -static int CreateMapOfEncodingKeys(TCascStorage * hs, PFILE_ENCODING_SEGMENT pEncodingSegment, DWORD dwNumSegments) +static int LoadDownloadManifest(TCascStorage * hs) { - PCASC_ENCODING_ENTRY pEncodingEntry; - DWORD dwMaxEntries; + PCASC_CKEY_ENTRY pCKeyEntry = FindCKeyEntry_CKey(hs, hs->DownloadCKey.CKey); + LPBYTE pbDownloadFile = NULL; + DWORD cbDownloadFile = 0; int nError = ERROR_SUCCESS; - // Sanity check - assert(hs->pIndexEntryMap != NULL); - assert(hs->pEncodingMap == NULL); - - // Calculate the largest eventual number of encoding entries - // Add space for extra entries - dwMaxEntries = (dwNumSegments * CASC_ENCODING_SEGMENT_SIZE) / (sizeof(CASC_ENCODING_ENTRY) + MD5_HASH_SIZE); + // Inform the user about what we are doing + if(hs->PfnCallback && hs->PfnCallback(hs->PtrCallbackParam, "Loading DOWNLOAD manifest", NULL, 0, 0)) + return ERROR_CANCELLED; - // Create the map of the encoding entries - hs->pEncodingMap = Map_Create(dwMaxEntries + CASC_EXTRA_FILES, MD5_HASH_SIZE, FIELD_OFFSET(CASC_ENCODING_ENTRY, EncodingKey)); - if(hs->pEncodingMap != NULL) + // Load the entire DOWNLOAD file to memory + pbDownloadFile = LoadInternalFileToMemory(hs, pCKeyEntry, &cbDownloadFile); + if(pbDownloadFile != NULL && cbDownloadFile != 0) { - LPBYTE pbStartOfSegment = (LPBYTE)(pEncodingSegment + dwNumSegments); + CASC_DOWNLOAD_HEADER DlHeader; - // Parse all segments - for(DWORD i = 0; i < dwNumSegments; i++) + // Capture the header of the DOWNLOAD file + nError = CaptureDownloadHeader(DlHeader, pbDownloadFile, cbDownloadFile); + if(nError == ERROR_SUCCESS) { - LPBYTE pbEncodingEntry = pbStartOfSegment; - LPBYTE pbEndOfSegment = pbStartOfSegment + CASC_ENCODING_SEGMENT_SIZE - sizeof(CASC_ENCODING_ENTRY) - MD5_HASH_SIZE; - - // Parse all encoding entries - while(pbEncodingEntry <= pbEndOfSegment) - { - // Get pointer to the encoding entry - pEncodingEntry = (PCASC_ENCODING_ENTRY)pbEncodingEntry; - if(pEncodingEntry->KeyCount == 0) - break; - - // Insert the pointer the array - Map_InsertObject(hs->pEncodingMap, pEncodingEntry, pEncodingEntry->EncodingKey); - - // Move to the next encoding entry - pbEncodingEntry += sizeof(CASC_ENCODING_ENTRY) + (pEncodingEntry->KeyCount * MD5_HASH_SIZE); - } - - // Move to the next segment - pbStartOfSegment += CASC_ENCODING_SEGMENT_SIZE; + // Parse the entire download manifest + nError = LoadDownloadManifest(hs, DlHeader, pbDownloadFile, pbDownloadFile + cbDownloadFile); } + + // Free the loaded manifest + CASC_FREE(pbDownloadFile); } - else - nError = ERROR_NOT_ENOUGH_MEMORY; + // If the DOWNLOAD manifest is not present, we won't abort the downloading process. return nError; } -static int LoadIndexFiles(TCascStorage * hs) +//----------------------------------------------------------------------------- +// INSTALL manifest. This is a replacement for ROOT, if loading ROOT fails +// https://wowdev.wiki/TACT#Install_manifest + +static int LoadInstallManifest(TCascStorage * hs) { - DWORD IndexArray[CASC_INDEX_COUNT]; - DWORD OldIndexArray[CASC_INDEX_COUNT]; - int nError; - int i; + PCASC_CKEY_ENTRY pCKeyEntry = FindCKeyEntry_CKey(hs, hs->InstallCKey.CKey); + LPBYTE pbInstallFile = NULL; + DWORD cbInstallFile = 0; + int nError = ERROR_SUCCESS; - // Scan all index files - memset(IndexArray, 0, sizeof(IndexArray)); - memset(OldIndexArray, 0, sizeof(OldIndexArray)); - nError = ScanIndexDirectory(hs->szIndexPath, IndexDirectory_OnFileFound, IndexArray, OldIndexArray, hs); - if(nError == ERROR_SUCCESS) + // Inform the user about what we are doing + if(hs->PfnCallback && hs->PfnCallback(hs->PtrCallbackParam, "Loading INSTALL manifest", NULL, 0, 0)) + return ERROR_CANCELLED; + + // Load the entire DOWNLOAD file to memory + pbInstallFile = LoadInternalFileToMemory(hs, pCKeyEntry, &cbInstallFile); + if (pbInstallFile != NULL && cbInstallFile != 0) { - // Load each index file - for(i = 0; i < CASC_INDEX_COUNT; i++) - { - hs->KeyMapping[i].szFileName = CreateIndexFileName(hs, i, IndexArray[i]); - if(hs->KeyMapping[i].szFileName != NULL) - { - nError = LoadKeyMapping(&hs->KeyMapping[i], i); - if(nError != ERROR_SUCCESS) - break; - } - } + nError = RootHandler_CreateInstall(hs, pbInstallFile, cbInstallFile); + CASC_FREE(pbInstallFile); } - - // Now we need to build the map of the index entries - if(nError == ERROR_SUCCESS) + else { - nError = CreateArrayOfIndexEntries(hs); + nError = GetLastError(); } return nError; } -static LPBYTE LoadEncodingFileToMemory(HANDLE hFile, DWORD * pcbEncodingFile) +static bool InsertWellKnownFile(TCascStorage * hs, const char * szFileName, CASC_CKEY_ENTRY & FakeCKeyEntry) { - CASC_ENCODING_HEADER EncodingHeader; - LPBYTE pbEncodingFile = NULL; - DWORD cbEncodingFile = 0; - DWORD dwSegmentPos = 0; - DWORD dwNumSegments = 0; - DWORD dwBytesRead = 0; - int nError = ERROR_BAD_FORMAT; + PCASC_CKEY_ENTRY pCKeyEntry = NULL; - // Read the encoding header - CascReadFile(hFile, &EncodingHeader, sizeof(CASC_ENCODING_HEADER), &dwBytesRead); - if(dwBytesRead == sizeof(CASC_ENCODING_HEADER)) + // We need to find the CKey entry in the central array + if(FakeCKeyEntry.Flags & CASC_CE_HAS_CKEY) { - // Check the version and sizes - if(EncodingHeader.Version != 0x01 || EncodingHeader.ChecksumSizeA != MD5_HASH_SIZE || EncodingHeader.ChecksumSizeB != MD5_HASH_SIZE) + // Did we find anything? + pCKeyEntry = FindCKeyEntry_CKey(hs, FakeCKeyEntry.CKey); + if(pCKeyEntry != NULL) { - assert(false); - return NULL; + // Insert the key to the root handler, unless it's already referenced by a name + if(pCKeyEntry->RefCount == 0) + hs->pRootHandler->Insert(szFileName, pCKeyEntry); + return true; } - - // Get the number of segments - dwNumSegments = ConvertBytesToInteger_4(EncodingHeader.Entries_TableA); - dwSegmentPos = ConvertBytesToInteger_4(EncodingHeader.Size_StringTable1); - if(EncodingHeader.Magic[0] == 'E' && EncodingHeader.Magic[1] == 'N' && dwSegmentPos != 0 && dwNumSegments != 0) - nError = ERROR_SUCCESS; - } - - // Calculate and allocate space for the entire file - if(nError == ERROR_SUCCESS) - { - cbEncodingFile = sizeof(CASC_ENCODING_HEADER) + - dwSegmentPos + - dwNumSegments * (sizeof(FILE_ENCODING_SEGMENT) + CASC_ENCODING_SEGMENT_SIZE); - pbEncodingFile = CASC_ALLOC(BYTE, cbEncodingFile); - if(pbEncodingFile == NULL) - nError = ERROR_NOT_ENOUGH_MEMORY; } - // If all went OK, we load the entire file to memory - if(nError == ERROR_SUCCESS) - { - // Copy the header itself - memcpy(pbEncodingFile, &EncodingHeader, sizeof(CASC_ENCODING_HEADER)); - - // Read the rest of the data - CascReadFile(hFile, pbEncodingFile + sizeof(CASC_ENCODING_HEADER), cbEncodingFile - sizeof(CASC_ENCODING_HEADER), &dwBytesRead); - if(dwBytesRead != (cbEncodingFile - sizeof(CASC_ENCODING_HEADER))) - nError = ERROR_FILE_CORRUPT; - } - - // Give the loaded file length - if(pcbEncodingFile != NULL) - *pcbEncodingFile = cbEncodingFile; - return pbEncodingFile; + return false; } -static LPBYTE LoadRootFileToMemory(HANDLE hFile, DWORD * pcbRootFile) +static int LoadBuildManifest(TCascStorage * hs, DWORD dwLocaleMask) { + PCASC_CKEY_ENTRY pCKeyEntry; + PDWORD FileSignature; LPBYTE pbRootFile = NULL; DWORD cbRootFile = 0; - DWORD dwBytesRead = 0; - int nError = ERROR_SUCCESS; + int nError = ERROR_BAD_FORMAT; - // Retrieve the size of the ROOT file - cbRootFile = CascGetFileSize(hFile, NULL); - if(cbRootFile == 0) - nError = ERROR_BAD_FORMAT; + // Sanity checks + assert(hs->CKeyMap.IsInitialized() == true); + assert(hs->pRootHandler == NULL); - // Allocate space for the entire file - if(nError == ERROR_SUCCESS) - { - pbRootFile = CASC_ALLOC(BYTE, cbRootFile); - if(pbRootFile == NULL) - nError = ERROR_NOT_ENOUGH_MEMORY; - } + // Locale: The default parameter is 0 - in that case, + // we assign the default locale, loaded from the .build.info file + if(dwLocaleMask == 0) + dwLocaleMask = hs->dwDefaultLocale; - // If all went OK, we load the entire file to memory - if(nError == ERROR_SUCCESS) + // Prioritize the VFS root over legacy ROOT file + pCKeyEntry = (hs->VfsRoot.ContentSize != CASC_INVALID_SIZE) ? &hs->VfsRoot : &hs->RootFile; + pCKeyEntry = FindCKeyEntry_CKey(hs, pCKeyEntry->CKey); + + // Inform the user about what we are doing + if(hs->PfnCallback && hs->PfnCallback(hs->PtrCallbackParam, "Loading ROOT manifest", NULL, 0, 0)) + return ERROR_CANCELLED; + + // Load the entire ROOT file to memory + pbRootFile = LoadInternalFileToMemory(hs, pCKeyEntry, &cbRootFile); + if(pbRootFile != NULL) { - // Read the entire file to memory - CascReadFile(hFile, pbRootFile, cbRootFile, &dwBytesRead); - if(dwBytesRead != cbRootFile) - nError = ERROR_FILE_CORRUPT; - } + // Ignore ROOT files that contain just a MD5 hash + if(cbRootFile > MD5_STRING_SIZE) + { + // Check the type of the ROOT file + FileSignature = (PDWORD)pbRootFile; + switch(FileSignature[0]) + { + case CASC_MNDX_ROOT_SIGNATURE: + nError = RootHandler_CreateMNDX(hs, pbRootFile, cbRootFile); + break; - // Give the loaded file length - if(pcbRootFile != NULL) - *pcbRootFile = cbRootFile; - return pbRootFile; -} + case CASC_DIABLO3_ROOT_SIGNATURE: + nError = RootHandler_CreateDiablo3(hs, pbRootFile, cbRootFile); + break; -static int LoadEncodingFile(TCascStorage * hs) -{ - PFILE_ENCODING_SEGMENT pEncodingSegment; - QUERY_KEY EncodingKey; - LPBYTE pbStartOfSegment; - LPBYTE pbEncodingFile = NULL; - HANDLE hFile = NULL; - DWORD cbEncodingFile = 0; - DWORD dwNumSegments = 0; - DWORD dwSegmentsPos = 0; - int nError = ERROR_SUCCESS; + case CASC_TVFS_ROOT_SIGNATURE: + nError = RootHandler_CreateTVFS(hs, pbRootFile, cbRootFile); + break; - // Open the encoding file - EncodingKey.pbData = hs->EncodingKey.pbData + MD5_HASH_SIZE; - EncodingKey.cbData = MD5_HASH_SIZE; - if(!CascOpenFileByIndexKey((HANDLE)hs, &EncodingKey, 0, &hFile)) - nError = GetLastError(); + case CASC_WOW82_ROOT_SIGNATURE: + nError = RootHandler_CreateWoW(hs, pbRootFile, cbRootFile, dwLocaleMask); + break; - // Load the entire ENCODING file to memory - if(nError == ERROR_SUCCESS) - { - // Load the necessary part of the ENCODING file to memory - pbEncodingFile = LoadEncodingFileToMemory(hFile, &cbEncodingFile); - if(pbEncodingFile == NULL || cbEncodingFile <= sizeof(CASC_ENCODING_HEADER)) - nError = ERROR_FILE_CORRUPT; + default: + + // + // Each of these handler creators must verify their format first. + // If the format was not recognized, they need to return ERROR_BAD_FORMAT + // + + nError = RootHandler_CreateOverwatch(hs, pbRootFile, cbRootFile); + if(nError == ERROR_BAD_FORMAT) + { + nError = RootHandler_CreateStarcraft1(hs, pbRootFile, cbRootFile); + if(nError == ERROR_BAD_FORMAT) + { + nError = RootHandler_CreateWoW(hs, pbRootFile, cbRootFile, dwLocaleMask); + } + } + break; + } + } - // Close the encoding file - CascCloseFile(hFile); + // Free the root file + CASC_FREE(pbRootFile); } - - // Verify all encoding segments - if(nError == ERROR_SUCCESS) + else { - PCASC_ENCODING_HEADER pEncodingHeader = (PCASC_ENCODING_HEADER)pbEncodingFile; - - // Convert size and offset - dwNumSegments = ConvertBytesToInteger_4(pEncodingHeader->Entries_TableA); - dwSegmentsPos = ConvertBytesToInteger_4(pEncodingHeader->Size_StringTable1); + nError = GetLastError(); + } - // Store the encoding file to the CASC storage - hs->EncodingFile.pbData = pbEncodingFile; - hs->EncodingFile.cbData = cbEncodingFile; + return nError; +} - // Allocate the array of encoding segments - pEncodingSegment = (PFILE_ENCODING_SEGMENT)(pbEncodingFile + sizeof(CASC_ENCODING_HEADER) + dwSegmentsPos); - pbStartOfSegment = (LPBYTE)(pEncodingSegment + dwNumSegments); +static int InitializeLocalDirectories(TCascStorage * hs, const TCHAR * szPath) +{ + TCHAR * szWorkPath; + int nError = ERROR_NOT_ENOUGH_MEMORY; - // Go through all encoding segments and verify them - for(DWORD i = 0; i < dwNumSegments; i++) + // Find the root directory of the storage. The root directory + // is the one with ".build.info" or ".build.db". + szWorkPath = CascNewStr(szPath); + if(szWorkPath != NULL) + { + // Get the length and go up until we find the ".build.info" or ".build.db" + for(;;) { - PCASC_ENCODING_ENTRY pEncodingEntry = (PCASC_ENCODING_ENTRY)pbStartOfSegment; - - // Check if there is enough space in the buffer - if((pbStartOfSegment + CASC_ENCODING_SEGMENT_SIZE) > (pbEncodingFile + cbEncodingFile)) + // Is this a game directory? + nError = CheckGameDirectory(hs, szWorkPath); + if(nError == ERROR_SUCCESS) { - nError = ERROR_FILE_CORRUPT; + nError = ERROR_SUCCESS; break; } - // Check the hash of the entire segment - // Note that verifying takes considerable time of the storage loading -// if(!VerifyDataBlockHash(pbStartOfSegment, CASC_ENCODING_SEGMENT_SIZE, pEncodingSegment->SegmentHash)) -// { -// nError = ERROR_FILE_CORRUPT; -// break; -// } - - // Check if the encoding key matches with the expected first value - if(memcmp(pEncodingEntry->EncodingKey, pEncodingSegment->FirstEncodingKey, MD5_HASH_SIZE)) + // Cut one path part + if(!CutLastPathPart(szWorkPath)) { - nError = ERROR_FILE_CORRUPT; + nError = ERROR_FILE_NOT_FOUND; break; } + } + + // Find the index directory + if (nError == ERROR_SUCCESS) + { + // First, check for more common "data" subdirectory + if ((hs->szIndexPath = CheckForIndexDirectory(hs, _T("data"))) != NULL) + nError = ERROR_SUCCESS; + + // Second, try the "darch" subdirectory (older builds of HOTS - Alpha) + else if ((hs->szIndexPath = CheckForIndexDirectory(hs, _T("darch"))) != NULL) + nError = ERROR_SUCCESS; - // Move to the next segment - pbStartOfSegment += CASC_ENCODING_SEGMENT_SIZE; - pEncodingSegment++; + else + nError = ERROR_FILE_NOT_FOUND; } - } - // Create the map of the encoding keys - // Note that the array of encoding keys is already sorted - no need to sort it - if(nError == ERROR_SUCCESS) - { - pEncodingSegment = (PFILE_ENCODING_SEGMENT)(pbEncodingFile + sizeof(CASC_ENCODING_HEADER) + dwSegmentsPos); - nError = CreateMapOfEncodingKeys(hs, pEncodingSegment, dwNumSegments); + // Free the work path buffer + CASC_FREE(szWorkPath); } return nError; } -static int LoadRootFile(TCascStorage * hs, DWORD dwLocaleMask) +static int InitializeOnlineDirectories(TCascStorage * hs, LPCTSTR szLocalCache, LPCSTR szCodeName, LPCSTR szRegion) { - PDWORD FileSignature; - HANDLE hFile = NULL; - LPBYTE pbRootFile = NULL; - DWORD cbRootFile = 0; - int nError = ERROR_SUCCESS; + TCHAR szCodeNameT[0x40]; - // Sanity checks - assert(hs->pEncodingMap != NULL); - assert(hs->pRootHandler == NULL); - - // Locale: The default parameter is 0 - in that case, - // we assign the default locale, loaded from the .build.info file - if(dwLocaleMask == 0) - dwLocaleMask = hs->dwDefaultLocale; - - // Load the entire ROOT file to memory - if(!CascOpenFileByEncodingKey((HANDLE)hs, &hs->RootKey, 0, &hFile)) - nError = GetLastError(); - - // Load the entire file to memory - if(nError == ERROR_SUCCESS) + CascStrCopy(szCodeNameT, _countof(szCodeNameT), szCodeName); + hs->szRootPath = CombinePath(szLocalCache, szCodeNameT); + if (hs->szRootPath != NULL) { - pbRootFile = LoadRootFileToMemory(hFile, &cbRootFile); - CascCloseFile(hFile); + // Create the name of the build file + hs->szBuildFile = CombinePath(hs->szRootPath, _T("versions")); + if(hs->szBuildFile != NULL) + { + hs->szCodeName = CascNewStr(szCodeNameT); + hs->szRegion = CascNewStr(szRegion); + if(hs->szCodeName != NULL) + { + hs->BuildFileType = CascVersionsDb; + hs->dwFeatures |= CASC_FEATURE_ONLINE; + return ERROR_SUCCESS; + } + } } - // Check if the version of the ROOT file - if(nError == ERROR_SUCCESS && pbRootFile != NULL) - { - FileSignature = (PDWORD)pbRootFile; - switch(FileSignature[0]) - { - case CASC_MNDX_ROOT_SIGNATURE: - nError = RootHandler_CreateMNDX(hs, pbRootFile, cbRootFile); - break; + return ERROR_NOT_ENOUGH_MEMORY; +} - case CASC_DIABLO3_ROOT_SIGNATURE: - nError = RootHandler_CreateDiablo3(hs, pbRootFile, cbRootFile); - break; +static DWORD GetStorageTotalFileCount(TCascStorage * hs) +{ + PCASC_CKEY_ENTRY pCKeyEntry; + size_t nItemCount = hs->CKeyArray.ItemCount(); + DWORD TotalFileCount = 0; - case CASC_OVERWATCH_ROOT_SIGNATURE: - nError = RootHandler_CreateOverwatch(hs, pbRootFile, cbRootFile); - break; + for(size_t i = 0; i < nItemCount; i++) + { + if((pCKeyEntry = (PCASC_CKEY_ENTRY)hs->CKeyArray.ItemAt(i)) != NULL) + { + if((pCKeyEntry->Flags & CASC_CE_FOLDER_ENTRY) == 0) + { + // If there is zero or one file name reference, we count the item as one file. + // If there is more than 1 name reference, we count the file as many times as number of references + DWORD RefCount = (pCKeyEntry->RefCount > 0) ? pCKeyEntry->RefCount : 1; - default: - if(IsRootFile_Starcraft1(pbRootFile, cbRootFile)) - nError = RootHandler_CreateSC1(hs, pbRootFile, cbRootFile); - else - nError = RootHandler_CreateWoW6(hs, pbRootFile, cbRootFile, dwLocaleMask); - break; + // Add the number of references to the total file count + TotalFileCount += RefCount; + } } } - // Insert entry for the - if(nError == ERROR_SUCCESS) - { - InsertExtraFile(hs, "ENCODING", &hs->EncodingKey); - InsertExtraFile(hs, "ROOT", &hs->RootKey); - InsertExtraFile(hs, "DOWNLOAD", &hs->DownloadKey); - InsertExtraFile(hs, "INSTALL", &hs->InstallKey); - } + return TotalFileCount; +} -#ifdef _DEBUG - if(nError == ERROR_SUCCESS) +static bool GetStorageProduct(TCascStorage * hs, void * pvStorageInfo, size_t cbStorageInfo, size_t * pcbLengthNeeded) +{ + PCASC_STORAGE_PRODUCT pProductInfo; + + // Verify whether we have enough space in the buffer + pProductInfo = (PCASC_STORAGE_PRODUCT)ProbeOutputBuffer(pvStorageInfo, cbStorageInfo, sizeof(CASC_STORAGE_PRODUCT), pcbLengthNeeded); + if(pProductInfo != NULL) { - //RootFile_Dump(hs, - // pbRootFile, - // cbRootFile, - // _T("\\casc_root_%build%.txt"), - // _T("\\Ladik\\Appdir\\CascLib\\listfile\\listfile-wow6.txt"), - // DUMP_LEVEL_INDEX_ENTRIES); + pProductInfo->szProductName = hs->szProductName; + pProductInfo->dwBuildNumber = hs->dwBuildNumber; + pProductInfo->Product = hs->Product; } -#endif - // Free the root file - CASC_FREE(pbRootFile); - return nError; + return (pProductInfo != NULL); } -static TCascStorage * FreeCascStorage(TCascStorage * hs) +static bool GetStorageTags(TCascStorage * hs, void * pvStorageInfo, size_t cbStorageInfo, size_t * pcbLengthNeeded) { - size_t i; + PCASC_STORAGE_TAGS pTags; + PCASC_TAG_ENTRY2 pTag; + char * szNameBuffer; + size_t cbMinLength; - if(hs != NULL) + // Does the storage support tags? + if(hs->TagsArray.IsInitialized() == false) { - // Free the root handler - if(hs->pRootHandler != NULL) - RootHandler_Close(hs->pRootHandler); - hs->pRootHandler = NULL; - - // Free the extra encoding entries - Array_Free(&hs->ExtraEntries); - - // Free the pointers to file entries - if(hs->pEncodingMap != NULL) - Map_Free(hs->pEncodingMap); - if(hs->EncodingFile.pbData != NULL) - CASC_FREE(hs->EncodingFile.pbData); - if(hs->pIndexEntryMap != NULL) - Map_Free(hs->pIndexEntryMap); - - // Close all data files - for(i = 0; i < CASC_MAX_DATA_FILES; i++) - { - if(hs->DataFileArray[i] != NULL) - { - FileStream_Close(hs->DataFileArray[i]); - hs->DataFileArray[i] = NULL; - } - } + SetLastError(ERROR_NOT_SUPPORTED); + return false; + } + + // Calculate the length of the tags + cbMinLength = FIELD_OFFSET(CASC_STORAGE_TAGS, Tags) + hs->TagsArray.ItemCount() * sizeof(CASC_STORAGE_TAG); + szNameBuffer = (char *)pvStorageInfo + cbMinLength; + + // Also include the tag length + for(size_t i = 0; i < hs->TagsArray.ItemCount(); i++) + { + pTag = (PCASC_TAG_ENTRY2)hs->TagsArray.ItemAt(i); + cbMinLength = cbMinLength + pTag->NameLength + 1; + } - // Close all key mappings - for(i = 0; i < CASC_INDEX_COUNT; i++) + // Verify whether we have enough space in the buffer + pTags = (PCASC_STORAGE_TAGS)ProbeOutputBuffer(pvStorageInfo, cbStorageInfo, cbMinLength, pcbLengthNeeded); + if(pTags != NULL) + { + // Fill the output structure + pTags->TagCount = hs->TagsArray.ItemCount(); + pTags->Reserved = 0; + + // Copy the tags + for(size_t i = 0; i < hs->TagsArray.ItemCount(); i++) { - if(hs->KeyMapping[i].szFileName != NULL) - CASC_FREE(hs->KeyMapping[i].szFileName); - if(hs->KeyMapping[i].pbFileData != NULL) - CASC_FREE(hs->KeyMapping[i].pbFileData); - hs->KeyMapping[i].pIndexEntries = NULL; + // Get the source tag + pTag = (PCASC_TAG_ENTRY2)hs->TagsArray.ItemAt(i); + + // Fill the target tag + pTags->Tags[i].szTagName = szNameBuffer; + pTags->Tags[i].TagNameLength = (DWORD)pTag->NameLength; + pTags->Tags[i].TagValue = pTag->TagValue; + + // Copy the tag name + memcpy(szNameBuffer, pTag->szTagName, pTag->NameLength); + szNameBuffer[pTag->NameLength] = 0; + szNameBuffer = szNameBuffer + pTag->NameLength + 1; } - - // Free the file paths - if(hs->szRootPath != NULL) - CASC_FREE(hs->szRootPath); - if(hs->szDataPath != NULL) - CASC_FREE(hs->szDataPath); - if(hs->szBuildFile != NULL) - CASC_FREE(hs->szBuildFile); - if(hs->szIndexPath != NULL) - CASC_FREE(hs->szIndexPath); - if(hs->szUrlPath != NULL) - CASC_FREE(hs->szUrlPath); - - // Free the blobs - FreeCascBlob(&hs->CdnConfigKey); - FreeCascBlob(&hs->CdnBuildKey); - FreeCascBlob(&hs->ArchivesGroup); - FreeCascBlob(&hs->ArchivesKey); - FreeCascBlob(&hs->PatchArchivesKey); - FreeCascBlob(&hs->PatchArchivesGroup); - FreeCascBlob(&hs->RootKey); - FreeCascBlob(&hs->PatchKey); - FreeCascBlob(&hs->DownloadKey); - FreeCascBlob(&hs->InstallKey); - FreeCascBlob(&hs->EncodingKey); - - // Free the storage structure - hs->szClassName = NULL; - CASC_FREE(hs); } - return NULL; + return (pTags != NULL); } -//----------------------------------------------------------------------------- -// Public functions - -bool WINAPI CascOpenStorage(const TCHAR * szDataPath, DWORD dwLocaleMask, HANDLE * phStorage) +static int LoadCascStorage(TCascStorage * hs, DWORD dwLocaleMask) { - TCascStorage * hs; int nError = ERROR_SUCCESS; - // Allocate the storage structure - hs = (TCascStorage *)CASC_ALLOC(TCascStorage, 1); - if(hs == NULL) - nError = ERROR_NOT_ENOUGH_MEMORY; - - // Load the storage configuration - if(nError == ERROR_SUCCESS) + // For online storages, we need to load CDN servers + if ((nError == ERROR_SUCCESS) && (hs->dwFeatures & CASC_FEATURE_ONLINE)) { - // Prepare the base storage parameters - memset(hs, 0, sizeof(TCascStorage)); - hs->szClassName = "TCascStorage"; - hs->dwFileBeginDelta = 0xFFFFFFFF; - hs->dwDefaultLocale = CASC_LOCALE_ENUS | CASC_LOCALE_ENGB; - hs->dwRefCount = 1; - nError = InitializeCascDirectories(hs, szDataPath); + nError = LoadCdnsInfo(hs); } - // Now we need to load the root file so we know the config files + // Now, load the main storage file ".build.info" (or ".build.db" in old storages) if(nError == ERROR_SUCCESS) { nError = LoadBuildInfo(hs); } - // Load the index files + // If the .build.info OR .build.db file has been loaded, + // proceed with loading the CDN config file + if (nError == ERROR_SUCCESS) + { + nError = LoadCdnConfigFile(hs); + } + + // Proceed with loading the CDN build file + if (nError == ERROR_SUCCESS) + { + nError = LoadCdnBuildFile(hs); + } + + // Load the index files. Store information from the index files to the CKeyArray. if(nError == ERROR_SUCCESS) { nError = LoadIndexFiles(hs); } - // Load the index files + // Load the ENCODING manifest if(nError == ERROR_SUCCESS) { - nError = LoadEncodingFile(hs); + nError = LoadEncodingManifest(hs); } - // Initialize the dynamic array for extra files - // Reserve space for 0x20 encoding entries + // We need to load the DOWNLOAD manifest. This will give us the information about + // how many physical files are in the storage, so we can start building file tables if(nError == ERROR_SUCCESS) { - nError = Array_Create(&hs->ExtraEntries, CASC_ENCODING_ENTRY_1, CASC_EXTRA_FILES); + nError = LoadDownloadManifest(hs); } - // Load the index files + // Load the build manifest ("ROOT" file) if(nError == ERROR_SUCCESS) { - nError = LoadRootFile(hs, dwLocaleMask); + // If we fail to load the ROOT file, we take the file names from the INSTALL manifest + nError = LoadBuildManifest(hs, dwLocaleMask); + if (nError != ERROR_SUCCESS) + { + nError = LoadInstallManifest(hs); + } } - // If something failed, free the storage and return - if(nError != ERROR_SUCCESS) + // Insert entries for files with well-known names. Their CKeys are in the BUILD file + // See https://wowdev.wiki/TACT#Encoding_table for their list + if (nError == ERROR_SUCCESS) + { + InsertWellKnownFile(hs, "ENCODING", hs->EncodingCKey); + InsertWellKnownFile(hs, "DOWNLOAD", hs->DownloadCKey); + InsertWellKnownFile(hs, "INSTALL", hs->InstallCKey); + InsertWellKnownFile(hs, "PATCH", hs->PatchFile); + InsertWellKnownFile(hs, "ROOT", hs->RootFile); + InsertWellKnownFile(hs, "SIZE", hs->SizeFile); + + // Also reset the total file count. CascGetStorageInfo will update it on next call + hs->TotalFiles = 0; + } + + // Load the encryption keys + if (nError == ERROR_SUCCESS) + { + nError = CascLoadEncryptionKeys(hs); + } + + return nError; +} + +//----------------------------------------------------------------------------- +// Public functions + +void WINAPI CascSetProgressCallback(PFNPROGRESSCALLBACK PtrUserCallback, void * PtrUserParam) +{ + PfnProgressCallback = PtrUserCallback; + PtrProgressParam = PtrUserParam; +} + +bool WINAPI CascOpenStorage(LPCTSTR szPath, DWORD dwLocaleMask, HANDLE * phStorage) +{ + TCascStorage * hs; + int nError = ERROR_NOT_ENOUGH_MEMORY; + + // Allocate the storage structure + if((hs = new TCascStorage()) != NULL) { - hs = FreeCascStorage(hs); - SetLastError(nError); + // Setup the directories + nError = InitializeLocalDirectories(hs, szPath); + if(nError == ERROR_SUCCESS) + { + nError = LoadCascStorage(hs, dwLocaleMask); + if(nError == ERROR_SUCCESS) + { + *phStorage = (HANDLE)hs; + return true; + } + } + + // Delete the so-far-allocated storage + hs = hs->Release(); } - *phStorage = (HANDLE)hs; - return (nError == ERROR_SUCCESS); + // Failed + SetLastError(nError); + *phStorage = NULL; + return false; +} + +// Allows to browse an online CDN storage +// szLocalCache: Local folder, where the online file will be cached. +// szCodeName: Product code name, e.g. "agent" for Battle.net Agent. More info: https://wowdev.wiki/TACT#Products +// szRegion: The region (or subvariant) of the product. Corresponds to the first column of the "versions" file. +bool WINAPI CascOpenOnlineStorage(LPCTSTR szLocalCache, LPCSTR szCodeName, LPCSTR szRegion, DWORD dwLocaleMask, HANDLE * phStorage) +{ + TCascStorage * hs; + int nError = ERROR_NOT_ENOUGH_MEMORY; + + // Allocate the storage structure + if((hs = new TCascStorage()) != NULL) + { + // Setup the directories + nError = InitializeOnlineDirectories(hs, szLocalCache, szCodeName, szRegion); + if(nError == ERROR_SUCCESS) + { + nError = LoadCascStorage(hs, dwLocaleMask); + if(nError == ERROR_SUCCESS) + { + *phStorage = (HANDLE)hs; + return true; + } + } + + // Delete the so-far-allocated storage + hs = hs->Release(); + } + + // Failed + SetLastError(nError); + *phStorage = NULL; + return false; } bool WINAPI CascGetStorageInfo( @@ -1120,10 +1240,11 @@ bool WINAPI CascGetStorageInfo( size_t * pcbLengthNeeded) { TCascStorage * hs; + PDWORD PtrOutputValue; DWORD dwInfoValue = 0; // Verify the storage handle - hs = IsValidStorageHandle(hStorage); + hs = TCascStorage::IsValid(hStorage); if(hs == NULL) { SetLastError(ERROR_INVALID_HANDLE); @@ -1133,45 +1254,43 @@ bool WINAPI CascGetStorageInfo( // Differentiate between info classes switch(InfoClass) { - case CascStorageFileCount: - dwInfoValue = (DWORD)hs->pIndexEntryMap->ItemCount; - break; - - case CascStorageFeatures: - dwInfoValue |= (hs->pRootHandler->dwRootFlags & ROOT_FLAG_HAS_NAMES) ? CASC_FEATURE_LISTFILE : 0; + case CascStorageLocalFileCount: + dwInfoValue = (DWORD)hs->LocalFiles; break; - case CascStorageGameInfo: - dwInfoValue = hs->dwGameInfo; + case CascStorageTotalFileCount: + if(hs->TotalFiles == 0) + hs->TotalFiles = GetStorageTotalFileCount(hs); + dwInfoValue = (DWORD)hs->TotalFiles; break; - case CascStorageGameBuild: - dwInfoValue = hs->dwBuildNumber; + case CascStorageFeatures: + dwInfoValue = hs->dwFeatures | hs->pRootHandler->GetFeatures(); break; case CascStorageInstalledLocales: dwInfoValue = hs->dwDefaultLocale; break; + case CascStorageProduct: + return GetStorageProduct(hs, pvStorageInfo, cbStorageInfo, pcbLengthNeeded); + + case CascStorageTags: + return GetStorageTags(hs, pvStorageInfo, cbStorageInfo, pcbLengthNeeded); + default: SetLastError(ERROR_INVALID_PARAMETER); return false; } // - // Return the required DWORD value + // Default: return a 32-bit unsigned value // - if(cbStorageInfo < sizeof(DWORD)) - { - *pcbLengthNeeded = sizeof(DWORD); - SetLastError(ERROR_INSUFFICIENT_BUFFER); - return false; - } - - // Give the number of files - *(PDWORD)pvStorageInfo = dwInfoValue; - return true; + PtrOutputValue = (PDWORD)ProbeOutputBuffer(pvStorageInfo, cbStorageInfo, sizeof(DWORD), pcbLengthNeeded); + if(PtrOutputValue != NULL) + PtrOutputValue[0] = dwInfoValue; + return (PtrOutputValue != NULL); } bool WINAPI CascCloseStorage(HANDLE hStorage) @@ -1179,7 +1298,7 @@ bool WINAPI CascCloseStorage(HANDLE hStorage) TCascStorage * hs; // Verify the storage handle - hs = IsValidStorageHandle(hStorage); + hs = TCascStorage::IsValid(hStorage); if(hs == NULL) { SetLastError(ERROR_INVALID_PARAMETER); @@ -1187,14 +1306,6 @@ bool WINAPI CascCloseStorage(HANDLE hStorage) } // Only free the storage if the reference count reaches 0 - if(hs->dwRefCount == 1) - { - FreeCascStorage(hs); - return true; - } - - // Just decrement number of references - hs->dwRefCount--; + hs->Release(); return true; } - diff --git a/dep/CascLib/src/CascPort.h b/dep/CascLib/src/CascPort.h index 5d9a7104f7b..87a2f2fddbd 100644 --- a/dep/CascLib/src/CascPort.h +++ b/dep/CascLib/src/CascPort.h @@ -37,12 +37,20 @@ #define WIN32_LEAN_AND_MEAN #endif +//#pragma warning(disable:4995) // warning C4995: 'sprintf': name was marked as #pragma deprecated + #include <tchar.h> #include <assert.h> + #include <intrin.h> // Support for intrinsic functions #include <ctype.h> + #include <io.h> #include <stdio.h> + #include <stdlib.h> + #include <direct.h> + #include <malloc.h> #include <windows.h> #include <wininet.h> + #include <strsafe.h> #include <sys/types.h> #define PLATFORM_LITTLE_ENDIAN @@ -52,8 +60,10 @@ #define PLATFORM_32BIT #endif - #define PATH_SEPARATOR '\\' - #define CREATE_DIRECTORY(name) CreateDirectory(name, NULL); + #define PATH_SEP_CHAR '\\' + #define PATH_SEP_STRING "\\" + + #pragma intrinsic(memcmp, memcpy) #define PLATFORM_WINDOWS #define PLATFORM_DEFINED // The platform is known now @@ -75,6 +85,8 @@ #include <dirent.h> #include <errno.h> #include <stddef.h> + #include <string.h> + #include <cassert> // Support for PowerPC on Max OS X #if (__ppc__ == 1) || (__POWERPC__ == 1) || (_ARCH_PPC == 1) @@ -90,9 +102,9 @@ #define PLATFORM_LITTLE_ENDIAN #endif - #define PATH_SEPARATOR '/' - #define CREATE_DIRECTORY(name) mkdir(name, 0755) - + #define PATH_SEP_CHAR '/' + #define PATH_SEP_STRING "/" + #define PLATFORM_MAC #define PLATFORM_DEFINED // The platform is known now @@ -103,7 +115,6 @@ // Assumption: we are not on Windows nor Macintosh, so this must be linux *grin* #if !defined(PLATFORM_DEFINED) - #include <sys/types.h> #include <sys/stat.h> #include <sys/mman.h> @@ -117,12 +128,13 @@ #include <stdarg.h> #include <string.h> #include <ctype.h> + #include <wchar.h> #include <assert.h> #include <errno.h> - #define PATH_SEPARATOR '/' - #define CREATE_DIRECTORY(name) mkdir(name, 0755) - + #define PATH_SEP_CHAR '/' + #define PATH_SEP_STRING "/" + #define PLATFORM_LITTLE_ENDIAN #define PLATFORM_LINUX #define PLATFORM_DEFINED @@ -145,20 +157,19 @@ typedef unsigned short USHORT; typedef int LONG; typedef unsigned int DWORD; - typedef unsigned long DWORD_PTR; - typedef long LONG_PTR; - typedef long INT_PTR; typedef long long LONGLONG; typedef unsigned long long ULONGLONG; typedef unsigned long long *PULONGLONG; typedef void * HANDLE; - typedef void * LPOVERLAPPED; // Unsupported on Linux and Mac typedef char TCHAR; typedef unsigned int LCID; typedef LONG * PLONG; typedef DWORD * PDWORD; typedef BYTE * LPBYTE; typedef char * LPSTR; + typedef const char * LPCSTR; + typedef TCHAR * LPTSTR; + typedef const TCHAR * LPCTSTR; #ifdef PLATFORM_32BIT #define _LZMA_UINT32_IS_ULONG @@ -179,7 +190,6 @@ #define _T(x) x #define _tcslen strlen - #define _tcscpy strcpy #define _tcscat strcat #define _tcschr strchr #define _tcsrchr strrchr @@ -187,9 +197,9 @@ #define _tcsspn strspn #define _tcsncmp strncmp #define _tprintf printf - #define _stprintf sprintf #define _tremove remove - #define _tmkdir mkdir + #define _taccess access + #define _access access #define _stricmp strcasecmp #define _strnicmp strncasecmp @@ -212,6 +222,7 @@ #if defined(PLATFORM_MAC) || defined(PLATFORM_LINUX) #define ERROR_SUCCESS 0 #define ERROR_FILE_NOT_FOUND ENOENT + #define ERROR_PATH_NOT_FOUND ENOENT #define ERROR_ACCESS_DENIED EPERM #define ERROR_INVALID_HANDLE EBADF #define ERROR_NOT_ENOUGH_MEMORY ENOMEM @@ -220,18 +231,34 @@ #define ERROR_DISK_FULL ENOSPC #define ERROR_ALREADY_EXISTS EEXIST #define ERROR_INSUFFICIENT_BUFFER ENOBUFS - #define ERROR_BAD_FORMAT 1000 // No such error code under Linux - #define ERROR_NO_MORE_FILES 1001 // No such error code under Linux - #define ERROR_HANDLE_EOF 1002 // No such error code under Linux - #define ERROR_CAN_NOT_COMPLETE 1003 // No such error code under Linux - #define ERROR_FILE_CORRUPT 1004 // No such error code under Linux - #define ERROR_FILE_ENCRYPTED 1005 // Returned by encrypted stream when can't find file key + #define ERROR_BAD_FORMAT 1000 // No such error code under Linux + #define ERROR_NO_MORE_FILES 1001 // No such error code under Linux + #define ERROR_HANDLE_EOF 1002 // No such error code under Linux + #define ERROR_CAN_NOT_COMPLETE 1003 // No such error code under Linux + #define ERROR_FILE_CORRUPT 1004 // No such error code under Linux + #define ERROR_FILE_ENCRYPTED 1005 // Returned by encrypted stream when can't find file key #endif #ifndef ERROR_FILE_INCOMPLETE -#define ERROR_FILE_INCOMPLETE 1006 // The required file part is missing +#define ERROR_FILE_INCOMPLETE 1006 // The required file part is missing +#endif + +#ifndef ERROR_FILE_OFFLINE +#define ERROR_FILE_OFFLINE 1007 // The file is not available in the local storage #endif +#ifndef ERROR_BUFFER_OVERFLOW +#define ERROR_BUFFER_OVERFLOW 1008 +#endif + +#ifndef ERROR_CANCELLED +#define ERROR_CANCELLED 1009 +#endif + +#ifndef _countof +#define _countof(x) (sizeof(x) / sizeof(x[0])) +#endif + //----------------------------------------------------------------------------- // Swapping functions @@ -273,4 +300,13 @@ #define BSWAP_ARRAY64_UNSIGNED(a,b) ConvertUInt64Buffer((a),(b)) #endif +//----------------------------------------------------------------------------- +// Forbidden functions, do not use + +#ifdef __CASCLIB_SELF__ +#define strcpy UNSAFE_DO_NOT_USE_STRCPY +#define strcat UNSAFE_DO_NOT_USE_STRCAT +#define sprintf UNSAFE_DO_NOT_USE_SPRINTF +#endif + #endif // __CASCPORT_H__ diff --git a/dep/CascLib/src/CascReadFile.cpp b/dep/CascLib/src/CascReadFile.cpp index 1b13e873f02..2720d6d5adb 100644 --- a/dep/CascLib/src/CascReadFile.cpp +++ b/dep/CascLib/src/CascReadFile.cpp @@ -1,4 +1,4 @@ -/*****************************************************************************/ +/****************************************************************************/ /* CascOpenFile.cpp Copyright (c) Ladislav Zezula 2014 */ /*---------------------------------------------------------------------------*/ /* System-dependent directory functions for CascLib */ @@ -13,302 +13,453 @@ #include "CascCommon.h" //----------------------------------------------------------------------------- -// Local structures - -typedef struct _BLTE_FRAME -{ - BYTE CompressedSize[4]; // Compressed file size as big endian - BYTE FrameSize[4]; // File size as big endian - BYTE md5[MD5_HASH_SIZE]; // Hash of the compressed frame - -} BLTE_FRAME, *PBLTE_FRAME; - -//----------------------------------------------------------------------------- // Local functions -TCascFile * IsValidFileHandle(HANDLE hFile); // In CascOpenFile.cpp - static int EnsureDataStreamIsOpen(TCascFile * hf) { TCascStorage * hs = hf->hs; TFileStream * pStream = NULL; + ULONGLONG EncodedSize = 0; TCHAR * szDataFile; - TCHAR szPlainName[0x40]; + TCHAR szCachePath[MAX_PATH]; + TCHAR szPlainName[0x80]; + int nError; - // If the file is not open yet, do it - if(hs->DataFileArray[hf->ArchiveIndex] == NULL) + // If the file is available locally, we rely on data files. + // If not, we download the file and open the stream + if(hf->pCKeyEntry->Flags & CASC_CE_FILE_IS_LOCAL) { - // Prepare the name of the data file - _stprintf(szPlainName, _T("data.%03u"), hf->ArchiveIndex); - szDataFile = CombinePath(hs->szIndexPath, szPlainName); + // If the file is not open yet, do it + if(hs->DataFiles[hf->ArchiveIndex] == NULL) + { + // Prepare the name of the data file + CascStrPrintf(szPlainName, _countof(szPlainName), _T("data.%03u"), hf->ArchiveIndex); + szDataFile = CombinePath(hs->szIndexPath, szPlainName); - // Open the data file - if(szDataFile != NULL) + // Open the data file + if(szDataFile != NULL) + { + // Open the data stream with read+write sharing to prevent Battle.net agent + // detecting a corruption and redownloading the entire package + pStream = FileStream_OpenFile(szDataFile, STREAM_FLAG_READ_ONLY | STREAM_FLAG_WRITE_SHARE | STREAM_PROVIDER_FLAT | STREAM_FLAG_FILL_MISSING | BASE_PROVIDER_FILE); + hs->DataFiles[hf->ArchiveIndex] = pStream; + CASC_FREE(szDataFile); + } + } + + // Return error or success + hf->pStream = hs->DataFiles[hf->ArchiveIndex]; + return (hf->pStream != NULL) ? ERROR_SUCCESS : ERROR_FILE_NOT_FOUND; + } + else + { + if(hf->bDownloadFileIf) { - // Open the stream - pStream = FileStream_OpenFile(szDataFile, STREAM_FLAG_READ_ONLY | STREAM_PROVIDER_FLAT | BASE_PROVIDER_FILE); - hs->DataFileArray[hf->ArchiveIndex] = pStream; - CASC_FREE(szDataFile); + // Create the local folder path and download the file from CDN + nError = DownloadFileFromCDN(hf->hs, _T("data"), hf->pCKeyEntry->EKey, NULL, szCachePath, _countof(szCachePath)); + if(nError == ERROR_SUCCESS) + { + hf->pStream = FileStream_OpenFile(szCachePath, BASE_PROVIDER_FILE | STREAM_PROVIDER_FLAT); + if(hf->pStream != NULL) + { + // Supply the file size, if unknown yet + if(hf->EncodedSize == CASC_INVALID_SIZE) + { + FileStream_GetSize(hf->pStream, &EncodedSize); + hf->pCKeyEntry->EncodedSize = (DWORD)EncodedSize; + hf->EncodedSize = (DWORD)EncodedSize; + } + + hf->bLocalFileStream = true; + return ERROR_SUCCESS; + } + } } + + return ERROR_FILE_OFFLINE; } +} - // Return error or success - hf->pStream = hs->DataFileArray[hf->ArchiveIndex]; - return (hf->pStream != NULL) ? ERROR_SUCCESS : ERROR_FILE_NOT_FOUND; +#ifdef _DEBUG +static unsigned int table_16C57A8[0x10] = +{ + 0x049396B8, 0x72A82A9B, 0xEE626CCA, 0x9917754F, + 0x15DE40B1, 0xF5A8A9B6, 0x421EAC7E, 0xA9D55C9A, + 0x317FD40C, 0x04FAF80D, 0x3D6BE971, 0x52933CFD, + 0x27F64B7D, 0xC6F5C11B, 0xD5757E3A, 0x6C388745 +}; + +// Obtained from Agent.exe v 2.15.0.6296 (d14ec9d9a1b396a42964b05f40ea55f37eae5478d550c07ebb6cb09e50968d62) +// Note the "Checksum" value probably won't match with older game versions. +static void VerifyHeaderSpan(PBLTE_ENCODED_HEADER pBlteHeader, ULONGLONG HeaderOffset) +{ + LPBYTE pbBlteHeader = (LPBYTE)pBlteHeader; + DWORD dwInt32; + BYTE EncodedOffset[4] = { 0 }; + BYTE HashedHeader[4] = { 0 }; + BYTE JenkinsHash[4]; + BYTE Checksum[4]; + size_t i, j; + + // Seems to be hardcoded to zero + assert(pBlteHeader->field_15 == 0); + + // Calculate the Jenkins hash and write it to the header + dwInt32 = hashlittle(pbBlteHeader, FIELD_OFFSET(BLTE_ENCODED_HEADER, JenkinsHash), 0x3D6BE971); + ConvertIntegerToBytes_4_LE(dwInt32, JenkinsHash); +// assert(memcmp(pBlteHeader->JenkinsHash, JenkinsHash, sizeof(JenkinsHash)) == 0); + + // Encode the lower 32-bits of the offset + dwInt32 = (DWORD)(HeaderOffset + FIELD_OFFSET(BLTE_ENCODED_HEADER, Signature)); + dwInt32 = table_16C57A8[dwInt32 & 0x0F] ^ dwInt32; + ConvertIntegerToBytes_4_LE(dwInt32, EncodedOffset); + + // Calculate checksum of the so-far filled structure + for (i = 0; i < FIELD_OFFSET(BLTE_ENCODED_HEADER, Checksum); i++) + HashedHeader[i & 3] ^= pbBlteHeader[i]; + + // XOR the two values together to get the final checksum. + for (j = 0; j < 4; j++, i++) + Checksum[j] = HashedHeader[i & 3] ^ EncodedOffset[i & 3]; +// assert(memcmp(pBlteHeader->Checksum, Checksum, sizeof(Checksum)) == 0); } +#endif -static int LoadFileFrames(TCascFile * hf) +static int ParseBlteHeader(TCascFile * hf, ULONGLONG HeaderOffset, LPBYTE pbEncodedBuffer, size_t cbEncodedBuffer, size_t * pcbHeaderSize) +{ + PBLTE_ENCODED_HEADER pEncodedHeader = (PBLTE_ENCODED_HEADER)pbEncodedBuffer; + PBLTE_HEADER pBlteHeader = (PBLTE_HEADER)pbEncodedBuffer; + DWORD ExpectedHeaderSize; + DWORD ExHeaderSize = 0; + DWORD HeaderSize; + DWORD FrameCount = 0; + + CASCLIB_UNUSED(HeaderOffset); + + // On files within storage segments ("data.###"), there is BLTE_ENCODED_HEADER + // On local files, there is just PBLTE_HEADER + if(ConvertBytesToInteger_4_LE(pBlteHeader->Signature) != BLTE_HEADER_SIGNATURE) + { + // There must be at least some bytes + if (cbEncodedBuffer < FIELD_OFFSET(BLTE_ENCODED_HEADER, MustBe0F)) + return ERROR_BAD_FORMAT; + if (pEncodedHeader->EncodedSize != hf->EncodedSize) + return ERROR_BAD_FORMAT; + +#ifdef _DEBUG + // Not really needed, it's here just for explanation of what the values mean + //assert(memcmp(hf->pCKeyEntry->EKey, pEncodedHeader->EKey.Value, MD5_HASH_SIZE) == 0); + VerifyHeaderSpan(pEncodedHeader, HeaderOffset); +#endif + // Capture the EKey + ExHeaderSize = FIELD_OFFSET(BLTE_ENCODED_HEADER, Signature); + pBlteHeader = (PBLTE_HEADER)(pbEncodedBuffer + ExHeaderSize); + } + + // Verify the signature + if(ConvertBytesToInteger_4_LE(pBlteHeader->Signature) != BLTE_HEADER_SIGNATURE) + return ERROR_BAD_FORMAT; + + // Capture the header size. If this is non-zero, then array + // of chunk headers follow. Otherwise, the file is just one chunk + HeaderSize = ConvertBytesToInteger_4(pBlteHeader->HeaderSize); + if (HeaderSize != 0) + { + if (pBlteHeader->MustBe0F != 0x0F) + return ERROR_BAD_FORMAT; + + // Verify the header size + FrameCount = ConvertBytesToInteger_3(pBlteHeader->FrameCount); + ExpectedHeaderSize = 0x0C + FrameCount * sizeof(BLTE_FRAME); + if (ExpectedHeaderSize != HeaderSize) + return ERROR_BAD_FORMAT; + + // Give the values + pcbHeaderSize[0] = ExHeaderSize + FIELD_OFFSET(BLTE_HEADER, MustBe0F) + sizeof(DWORD); + } + else + { + pcbHeaderSize[0] = ExHeaderSize + FIELD_OFFSET(BLTE_HEADER, MustBe0F); + } + + // Give the frame count + hf->FrameCount = FrameCount; + return ERROR_SUCCESS; +} + +static LPBYTE ReadMissingHeaderData(TCascFile * hf, ULONGLONG DataFileOffset, LPBYTE pbEncodedBuffer, size_t cbEncodedBuffer, size_t cbTotalHeaderSize) +{ + LPBYTE pbNewBuffer; + + // Reallocate the buffer + pbNewBuffer = CASC_REALLOC(BYTE, pbEncodedBuffer, cbTotalHeaderSize); + if (pbNewBuffer != NULL) + { + // Load the missing data + DataFileOffset += cbEncodedBuffer; + if (FileStream_Read(hf->pStream, &DataFileOffset, pbNewBuffer + cbEncodedBuffer, (DWORD)(cbTotalHeaderSize - cbEncodedBuffer))) + { + return pbNewBuffer; + } + } + + // If anything failed, we free the original buffer and return NULL; + CASC_FREE(pbEncodedBuffer); + return NULL; +} + +static int LoadFileFrames(TCascFile * hf, ULONGLONG DataFileOffset, LPBYTE pbFramePtr, LPBYTE pbFrameEnd, size_t cbHeaderSize) { - PBLTE_FRAME pFileFrames; PBLTE_FRAME pFileFrame; - ULONGLONG ArchiveFileOffset; - DWORD FrameOffset = 0; - DWORD FileSize = 0; + DWORD ContentSize = 0; + DWORD FileOffset = 0; int nError = ERROR_SUCCESS; assert(hf != NULL); assert(hf->pStream != NULL); - assert(hf->pFrames != NULL); + assert(hf->pFrames == NULL); - // Allocate frame array - pFileFrames = pFileFrame = CASC_ALLOC(BLTE_FRAME, hf->FrameCount); - if(pFileFrames != NULL) + if (hf->FrameCount != 0) { - // Load the frame array - ArchiveFileOffset = hf->FramesOffset; - if(FileStream_Read(hf->pStream, &ArchiveFileOffset, pFileFrames, hf->FrameCount * sizeof(BLTE_FRAME))) - { - // Move the raw archive offset - ArchiveFileOffset += (hf->FrameCount * sizeof(BLTE_FRAME)); + // Move the raw archive offset + DataFileOffset += (hf->FrameCount * sizeof(BLTE_FRAME)); + // Allocate array of file frames + hf->pFrames = CASC_ALLOC(CASC_FILE_FRAME, hf->FrameCount); + if (hf->pFrames != NULL) + { // Copy the frames to the file structure - for(DWORD i = 0; i < hf->FrameCount; i++, pFileFrame++) + for (DWORD i = 0; i < hf->FrameCount; i++, pbFramePtr += sizeof(BLTE_FRAME)) { - hf->pFrames[i].FrameArchiveOffset = (DWORD)ArchiveFileOffset; - hf->pFrames[i].FrameFileOffset = FrameOffset; - hf->pFrames[i].CompressedSize = ConvertBytesToInteger_4(pFileFrame->CompressedSize); - hf->pFrames[i].FrameSize = ConvertBytesToInteger_4(pFileFrame->FrameSize); - memcpy(hf->pFrames[i].md5, pFileFrame->md5, MD5_HASH_SIZE); - - ArchiveFileOffset += hf->pFrames[i].CompressedSize; - FrameOffset += hf->pFrames[i].FrameSize; - FileSize += hf->pFrames[i].FrameSize; + // Capture the file frame + if ((pbFramePtr + sizeof(BLTE_FRAME)) > pbFrameEnd) + return ERROR_BAD_FORMAT; + pFileFrame = (PBLTE_FRAME)pbFramePtr; + + // Convert the file frame to the native format + hf->pFrames[i].DataFileOffset = (DWORD)DataFileOffset; + hf->pFrames[i].FileOffset = CASC_INVALID_POS; + hf->pFrames[i].EncodedSize = ConvertBytesToInteger_4(pFileFrame->EncodedSize); + hf->pFrames[i].ContentSize = ConvertBytesToInteger_4(pFileFrame->ContentSize); + hf->pFrames[i].FrameHash = pFileFrame->FrameHash; + + DataFileOffset += hf->pFrames[i].EncodedSize; + ContentSize += hf->pFrames[i].ContentSize; + FileOffset += hf->pFrames[i].ContentSize; } - } - else - nError = GetLastError(); - // Note: on ENCODING file, this value is almost always bigger - // then the real size of ENCODING. We handle this problem - // by calculating size of the ENCODIG file from its header. - hf->FileSize = FileSize; + // Save the content size of the file + if(hf->pCKeyEntry->ContentSize == CASC_INVALID_SIZE) + { + hf->pCKeyEntry->ContentSize = ContentSize; + hf->ContentSize = ContentSize; + } + } + } + else + { + // The content size in the file structure must be valid at this point, + // otherwise we don't know the frame content size + if (hf->ContentSize == CASC_INVALID_SIZE) + { + assert(false); + return ERROR_CAN_NOT_COMPLETE; + } -#ifdef CASCLIB_TEST - hf->FileSize_FrameSum = FileSize; -#endif + // Save the number of file frames + hf->FrameCount = 1; - // Free the array - CASC_FREE(pFileFrames); + // Allocate single "dummy" frame + hf->pFrames = CASC_ALLOC(CASC_FILE_FRAME, 1); + if (hf->pFrames != NULL) + { + memset(&hf->pFrames->FrameHash, 0, sizeof(CONTENT_KEY)); + hf->pFrames->DataFileOffset = (DWORD)DataFileOffset; + hf->pFrames->FileOffset = CASC_INVALID_POS; + hf->pFrames->EncodedSize = (DWORD)(hf->EncodedSize - cbHeaderSize); + hf->pFrames->ContentSize = hf->ContentSize; + } } - else - nError = ERROR_NOT_ENOUGH_MEMORY; + if (hf->pFrames == NULL) + nError = ERROR_NOT_ENOUGH_MEMORY; return nError; } -static int EnsureHeaderAreaIsLoaded(TCascFile * hf) +static int LoadEncodedHeaderAndFileFrames(TCascFile * hf) { - TCascStorage * hs = hf->hs; - ULONGLONG FileOffset = hf->HeaderOffset; - LPBYTE pbHeaderArea; - DWORD FileSignature; - DWORD FileSize; - BYTE HeaderArea[MAX_HEADER_AREA_SIZE]; - int nError; - - // We need the data file to be open - nError = EnsureDataStreamIsOpen(hf); - if(nError != ERROR_SUCCESS) - return nError; - - // Make sure that we already know the shift - // to the begin of file data. - // Note that older builds of Heroes of the Storm have entries pointing - // to the beginning of the header area. - // Newer versions of HOTS have encoding entries pointing directly to - // the BLTE header - if(hs->dwFileBeginDelta == 0xFFFFFFFF) - { - FileSignature = 0; - FileOffset = hf->HeaderOffset; - if(!FileStream_Read(hf->pStream, &FileOffset, &FileSignature, sizeof(DWORD))) - return ERROR_FILE_CORRUPT; + LPBYTE pbEncodedBuffer; + size_t cbEncodedBuffer = MAX_ENCODED_HEADER; + int nError = ERROR_SUCCESS; - hs->dwFileBeginDelta = (FileSignature == BLTE_HEADER_SIGNATURE) ? BLTE_HEADER_DELTA : 0; - } + // Should only be called when the file frames are NOT loaded + assert(hf->pFrames == NULL); + assert(hf->FrameCount == 0); - // If the file size is not loaded yet, do it - if(hf->FrameCount == 0) + // Allocate the initial buffer for the encoded headers + pbEncodedBuffer = CASC_ALLOC(BYTE, MAX_ENCODED_HEADER); + if (pbEncodedBuffer != NULL) { - // Load the part before BLTE header + header itself - FileOffset = hf->HeaderOffset - hs->dwFileBeginDelta; - if(!FileStream_Read(hf->pStream, &FileOffset, HeaderArea, sizeof(HeaderArea))) - return ERROR_FILE_CORRUPT; - - // Copy the MD5 hash of the frame array - memcpy(hf->FrameArrayHash, HeaderArea, MD5_HASH_SIZE); - pbHeaderArea = HeaderArea + MD5_HASH_SIZE; - - // Copy the file size - FileSize = ConvertBytesToInteger_4_LE(pbHeaderArea); - pbHeaderArea += 0x0E; - - // Verify the BLTE signature - if(ConvertBytesToInteger_4_LE(pbHeaderArea) != BLTE_HEADER_SIGNATURE) - return ERROR_BAD_FORMAT; - pbHeaderArea += sizeof(DWORD); + ULONGLONG ReadOffset = hf->ArchiveOffset; + size_t cbTotalHeaderSize; + size_t cbHeaderSize = 0; - // Load the size of the frame headers - hf->HeaderSize = ConvertBytesToInteger_4(pbHeaderArea); - if(hf->HeaderSize & 0x80000000) - return ERROR_BAD_FORMAT; - pbHeaderArea += sizeof(DWORD); + // At this point, we expect encoded size to be known + assert(hf->EncodedSize != CASC_INVALID_SIZE); - // Read the header size - assert(hs->dwFileBeginDelta <= BLTE_HEADER_DELTA); - hf->HeaderOffset += (BLTE_HEADER_DELTA - hs->dwFileBeginDelta); - hf->FrameCount = 1; + // Do not read more than encoded size + cbEncodedBuffer = CASCLIB_MIN(cbEncodedBuffer, hf->EncodedSize); - // Retrieve the frame count, if different from 1 - if(hf->HeaderSize != 0) + // Load the entire (eventual) header area. This is faster than doing + // two read operations in a row. Read as much as possible. If the file is cut, + // the FileStream will pad it with zeros + if (FileStream_Read(hf->pStream, &ReadOffset, pbEncodedBuffer, (DWORD)cbEncodedBuffer)) { - // The next byte must be 0x0F - if(pbHeaderArea[0] != 0x0F) - return ERROR_BAD_FORMAT; - pbHeaderArea++; + // Parse the BLTE header + nError = ParseBlteHeader(hf, ReadOffset, pbEncodedBuffer, cbEncodedBuffer, &cbHeaderSize); + if (nError == ERROR_SUCCESS) + { + // If the headers are larger than the initial read size, + // We read the missing data + cbTotalHeaderSize = cbHeaderSize + (hf->FrameCount * sizeof(BLTE_FRAME)); + if (cbTotalHeaderSize > cbEncodedBuffer) + { + pbEncodedBuffer = ReadMissingHeaderData(hf, ReadOffset, pbEncodedBuffer, cbEncodedBuffer, cbTotalHeaderSize); + if (pbEncodedBuffer == NULL) + nError = GetLastError(); + cbEncodedBuffer = cbTotalHeaderSize; + } - // Next three bytes form number of frames - hf->FrameCount = ConvertBytesToInteger_3(pbHeaderArea); + // Load the array of frame headers + if (nError == ERROR_SUCCESS) + { + nError = LoadFileFrames(hf, ReadOffset + cbHeaderSize, pbEncodedBuffer + cbHeaderSize, pbEncodedBuffer + cbEncodedBuffer, cbHeaderSize); + } + } + } + else + { + nError = ERROR_FILE_CORRUPT; } -#ifdef CASCLIB_TEST - hf->FileSize_HdrArea = FileSize; -#endif + // Free the frame buffer + CASC_FREE(pbEncodedBuffer); + } + else + { + nError = ERROR_NOT_ENOUGH_MEMORY; } - return ERROR_SUCCESS; + return nError; } -static int EnsureFrameHeadersLoaded(TCascFile * hf) +static int EnsureFileFramesLoaded(TCascFile * hf) { - int nError; - - // Make sure we have header area loaded - nError = EnsureHeaderAreaIsLoaded(hf); - if(nError != ERROR_SUCCESS) - return nError; + int nError = ERROR_SUCCESS; - // If the frame headers are not loaded yet, do it + // If the encoded frames are not loaded, do it now if(hf->pFrames == NULL) { - // Allocate the frame array - hf->pFrames = CASC_ALLOC(CASC_FILE_FRAME, hf->FrameCount); - if(hf->pFrames != NULL) - { - // Either load the frames from the file or supply them on our own - if(hf->HeaderSize != 0) - { - hf->FramesOffset = hf->HeaderOffset + sizeof(DWORD) + sizeof(DWORD) + sizeof(DWORD); - nError = LoadFileFrames(hf); - } - else - { - // Offset of the first frame is right after the file frames - hf->FramesOffset = hf->HeaderOffset + sizeof(DWORD) + sizeof(DWORD); - - hf->pFrames[0].FrameArchiveOffset = hf->FramesOffset; - hf->pFrames[0].FrameFileOffset = 0; - hf->pFrames[0].CompressedSize = hf->CompressedSize; - hf->pFrames[0].FrameSize = hf->FileSize; - memset(hf->pFrames[0].md5, 0, MD5_HASH_SIZE); - } - } + // We need the data file to be open + nError = EnsureDataStreamIsOpen(hf); + if(nError != ERROR_SUCCESS) + return nError; - // Return result - return (hf->pFrames != NULL) ? ERROR_SUCCESS : ERROR_FILE_CORRUPT; + // Make sure we have header area loaded + nError = LoadEncodedHeaderAndFileFrames(hf); } - return ERROR_SUCCESS; + return nError; } -static PCASC_FILE_FRAME FindFileFrame(TCascFile * hf, DWORD FilePointer) +static int LoadEncodedFrame(TFileStream * pStream, PCASC_FILE_FRAME pFrame, LPBYTE pbEncodedFrame, bool bVerifyIntegrity) { - PCASC_FILE_FRAME pFrame = hf->pFrames; - DWORD FrameBegin; - DWORD FrameEnd; - - // Sanity checks - assert(hf->pFrames != NULL); - assert(hf->FrameCount != 0); + ULONGLONG FileOffset = pFrame->DataFileOffset; + int nError = ERROR_SUCCESS; - // Find the frame where to read from - for(DWORD i = 0; i < hf->FrameCount; i++, pFrame++) + // Load the encoded frame to memory + if(FileStream_Read(pStream, &FileOffset, pbEncodedFrame, pFrame->EncodedSize)) { - // Does the read request fit into the current frame? - FrameBegin = pFrame->FrameFileOffset; - FrameEnd = FrameBegin + pFrame->FrameSize; - if(FrameBegin <= FilePointer && FilePointer < FrameEnd) - return pFrame; + if (bVerifyIntegrity) + { + if (!CascVerifyDataBlockHash(pbEncodedFrame, pFrame->EncodedSize, pFrame->FrameHash.Value)) + nError = ERROR_FILE_CORRUPT; + } + } + else + { + nError = GetLastError(); } - // Not found, sorry - return NULL; + return nError; } static int ProcessFileFrame( + TCascStorage * hs, LPBYTE pbOutBuffer, DWORD cbOutBuffer, LPBYTE pbInBuffer, DWORD cbInBuffer, DWORD dwFrameIndex) { - LPBYTE pbTempBuffer; - LPBYTE pbWorkBuffer; - DWORD cbTempBuffer = CASCLIB_MAX(cbInBuffer, cbOutBuffer); - DWORD cbWorkBuffer = cbOutBuffer + 1; + LPBYTE pbWorkBuffer = NULL; + DWORD cbOutBufferExpected = 0; + DWORD cbWorkBuffer = 0; DWORD dwStepCount = 0; bool bWorkComplete = false; int nError = ERROR_SUCCESS; - // Allocate the temporary buffer that will serve as output - pbWorkBuffer = pbTempBuffer = CASC_ALLOC(BYTE, cbTempBuffer); - if(pbWorkBuffer == NULL) - return ERROR_NOT_ENOUGH_MEMORY; - // Perform the loop - for(;;) + while(bWorkComplete == false) { - // Set the output buffer. - // Even operations: extract to temporary buffer - // Odd operations: extract to output buffer - pbWorkBuffer = (dwStepCount & 0x01) ? pbOutBuffer : pbTempBuffer; - cbWorkBuffer = (dwStepCount & 0x01) ? cbOutBuffer : cbTempBuffer; + // There should never be a 3rd step + assert(dwStepCount < 2); - // Perform the operation specific to the operation ID + // Perform the operation specific by the first byte switch(pbInBuffer[0]) { case 'E': // Encrypted files - nError = CascDecrypt(pbWorkBuffer, &cbWorkBuffer, pbInBuffer + 1, cbInBuffer - 1, dwFrameIndex); - bWorkComplete = (nError != ERROR_SUCCESS); + + // The work buffer should not have been allocated by any step + assert(pbWorkBuffer == NULL && cbWorkBuffer == 0); + + // Allocate temporary buffer to decrypt into + // Example storage: "2016 - WoW/23420", File: "4ee6bc9c6564227f1748abd0b088e950" + pbWorkBuffer = CASC_ALLOC(BYTE, cbInBuffer - 1); + cbWorkBuffer = cbInBuffer - 1; + if(pbWorkBuffer == NULL) + return ERROR_NOT_ENOUGH_MEMORY; + + // Decrypt the stream to the work buffer + nError = CascDecrypt(hs, pbWorkBuffer, &cbWorkBuffer, pbInBuffer + 1, cbInBuffer - 1, dwFrameIndex); + if(nError != ERROR_SUCCESS) + { + bWorkComplete = true; + break; + } + + // When encrypted, there is always one more step after this. + // Setup the work buffer as input buffer for the next operation + pbInBuffer = pbWorkBuffer; + cbInBuffer = cbWorkBuffer; break; case 'Z': // ZLIB compressed files - nError = CascDecompress(pbWorkBuffer, &cbWorkBuffer, pbInBuffer + 1, cbInBuffer - 1); + + // If we decompressed less than expected, we simply fill the rest with zeros + // Example: INSTALL file from the TACT CASC storage + cbOutBufferExpected = cbOutBuffer; + nError = CascDecompress(pbOutBuffer, &cbOutBuffer, pbInBuffer + 1, cbInBuffer - 1); + + // We exactly know what the output buffer size will be. + // If the uncompressed data is smaller, fill the rest with zeros + if(cbOutBuffer < cbOutBufferExpected) + memset(pbOutBuffer + cbOutBuffer, 0, (cbOutBufferExpected - cbOutBuffer)); bWorkComplete = true; break; case 'N': // Normal stored files - nError = CascDirectCopy(pbWorkBuffer, &cbWorkBuffer, pbInBuffer + 1, cbInBuffer - 1); + nError = CascDirectCopy(pbOutBuffer, &cbOutBuffer, pbInBuffer + 1, cbInBuffer - 1); bWorkComplete = true; break; @@ -320,48 +471,131 @@ static int ProcessFileFrame( break; } - // Are we done? - if(bWorkComplete) - break; - - // Set the input buffer to the work buffer - pbInBuffer = pbWorkBuffer; - cbInBuffer = cbWorkBuffer; + // Increment the step count dwStepCount++; } - // If the data are currently in the temporary buffer, - // we need to copy them to output buffer - if(nError == ERROR_SUCCESS && pbWorkBuffer != pbOutBuffer) + // Free the temporary buffer + CASC_FREE(pbWorkBuffer); + return nError; +} + +static bool GetFileFullInfo(TCascFile * hf, void * pvFileInfo, size_t cbFileInfo, size_t * pcbLengthNeeded) +{ + PCASC_FILE_FULL_INFO pFileInfo; + PCASC_CKEY_ENTRY pCKeyEntry = hf->pCKeyEntry; + TCascStorage * hs = hf->hs; + + // Verify whether we have enough space in the buffer + pFileInfo = (PCASC_FILE_FULL_INFO)ProbeOutputBuffer(pvFileInfo, cbFileInfo, sizeof(CASC_FILE_FULL_INFO), pcbLengthNeeded); + if(pFileInfo != NULL) { - if(cbWorkBuffer != cbOutBuffer) - nError = ERROR_INSUFFICIENT_BUFFER; - memcpy(pbOutBuffer, pbWorkBuffer, cbOutBuffer); + // Reset the entire structure + CopyMemory16(pFileInfo->CKey, pCKeyEntry->CKey); + CopyMemory16(pFileInfo->EKey, pCKeyEntry->EKey); + pFileInfo->FileDataId = CASC_INVALID_ID; + pFileInfo->LocaleFlags = CASC_INVALID_ID; + pFileInfo->ContentFlags = CASC_INVALID_ID; + + // Supply information not depending on root + CascStrPrintf(pFileInfo->DataFileName, _countof(pFileInfo->DataFileName), "data.%03u", hf->ArchiveIndex); + pFileInfo->StorageOffset = pCKeyEntry->StorageOffset; + pFileInfo->SegmentOffset = hf->ArchiveOffset; + pFileInfo->FileNameHash = 0; + pFileInfo->TagBitMask = pCKeyEntry->TagBitMask; + pFileInfo->SegmentIndex = hf->ArchiveIndex; + pFileInfo->ContentSize = hf->ContentSize; + pFileInfo->EncodedSize = hf->EncodedSize; + + // Supply the root-specific information + hs->pRootHandler->GetInfo(pCKeyEntry, pFileInfo); } - // Free the temporary buffer - CASC_FREE(pbTempBuffer); - return nError; + return (pFileInfo != NULL); } //----------------------------------------------------------------------------- // Public functions +bool WINAPI CascGetFileInfo(HANDLE hFile, CASC_FILE_INFO_CLASS InfoClass, void * pvFileInfo, size_t cbFileInfo, size_t * pcbLengthNeeded) +{ + TCascFile * hf; + LPBYTE pbOutputValue = NULL; + LPBYTE pbInfoValue = NULL; + size_t cbInfoValue = 0; + + // Validate the file handle + if((hf = TCascFile::IsValid(hFile)) == NULL) + { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + // Differentiate between info classes + switch(InfoClass) + { + case CascFileContentKey: + + // Do we have content key at all? + if(hf->pCKeyEntry == NULL || (hf->pCKeyEntry->Flags & CASC_CE_HAS_CKEY) == 0) + { + SetLastError(ERROR_NOT_SUPPORTED); + return false; + } + + // Give the content key + pbInfoValue = hf->pCKeyEntry->CKey; + cbInfoValue = CASC_CKEY_SIZE; + break; + + case CascFileEncodedKey: + + // Do we have content key at all? + if(hf->pCKeyEntry == NULL || (hf->pCKeyEntry->Flags & CASC_CE_HAS_EKEY) == 0) + { + SetLastError(ERROR_NOT_SUPPORTED); + return false; + } + + // Give the content key + pbInfoValue = hf->pCKeyEntry->EKey; + cbInfoValue = CASC_CKEY_SIZE; + break; + + case CascFileFullInfo: + return GetFileFullInfo(hf, pvFileInfo, cbFileInfo, pcbLengthNeeded); + + default: + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } + + // Sanity check + assert(pbInfoValue != NULL); + assert(cbInfoValue != 0); + + // Give the result + pbOutputValue = (LPBYTE)ProbeOutputBuffer(pvFileInfo, cbFileInfo, cbInfoValue, pcbLengthNeeded); + if(pbOutputValue != NULL) + memcpy(pbOutputValue, pbInfoValue, cbInfoValue); + return (pbOutputValue != NULL); +} + // // THE FILE SIZE PROBLEM // // There are members called "FileSize" in many CASC-related structure // For various files, these variables have different meaning. // -// Storage FileName FileSize FrameSum HdrArea IdxEntry EncEntry RootEntry -// ----------- -------- ---------- -------- -------- -------- -------- --------- -// HotS(29049) ENCODING 0x0024BA45 - 0x0024b98a 0x0024BA45 0x0024BA45 n/a n/a -// HotS(29049) ROOT 0x00193340 - 0x00193340 0x0010db65 0x0010db65 0x00193340 n/a -// HotS(29049) (other) 0x00001080 - 0x00001080 0x000008eb 0x000008eb 0x00001080 0x00001080 -// -// WoW(18888) ENCODING 0x030d487b - 0x030dee79 0x030d487b 0x030d487b n/a n/a -// WoW(18888) ROOT 0x016a9800 - n/a 0x0131313d 0x0131313d 0x016a9800 n/a -// WoW(18888) (other) 0x000007d0 - 0x000007d0 0x00000397 0x00000397 0x000007d0 n/a +// Storage FileName FileSize FrameSum HdrArea CKeyEntry EKeyEntry RootEntry +// ----------- -------- ---------- -------- -------- ---------- ---------- ---------- +// HotS(29049) ENCODING 0x0024BA45 - 0x0024b98a 0x0024BA45 n/a 0x0024BA45 n/a +// HotS(29049) ROOT 0x00193340 - 0x00193340 0x0010db65 0x00193340 0x0010db65 n/a +// HotS(29049) (other) 0x00001080 - 0x00001080 0x000008eb 0x00001080 0x000008eb 0x00001080 +// +// WoW(18888) ENCODING 0x030d487b - 0x030dee79 0x030d487b n/a 0x030d487b n/a +// WoW(18888) ROOT 0x016a9800 - n/a 0x0131313d 0x016a9800 0x0131313d n/a +// WoW(18888) (other) 0x000007d0 - 0x000007d0 0x00000397 0x000007d0 0x00000397 n/a // DWORD WINAPI CascGetFileSize(HANDLE hFile, PDWORD pdwFileSizeHigh) @@ -372,24 +606,32 @@ DWORD WINAPI CascGetFileSize(HANDLE hFile, PDWORD pdwFileSizeHigh) CASCLIB_UNUSED(pdwFileSizeHigh); // Validate the file handle - if((hf = IsValidFileHandle(hFile)) == NULL) + if((hf = TCascFile::IsValid(hFile)) == NULL) { SetLastError(ERROR_INVALID_HANDLE); return CASC_INVALID_SIZE; } - // Make sure that the file header area is loaded - nError = EnsureFrameHeadersLoaded(hf); - if(nError != ERROR_SUCCESS) + // Someone may have provided file content size. + // If yes, do not load the frames, as it's not necessary. + if(hf->ContentSize == CASC_INVALID_SIZE) { - SetLastError(nError); - return CASC_INVALID_SIZE; + // Make sure that the file header area is loaded + nError = EnsureFileFramesLoaded(hf); + if(nError != ERROR_SUCCESS) + { + SetLastError(nError); + return CASC_INVALID_SIZE; + } + + // The content size should be loaded from the frames + assert(hf->ContentSize != CASC_INVALID_SIZE); } // Give the file size to the caller if(pdwFileSizeHigh != NULL) *pdwFileSizeHigh = 0; - return hf->FileSize; + return hf->ContentSize; } DWORD WINAPI CascSetFilePointer(HANDLE hFile, LONG lFilePos, LONG * plFilePosHigh, DWORD dwMoveMethod) @@ -400,7 +642,7 @@ DWORD WINAPI CascSetFilePointer(HANDLE hFile, LONG lFilePos, LONG * plFilePosHig DWORD dwFilePosHi; // If the hFile is not a valid file handle, return an error. - hf = IsValidFileHandle(hFile); + hf = TCascFile::IsValid(hFile); if(hf == NULL) { SetLastError(ERROR_INVALID_HANDLE); @@ -419,7 +661,7 @@ DWORD WINAPI CascSetFilePointer(HANDLE hFile, LONG lFilePos, LONG * plFilePosHig break; case FILE_END: - FilePosition = hf->FileSize; + FilePosition = hf->ContentSize; break; default: @@ -458,16 +700,7 @@ DWORD WINAPI CascSetFilePointer(HANDLE hFile, LONG lFilePos, LONG * plFilePosHig bool WINAPI CascReadFile(HANDLE hFile, void * pvBuffer, DWORD dwBytesToRead, PDWORD pdwBytesRead) { - PCASC_FILE_FRAME pFrame = NULL; - ULONGLONG StreamSize; - ULONGLONG FileOffset; TCascFile * hf; - LPBYTE pbBuffer = (LPBYTE)pvBuffer; - DWORD dwStartPointer = 0; - DWORD dwFilePointer = 0; - DWORD dwEndPointer = 0; - DWORD dwFrameSize; - bool bReadResult; int nError = ERROR_SUCCESS; // The buffer must be valid @@ -478,7 +711,7 @@ bool WINAPI CascReadFile(HANDLE hFile, void * pvBuffer, DWORD dwBytesToRead, PDW } // Validate the file handle - if((hf = IsValidFileHandle(hFile)) == NULL) + if((hf = TCascFile::IsValid(hFile)) == NULL) { SetLastError(ERROR_INVALID_HANDLE); return false; @@ -487,134 +720,116 @@ bool WINAPI CascReadFile(HANDLE hFile, void * pvBuffer, DWORD dwBytesToRead, PDW // If the file frames are not loaded yet, do it now if(nError == ERROR_SUCCESS) { - nError = EnsureFrameHeadersLoaded(hf); + nError = EnsureFileFramesLoaded(hf); } // If the file position is at or beyond end of file, do nothing - if(nError == ERROR_SUCCESS && hf->FilePointer >= hf->FileSize) + if(nError == ERROR_SUCCESS) { - *pdwBytesRead = 0; - return true; + // Check the starting position + if(hf->FilePointer >= hf->ContentSize) + { + *pdwBytesRead = 0; + return true; + } + + // Check the ending position + if((hf->FilePointer + dwBytesToRead) > hf->ContentSize) + { + dwBytesToRead = hf->ContentSize - hf->FilePointer; + } } - // Find the file frame where to read from + // Allocate cache buffer for the entire file. This is the fastest approach + // (without reallocations). However, this may consume quite a lot of memory + // (Storage: "2016 - Starcraft II/45364", file: "3d815f40c0413701aa2bd214070d0062" + // needs 0x239a09b3 bytes of memory (~600 MB) if(nError == ERROR_SUCCESS) { - // Get the frame - pFrame = FindFileFrame(hf, hf->FilePointer); - if(pFrame == NULL || pFrame->CompressedSize < 1) - nError = ERROR_FILE_CORRUPT; + if(hf->pbFileCache == NULL) + { + // Allocate buffer + hf->pbFileCache = CASC_ALLOC(BYTE, hf->ContentSize); + hf->cbFileCache = hf->ContentSize; + if(hf->pbFileCache == NULL) + nError = ERROR_NOT_ENOUGH_MEMORY; + } } - // Perform the read + // Load all frames that are not loaded yet if(nError == ERROR_SUCCESS) { - // If not enough bytes in the file remaining, cut them - dwStartPointer = dwFilePointer = hf->FilePointer; - dwEndPointer = dwStartPointer + dwBytesToRead; - if(dwEndPointer > hf->FileSize) - dwEndPointer = hf->FileSize; - - // Perform block read from each file frame - while(dwFilePointer < dwEndPointer) + PCASC_FILE_FRAME pFrame = hf->pFrames; + DWORD StartFrameOffset = 0; + DWORD StartReadOffset = hf->FilePointer; + DWORD EndReadOffset = hf->FilePointer + dwBytesToRead; + + for(DWORD i = 0; (i < hf->FrameCount) && (nError == ERROR_SUCCESS); i++, pFrame++) { - LPBYTE pbFrameData = NULL; - DWORD dwFrameStart = pFrame->FrameFileOffset; - DWORD dwFrameEnd = pFrame->FrameFileOffset + pFrame->FrameSize; + LPBYTE pbDecodedFrame = hf->pbFileCache + StartFrameOffset; + LPBYTE pbEncodedFrame; + DWORD EndFrameOffset = StartFrameOffset + pFrame->ContentSize; - // Shall we populate the cache with a new data? - if(dwFrameStart != hf->CacheStart || hf->CacheEnd != dwFrameEnd) + // Does that frame belong to the range? + if(StartReadOffset < EndFrameOffset && EndReadOffset > StartFrameOffset) { - // Shall we reallocate the cache buffer? - if(pFrame->FrameSize > hf->cbFileCache) - { - if(hf->pbFileCache != NULL) - CASC_FREE(hf->pbFileCache); - - hf->pbFileCache = CASC_ALLOC(BYTE, pFrame->FrameSize); - hf->cbFileCache = pFrame->FrameSize; - } - - // We also need to allocate buffer for the raw data - pbFrameData = CASC_ALLOC(BYTE, pFrame->CompressedSize); - if(pbFrameData == NULL) - { - nError = ERROR_NOT_ENOUGH_MEMORY; - break; - } - - // Load the raw file data to memory - FileOffset = pFrame->FrameArchiveOffset; - bReadResult = FileStream_Read(hf->pStream, &FileOffset, pbFrameData, pFrame->CompressedSize); - - // Note: The raw file data size could be less than expected - // Happened in WoW build 19342 with the ROOT file. MD5 in the frame header - // is zeroed, which means it should not be checked - // Frame File: data.029 - // Frame Offs: 0x013ED9F0 size 0x01325B32 - // Frame End: 0x02713522 - // File Size: 0x027134FC - if(bReadResult == false && GetLastError() == ERROR_HANDLE_EOF && !IsValidMD5(pFrame->md5)) + // Is the frame already loaded? + if (pFrame->FileOffset == CASC_INVALID_POS) { - // Get the size of the remaining file - FileStream_GetSize(hf->pStream, &StreamSize); - dwFrameSize = (DWORD)(StreamSize - FileOffset); - - // If the frame offset is before EOF and frame end is beyond EOF, correct it - if(FileOffset < StreamSize && dwFrameSize < pFrame->CompressedSize) + // Allocate space for the encoded frame + pbEncodedFrame = CASC_ALLOC(BYTE, pFrame->EncodedSize); + if (pbEncodedFrame != NULL) { - memset(pbFrameData + dwFrameSize, 0, (pFrame->CompressedSize - dwFrameSize)); - bReadResult = true; + // Load the encoded frame data + nError = LoadEncodedFrame(hf->pStream, pFrame, pbEncodedFrame, hf->bVerifyIntegrity); + if (nError == ERROR_SUCCESS) + { + // Decode the frame + nError = ProcessFileFrame(hf->hs, + pbDecodedFrame, + pFrame->ContentSize, + pbEncodedFrame, + pFrame->EncodedSize, + (DWORD)(pFrame - hf->pFrames)); + if (nError == ERROR_SUCCESS) + { + // Mark the frame as loaded + pFrame->FileOffset = StartFrameOffset; + } + } + + // Free the frame buffer + CASC_FREE(pbEncodedFrame); } - } - - // If the read result failed, we cannot finish reading it - if(bReadResult && VerifyDataBlockHash(pbFrameData, pFrame->CompressedSize, pFrame->md5)) - { - // Convert the source frame to the file cache - nError = ProcessFileFrame(hf->pbFileCache, - pFrame->FrameSize, - pbFrameData, - pFrame->CompressedSize, - (DWORD)(pFrame - hf->pFrames)); - if(nError == ERROR_SUCCESS) + else { - // Set the start and end of the cache - hf->CacheStart = dwFrameStart; - hf->CacheEnd = dwFrameEnd; + nError = ERROR_NOT_ENOUGH_MEMORY; } } - else - { - nError = ERROR_FILE_CORRUPT; - } - - // Free the raw frame data - CASC_FREE(pbFrameData); } - // Copy the decompressed data - if(dwFrameEnd > dwEndPointer) - dwFrameEnd = dwEndPointer; - memcpy(pbBuffer, hf->pbFileCache + (dwFilePointer - dwFrameStart), (dwFrameEnd - dwFilePointer)); - pbBuffer += (dwFrameEnd - dwFilePointer); - - // Move pointers - dwFilePointer = dwFrameEnd; - pFrame++; + // If the frame start is past the read offset, stop the loop + if ((StartFrameOffset + pFrame->ContentSize) >= EndReadOffset) + break; + StartFrameOffset += pFrame->ContentSize; } } - // Update the file position + // Now all frames have been loaded into the cache; copy the entire block to the output buffer if(nError == ERROR_SUCCESS) { + // Copy the entire data + memcpy(pvBuffer, hf->pbFileCache + hf->FilePointer, dwBytesToRead); + hf->FilePointer += dwBytesToRead; + + // Give the number of bytes read if(pdwBytesRead != NULL) - *pdwBytesRead = (dwFilePointer - dwStartPointer); - hf->FilePointer = dwFilePointer; + *pdwBytesRead = dwBytesToRead; + return true; } - - if(nError != ERROR_SUCCESS) + else + { SetLastError(nError); - return (nError == ERROR_SUCCESS); + return false; + } } - diff --git a/dep/CascLib/src/CascRootFile_Diablo3.cpp b/dep/CascLib/src/CascRootFile_Diablo3.cpp index f695ad978b1..bbe369c7646 100644 --- a/dep/CascLib/src/CascRootFile_Diablo3.cpp +++ b/dep/CascLib/src/CascRootFile_Diablo3.cpp @@ -20,61 +20,36 @@ #define DIABLO3_SUBDIR_SIGNATURE 0xEAF1FE87 #define DIABLO3_PACKAGES_SIGNATURE 0xAABB0002 #define DIABLO3_MAX_SUBDIRS 0x20 - -#define DIABLO3_INVALID_INDEX 0xFFFFFFFF -#define DIABLO3_INVALID_FILE 0xFFFFFFFF #define DIABLO3_MAX_ASSETS 70 // Maximum possible number of assets -#define DIABLO3_MAX_LEVEL0_LENGTH 0x10 // Maximum length of the level-0 directory name - -#define INVALID_FILE_INDEX 0xFFFFFFFF -#define INVALID_ASSET_INDEX 0xFF - -#define ENTRY_FLAG_DIRECTORY_ENTRY 0x80 // The file is actually a directory entry -#define ENTRY_FLAG_PLAIN_NAME 0x01 // If set, the file entry contains offset of the plain file name -#define ENTRY_FLAG_FULL_NAME 0x02 // If set, the file entry contains offset of the full name -#define ENTRY_FLAG_FLAGS_MASK 0xF0 // Mask for the entry flags -#define ENTRY_FLAG_NAME_MASK 0x0F // Mask for the entry file name type - -// Values for CASC_FILE_ENTRY::dwFlags -#define CASC_ENTRY_SHORT_NAME 0x000000001 // If set, the name is in format XXYYplain-name[\sub-index].ext -#define CASC_ENTRY_HAS_SUBINDEX 0x000000002 // If set, the subitem is present in the file name (i.e. XXYYplain-name\sub-index.ext) - -#define SEARCH_PHASE_NAMES 0 // Searching named entry -#define SEARCH_PHASE_FILE_IDS 1 // Searching filed by ID - -// Macro for constructing 64-bit integer from root-index, file-index and sub-index -// The result value is RRAAAAAAAASSSSSS -#define MAKE_INDEX64(ri, fi, si) (((ULONGLONG)ri << 0x38) | ((ULONGLONG)fi << 0x18) | ((ULONGLONG)si)) -#define INDEX64_ROOT_INDEX(hash) (DWORD)((hash >> 0x38) & 0x000000FF) -#define INDEX64_FILE_INDEX(hash) (DWORD)((hash >> 0x18) & 0xFFFFFFFF) -#define INDEX64_SUB_INDEX(hash) (DWORD)((hash >> 0x00) & 0x00FFFFFF) +#define DIABLO3_MAX_ROOT_FOLDERS 0x20 // Maximum count of root directory named entries // On-disk structure for a file given by file number -typedef struct _DIABLO3_FILEID1_ENTRY +typedef struct _DIABLO3_ASSET_ENTRY { - ENCODING_KEY EncodingKey; // Encoding key for the file - DWORD FileIndex; // File index -} DIABLO3_FILEID1_ENTRY, *PDIABLO3_FILEID1_ENTRY; + CONTENT_KEY CKey; // Content key for the file + DWORD FileIndex; // File index +} DIABLO3_ASSET_ENTRY, *PDIABLO3_ASSET_ENTRY; // On-disk structure for a file given by file number and suffix -typedef struct _DIABLO3_FILEID2_ENTRY +typedef struct _DIABLO3_ASSETIDX_ENTRY { - ENCODING_KEY EncodingKey; // Encoding key for the file - DWORD FileIndex; // File index - DWORD SubIndex; // File subindex, like "SoundBank\3D Ambience\0000.smp" -} DIABLO3_FILEID2_ENTRY, *PDIABLO3_FILEID2_ENTRY; + CONTENT_KEY CKey; // Content key for the file + DWORD FileIndex; // File index + DWORD SubIndex; // File subindex, like "SoundBank\3D Ambience\0000.smp" +} DIABLO3_ASSETIDX_ENTRY, *PDIABLO3_ASSETIDX_ENTRY; -// On-disk structure of the named entry +// In-memory structure of the named entry typedef struct _DIABLO3_NAMED_ENTRY { - ENCODING_KEY EncodingKey; // Encoding key for the file - BYTE szFileName[1]; // ASCIIZ file name (variable length) + PCONTENT_KEY pCKey; // Pointer to the content key + const char * szFileName; // Pointer to the zero-terminated file name + const char * szFileEnd; // Position of the zero terminator (aka end of the file name) } DIABLO3_NAMED_ENTRY, *PDIABLO3_NAMED_ENTRY; // On-disk structure of CoreToc.dat header typedef struct _DIABLO3_CORE_TOC_HEADER { - DWORD EntryCounts[DIABLO3_MAX_ASSETS]; // Array of number of entries (files) for each asset (level-1 directory) + DWORD EntryCounts[DIABLO3_MAX_ASSETS]; // Array of number of entries (files) for each asset DWORD EntryOffsets[DIABLO3_MAX_ASSETS]; // Array of offsets of each DIABLO3_CORE_TOC_ENTRY, relative to data after header DWORD Unknowns[DIABLO3_MAX_ASSETS]; // Unknown DWORD Alignment; @@ -89,33 +64,19 @@ typedef struct _DIABLO3_CORE_TOC_ENTRY } DIABLO3_CORE_TOC_ENTRY, *PDIABLO3_CORE_TOC_ENTRY; -// In-memory structure of parsed directory header -typedef struct _DIABLO3_DIR_HEADER -{ - LPBYTE pbEntries1; - LPBYTE pbEntries2; - LPBYTE pbEntries3; - DWORD dwEntries1; - DWORD dwEntries2; - DWORD dwEntries3; -} DIABLO3_DIR_HEADER, *PDIABLO3_DIR_HEADER; - -// In-memory structure of loaded CoreTOC.dat -typedef struct _DIABLO3_CORE_TOC +// In-memory structure of parsed directory data +typedef struct _DIABLO3_DIRECTORY { - DIABLO3_CORE_TOC_HEADER Hdr; // Header of CoreTOC.dat - - LPBYTE pbCoreToc; // Content of the CoreTOC.dat file - DIABLO3_CORE_TOC_ENTRY Entries[1]; // Buffer for storing the entries (variable length) - -} DIABLO3_CORE_TOC, *PDIABLO3_CORE_TOC; - -// On-disk structure of Packages.dat header -typedef struct _DIABLO3_PACKAGES_DAT_HEADER -{ - DWORD Signature; - DWORD NumberOfNames; -} DIABLO3_PACKAGES_DAT_HEADER, *PDIABLO3_PACKAGES_DAT_HEADER; + LPBYTE pbDirectoryData; // The begin of the directory data block + LPBYTE pbDirectoryEnd; // The end of the directory data block + LPBYTE pbAssetEntries; // Pointer to asset entries without subitem number. Example: "SoundBank\SoundFile.smp" + LPBYTE pbAssetIdxEntries; // Pointer to asset entries with subitem number + LPBYTE pbNamedEntries; // Pointer to named entries. These are for files with arbitrary names, and they do not belong to an asset + DWORD dwAssetEntries; // Number of asset entries without subitem number + DWORD dwAssetIdxEntries; + DWORD dwNamedEntries; + DWORD dwNodeIndex; // Index of file node for this folder +} DIABLO3_DIRECTORY, *PDIABLO3_DIRECTORY; // Structure for conversion DirectoryID -> Directory name typedef struct _DIABLO3_ASSET_INFO @@ -126,35 +87,6 @@ typedef struct _DIABLO3_ASSET_INFO } DIABLO3_ASSET_INFO; typedef const DIABLO3_ASSET_INFO * PDIABLO3_ASSET_INFO; -// In-memory structure of a file entry in the linear file list -typedef struct _CASC_FILE_ENTRY -{ - ENCODING_KEY EncodingKey; // Encoding key - ULONGLONG FileNameHash; // Hash of the full file name - DWORD dwFileName; // Offset of the name (in name's dynamic array) - DWORD dwFlags; // Entry flags (see CASC_ENTRY_XXXX) - - DWORD NameOffset; // Offset of the name (in name's dynamic array) - USHORT SubIndex; // File\SubFile index - BYTE AssetIndex; // Asset index (aka directory index) - BYTE EntryFlags; // Entry flags -} CASC_FILE_ENTRY, *PCASC_FILE_ENTRY; - -//----------------------------------------------------------------------------- -// Structure definitions for Diablo3 root file - -struct TRootHandler_Diablo3 : public TRootHandler -{ - // Linear global list of all files - DYNAMIC_ARRAY FileTable; - - // Linear global list of names - DYNAMIC_ARRAY FileNames; - - // Global map of FileName -> FileEntry - PCASC_MAP pRootMap; -}; - //----------------------------------------------------------------------------- // Local variables @@ -231,969 +163,727 @@ static const DIABLO3_ASSET_INFO Assets[] = {"Accolade", "aco"}, // 0x42 }; -static const DIABLO3_ASSET_INFO UnknownAsset = {"Unknown", "unk"}; - #define DIABLO3_ASSET_COUNT (sizeof(Assets) / sizeof(Assets[0])) //----------------------------------------------------------------------------- -// Local functions - -static PDIABLO3_ASSET_INFO GetAssetInfo(DWORD dwAssetIndex) -{ - if(dwAssetIndex < DIABLO3_ASSET_COUNT && Assets[dwAssetIndex].szDirectoryName != NULL) - return &Assets[dwAssetIndex]; - return &UnknownAsset; -} - -static DWORD VerifyNamedFileEntry(LPBYTE pbNamedEntry, LPBYTE pbFileEnd) -{ - LPBYTE pbFileName = ((PDIABLO3_NAMED_ENTRY)pbNamedEntry)->szFileName; - - // Find the end of the name - while(pbFileName < pbFileEnd && pbFileName[0] != 0) - pbFileName++; +// Handler definitions for Diablo3 root file - // Did we get past the end of the root file? - if(pbFileName >= pbFileEnd) - return 0; - pbFileName++; - - // Return the length of the structure - return (DWORD)(pbFileName - pbNamedEntry); -} - -static char * FindPackageName( - PCASC_MAP pPackageMap, - const char * szAssetName, - const char * szPlainName) +struct TDiabloRoot : public TFileTreeRoot { - char szFileName[MAX_PATH+1]; - size_t nLength; + public: - // Construct the name without extension and find it in the map - nLength = sprintf(szFileName, "%s\\%s", szAssetName, szPlainName); - return (char *)Map_FindString(pPackageMap, szFileName, szFileName + nLength); -} + TDiabloRoot() : TFileTreeRoot(0) + { + memset(RootFolders, 0, sizeof(RootFolders)); + pFileIndices = NULL; + pbCoreTocFile = NULL; + pbCoreTocData = NULL; + nFileIndices = 0; + cbCoreTocFile = 0; + + // Map for searching a real file extension + memset(&PackagesMap, 0, sizeof(CASC_MAP)); + pbPackagesDat = NULL; + cbPackagesDat = 0; + + // We have file names and return CKey as result of search + dwFeatures |= (CASC_FEATURE_FILE_NAMES | CASC_FEATURE_ROOT_CKEY); + } -static size_t CreateShortName( - PCASC_MAP pPackageMap, - DWORD dwRootIndex, // Level-0-dir: Index of the root subdirectory - DWORD dwAssetIndex, // Level-1-dir: Index of the asset name - const char * szPlainName, // Plain name of the file, without extension - DWORD dwSubIndex, - char * szBuffer) -{ - PDIABLO3_ASSET_INFO pAssetInfo = GetAssetInfo(dwAssetIndex); - const char * szPackageName = NULL; - const char * szFormat; - size_t nLength; - - // Write the level-0 directory index as 2-digit hexa number - assert(dwRootIndex < 0x100); - *szBuffer++ = IntToHexChar[dwRootIndex >> 0x04]; - *szBuffer++ = IntToHexChar[dwRootIndex & 0x0F]; - - // Write the level-1 directory index as 2-digit hexa number - assert(dwAssetIndex < 0x100); - *szBuffer++ = IntToHexChar[dwAssetIndex >> 0x04]; - *szBuffer++ = IntToHexChar[dwAssetIndex & 0x0F]; - - // Construct the file name with ending "." for extension - szFormat = (dwSubIndex != DIABLO3_INVALID_INDEX) ? "%s\\%04u." : "%s."; - nLength = sprintf(szBuffer, szFormat, szPlainName, dwSubIndex); - - // Try to fixup the file extension from the package name. - // File extensions are not predictable because for subitems, - // they are not always equal to the main items: - // - // SoundBank\3D Ambience.sbk - // SoundBank\3D Ambience\0000.smp - // SoundBank\3D Ambience\0002.smp - // ... - // SoundBank\Angel.sbk - // SoundBank\Angel\0000.fsb - // SoundBank\Angel\0002.fsb - // - // We use the Base\Data_D3\PC\Misc\Packages.dat for real file extensions, where possible - // - if(pPackageMap != NULL) + ~TDiabloRoot() { - // Retrieve the asset name - szPackageName = FindPackageName(pPackageMap, pAssetInfo->szDirectoryName, szBuffer); - if(szPackageName != NULL) - { - strcpy(szBuffer, szPackageName + strlen(pAssetInfo->szDirectoryName) + 1); - nLength = strlen(szBuffer); - } + FreeLoadingStuff(); } - // If we havent't found the package, we either use the default asset extension or "unk" - if(szPackageName == NULL) + void AppendBackslashToTotalPath(PATH_BUFFER & PathBuffer) { - if(dwSubIndex == DIABLO3_INVALID_INDEX) + if(PathBuffer.szPtr < PathBuffer.szEnd) { - strcpy(szBuffer + nLength, pAssetInfo->szExtension); - nLength += strlen(pAssetInfo->szExtension); - } - else - { - strcpy(szBuffer + nLength, "unk"); - nLength += 3; + PathBuffer.szPtr[0] = '\\'; + PathBuffer.szPtr++; } } - // Return the length of the short file name - return nLength + 4; -} - -static size_t CreateFileName( - TRootHandler_Diablo3 * pRootHandler, - const char * szShortName, // Short file name of the file - char * szBuffer) -{ - PCASC_FILE_ENTRY pRootEntry; - const char * szNameLevel0; - const char * szNameLevel1 = NULL; - DWORD dwRootIndex0 = 0; - DWORD dwAssetIndex = 0; - - // Retrieve the level-0 and level-1 directory indexes - ConvertStringToInt08(szShortName+0, &dwRootIndex0); - ConvertStringToInt08(szShortName+2, &dwAssetIndex); - - // Retrieve the name of the level-0 directory (aka root subdirectory) - pRootEntry = (PCASC_FILE_ENTRY)Array_ItemAt(&pRootHandler->FileTable, dwRootIndex0); - szNameLevel0 = (char *)Array_ItemAt(&pRootHandler->FileNames, pRootEntry->dwFileName); - - // Retrieve the name of the level-1 directory (aka asset name) - if(dwAssetIndex < DIABLO3_ASSET_COUNT) - szNameLevel1 = Assets[dwAssetIndex].szDirectoryName; - if(szNameLevel1 == NULL) - szNameLevel1 = UnknownAsset.szDirectoryName; - - // Copy the rest of the name as-is - return sprintf(szBuffer, "%s\\%s\\%s", szNameLevel0, szNameLevel1, szShortName + 4); -} - - -// Creates a map of String -> Pointer -static PCASC_MAP CreatePackageMap( - LPBYTE pbPackagesDat, - LPBYTE pbPackagesEnd) -{ - PDIABLO3_PACKAGES_DAT_HEADER pDatHeader = (PDIABLO3_PACKAGES_DAT_HEADER)pbPackagesDat; - PCASC_MAP pPackageMap; - - // Get the header - if((pbPackagesDat + sizeof(DIABLO3_PACKAGES_DAT_HEADER)) >= pbPackagesEnd) - return NULL; - pbPackagesDat += sizeof(DIABLO3_PACKAGES_DAT_HEADER); - - // Check the signature and name count - if(pDatHeader->Signature != DIABLO3_PACKAGES_SIGNATURE) - return NULL; - - // Create the map for fast search of the file name - pPackageMap = Map_Create(pDatHeader->NumberOfNames, KEY_LENGTH_STRING, 0); - if(pPackageMap != NULL) + void AppendPathToTotalPath(PATH_BUFFER & PathBuffer, const char * szFileName, const char * szFileEnd) { - char * szFileName = (char *)pbPackagesDat; + char * szPathPtr = PathBuffer.szPtr; + size_t nLength = (szFileEnd - szFileName); - // Go as long as there is something - for(DWORD i = 0; i < pDatHeader->NumberOfNames; i++) + // Append the name + if((szPathPtr + nLength) < PathBuffer.szEnd) { - // Get the file extension - if((LPBYTE)szFileName >= pbPackagesEnd) - break; - - // Insert the file name to the map. The file extension is not included - Map_InsertString(pPackageMap, szFileName, true); - szFileName = szFileName + strlen(szFileName) + 1; + memcpy(szPathPtr, szFileName, nLength); + szPathPtr += nLength; } - } - - return pPackageMap; -} - -// Insert an entry with file name as-is -static int InsertFileEntry( - TRootHandler_Diablo3 * pRootHandler, - ENCODING_KEY & EncodingKey, - const char * szFileName, - size_t cchFileName) -{ - PCASC_FILE_ENTRY pFileEntry; - // We must not allow the file name array to be reallocated. - // Reallocating the array would cause pointers in TRootHandler_Diablo3::pRootMap - // become invalid - if(pRootHandler->FileTable.ItemCount >= pRootHandler->FileTable.ItemCountMax) - { - assert(false); - return ERROR_NOT_ENOUGH_MEMORY; + // Append zero terminator + if(szPathPtr < PathBuffer.szEnd) + szPathPtr[0] = 0; + PathBuffer.szPtr = szPathPtr; } - // Insert the plain name to the root handler's global name list - szFileName = (const char *)Array_Insert(&pRootHandler->FileNames, szFileName, cchFileName); - if(szFileName == NULL) - return ERROR_NOT_ENOUGH_MEMORY; - - // Make sure that we don't exceed the file limit at this phase - pFileEntry = (PCASC_FILE_ENTRY)Array_Insert(&pRootHandler->FileTable, NULL, 1); - assert(pFileEntry != NULL); - - // Store the info into the file entry - pFileEntry->EncodingKey = EncodingKey; - pFileEntry->FileNameHash = CalcFileNameHash(szFileName); - pFileEntry->dwFileName = (DWORD)Array_IndexOf(&pRootHandler->FileNames, szFileName); - pFileEntry->dwFlags = 0; - - // Verify collisions (debug version only) - assert(Map_FindObject(pRootHandler->pRootMap, &pFileEntry->FileNameHash, NULL) == NULL); - - // Calculate the file name hash - Map_InsertObject(pRootHandler->pRootMap, pFileEntry, &pFileEntry->FileNameHash); - - // Success - return ERROR_SUCCESS; -} - -static int ParseDirEntries_FileId1( - TRootHandler_Diablo3 * pRootHandler, - LPBYTE pbFileEntries, - DWORD dwFileEntries, - DWORD dwRootDirIndex) -{ - PDIABLO3_FILEID1_ENTRY pEntry = (PDIABLO3_FILEID1_ENTRY)pbFileEntries; - PCASC_FILE_ENTRY pFileEntry; - - // Overflow test - if((pRootHandler->FileTable.ItemCount + dwFileEntries) >= pRootHandler->FileTable.ItemCountMax) + PDIABLO3_ASSET_INFO GetAssetInfo(DWORD dwAssetIndex) { - assert(false); - return ERROR_NOT_ENOUGH_MEMORY; + if(dwAssetIndex < DIABLO3_ASSET_COUNT && Assets[dwAssetIndex].szDirectoryName != NULL) + return &Assets[dwAssetIndex]; + return NULL; } - // Parse the all ID1 entries in the file - for(DWORD i = 0; i < dwFileEntries; i++, pEntry++) + char * FindPackageName(const char * szAssetName, const char * szPlainName) { - // Insert the file entry to the global list - pFileEntry = (PCASC_FILE_ENTRY)Array_Insert(&pRootHandler->FileTable, NULL, 1); - assert(pFileEntry != NULL); - - // Fill the index entry - pFileEntry->EncodingKey = pEntry->EncodingKey; - pFileEntry->FileNameHash = MAKE_INDEX64(dwRootDirIndex, pEntry->FileIndex, 0); - pFileEntry->dwFlags = CASC_ENTRY_SHORT_NAME; - } - - return ERROR_SUCCESS; -} + char szFileName[MAX_PATH+1]; + size_t nLength; -static int ParseDirEntries_FileId2( - TRootHandler_Diablo3 * pRootHandler, - LPBYTE pbFileEntries, - DWORD dwFileEntries, - DWORD dwRootDirIndex) -{ - PDIABLO3_FILEID2_ENTRY pEntry = (PDIABLO3_FILEID2_ENTRY)pbFileEntries; - PCASC_FILE_ENTRY pFileEntry; - - // Overflow test - if((pRootHandler->FileTable.ItemCount + dwFileEntries) >= pRootHandler->FileTable.ItemCountMax) - { - assert(false); - return ERROR_NOT_ENOUGH_MEMORY; + // Construct the name without extension and find it in the map + nLength = CascStrPrintf(szFileName, _countof(szFileName), "%s\\%s", szAssetName, szPlainName); + return (char *)PackagesMap.FindString(szFileName, szFileName + nLength); } - // Parse the all ID1 entries in the file - for(DWORD i = 0; i < dwFileEntries; i++, pEntry++) + LPBYTE LoadFileToMemory(TCascStorage * hs, const char * szFileName, DWORD * pcbFileData) { - // Insert the file entry to the global list - pFileEntry = (PCASC_FILE_ENTRY)Array_Insert(&pRootHandler->FileTable, NULL, 1); - assert(pFileEntry != NULL); - - // Fill the index entry - pFileEntry->EncodingKey = pEntry->EncodingKey; - pFileEntry->FileNameHash = MAKE_INDEX64(dwRootDirIndex, pEntry->FileIndex, pEntry->SubIndex); - pFileEntry->dwFlags = CASC_ENTRY_SHORT_NAME | CASC_ENTRY_HAS_SUBINDEX; - } + PCASC_CKEY_ENTRY pCKeyEntry; + LPBYTE pbFileData = NULL; - return ERROR_SUCCESS; -} - -static int ParseDirEntries_Named( - TRootHandler_Diablo3 * pRootHandler, - LPBYTE pbFileEntries, - LPBYTE pbFileEnd, - DWORD dwFileEntries, - DWORD dwRootDirIndex) -{ - char szFileName[MAX_PATH+1]; - char * szNamePtr = szFileName; - DWORD cbFileEntry; - int nError = ERROR_SUCCESS; + // Try to find CKey for the file + pCKeyEntry = GetFile(hs, szFileName); + if(pCKeyEntry != NULL) + pbFileData = LoadInternalFileToMemory(hs, pCKeyEntry, pcbFileData); - // Overflow test - if((pRootHandler->FileTable.ItemCount + dwFileEntries) >= pRootHandler->FileTable.ItemCountMax) - { - assert(false); - return ERROR_NOT_ENOUGH_MEMORY; + return pbFileData; } - // If we the file is not in the root directory itself, - // prepare the prefix for the root directory. - if(dwRootDirIndex != DIABLO3_INVALID_INDEX) + static LPBYTE CaptureDirectoryData( + DIABLO3_DIRECTORY & DirHeader, + LPBYTE pbDirectory, + DWORD cbDirectory) { - PCASC_FILE_ENTRY pRootEntry = (PCASC_FILE_ENTRY)Array_ItemAt(&pRootHandler->FileTable, dwRootDirIndex); - const char * szRootName = (const char *)Array_ItemAt(&pRootHandler->FileNames, pRootEntry->dwFileName); + LPBYTE pbDirectoryData = pbDirectory; + LPBYTE pbDataEnd = pbDirectory + cbDirectory; + DWORD Signature = 0; + + // + // Structure of a Diablo3 directory header + // 1) Signature (4 bytes) + // 2) Number of DIABLO3_ASSET_ENTRY entries (4 bytes) + // 3) Array of DIABLO3_ASSET_ENTRY entries + // 4) Number of DIABLO3_ASSETIDX_ENTRY entries (4 bytes) + // 5) Array of DIABLO3_ASSETIDX_ENTRY entries + // 6) Number of DIABLO3_NAMED_ENTRY entries (4 bytes) + // 7) Array of DIABLO3_NAMED_ENTRY entries + // + + // Prepare the header signature + memset(&DirHeader, 0, sizeof(DIABLO3_DIRECTORY)); + + // Get the header signature + pbDirectory = CaptureInteger32(pbDirectory, pbDataEnd, &Signature); + if((pbDirectory == NULL) || (Signature != CASC_DIABLO3_ROOT_SIGNATURE && Signature != DIABLO3_SUBDIR_SIGNATURE)) + return NULL; + + // Subdirectories have extra two arrays + if(Signature == DIABLO3_SUBDIR_SIGNATURE) + { + // Capture the number of DIABLO3_ASSET_ENTRY items + pbDirectory = CaptureInteger32(pbDirectory, pbDataEnd, &DirHeader.dwAssetEntries); + if(pbDirectory == NULL) + return NULL; + + // Capture the array of DIABLO3_ASSET_ENTRY + pbDirectory = CaptureArray(pbDirectory, pbDataEnd, &DirHeader.pbAssetEntries, DIABLO3_ASSET_ENTRY, DirHeader.dwAssetEntries); + if(pbDirectory == NULL) + return NULL; + + // Capture the number of DIABLO3_ASSETIDX_ENTRY items + pbDirectory = CaptureInteger32(pbDirectory, pbDataEnd, &DirHeader.dwAssetIdxEntries); + if(pbDirectory == NULL) + return NULL; + + // Capture the array of DIABLO3_ASSETIDX_ENTRY + pbDirectory = CaptureArray(pbDirectory, pbDataEnd, &DirHeader.pbAssetIdxEntries, DIABLO3_ASSETIDX_ENTRY, DirHeader.dwAssetIdxEntries); + if(pbDirectory == NULL) + return NULL; + } - // Copy the root directory name - while(szRootName[0] != 0) - *szNamePtr++ = *szRootName++; + // Capture the number of DIABLO3_NAMED_ENTRY array + pbDirectory = CaptureInteger32(pbDirectory, pbDataEnd, &DirHeader.dwNamedEntries); + if(pbDirectory == NULL) + return NULL; - // Append the backslash - *szNamePtr++ = '\\'; - } + // Note: Do not capture the array here. We will do that later, + // when we will be parsing the directory + DirHeader.pbNamedEntries = pbDirectory; - // Parse the file entry - while(pbFileEntries < pbFileEnd) - { - PDIABLO3_NAMED_ENTRY pNamedEntry = (PDIABLO3_NAMED_ENTRY)pbFileEntries; - DWORD cchFileName; - - // Verify the named entry whether it does not go beyond the EOF - cbFileEntry = VerifyNamedFileEntry(pbFileEntries, pbFileEnd); - if(cbFileEntry == 0) - return ERROR_FILE_CORRUPT; - - // Append the file name to the prepared file name - // This way we obtain the full name and the name lookup - // will be fully operational - memcpy(szNamePtr, pNamedEntry->szFileName, (cbFileEntry - sizeof(ENCODING_KEY))); - cchFileName = (DWORD)((szNamePtr - szFileName) + (cbFileEntry - sizeof(ENCODING_KEY))); - - // Insert the named entry to the global file table - nError = InsertFileEntry(pRootHandler, - pNamedEntry->EncodingKey, - szFileName, - cchFileName); - if(nError != ERROR_SUCCESS) - return nError; - - // Move the pointer to the next entry - pbFileEntries += cbFileEntry; + // Put the directory range + DirHeader.pbDirectoryData = pbDirectoryData; + DirHeader.pbDirectoryEnd = pbDirectoryData + cbDirectory; + return pbDirectory; } - return ERROR_SUCCESS; -} - -static void ResolveFullFileNames( - TRootHandler_Diablo3 * pRootHandler, - PDIABLO3_CORE_TOC_ENTRY pCoreTocEntries, - PCASC_MAP pPackageMap, - LPBYTE pbCoreTocFile, - DWORD dwFileIndexes) -{ - PCASC_FILE_ENTRY pFileEntry; - char * szPlainName; - char * szNamePtr; - size_t nLength; - DWORD dwRootIndex; - DWORD dwFileIndex; - DWORD dwSubIndex; - char szShortName[MAX_PATH+1]; - char szFullName[MAX_PATH+1]; - - // Keep compiler happy - CASCLIB_UNUSED(dwFileIndexes); - - // Parse the entire file table - for(size_t i = 0; i < pRootHandler->FileTable.ItemCount; i++) + LPBYTE CaptureCoreTocHeader( + PDIABLO3_CORE_TOC_HEADER * PtrHeader, + PDWORD PtrMaxIndex, + LPBYTE pbDataPtr, + LPBYTE pbDataEnd) { - // Retrieve the file entry at n-th position - pFileEntry = (PCASC_FILE_ENTRY)Array_ItemAt(&pRootHandler->FileTable, i); + PDIABLO3_CORE_TOC_HEADER pTocHeader = (PDIABLO3_CORE_TOC_HEADER)pbDataPtr; + DWORD dwMaxFileIndex = 0; - // Skip the items that already have full name - if(pFileEntry->dwFlags & CASC_ENTRY_SHORT_NAME) - { - // Retrieve the file index of that file - dwRootIndex = INDEX64_ROOT_INDEX(pFileEntry->FileNameHash); - dwFileIndex = INDEX64_FILE_INDEX(pFileEntry->FileNameHash); - dwSubIndex = (pFileEntry->dwFlags & CASC_ENTRY_HAS_SUBINDEX) ? INDEX64_SUB_INDEX(pFileEntry->FileNameHash) : DIABLO3_INVALID_INDEX; - assert(dwFileIndex < dwFileIndexes); - - // Get the plain name of the file - szPlainName = (char *)(pbCoreTocFile + pCoreTocEntries[dwFileIndex].NameOffset); - - // Create the short file name - nLength = CreateShortName(pPackageMap, - dwRootIndex, - pCoreTocEntries[dwFileIndex].AssetIndex, - szPlainName, - dwSubIndex, - szShortName); - - // Insert the short name to the list of the names - szNamePtr = (char *)Array_Insert(&pRootHandler->FileNames, szShortName, nLength + 1); - pFileEntry->dwFileName = (DWORD)Array_IndexOf(&pRootHandler->FileNames, szNamePtr); - - // Create the full file name - nLength = CreateFileName(pRootHandler, szShortName, szFullName); - pFileEntry->FileNameHash = CalcFileNameHash(szFullName); - - // Insert the entry to the name map. Use the mapping of FullName -> FileHash - Map_InsertObject(pRootHandler->pRootMap, pFileEntry, &pFileEntry->FileNameHash); - } - } -} + // Check the space for header + if((pbDataPtr + sizeof(DIABLO3_CORE_TOC_HEADER)) > pbDataEnd) + return NULL; + pbDataPtr += sizeof(DIABLO3_CORE_TOC_HEADER); -static LPBYTE LoadFileToMemory(TCascStorage * hs, LPBYTE pbEncodingKey, DWORD * pcbFileData) -{ - QUERY_KEY EncodingKey; - LPBYTE pbFileData = NULL; - HANDLE hFile; - DWORD cbBytesRead = 0; - DWORD cbFileData = 0; - - // Open the file by encoding key - EncodingKey.pbData = pbEncodingKey; - EncodingKey.cbData = MD5_HASH_SIZE; - if(CascOpenFileByEncodingKey((HANDLE)hs, &EncodingKey, 0, &hFile)) - { - // Retrieve the file size - cbFileData = CascGetFileSize(hFile, NULL); - if(cbFileData > 0) + // Verify all asset arrays + for(size_t i = 0; i < DIABLO3_MAX_ASSETS; i++) { - pbFileData = CASC_ALLOC(BYTE, cbFileData); - if(pbFileData != NULL) + PDIABLO3_CORE_TOC_ENTRY pTocEntry = (PDIABLO3_CORE_TOC_ENTRY)(pbDataPtr + pTocHeader->EntryOffsets[i]); + DWORD EntryOffset = pTocHeader->EntryOffsets[i]; + DWORD EntryCount = pTocHeader->EntryCounts[i]; + + // Verify file range + if((pbDataPtr + EntryOffset + EntryCount * sizeof(DIABLO3_CORE_TOC_ENTRY)) > pbDataEnd) + return NULL; + + // Find out the entry with the maximum index + for(DWORD n = 0; n < EntryCount; n++) { - CascReadFile(hFile, pbFileData, cbFileData, &cbBytesRead); + if(pTocEntry->FileIndex >= dwMaxFileIndex) + dwMaxFileIndex = pTocEntry->FileIndex; + pTocEntry++; } } - // Close the file - CascCloseFile(hFile); + // Give data and return + PtrMaxIndex[0] = dwMaxFileIndex; + PtrHeader[0] = pTocHeader; + return pbDataPtr; } - // Give the file to the caller - if(pcbFileData != NULL) - pcbFileData[0] = cbBytesRead; - return pbFileData; -} - -static LPBYTE LoadFileToMemory(TCascStorage * hs, const char * szFileName, DWORD * pcbFileData) -{ - LPBYTE pbEncodingKey = NULL; - LPBYTE pbFileData = NULL; - - // Try to find encoding key for the file - pbEncodingKey = RootHandler_GetKey(hs->pRootHandler, szFileName); - if(pbEncodingKey != NULL) - pbFileData = LoadFileToMemory(hs, pbEncodingKey, pcbFileData); - - return pbFileData; -} - -static int ParseDirectoryHeader( - PDIABLO3_DIR_HEADER pDirHeader, - LPBYTE pbDirFile, - LPBYTE pbFileEnd) -{ - DWORD dwSignature = 0; - - // - // Structure of a Diablo3 directory file - // 1) Signature (4 bytes) - // 2) Number of DIABLO3_FILEID1_ENTRY entries (4 bytes) - // 3) Array of DIABLO3_FILEID1_ENTRY entries - // 4) Number of DIABLO3_FILEID2_ENTRY entries (4 bytes) - // 5) Array of DIABLO3_FILEID2_ENTRY entries - // 6) Number of DIABLO3_NAMED_ENTRY entries (4 bytes) - // 7) Array of DIABLO3_NAMED_ENTRY entries - // - - // Prepare the header signature - memset(pDirHeader, 0, sizeof(DIABLO3_DIR_HEADER)); - - // Get the signature - if((pbDirFile + sizeof(DWORD)) >= pbFileEnd) - return ERROR_BAD_FORMAT; - dwSignature = *(PDWORD)pbDirFile; - - // Check the signature - if(dwSignature != CASC_DIABLO3_ROOT_SIGNATURE && dwSignature != DIABLO3_SUBDIR_SIGNATURE) - return ERROR_BAD_FORMAT; - pbDirFile += sizeof(DWORD); - - // Subdirectories have extra two arrays - if(dwSignature == DIABLO3_SUBDIR_SIGNATURE) + LPBYTE CaptureNamedEntry( + LPBYTE pbDataPtr, + LPBYTE pbDataEnd, + PDIABLO3_NAMED_ENTRY pEntry) { - // Get the number of DIABLO3_FILEID1_ENTRY items - if((pbDirFile + sizeof(DWORD)) >= pbFileEnd) - return ERROR_BAD_FORMAT; - pDirHeader->dwEntries1 = *(PDWORD)pbDirFile; - - // Get the array of DIABLO3_FILEID1_ENTRY - pDirHeader->pbEntries1 = (pbDirFile + sizeof(DWORD)); - pbDirFile = pbDirFile + sizeof(DWORD) + pDirHeader->dwEntries1 * sizeof(DIABLO3_FILEID1_ENTRY); - - // Get the number of DIABLO3_FILEID2_ENTRY items - if((pbDirFile + sizeof(DWORD)) >= pbFileEnd) - return ERROR_BAD_FORMAT; - pDirHeader->dwEntries2 = *(PDWORD)pbDirFile; - - // Get the array of DIABLO3_FILEID2_ENTRY - pDirHeader->pbEntries2 = (pbDirFile + sizeof(DWORD)); - pbDirFile = pbDirFile + sizeof(DWORD) + pDirHeader->dwEntries2 * sizeof(DIABLO3_FILEID2_ENTRY); - } + // Capture the content key + pbDataPtr = CaptureContentKey(pbDataPtr, pbDataEnd, &pEntry->pCKey); + if(pbDataPtr == NULL) + return NULL; + + // Capture file name. Must be ASCIIZ file name + pEntry->szFileName = (const char *)pbDataPtr; + while(pbDataPtr < pbDataEnd && pbDataPtr[0] != 0) + pbDataPtr++; + + // Did we find a zero char? + if(pbDataPtr < pbDataEnd && pbDataPtr[0] == 0) + { + pEntry->szFileEnd = (const char *)pbDataPtr; + return pbDataPtr + 1; + } - // Get the pointer and length DIABLO3_NAMED_ENTRY array - if((pbDirFile + sizeof(DWORD)) >= pbFileEnd) - return ERROR_BAD_FORMAT; - pDirHeader->dwEntries3 = *(PDWORD)pbDirFile; - pDirHeader->pbEntries3 = (pbDirFile + sizeof(DWORD)); - return ERROR_SUCCESS; -} + return NULL; + } -static DWORD ScanDirectoryFile( - TCascStorage * hs, - LPBYTE pbRootFile, - LPBYTE pbFileEnd) -{ - PDIABLO3_NAMED_ENTRY pNamedEntry; - DIABLO3_DIR_HEADER RootHeader; - DIABLO3_DIR_HEADER DirHeader; - LPBYTE pbSubDir; - DWORD dwTotalFileCount; - DWORD cbNamedEntry; - DWORD cbSubDir; - int nError; - - // Parse the directory header in order to retrieve the items - nError = ParseDirectoryHeader(&RootHeader, pbRootFile, pbFileEnd); - if(nError != ERROR_SUCCESS) - return 0; - - // Add the root directory's entries - dwTotalFileCount = RootHeader.dwEntries1 + RootHeader.dwEntries2 + RootHeader.dwEntries3; - - // Parse the named entries - for(DWORD i = 0; i < RootHeader.dwEntries3; i++) + int LoadDirectoryFile(TCascStorage * hs, DIABLO3_DIRECTORY & DirHeader, PCASC_CKEY_ENTRY pCKeyEntry) { - // Get the this named entry - if((cbNamedEntry = VerifyNamedFileEntry(RootHeader.pbEntries3, pbFileEnd)) == 0) - return 0; - pNamedEntry = (PDIABLO3_NAMED_ENTRY)RootHeader.pbEntries3; - RootHeader.pbEntries3 += cbNamedEntry; - - // Load the subdirectory to memory - pbSubDir = LoadFileToMemory(hs, pNamedEntry->EncodingKey.Value, &cbSubDir); - if(pbSubDir != NULL) + LPBYTE pbData; + DWORD cbData = 0; + + // Load the n-th folder + pbData = LoadInternalFileToMemory(hs, pCKeyEntry, &cbData); + if(pbData && cbData) { - // Count the files in the subdirectory - if(ParseDirectoryHeader(&DirHeader, pbSubDir, pbSubDir + cbSubDir) == ERROR_SUCCESS) + if(CaptureDirectoryData(DirHeader, pbData, cbData) == NULL) { - dwTotalFileCount += DirHeader.dwEntries1 + DirHeader.dwEntries2 + DirHeader.dwEntries3; + // Clear the directory + CASC_FREE(pbData); + return ERROR_BAD_FORMAT; } - - // Free the subdirectory - CASC_FREE(pbSubDir); } + return ERROR_SUCCESS; } - // Return the total number of entries - return dwTotalFileCount; -} + bool CreateAssetFileName( + PATH_BUFFER & PathBuffer, + DWORD FileIndex, + DWORD SubIndex) + { + PDIABLO3_CORE_TOC_ENTRY pTocEntry; + PDIABLO3_ASSET_INFO pAssetInfo; + const char * szPackageName = NULL; + const char * szPlainName; + const char * szFormat; + char * szPathEnd = PathBuffer.szEnd; + char * szPathPtr = PathBuffer.szPtr; + size_t nLength = 0; + + // Find and check the entry + pTocEntry = pFileIndices + FileIndex; + if(pTocEntry->FileIndex == FileIndex) + { + // Retrieve the asset information + pAssetInfo = GetAssetInfo(pTocEntry->AssetIndex); + + // Either use the asset info for getting the folder name or supply "Asset##" + if(pAssetInfo != NULL) + { + CascStrCopy(szPathPtr, (szPathEnd - szPathPtr), pAssetInfo->szDirectoryName); + szPathPtr += strlen(szPathPtr); + } + else + { + szPathPtr[0] = 'A'; + szPathPtr[1] = 's'; + szPathPtr[2] = 's'; + szPathPtr[3] = 'e'; + szPathPtr[4] = 't'; + szPathPtr[5] = (char)('0' + (pTocEntry->AssetIndex / 10)); + szPathPtr[6] = (char)('0' + (pTocEntry->AssetIndex % 10)); + szPathPtr += 7; + } -static int ParseDirectoryFile( - TRootHandler_Diablo3 * pRootHandler, - LPBYTE pbDirFile, - LPBYTE pbFileEnd, - DWORD dwRootDirIndex) -{ - DIABLO3_DIR_HEADER DirHeader; - int nError; + // Put the backslash + if(szPathPtr < PathBuffer.szEnd) + *szPathPtr++ = '\\'; + + // Construct the file name, up to the extension. Don't include the '.' + szPlainName = (const char *)(pbCoreTocData + pTocEntry->NameOffset); + szFormat = (SubIndex != CASC_INVALID_INDEX) ? "%s\\%04u" : "%s"; + nLength = CascStrPrintf(szPathPtr, (szPathEnd - szPathPtr), szFormat, szPlainName, SubIndex); + + // Try to fixup the file extension from the package name. + // File extensions are not predictable because for subitems, + // they are not always equal to the main items: + // + // SoundBank\3D Ambience.sbk + // SoundBank\3D Ambience\0000.smp + // SoundBank\3D Ambience\0002.smp + // ... + // SoundBank\Angel.sbk + // SoundBank\Angel\0000.fsb + // SoundBank\Angel\0002.fsb + // + // We use the Base\Data_D3\PC\Misc\Packages.dat for real file extensions, where possible + // + + if(PackagesMap.IsInitialized() && pAssetInfo != NULL) + { + // Retrieve the asset name + szPackageName = FindPackageName(pAssetInfo->szDirectoryName, szPathPtr); + if(szPackageName != NULL) + { + CascStrCopy(PathBuffer.szPtr, (PathBuffer.szEnd - PathBuffer.szPtr), szPackageName); + return true; + } + } - // Sanity checks - assert(pRootHandler->FileTable.ItemArray != NULL); - assert(pRootHandler->FileTable.ItemCount < pRootHandler->FileTable.ItemCountMax); + // Use the extension from the AssetInfo, if we have any + if(pAssetInfo != NULL && pAssetInfo->szExtension != NULL) + { + szPathPtr[nLength++] = '.'; + CascStrCopy(szPathPtr + nLength, (szPathEnd - (szPathPtr + nLength)), pAssetInfo->szExtension); + return true; + } - // Parse the directory header in order to retrieve the items - nError = ParseDirectoryHeader(&DirHeader, pbDirFile, pbFileEnd); - if(nError != ERROR_SUCCESS) - return nError; + // Otherwise, supply "a##" + CascStrPrintf(szPathPtr + nLength, (szPathEnd - (szPathPtr + nLength)), ".a%02u", pTocEntry->AssetIndex); + return true; + } - // Process all DIABLO3_FILEID1_ENTRY entries. These are for files - // belonging to an asset group, without subitem number. - // Example: "SoundBank\SoundFile.smp" - // We skip inserting them to the name map, because the names are not known yet - if(DirHeader.pbEntries1 && DirHeader.dwEntries1) - { - assert(dwRootDirIndex != DIABLO3_INVALID_INDEX); - nError = ParseDirEntries_FileId1(pRootHandler, DirHeader.pbEntries1, DirHeader.dwEntries1, dwRootDirIndex); - if(nError != ERROR_SUCCESS) - return nError; + return false; } - // Parse all DIABLO3_FILEID2_ENTRY entries. These are for files - // belonging to an asset group, with a subitem number. - // Example: "SoundBank\SoundFile\0001.smp" - // We skip inserting them to the name map, because the names are not known yet - if(DirHeader.pbEntries2 && DirHeader.dwEntries2) + // Parse the asset entries + int ParseAssetEntries( + TCascStorage * hs, + DIABLO3_DIRECTORY & Directory, + PATH_BUFFER & PathBuffer) { - assert(dwRootDirIndex != DIABLO3_INVALID_INDEX); - nError = ParseDirEntries_FileId2(pRootHandler, DirHeader.pbEntries2, DirHeader.dwEntries2, dwRootDirIndex); - if(nError != ERROR_SUCCESS) - return nError; - } + PDIABLO3_ASSET_ENTRY pEntry = (PDIABLO3_ASSET_ENTRY)Directory.pbAssetEntries; + PCASC_CKEY_ENTRY pCKeyEntry; + DWORD dwEntries = Directory.dwAssetEntries; + // Do nothing if there is no entries + if(pEntry != NULL && dwEntries != 0) + { + // Insert all asset entries to the file tree + for(DWORD i = 0; i < dwEntries; i++, pEntry++) + { + pCKeyEntry = FindCKeyEntry_CKey(hs, pEntry->CKey.Value); + if(pCKeyEntry != NULL) + { + // Construct the full path name of the entry + if(CreateAssetFileName(PathBuffer, pEntry->FileIndex, CASC_INVALID_INDEX)) + { + // Insert the entry to the file tree + FileTree.InsertByName(pCKeyEntry, PathBuffer.szBegin); + } + } + } + } - // Parse all named entries. These are for files with arbitrary names, - // and they do not belong to an asset. - if(DirHeader.pbEntries3 && DirHeader.dwEntries3) - { - nError = ParseDirEntries_Named(pRootHandler, DirHeader.pbEntries3, pbFileEnd, DirHeader.dwEntries3, dwRootDirIndex); - if(nError != ERROR_SUCCESS) - return nError; + return ERROR_SUCCESS; } - // Give the directory to the caller - return nError; -} - -static int ParseCoreTOC( - TRootHandler_Diablo3 * pRootHandler, - PCASC_MAP pPackageMap, - LPBYTE pbCoreTocFile, - LPBYTE pbCoreTocEnd) -{ - PDIABLO3_CORE_TOC_HEADER pTocHeader; - PDIABLO3_CORE_TOC_ENTRY pSortedEntries; - PDIABLO3_CORE_TOC_ENTRY pTocEntry; - LPBYTE pbCoreTocNames; - DWORD dwFileIndexes = 0; - DWORD i; - - // Check the space for header - if((pbCoreTocFile + sizeof(DIABLO3_CORE_TOC_HEADER)) > pbCoreTocEnd) - return ERROR_FILE_CORRUPT; - pTocHeader = (PDIABLO3_CORE_TOC_HEADER)pbCoreTocFile; - pbCoreTocFile += sizeof(DIABLO3_CORE_TOC_HEADER); - - // Calculate space needed for allocation - for(i = 0; i < DIABLO3_MAX_ASSETS; i++) + int ParseAssetAndIdxEntries( + TCascStorage * hs, + DIABLO3_DIRECTORY & Directory, + PATH_BUFFER & PathBuffer) { - // Get the first entry - pTocEntry = (PDIABLO3_CORE_TOC_ENTRY)(pbCoreTocFile + pTocHeader->EntryOffsets[i]); + PDIABLO3_ASSETIDX_ENTRY pEntry = (PDIABLO3_ASSETIDX_ENTRY)Directory.pbAssetIdxEntries; + PCASC_CKEY_ENTRY pCKeyEntry; + DWORD dwEntries = Directory.dwAssetIdxEntries; - // Find out the entry with the maximum index - for(DWORD n = 0; n < pTocHeader->EntryCounts[i]; n++) + // Do nothing if there is no entries + if(pEntry != NULL && dwEntries != 0) { - if(pTocEntry->FileIndex >= dwFileIndexes) - dwFileIndexes = pTocEntry->FileIndex + 1; - pTocEntry++; + // Insert all asset entries to the file tree + for(DWORD i = 0; i < dwEntries; i++, pEntry++) + { + pCKeyEntry = FindCKeyEntry_CKey(hs, pEntry->CKey.Value); + if(pCKeyEntry != NULL) + { + // Construct the full path name of the entry + if(CreateAssetFileName(PathBuffer, pEntry->FileIndex, pEntry->SubIndex)) + { + // Insert the entry to the file tree +// fprintf(fp, "%08u %04u %s\n", pEntry->FileIndex, pEntry->SubIndex, PathBuffer.szBegin); + FileTree.InsertByName(pCKeyEntry, PathBuffer.szBegin); + } + } + } } + + return ERROR_SUCCESS; } - // Allocate and populate the array of DIABLO3_CORE_TOC_ENTRYs - pSortedEntries = CASC_ALLOC(DIABLO3_CORE_TOC_ENTRY, dwFileIndexes); - if(pSortedEntries != NULL) + // Parse the named entries of all folders + int ParseDirectory_Phase1( + TCascStorage * hs, + DIABLO3_DIRECTORY & Directory, + PATH_BUFFER & PathBuffer, + bool bIsRootDirectory) { - // Initialize all entries to invalid - memset(pSortedEntries, 0xFF, dwFileIndexes * sizeof(DIABLO3_CORE_TOC_ENTRY)); + DIABLO3_NAMED_ENTRY NamedEntry; + char * szSavePtr = PathBuffer.szPtr; + size_t nFolderIndex = 0; + int nError = ERROR_SUCCESS; - // Populate the linear array with the entries - for(i = 0; i < DIABLO3_MAX_ASSETS; i++) + // Do nothing if there is no named headers + if(Directory.pbNamedEntries && Directory.dwNamedEntries) { - // Set the pointers - pTocEntry = (PDIABLO3_CORE_TOC_ENTRY)(pbCoreTocFile + pTocHeader->EntryOffsets[i]); - pbCoreTocNames = (LPBYTE)(pTocEntry + pTocHeader->EntryCounts[i]); - - // Setup the entries - for(DWORD n = 0; n < pTocHeader->EntryCounts[i]; n++) + PCASC_CKEY_ENTRY pCKeyEntry; + PCASC_FILE_NODE pFileNode; + LPBYTE pbDataPtr = Directory.pbNamedEntries; + LPBYTE pbDataEnd = Directory.pbDirectoryEnd; + DWORD dwNodeIndex; + + // Parse all entries + while(pbDataPtr < pbDataEnd) { - pSortedEntries[pTocEntry->FileIndex].AssetIndex = pTocEntry->AssetIndex; - pSortedEntries[pTocEntry->FileIndex].FileIndex = pTocEntry->FileIndex; - pSortedEntries[pTocEntry->FileIndex].NameOffset = (DWORD)(pbCoreTocNames - pbCoreTocFile) + pTocEntry->NameOffset; - pTocEntry++; + // Capture the named entry + pbDataPtr = CaptureNamedEntry(pbDataPtr, pbDataEnd, &NamedEntry); + if(pbDataPtr == NULL) + return ERROR_BAD_FORMAT; + + // Append the path fragment to the total path + AppendPathToTotalPath(PathBuffer, NamedEntry.szFileName, NamedEntry.szFileEnd); + + // Check whether the file exists in the storage + pCKeyEntry = FindCKeyEntry_CKey(hs, NamedEntry.pCKey->Value); + if(pCKeyEntry != NULL) + { + // Create file node belonging to this folder + pFileNode = FileTree.InsertByName(pCKeyEntry, PathBuffer.szBegin); + dwNodeIndex = (DWORD)FileTree.IndexOf(pFileNode); + + // If we are parsing root folder, we also need to load the data of the sub-folder file + if(bIsRootDirectory) + { + // Mark the node as directory + AppendBackslashToTotalPath(PathBuffer); + pCKeyEntry->Flags |= CASC_CE_FOLDER_ENTRY; + pFileNode->Flags |= CFN_FLAG_FOLDER; + + // Load the sub-directory file + nError = LoadDirectoryFile(hs, RootFolders[nFolderIndex], pCKeyEntry); + if(nError != ERROR_SUCCESS) + return nError; + + // Parse the sub-directory file + nError = ParseDirectory_Phase1(hs, RootFolders[nFolderIndex], PathBuffer, false); + if(nError != ERROR_SUCCESS) + return nError; + + // Also save the item pointer and increment the folder index + RootFolders[nFolderIndex].dwNodeIndex = dwNodeIndex; + nFolderIndex++; + } + + // Restore the path pointer + PathBuffer.szPtr = szSavePtr; + szSavePtr[0] = 0; + } } } - // Now use the linear array to resolve the asset indexes and plain names - ResolveFullFileNames(pRootHandler, pSortedEntries, pPackageMap, pbCoreTocFile, dwFileIndexes); - CASC_FREE(pSortedEntries); + return nError; } - return ERROR_SUCCESS; -} - -//----------------------------------------------------------------------------- -// Implementation of Diablo III root file - -static int D3Handler_Insert(TRootHandler_Diablo3 * pRootHandler, const char * szFileName, LPBYTE pbEncodingKey) -{ - ENCODING_KEY EncodingKey; - DWORD dwFileIndex; - - // Don't let the number of items to overflow - if(pRootHandler->FileTable.ItemCount >= pRootHandler->FileTable.ItemCountMax) - return ERROR_NOT_ENOUGH_MEMORY; - - // Insert the item - EncodingKey = *(PENCODING_KEY)pbEncodingKey; - dwFileIndex = InsertFileEntry(pRootHandler, - EncodingKey, - szFileName, - strlen(szFileName) + 1); - return (dwFileIndex != INVALID_FILE_INDEX) ? ERROR_SUCCESS : ERROR_NOT_ENOUGH_MEMORY; -} - -static LPBYTE D3Handler_Search(TRootHandler_Diablo3 * pRootHandler, TCascSearch * pSearch, PDWORD /* PtrFileSize */, PDWORD /* PtrLocaleFlags */, PDWORD /* PtrFileDataId */) -{ - PCASC_FILE_ENTRY pFileEntry; - const char * szSrcName = NULL; - - // Are we still inside the root directory range? - while(pSearch->IndexLevel1 < pRootHandler->FileTable.ItemCount) + // Parse the nameless entries of all folders + int ParseDirectory_Phase2(TCascStorage * hs) { - // Get the n-th directory and the file name - pFileEntry = (PCASC_FILE_ENTRY)Array_ItemAt(&pRootHandler->FileTable, pSearch->IndexLevel1); - szSrcName = (char *)Array_ItemAt(&pRootHandler->FileNames, pFileEntry->dwFileName); + PATH_BUFFER PathBuffer; + char szPathBuffer[MAX_PATH]; - // This is either a full file name or an abbreviated name - if(pFileEntry->dwFlags & CASC_ENTRY_SHORT_NAME) + // Parse each root subdirectory + for(size_t i = 0; i < DIABLO3_MAX_ROOT_FOLDERS; i++) { - CreateFileName(pRootHandler, szSrcName, pSearch->szFileName); - } - else - { - strcpy(pSearch->szFileName, szSrcName); + // Is this root folder loaded? + if(RootFolders[i].pbDirectoryData != NULL) + { + PathBuffer.szBegin = szPathBuffer; + PathBuffer.szPtr = szPathBuffer; + PathBuffer.szEnd = szPathBuffer + MAX_PATH - 1; + szPathBuffer[0] = 0; + + // Retrieve the parent name + if(RootFolders[i].dwNodeIndex != 0) + { + FileTree.PathAt(szPathBuffer, MAX_PATH, RootFolders[i].dwNodeIndex); + PathBuffer.szPtr = PathBuffer.szBegin + strlen(szPathBuffer); + } + + // Array of DIABLO3_ASSET_ENTRY entries. + // These are for files belonging to an asset, without subitem number. + // Example: "SoundBank\SoundFile.smp" + ParseAssetEntries(hs, RootFolders[i], PathBuffer); + + // Array of DIABLO3_ASSETIDX_ENTRY entries. + // These are for files belonging to an asset, with a subitem number. + // Example: "SoundBank\SoundFile\0001.smp" + ParseAssetAndIdxEntries(hs, RootFolders[i], PathBuffer); + } } - // Prepare for the next search - pSearch->IndexLevel1++; - return pFileEntry->EncodingKey.Value; + return ERROR_SUCCESS; } - // No more entries - return NULL; -} + // Creates an array of DIABLO3_CORE_TOC_ENTRY entries indexed by FileIndex + // Used as lookup table when we have FileIndex and need Asset+PlainName + int CreateMapOfFileIndices(TCascStorage * hs, const char * szFileName) + { + PDIABLO3_CORE_TOC_HEADER pTocHeader = NULL; + LPBYTE pbCoreTocPtr = pbCoreTocFile; + DWORD dwMaxFileIndex = 0; + int nError = ERROR_CAN_NOT_COMPLETE; -static void D3Handler_EndSearch(TRootHandler_Diablo3 * /* pRootHandler */, TCascSearch * /* pSearch */) -{ - // Do nothing -} + // Load the entire file to memory + pbCoreTocFile = pbCoreTocPtr = LoadFileToMemory(hs, szFileName, &cbCoreTocFile); + if(pbCoreTocFile && cbCoreTocFile) + { + LPBYTE pbCoreTocEnd = pbCoreTocFile + cbCoreTocFile; -static LPBYTE D3Handler_GetKey(TRootHandler_Diablo3 * pRootHandler, const char * szFileName) -{ - PCASC_FILE_ENTRY pFileEntry; - ULONGLONG FileNameHash = CalcFileNameHash(szFileName); + // Capture the header + if((pbCoreTocPtr = CaptureCoreTocHeader(&pTocHeader, &dwMaxFileIndex, pbCoreTocPtr, pbCoreTocEnd)) == NULL) + return ERROR_BAD_FORMAT; - // Find the file in the name table - pFileEntry = (PCASC_FILE_ENTRY)Map_FindObject(pRootHandler->pRootMap, &FileNameHash, NULL); - return (pFileEntry != NULL) ? pFileEntry->EncodingKey.Value : NULL; -} + // If there are no indices, return NULL + if(dwMaxFileIndex == 0) + return ERROR_SUCCESS; -static DWORD D3Handler_GetFileId(TRootHandler_Diablo3 * /* pRootHandler */, const char * /* szFileName */) -{ - // Not implemented for D3 - return 0; -} + // Allocate and populate the array of DIABLO3_CORE_TOC_ENTRYs + pFileIndices = CASC_ALLOC(DIABLO3_CORE_TOC_ENTRY, dwMaxFileIndex + 1); + if(pFileIndices != NULL) + { + // Initialize all entries to invalid + memset(pFileIndices, 0xFF, (dwMaxFileIndex + 1) * sizeof(DIABLO3_CORE_TOC_ENTRY)); + + // Populate the linear array with the file indices + for(size_t i = 0; i < DIABLO3_MAX_ASSETS; i++) + { + PDIABLO3_CORE_TOC_ENTRY pTocEntry = (PDIABLO3_CORE_TOC_ENTRY)(pbCoreTocPtr + pTocHeader->EntryOffsets[i]); + LPBYTE pbCoreTocNames = (LPBYTE)(pTocEntry + pTocHeader->EntryCounts[i]); + + // Setup the entries + for(DWORD n = 0; n < pTocHeader->EntryCounts[i]; n++) + { + DWORD dwFileIndex = pTocEntry->FileIndex; + + pFileIndices[dwFileIndex].AssetIndex = pTocEntry->AssetIndex; + pFileIndices[dwFileIndex].FileIndex = pTocEntry->FileIndex; + pFileIndices[dwFileIndex].NameOffset = (DWORD)(pbCoreTocNames - pbCoreTocPtr) + pTocEntry->NameOffset; + pTocEntry++; + } + } + + // Save the file to the root handler + pbCoreTocData = pbCoreTocPtr; + nFileIndices = dwMaxFileIndex; + nError = ERROR_SUCCESS; + } + } + return nError; + } -static void D3Handler_Close(TRootHandler_Diablo3 * pRootHandler) -{ - if(pRootHandler != NULL) + // Packages.dat contains a list of full file names (without locale prefix). + // They are not sorted, nor they correspond to file IDs. + // Does the sort order mean something? Perhaps we could use them as listfile? + int CreateMapOfRealNames(TCascStorage * hs, const char * szFileName) { - // Free the file map - Map_Free(pRootHandler->pRootMap); + DWORD Signature = 0; + DWORD NumberOfNames = 0; - // Free the array of the file entries and file names - Array_Free(&pRootHandler->FileTable); - Array_Free(&pRootHandler->FileNames); + // Load the entire file to memory + pbPackagesDat = LoadFileToMemory(hs, szFileName, &cbPackagesDat); + if(pbPackagesDat && cbPackagesDat) + { + LPBYTE pbPackagesPtr = pbPackagesDat; + LPBYTE pbPackagesEnd = pbPackagesDat + cbPackagesDat; +/* + LPBYTE pbPackagesPtr = pbPackagesDat + 8; + FILE * fp = fopen("E:\\Packages.dat", "wt"); + if(fp != NULL) + { + while(pbPackagesPtr < pbPackagesEnd) + { + fprintf(fp, "%s\n", pbPackagesPtr); + pbPackagesPtr = pbPackagesPtr + strlen((char *)pbPackagesPtr) + 1; + } + fclose(fp); + } +*/ + // Get the header. There is just Signature + NumberOfNames + if((pbPackagesPtr = CaptureInteger32(pbPackagesPtr, pbPackagesEnd, &Signature)) == NULL) + return ERROR_BAD_FORMAT; + if((pbPackagesPtr = CaptureInteger32(pbPackagesPtr, pbPackagesEnd, &NumberOfNames)) == NULL) + return ERROR_BAD_FORMAT; + if(Signature != DIABLO3_PACKAGES_SIGNATURE || NumberOfNames == 0) + return ERROR_BAD_FORMAT; + + // Create the map for fast search of the file name + if(PackagesMap.Create(NumberOfNames, 0, 0, KeyIsString) == ERROR_SUCCESS) + { + const char * szPackageName = (const char *)pbPackagesPtr; + + // Go as long as there is something + for(DWORD i = 0; i < NumberOfNames; i++) + { + // Get the file extension + if((LPBYTE)szPackageName >= pbPackagesEnd) + break; + + // Insert the file name to the map. The file extension is not included + PackagesMap.InsertString(szPackageName, true); + szPackageName = szPackageName + strlen(szPackageName) + 1; + } + } + } - // Free the root file itself - CASC_FREE(pRootHandler); + return ERROR_SUCCESS; } -} -/* -static void DumpRootFile(TDumpContext * dc, LPBYTE pbFileData, LPBYTE pbFileDataEnd) -{ - char szMD5Buffer[MD5_STRING_SIZE+1]; - DWORD dwSignature; - DWORD dwItemCount; - DWORD i; - - dwSignature = *(PDWORD)pbFileData; - if(dwSignature != CASC_DIABLO3_SUBDIR_SIGNATURE) - return; - pbFileData += sizeof(DWORD); - - // Dump items that contain EncodingKey + AssetId - dwItemCount = *(PDWORD)pbFileData; - pbFileData += sizeof(DWORD); - for(i = 0; i < dwItemCount; i++) + int Load(TCascStorage * hs, DIABLO3_DIRECTORY & RootDirectory) { - PCASC_DIABLO3_ASSET_ENTRY pEntry = (PCASC_DIABLO3_ASSET_ENTRY)pbFileData; + PATH_BUFFER PathBuffer; + char szPathBuffer[MAX_PATH]; + int nError; + + // Initialize path buffer and go parse the directory + PathBuffer.szBegin = szPathBuffer; + PathBuffer.szPtr = szPathBuffer; + PathBuffer.szEnd = szPathBuffer + MAX_PATH; + szPathBuffer[0] = 0; + + // Always parse the named entries first. They always point to a file. + // These are entries with arbitrary names, and they do not belong to an asset + nError = ParseDirectory_Phase1(hs, RootDirectory, PathBuffer, true); + if(nError == ERROR_SUCCESS) + { + // The asset entries in the ROOT file don't contain file names, but indices. + // To convert a file index to a file name, we need to load and parse the "Base\\CoreTOC.dat" file. + nError = CreateMapOfFileIndices(hs, "Base\\CoreTOC.dat"); + if(nError == ERROR_SUCCESS) + { + // The file "Base\Data_D3\PC\Misc\Packages.dat" contains the file names + // (without level-0 and level-1 directory). + // We can use these names for supplying the missing extensions + CreateMapOfRealNames(hs, "Base\\Data_D3\\PC\\Misc\\Packages.dat"); + + // Now parse all folders and resolve the full names + ParseDirectory_Phase2(hs); + } - if((pbFileData + sizeof(*pEntry)) > pbFileDataEnd) - return; - pbFileData += sizeof(*pEntry); + // Free all stuff that was used during loading of the ROOT file + FreeLoadingStuff(); + } - dump_print(dc, "%s %08X\n", StringFromMD5(pEntry->EncodingKey, szMD5Buffer), pEntry->AssetId); + return nError; } - // Terminate with two newlines - dump_print(dc, "\n"); - - // Dump items that contain EncodingKey + AssetId + FileNumber - dwItemCount = *(PDWORD)pbFileData; - pbFileData += sizeof(DWORD); - for(i = 0; i < dwItemCount; i++) + void FreeLoadingStuff() { - PCASC_DIABLO3_ASSET_ENTRY2 pEntry = (PCASC_DIABLO3_ASSET_ENTRY2)pbFileData; + // Free the captured root sub-directories + for(size_t i = 0; i < DIABLO3_MAX_SUBDIRS; i++) + CASC_FREE(RootFolders[i].pbDirectoryData); - if((pbFileData + sizeof(*pEntry)) > pbFileDataEnd) - return; - pbFileData += sizeof(*pEntry); + // Free the package map + PackagesMap.Free(); - dump_print(dc, "%s %08X %08X\n", StringFromMD5((LPBYTE)pEntry->EncodingKey, szMD5Buffer), pEntry->AssetId, pEntry->FileNumber); - } - - // Terminate with two newlines - dump_print(dc, "\n"); + // Free the array of file indices + CASC_FREE(pFileIndices); - // Dump items that contain EncodingKey + FileName - dwItemCount = *(PDWORD)pbFileData; - pbFileData += sizeof(DWORD); - for(i = 0; i < dwItemCount; i++) - { - PDIABLO3_NAMED_ENTRY pEntry = (PDIABLO3_NAMED_ENTRY)pbFileData; - DWORD dwEntrySize = VerifyNamedFileEntry(pbFileData, pbFileDataEnd); + // Free the loaded CoreTOC.dat file + CASC_FREE(pbCoreTocFile); - if((pbFileData + dwEntrySize) > pbFileDataEnd) - return; - pbFileData += dwEntrySize; - - dump_print(dc, "%s %s\n", StringFromMD5((LPBYTE)pEntry->EncodingKey, szMD5Buffer), pEntry->szFileName); + // Free the loaded Packages.dat file + CASC_FREE(pbPackagesDat); } - dump_print(dc, "\n\n"); -} -*/ + // Array of root directory subdirectories + DIABLO3_DIRECTORY RootFolders[DIABLO3_MAX_ROOT_FOLDERS]; + + // Array of DIABLO3_TOC_ENTRY structures, sorted by the file index + // Used for converting FileIndex -> Asset+PlainName during loading + PDIABLO3_CORE_TOC_ENTRY pFileIndices; + LPBYTE pbCoreTocFile; + LPBYTE pbCoreTocData; + size_t nFileIndices; + DWORD cbCoreTocFile; + + // Map for searching a real file extension + CASC_MAP PackagesMap; + LPBYTE pbPackagesDat; + DWORD cbPackagesDat; +}; + //----------------------------------------------------------------------------- // Public functions int RootHandler_CreateDiablo3(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile) { - TRootHandler_Diablo3 * pRootHandler; - PCASC_MAP pPackageMap = NULL; - LPBYTE pbRootFileEnd = pbRootFile + cbRootFile; - LPBYTE pbPackagesDat = NULL; - DWORD dwTotalFileCount; - DWORD cbPackagesDat = 0; - int nError; - - // Allocate the root handler object - hs->pRootHandler = pRootHandler = CASC_ALLOC(TRootHandler_Diablo3, 1); - if(pRootHandler == NULL) - return ERROR_NOT_ENOUGH_MEMORY; - - // Fill-in the handler functions - memset(pRootHandler, 0, sizeof(TRootHandler_Diablo3)); - pRootHandler->Insert = (ROOT_INSERT)D3Handler_Insert; - pRootHandler->Search = (ROOT_SEARCH)D3Handler_Search; - pRootHandler->EndSearch = (ROOT_ENDSEARCH)D3Handler_EndSearch; - pRootHandler->GetKey = (ROOT_GETKEY)D3Handler_GetKey; - pRootHandler->Close = (ROOT_CLOSE)D3Handler_Close; - pRootHandler->GetFileId = (ROOT_GETFILEID)D3Handler_GetFileId; - - // Fill-in the flags - pRootHandler->dwRootFlags |= ROOT_FLAG_HAS_NAMES; - - // Scan the total number of files in the root directories - // Reserve space for extra files - dwTotalFileCount = ScanDirectoryFile(hs, pbRootFile, pbRootFileEnd); - if(dwTotalFileCount == 0) - return ERROR_FILE_CORRUPT; - dwTotalFileCount += CASC_EXTRA_FILES; - - // Allocate the global linear file table - // Note: This is about 18 MB of memory for Diablo III PTR build 30013 - nError = Array_Create(&pRootHandler->FileTable, CASC_FILE_ENTRY, dwTotalFileCount); - if(nError != ERROR_SUCCESS) - return nError; + TDiabloRoot * pRootHandler = NULL; + DIABLO3_DIRECTORY RootDirectory; + int nError = ERROR_BAD_FORMAT; - // Allocate global buffer for file names. - // The size of the buffer was taken from Diablo III build 30013 - nError = Array_Create(&pRootHandler->FileNames, char, 0x01000000); - if(nError != ERROR_SUCCESS) - return nError; - - // Create map of ROOT_ENTRY -> FileEntry - pRootHandler->pRootMap = Map_Create(dwTotalFileCount, sizeof(ULONGLONG), FIELD_OFFSET(CASC_FILE_ENTRY, FileNameHash)); - if(pRootHandler->pRootMap == NULL) - return ERROR_NOT_ENOUGH_MEMORY; - - // Parse the ROOT file and insert all entries in the file table - nError = ParseDirectoryFile(pRootHandler, pbRootFile, pbRootFileEnd, DIABLO3_INVALID_INDEX); - if(nError == ERROR_SUCCESS) + // Verify the header of the ROOT file + if(TDiabloRoot::CaptureDirectoryData(RootDirectory, pbRootFile, cbRootFile) != NULL) { - size_t dwRootEntries = pRootHandler->FileTable.ItemCount; - - // We expect the number of level-0 to be less than maximum - assert(dwRootEntries < DIABLO3_MAX_SUBDIRS); - - // Now parse the all root items and load them - for(DWORD i = 0; i < dwRootEntries; i++) + // Allocate the root handler object + pRootHandler = new TDiabloRoot(); + if(pRootHandler != NULL) { - PCASC_FILE_ENTRY pRootEntry = (PCASC_FILE_ENTRY)Array_ItemAt(&pRootHandler->FileTable, i); - - // Load the entire file to memory - pbRootFile = LoadFileToMemory(hs, pRootEntry->EncodingKey.Value, &cbRootFile); - if(pbRootFile != NULL) + // Load the root directory. If load failed, we free the object + nError = pRootHandler->Load(hs, RootDirectory); + if(nError != ERROR_SUCCESS) { - nError = ParseDirectoryFile(pRootHandler, pbRootFile, pbRootFile + cbRootFile, i); - CASC_FREE(pbRootFile); + delete pRootHandler; + pRootHandler = NULL; } } } - // Note: The file "Base\Data_D3\PC\Misc\Packages.dat" contains the names - // of the files (without level-0 and level-1 directory). We can use these - // names for supplying the missing extensions - if(nError == ERROR_SUCCESS) - { - // Load the entire file to memory - pbPackagesDat = LoadFileToMemory(hs, "Base\\Data_D3\\PC\\Misc\\Packages.dat", &cbPackagesDat); - if(pbPackagesDat != NULL) - { - pPackageMap = CreatePackageMap(pbPackagesDat, pbPackagesDat + cbPackagesDat); - } - } - - // Vast majorify of files at this moment don't have names. - // We can load the Base\CoreTOC.dat file in order - // to get directory asset indexes, file names and extensions - if(nError == ERROR_SUCCESS) - { - LPBYTE pbCoreTOC; - DWORD cbCoreTOC = 0; - - // Load the entire file to memory - pbCoreTOC = LoadFileToMemory(hs, "Base\\CoreTOC.dat", &cbCoreTOC); - if(pbCoreTOC != NULL) - { - ParseCoreTOC(pRootHandler, pPackageMap, pbCoreTOC, pbCoreTOC + cbCoreTOC); - CASC_FREE(pbCoreTOC); - } - } - - // Free the packages map - if(pPackageMap != NULL) - Map_Free(pPackageMap); - if(pbPackagesDat != NULL) - CASC_FREE(pbPackagesDat); + // Assign the root directory (or NULL) and return error + hs->pRootHandler = pRootHandler; return nError; } diff --git a/dep/CascLib/src/CascRootFile_Install.cpp b/dep/CascLib/src/CascRootFile_Install.cpp new file mode 100644 index 00000000000..a0b00f73168 --- /dev/null +++ b/dep/CascLib/src/CascRootFile_Install.cpp @@ -0,0 +1,121 @@ +/*****************************************************************************/ +/* CascRootFile_Install.cpp Copyright (c) Ladislav Zezula 2018 */ +/*---------------------------------------------------------------------------*/ +/* Support for ROOT handler based on INSTALL manifest */ +/*---------------------------------------------------------------------------*/ +/* Date Ver Who Comment */ +/* -------- ---- --- ------- */ +/* 21.05.19 1.00 Lad The first version of CascRootFile_Install.cpp */ +/*****************************************************************************/ + +#define __CASCLIB_SELF__ +#include "CascLib.h" +#include "CascCommon.h" + +//----------------------------------------------------------------------------- +// Handler definitions for Starcraft I root file + +struct TRootHandler_Install : public TFileTreeRoot +{ + public: + + TRootHandler_Install() : TFileTreeRoot(0) + { + // We have file names and return CKey as result of search + dwFeatures |= (CASC_FEATURE_FILE_NAMES | CASC_FEATURE_ROOT_CKEY); + } + + static int CaptureInstallHeader(CASC_INSTALL_HEADER & InHeader, LPBYTE pbFileData, size_t cbFileData) + { + PFILE_INSTALL_HEADER pFileHeader = (PFILE_INSTALL_HEADER)pbFileData; + + // Check the signature ('DL') and version + if (cbFileData < sizeof(FILE_INSTALL_HEADER) || pFileHeader->Magic != FILE_MAGIC_INSTALL || pFileHeader->Version != 1) + return ERROR_BAD_FORMAT; + + // Note that we don't support CKey sizes greater than 0x10 in the INSTALL file + if (pFileHeader->EKeyLength > MD5_HASH_SIZE) + return ERROR_BAD_FORMAT; + + // Capture the header version 1 + memset(&InHeader, 0, sizeof(CASC_INSTALL_HEADER)); + InHeader.Magic = pFileHeader->Magic; + InHeader.Version = pFileHeader->Version; + InHeader.EKeyLength = pFileHeader->EKeyLength; + InHeader.TagCount = ConvertBytesToInteger_2(pFileHeader->TagCount); + InHeader.EntryCount = ConvertBytesToInteger_4(pFileHeader->EntryCount); + InHeader.HeaderLength = sizeof(FILE_INSTALL_HEADER); + return ERROR_SUCCESS; + } + + int Load(TCascStorage * hs, CASC_INSTALL_HEADER InHeader, LPBYTE pbInstallFile, LPBYTE pbInstallEnd) + { + PCASC_CKEY_ENTRY pCKeyEntry; + const char * szString; + size_t nBitmapLength; + size_t nFileCount = InHeader.EntryCount; + + // Skip the header + pbInstallFile += InHeader.HeaderLength; + + // Skip the tags + for (DWORD i = 0; i < InHeader.TagCount; i++) + { + szString = (const char *)pbInstallFile; + nBitmapLength = GetTagBitmapLength(pbInstallFile, pbInstallEnd, InHeader.EntryCount); + pbInstallFile = pbInstallFile + strlen(szString) + 1 + sizeof(USHORT) + nBitmapLength; + } + + // Load the names and insert them to the root handler + while(nFileCount > 0 && pbInstallFile < pbInstallEnd) + { + // File Name and CKey + szString = (const char *)pbInstallFile; + pbInstallFile += strlen(szString) + 1; + + // Verify whether it is a known entry + pCKeyEntry = FindCKeyEntry_CKey(hs, pbInstallFile); + pbInstallFile += MD5_HASH_SIZE + sizeof(DWORD); + + // Insert the FileName+CKey to the file tree + if (pCKeyEntry != NULL) + FileTree.InsertByName(pCKeyEntry, szString); + nFileCount--; + } + + return ERROR_SUCCESS; + } +}; + +//----------------------------------------------------------------------------- +// Public functions + +// +// Starcraft ROOT file is a text file with the following format: +// HD2/portraits/NBluCrit/NLCFID01.webm|c2795b120592355d45eba9cdc37f691e +// locales/enUS/Assets/campaign/EXPZerg/Zerg08/staredit/wav/zovtra01.ogg|316b0274bf2dabaa8db60c3ff1270c85 +// locales/zhCN/Assets/sound/terran/ghost/tghdth01.wav|6637ed776bd22089e083b8b0b2c0374c +// + +int RootHandler_CreateInstall(TCascStorage * hs, LPBYTE pbInstallFile, DWORD cbInstallFile) +{ + CASC_INSTALL_HEADER InHeader; + TRootHandler_Install * pRootHandler = NULL; + int nError = ERROR_BAD_FORMAT; + + // Capture the header of the DOWNLOAD file + nError = TRootHandler_Install::CaptureInstallHeader(InHeader, pbInstallFile, cbInstallFile); + if (nError == ERROR_SUCCESS) + { + // Allocate the root handler object + pRootHandler = new TRootHandler_Install(); + if (pRootHandler != NULL) + { + // Parse the entire install manifest + nError = pRootHandler->Load(hs, InHeader, pbInstallFile, pbInstallFile + cbInstallFile); + hs->pRootHandler = pRootHandler; + } + } + + return nError; +} diff --git a/dep/CascLib/src/CascRootFile_Mndx.cpp b/dep/CascLib/src/CascRootFile_Mndx.cpp index bc81d088fc0..9dca8d30eb4 100644 --- a/dep/CascLib/src/CascRootFile_Mndx.cpp +++ b/dep/CascLib/src/CascRootFile_Mndx.cpp @@ -1,94 +1,102 @@ /*****************************************************************************/ -/* CascMndxRoot.cpp Copyright (c) Ladislav Zezula 2014 */ +/* CascRootFile_MNDX.cpp Copyright (c) Ladislav Zezula 2014 */ /*---------------------------------------------------------------------------*/ /* Common functions for CascLib */ /* Note: "HOTS" refers to Play.exe, v2.5.0.29049 (Heroes of the Storm Alpha) */ /*---------------------------------------------------------------------------*/ /* Date Ver Who Comment */ /* -------- ---- --- ------- */ -/* 18.05.14 1.00 Lad The first version of CascMndxRoot.cpp */ +/* 18.05.14 1.00 Lad The first version of CascRootFile_MNDX.cpp */ /*****************************************************************************/ #define __CASCLIB_SELF__ #include "CascLib.h" #include "CascCommon.h" -#include "CascMndx.h" //----------------------------------------------------------------------------- // Local defines -#define CASC_MAR_SIGNATURE 0x0052414d // 'MAR\0' +#define MNDX_MAR_SIGNATURE 0x0052414d // 'MAR\0' +#define MAR_PACKAGE_NAMES 0 // MAR with package names only +#define MAR_STRIPPED_NAMES 1 // MAR with names where packages were stripped +#define MAR_FULL_NAMES 2 // MAR with full file names +#define MAR_COUNT 3 // Maximum of 3 MAR files are supported + +#define MNDX_SEARCH_INITIALIZING 0 +#define MNDX_SEARCH_SEARCHING 2 +#define MNDX_SEARCH_FINISHED 4 + +#define MNDX_MAX_ENTRIES(type) (0xFFFFFFFF / sizeof(type)) + +#define MNDX_INVALID_SIZE_T ((size_t)(-1)) + +#define MNDX_LAST_CKEY_ENTRY 0x80000000 //----------------------------------------------------------------------------- // Local structures -typedef struct _FILE_MNDX_HEADER +typedef union _SETBITS { - DWORD Signature; // 'MNDX' - DWORD HeaderVersion; // Must be <= 2 - DWORD FormatVersion; + struct + { + DWORD Lower08 : 8; // Number of set bits in the lower 1 byte + DWORD Lower16 : 8; // Number of set bits in the lower 2 bytes + DWORD Lower24 : 8; // Number of set bits in the lower 3 bytes + DWORD Lower32 : 8; // Number of set bits in the 32-bit integer + } u; -} FILE_MNDX_HEADER, *PFILE_MNDX_HEADER; + DWORD SetBitsAll; // The total set bits mask -typedef struct _FILE_MAR_INFO +} SETBITS, *PSETBITS; + +typedef struct _HASH_ENTRY { - DWORD MarIndex; - DWORD MarDataSize; - DWORD MarDataSizeHi; - DWORD MarDataOffset; - DWORD MarDataOffsetHi; -} FILE_MAR_INFO, *PFILE_MAR_INFO; + DWORD NodeIndex; // Index of the path node + DWORD NextIndex; // ID of the first subnode in the hash table + + union + { + DWORD FragmentOffset; // Offset of the path fragment in the TPathFragmentTable + DWORD ChildTableIndex; // Starting search index for the child database (if child database is present) + char SingleChar; // If the upper 24 bits of the FragmentOffset is 0xFFFFFFFF, this single character + }; + // Otherwise --> Offset to the name fragment table +} HASH_ENTRY, *PHASH_ENTRY; -typedef struct _CASC_MNDX_INFO +typedef struct _FILE_MNDX_HEADER { - BYTE RootFileName[MD5_HASH_SIZE]; // Name (aka MD5) of the root file + DWORD Signature; // 'MNDX' DWORD HeaderVersion; // Must be <= 2 DWORD FormatVersion; - DWORD field_1C; - DWORD field_20; - DWORD MarInfoOffset; // Offset of the first MAR entry info - DWORD MarInfoCount; // Number of the MAR info entries - DWORD MarInfoSize; // Size of the MAR info entry - DWORD MndxEntriesOffset; - DWORD MndxEntriesTotal; // Total number of MNDX root entries - DWORD MndxEntriesValid; // Number of valid MNDX root entries - DWORD MndxEntrySize; // Size of one MNDX root entry - struct _MAR_FILE * pMarFile1; // File name list for the packages - struct _MAR_FILE * pMarFile2; // File name list for names stripped of package names - struct _MAR_FILE * pMarFile3; // File name list for complete names -// PCASC_ROOT_ENTRY_MNDX pMndxEntries; -// PCASC_ROOT_ENTRY_MNDX * ppValidEntries; - bool bRootFileLoaded; // true if the root info file was properly loaded - -} CASC_MNDX_INFO, *PCASC_MNDX_INFO; - -typedef struct _CASC_MNDX_PACKAGE -{ - char * szFileName; // Pointer to file name - size_t nLength; // Length of the file name -} CASC_MNDX_PACKAGE, *PCASC_MNDX_PACKAGE; +} FILE_MNDX_HEADER, *PFILE_MNDX_HEADER; -typedef struct _CASC_MNDX_PACKAGES +typedef struct _MNDX_PACKAGE { - char * szNameBuffer; // Pointer to the buffer for file names - size_t NameEntries; // Number of name entries in Names - size_t NameBufferUsed; // Number of bytes used in the name buffer - size_t NameBufferMax; // Total size of the name buffer - - CASC_MNDX_PACKAGE Packages[1]; // List of packages + char * szFileName; // Pointer to file name + size_t nLength; // Length of the file name + size_t nIndex; // Package index -} CASC_MNDX_PACKAGES, *PCASC_MNDX_PACKAGES; +} MNDX_PACKAGE, *PMNDX_PACKAGE; // Root file entry for CASC storages with MNDX root file (Heroes of the Storm) // Corresponds to the in-file structure -typedef struct _CASC_ROOT_ENTRY_MNDX +typedef struct _MNDX_CKEY_ENTRY { DWORD Flags; // High 8 bits: Flags, low 24 bits: package index - BYTE EncodingKey[MD5_HASH_SIZE]; // Encoding key for the file - DWORD FileSize; // Uncompressed file size, in bytes + BYTE CKey[MD5_HASH_SIZE]; // Content key for the file + DWORD ContentSize; // Uncompressed file size, in bytes + +} MNDX_CKEY_ENTRY, *PMNDX_CKEY_ENTRY; -} CASC_ROOT_ENTRY_MNDX, *PCASC_ROOT_ENTRY_MNDX; +typedef struct _FILE_MAR_INFO +{ + DWORD MarIndex; + DWORD MarDataSize; + DWORD MarDataSizeHi; + DWORD MarDataOffset; + DWORD MarDataOffsetHi; +} FILE_MAR_INFO, *PFILE_MAR_INFO; //----------------------------------------------------------------------------- // Local variables @@ -229,3396 +237,2745 @@ unsigned char table_1BA1818[0x800] = // Local functions - Number of set bits in an integer // HOTS: inlined -DWORD GetNumberOfSetBits(DWORD Value32) +static SETBITS GetNumberOfSetBits(DWORD Value32) { + SETBITS SetBits; + Value32 = ((Value32 >> 1) & 0x55555555) + (Value32 & 0x55555555); Value32 = ((Value32 >> 2) & 0x33333333) + (Value32 & 0x33333333); Value32 = ((Value32 >> 4) & 0x0F0F0F0F) + (Value32 & 0x0F0F0F0F); + SetBits.SetBitsAll = Value32 * 0x01010101; - return (Value32 * 0x01010101); -} - -#define GetNumbrOfSetBits32(x) (GetNumberOfSetBits(x) >> 0x18) - -//----------------------------------------------------------------------------- -// Local functions - common - -static bool RootFileRead(LPBYTE pbFilePointer, LPBYTE pbFileEnd, void * pvBuffer, size_t dwBytesToRead) -{ - // False if the file pointer is beyond the end - if(pbFilePointer > pbFileEnd) - return false; - - // False if there is not enough bytes available - if((size_t)(pbFileEnd - pbFilePointer) < dwBytesToRead) - return false; - - memcpy(pvBuffer, pbFilePointer, dwBytesToRead); - return true; -} - -//----------------------------------------------------------------------------- -// Local functions - TMndxFindResult - -// HOTS: 01956EE0 -TMndxFindResult::TMndxFindResult() -{ - szSearchMask = NULL; - cchSearchMask = 0; - field_8 = 0; - szFoundPath = NULL; - cchFoundPath = 0; - FileNameIndex = 0; - pStruct40 = NULL; + return SetBits; } -// HOTS: 01956F00 -TMndxFindResult::~TMndxFindResult() +static DWORD GetNumberOfSetBits32(DWORD Value32) { - FreeStruct40(); + return GetNumberOfSetBits(Value32).u.Lower32; } -// HOTS: 01956F30 -int TMndxFindResult::CreateStruct40() +static LPBYTE CaptureData(LPBYTE pbRootPtr, LPBYTE pbRootEnd, void * pvBuffer, size_t cbLength) { - if(pStruct40 != NULL) - return ERROR_INVALID_PARAMETER; + // Check whether there is enough data in the buffer + if((pbRootPtr + cbLength) > pbRootEnd) + return NULL; - pStruct40 = new TStruct40(); - return (pStruct40 != NULL) ? ERROR_SUCCESS : ERROR_NOT_ENOUGH_MEMORY; + // Copy the data + memcpy(pvBuffer, pbRootPtr, cbLength); + return pbRootPtr + cbLength; } -void TMndxFindResult::FreeStruct40() -{ - if(pStruct40 != NULL) - delete pStruct40; - pStruct40 = NULL; -} +//----------------------------------------------------------------------------- +// The TPathStop structure -// HOTS: 01956E70 -int TMndxFindResult::SetSearchPath( - const char * szNewSearchMask, - size_t cchNewSearchMask) +struct TPathStop { - if(szSearchMask == NULL && cchSearchMask != 0) - return ERROR_INVALID_PARAMETER; + TPathStop() + { + LoBitsIndex = 0; + field_4 = 0; + Count = 0; + HiBitsIndex_PathFragment = CASC_INVALID_INDEX; + field_10 = 0xFFFFFFFF; + } - if(pStruct40 != NULL) - pStruct40->SearchPhase = CASC_SEARCH_INITIALIZING; + TPathStop(DWORD arg_0, DWORD arg_4, DWORD arg_8) + { + LoBitsIndex = arg_0; + field_4 = arg_4; + Count = arg_8; + HiBitsIndex_PathFragment = CASC_INVALID_INDEX; + field_10 = 0xFFFFFFFF; + } - szSearchMask = szNewSearchMask; - cchSearchMask = cchNewSearchMask; - return ERROR_SUCCESS; -} + DWORD LoBitsIndex; + DWORD field_4; + DWORD Count; + DWORD HiBitsIndex_PathFragment; + DWORD field_10; +}; //----------------------------------------------------------------------------- -// TByteStream functions +// Basic array implementations -// HOTS: 01959990 -TByteStream::TByteStream() +class TByteStream { - pbByteData = NULL; - pvMappedFile = NULL; - cbByteData = 0; - field_C = 0; - hFile = 0; - hMap = 0; -} + public: -// HOTS: 19599F0 -void TByteStream::ExchangeWith(TByteStream & Target) -{ - TByteStream WorkBuff; - - WorkBuff = *this; - *this = Target; - Target = WorkBuff; -} + // HOTS: 01959990 + TByteStream() + { + pbByteData = NULL; + pvMappedFile = NULL; + cbByteData = 0; + field_C = 0; + hFile = 0; + hMap = 0; + } -// HOTS: 19599F0 -int TByteStream::GetBytes(DWORD cbByteCount, PARRAY_POINTER PtrArray) -{ - if(cbByteData < cbByteCount) - return ERROR_BAD_FORMAT; + // HOTS: 19599F0 + template <typename T> + int GetBytes(size_t length, T ** Pointer) + { + // Is there enough bytes in the array? + if(length > cbByteData) + return ERROR_BAD_FORMAT; - // Give the buffer to the caller - PtrArray->Bytes = pbByteData; + // Give the buffer to the caller + Pointer[0] = (T *)(pbByteData); - // Move pointers - pbByteData += cbByteCount; - cbByteData -= cbByteCount; - return ERROR_SUCCESS; -} + // Move pointers + pbByteData += length; + cbByteData -= length; + return ERROR_SUCCESS; + } -// HOTS: 1957190 -int TByteStream::GetArray_DWORDs(PARRAY_POINTER PtrArray, DWORD ItemCount) -{ - if(PtrArray == NULL && ItemCount != 0) - return ERROR_INVALID_PARAMETER; - if(ItemCount > CASC_MAX_ENTRIES(DWORD)) - return ERROR_NOT_ENOUGH_MEMORY; + int CopyBytes(void * value, size_t length) + { + // Is there enough bytes in the array? + if(length > cbByteData) + return ERROR_BAD_FORMAT; - return GetBytes(ItemCount * 4, PtrArray); -} + // Give the buffer to the caller + memcpy(value, pbByteData, length); -// HOTS: 19571E0 -int TByteStream::GetArray_Triplets(PARRAY_POINTER PtrArray, DWORD ItemCount) -{ - if(PtrArray == NULL && ItemCount != 0) - return ERROR_INVALID_PARAMETER; - if(ItemCount > CASC_MAX_ENTRIES(TRIPLET)) - return ERROR_NOT_ENOUGH_MEMORY; + // Move pointers + pbByteData += length; + cbByteData -= length; + return ERROR_SUCCESS; + } - return GetBytes(ItemCount * sizeof(TRIPLET), PtrArray); -} + // HOTS: 1959A60 + int SkipBytes(size_t cbByteCount) + { + LPBYTE Pointer; -// HOTS: 1957230 -int TByteStream::GetArray_BYTES(PARRAY_POINTER PtrArray, DWORD ItemCount) -{ - if(PtrArray == NULL && ItemCount != 0) - return ERROR_INVALID_PARAMETER; - if(ItemCount > CASC_MAX_ENTRIES(BYTE)) - return ERROR_NOT_ENOUGH_MEMORY; + return GetBytes<BYTE>(cbByteCount, &Pointer); + } - return GetBytes(ItemCount, PtrArray); -} + // HOTS: 1959AF0 + int SetByteBuffer(LPBYTE pbNewByteData, size_t cbNewByteData) + { + if(pbNewByteData != NULL || cbNewByteData == 0) + { + pbByteData = pbNewByteData; + cbByteData = cbNewByteData; + return ERROR_SUCCESS; + } -// HOTS: 1957280 -int TByteStream::GetArray_NameTable(PARRAY_POINTER PtrArray, DWORD ItemCount) -{ - if(PtrArray == NULL && ItemCount != 0) return ERROR_INVALID_PARAMETER; - if(ItemCount > CASC_MAX_ENTRIES(NAME_FRAG)) - return ERROR_NOT_ENOUGH_MEMORY; - - return GetBytes(ItemCount * sizeof(NAME_FRAG), PtrArray); -} + } -// HOTS: 1959A60 -int TByteStream::SkipBytes(DWORD cbByteCount) -{ - ARRAY_POINTER Dummy; + // HOTS: 1957160 <DWORD> + template <typename T> + int GetValue(T & Value) + { + T * Pointer; + int nError; - return GetBytes(cbByteCount, &Dummy); -} + nError = GetBytes(sizeof(T), (LPBYTE *)(&Pointer)); + if(nError != ERROR_SUCCESS) + return nError; -// HOTS: 1959AF0 -int TByteStream::SetByteBuffer(LPBYTE pbNewByteData, DWORD cbNewByteData) -{ - if(pbNewByteData != NULL || cbNewByteData == 0) - { - pbByteData = pbNewByteData; - cbByteData = cbNewByteData; + Value = Pointer[0]; return ERROR_SUCCESS; } - return ERROR_INVALID_PARAMETER; -} - - -// HOTS: 1957160 -int TByteStream::GetValue_DWORD(DWORD & Value) -{ - ARRAY_POINTER Pointer; - int nError; - - nError = GetBytes(sizeof(DWORD), &Pointer); - if(nError != ERROR_SUCCESS) - return nError; - - Value = Pointer.Uint32s[0]; - return ERROR_SUCCESS; -} - -int TByteStream::GetValue_ItemCount(DWORD & NumberOfBytes, DWORD & ItemCount, DWORD ItemSize) -{ - ARRAY_POINTER Pointer; - ULONGLONG ByteCount; - int nError; - - // Verify if there is at least - 8 bytes - nError = GetBytes(sizeof(ULONGLONG), &Pointer); - if(nError != ERROR_SUCCESS) - return nError; - - // Extract the number of bytes - ByteCount = Pointer.Int64Ptr[0]; - if(ByteCount > 0xFFFFFFFF || (ByteCount % ItemSize) != 0) - return ERROR_BAD_FORMAT; + // Retrieves the item count in the array + template <typename T> + int GetArrayItemCount(DWORD & ArraySize, DWORD & ItemCount) + { + ULONGLONG ByteCount; + int nError; - // Give the result to the caller - NumberOfBytes = (DWORD)ByteCount; - ItemCount = (DWORD)(ByteCount / ItemSize); - return ERROR_SUCCESS; -} + // The first 8 bytes is the byte size of the array + nError = GetValue<ULONGLONG>(ByteCount); + if(nError != ERROR_SUCCESS) + return nError; -//----------------------------------------------------------------------------- -// TGenericArray functions + // Extract the number of bytes + if(ByteCount > 0xFFFFFFFF || (ByteCount % sizeof(T)) != 0) + return ERROR_BAD_FORMAT; -TGenericArray::TGenericArray() -{ - DataBuffer.Bytes = NULL; - FirstValid.Bytes = NULL; - ArrayPointer.Bytes = NULL; - ItemCount = 0; - MaxItemCount = 0; - bIsValidArray = false; -} + // Give the result to the caller + ItemCount = (DWORD)(ByteCount / sizeof(T)); + ArraySize = (DWORD)(ByteCount); + return ERROR_SUCCESS; + } -TGenericArray::~TGenericArray() -{ - if(DataBuffer.Bytes != NULL) - CASC_FREE(DataBuffer.Bytes); -} + // HOTS: 1957190: <DWORD> + // HOTS: 19571E0: <BASEVALS> + // HOTS: 1957230: <BYTE> + // HOTS: 1957280: <HASH_ENTRY> + template <typename T> + int GetArray(T ** Pointer, size_t ItemCount) + { + int nError = ERROR_SUCCESS; -// HOTS: inlined -void TGenericArray::ExchangeWith(TGenericArray & Target) -{ - TGenericArray WorkBuff; + // Verify parameters + if(Pointer == NULL && ItemCount != 0) + return ERROR_INVALID_PARAMETER; + if(ItemCount > MNDX_MAX_ENTRIES(T)) + return ERROR_NOT_ENOUGH_MEMORY; - WorkBuff = *this; - *this = Target; - Target = WorkBuff; -} + // Allocate bytes for the array + if (Pointer != NULL) + { + Pointer[0] = CASC_ALLOC(T, ItemCount); + if (Pointer[0] == NULL) + return ERROR_NOT_ENOUGH_MEMORY; -// HOTS: Inlined -void TGenericArray::CopyFrom(TGenericArray & Source) -{ - if(DataBuffer.Bytes != NULL) - CASC_FREE(DataBuffer.Bytes); - *this = Source; -} + // Get the pointer to the array + nError = CopyBytes(Pointer[0], sizeof(T) * ItemCount); + } -// HOTS: 1957090 (SetDwordsValid) -// HOTS: 19570B0 (SetTripletsValid) -// HOTS: 19570D0 (? SetBitsValid ?) -// HOTS: 19570F0 (SetNameFragmentsValid) -int TGenericArray::SetArrayValid() -{ - if(bIsValidArray != 0) - return 1; + return nError; + } - bIsValidArray = true; - return ERROR_SUCCESS; -} + LPBYTE pbByteData; + void * pvMappedFile; + size_t cbByteData; + DWORD field_C; + HANDLE hFile; + HANDLE hMap; +}; +//----------------------------------------------------------------------------- +// TGenericArray interface/implementation -// HOTS: 19575A0 -void TGenericArray::SetMaxItems_CHARS(DWORD NewMaxItemCount) +template <typename T> +class TGenericArray { - ARRAY_POINTER OldDataBuffer = DataBuffer; - ARRAY_POINTER NewDataBuffer; + public: - // Allocate new data buffer - NewDataBuffer.Chars = CASC_ALLOC(char, NewMaxItemCount); - if(NewDataBuffer.Chars != NULL) + TGenericArray() { - // Copy the old items to the buffer - for(DWORD i = 0; i < ItemCount; i++) - { - NewDataBuffer.Chars[i] = FirstValid.Chars[i]; - } + ItemArray = NULL; + ItemCount = 0; + MaxItemCount = 0; + bIsValidArray = false; } - DataBuffer = NewDataBuffer; - FirstValid = NewDataBuffer; - ArrayPointer = NewDataBuffer; - MaxItemCount = NewMaxItemCount; - CASC_FREE(OldDataBuffer.Chars); -} - -// HOTS: 1957600 -void TGenericArray::SetMaxItems_PATH_STOP(DWORD NewMaxItemCount) -{ - ARRAY_POINTER OldDataBuffer = DataBuffer; - ARRAY_POINTER NewDataBuffer; + ~TGenericArray() + { + CASC_FREE(ItemArray); + } - // Allocate new data buffer - NewDataBuffer.PathStopPtr = CASC_ALLOC(PATH_STOP, NewMaxItemCount); - if(NewDataBuffer.PathStopPtr != NULL) + T & operator[] (size_t index) { - // Copy the old items to the buffer - for(DWORD i = 0; i < ItemCount; i++) - { - NewDataBuffer.PathStopPtr[i] = FirstValid.PathStopPtr[i]; - } + assert(index < ItemCount); + return ItemArray[index]; } - DataBuffer = NewDataBuffer; - FirstValid = NewDataBuffer; - ArrayPointer = NewDataBuffer; - MaxItemCount = NewMaxItemCount; - CASC_FREE(OldDataBuffer.PathStopPtr); -} + // HOTS: 1957090 (SetDwordsValid) + // HOTS: 19570B0 (SetBaseValsValid) + // HOTS: 19570D0 (? SetBitsValid ?) + // HOTS: 19570F0 (SetPathFragmentsValid) + int SetArrayValid() + { + if(bIsValidArray != 0) + return ERROR_ALREADY_EXISTS; -// HOTS: inline -void TGenericArray::InsertOneItem_CHAR(char NewItem) -{ - DWORD NewMaxItemCount; - DWORD NewItemCount; + bIsValidArray = true; + return ERROR_SUCCESS; + } - NewItemCount = ItemCount + 1; - if(NewItemCount > MaxItemCount) + // HOTS: 19575A0 (char) + // HOTS: 1957600 (TPathStop) + void SetMaxItems(DWORD NewMaxItemCount) { - NewMaxItemCount = NewItemCount; + T * OldArray = ItemArray; + T * NewArray; - if(MaxItemCount > (NewItemCount / 2)) + // Allocate new data buffer + NewArray = CASC_ALLOC(T, NewMaxItemCount); + if(NewArray != NULL) { - if(MaxItemCount <= (CASC_MAX_ENTRIES(BYTE) / 2)) - NewMaxItemCount = MaxItemCount + MaxItemCount; - else - NewMaxItemCount = CASC_MAX_ENTRIES(BYTE); + // Copy the old items to the buffer + for(size_t i = 0; i < ItemCount; i++) + { + NewArray[i] = ItemArray[i]; + } } - SetMaxItems_CHARS(NewMaxItemCount); + ItemArray = NewArray; + MaxItemCount = NewMaxItemCount; + CASC_FREE(OldArray); } - // Put the character to the slot that has been reserved - FirstValid.Chars[ItemCount++] = NewItem; -} - -// HOTS: 1958330, inline -void TGenericArray::InsertOneItem_PATH_STOP(PATH_STOP & NewItem) -{ - DWORD NewMaxItemCount; - DWORD NewItemCount; - - NewItemCount = ItemCount + 1; - if(NewItemCount > MaxItemCount) + // HOTS: 19575A0 (char) + // HOTS: 1957600 (TPathStop) + void SetMaxItemsIf(DWORD NewMaxItemCount) { - NewMaxItemCount = NewItemCount; - - if(MaxItemCount > (NewItemCount / 2)) + if(NewMaxItemCount > MaxItemCount) { - if(MaxItemCount <= (CASC_MAX_ENTRIES(PATH_STOP) / 2)) - NewMaxItemCount = MaxItemCount + MaxItemCount; - else - NewMaxItemCount = CASC_MAX_ENTRIES(PATH_STOP); - } + if(MaxItemCount > (NewMaxItemCount / 2)) + { + if(MaxItemCount <= (MNDX_MAX_ENTRIES(T) / 2)) + NewMaxItemCount = MaxItemCount + MaxItemCount; + else + NewMaxItemCount = MNDX_MAX_ENTRIES(T); + } - SetMaxItems_PATH_STOP(NewMaxItemCount); + SetMaxItems(NewMaxItemCount); + } } - // Put the structure to the slot that has been reserved - FirstValid.PathStopPtr[ItemCount++] = NewItem; -} + // HOTS: inline <char> + // HOTS: 1958330 <TPathStop> + void Insert(T NewItem) + { + // Make sure we have enough capacity for the new item + SetMaxItemsIf(ItemCount + 1); -// HOTS: 19583A0 -void TGenericArray::sub_19583A0(DWORD NewItemCount) -{ - DWORD OldMaxItemCount = MaxItemCount; + // Put the character to the slot that has been reserved + ItemArray[ItemCount++] = NewItem; + } - if(NewItemCount > MaxItemCount) + // HOTS: 19583A0 <TPathStop> + void GrowArray(DWORD NewItemCount) { - DWORD NewMaxItemCount = NewItemCount; + DWORD OldMaxItemCount = MaxItemCount; - if(MaxItemCount > (NewItemCount / 2)) + // Make sure we have enough capacity for new items + SetMaxItemsIf(NewItemCount); + + // Initialize the newly inserted items + for(DWORD i = OldMaxItemCount; i < NewItemCount; i++) { - if(MaxItemCount <= (CASC_MAX_ENTRIES(PATH_STOP) / 2)) - NewMaxItemCount = MaxItemCount + MaxItemCount; - else - NewMaxItemCount = CASC_MAX_ENTRIES(PATH_STOP); + ItemArray[i] = T(); } - SetMaxItems_PATH_STOP(NewMaxItemCount); + ItemCount = NewItemCount; } - // Initialize the newly inserted items - for(DWORD i = OldMaxItemCount; i < NewItemCount; i++) + // HOTS: 1957440 <DWORD> + // HOTS: 19574E0 <BASEVALS> + // HOTS: 1957690 <BYTE> + // HOTS: 1957700 <HASH_ENTRY> + // HOTS: 195A220 <char> + // HOTS: 1958580 <TBitStream, DWORD> + int LoadFromStream(TByteStream & InStream) { - FirstValid.PathStopPtr[i].ItemIndex = 0; - FirstValid.PathStopPtr[i].field_4 = 0; - FirstValid.PathStopPtr[i].field_8 = 0; - FirstValid.PathStopPtr[i].field_C = 0xFFFFFFFF; - FirstValid.PathStopPtr[i].field_10 = 0xFFFFFFFF; - } - - ItemCount = NewItemCount; -} - -// HOTS: 1957440 -int TGenericArray::LoadDwordsArray(TByteStream & InStream) -{ - DWORD NumberOfBytes; - int nError; - - // Get and verify the number of items - nError = InStream.GetValue_ItemCount(NumberOfBytes, ItemCount, sizeof(DWORD)); - if(nError != ERROR_SUCCESS) - return nError; - - nError = InStream.GetArray_DWORDs(&ArrayPointer, ItemCount); - if(nError != ERROR_SUCCESS) - return nError; + DWORD NumberOfBytes; + int nError; - nError = InStream.SkipBytes((0 - (DWORD)NumberOfBytes) & 0x07); - if(nError != ERROR_SUCCESS) - return nError; - - return SetArrayValid(); -} - -// HOTS: 19574E0 -int TGenericArray::LoadTripletsArray(TByteStream & InStream) -{ - DWORD NumberOfBytes; - int nError; - - // Get and verify the number of items - nError = InStream.GetValue_ItemCount(NumberOfBytes, ItemCount, sizeof(TRIPLET)); - if(nError != ERROR_SUCCESS) - return nError; - - nError = InStream.GetArray_Triplets(&ArrayPointer, ItemCount); - if(nError != ERROR_SUCCESS) - return nError; - - nError = InStream.SkipBytes((0 - (DWORD)NumberOfBytes) & 0x07); - if(nError != ERROR_SUCCESS) - return nError; - - return SetArrayValid(); -} - -// HOTS: 1957690 -int TGenericArray::LoadByteArray(TByteStream & InStream) -{ - DWORD NumberOfBytes; - int nError; + // Get and verify the number of items + nError = InStream.GetArrayItemCount<T>(NumberOfBytes, ItemCount); + if(nError != ERROR_SUCCESS) + return nError; - // Get and verify the number of items - nError = InStream.GetValue_ItemCount(NumberOfBytes, ItemCount, sizeof(BYTE)); - if(nError != ERROR_SUCCESS) - return nError; + // Get the pointer to the array + nError = InStream.GetArray<T>(&ItemArray, ItemCount); + if(nError != ERROR_SUCCESS) + return nError; - nError = InStream.GetArray_BYTES(&ArrayPointer, ItemCount); - if(nError != ERROR_SUCCESS) - return nError; + nError = InStream.SkipBytes((0 - (DWORD)NumberOfBytes) & 0x07); + if(nError != ERROR_SUCCESS) + return nError; - nError = InStream.SkipBytes((0 - (DWORD)NumberOfBytes) & 0x07); - if(nError != ERROR_SUCCESS) - return nError; + return SetArrayValid(); + } - return SetArrayValid(); -} + T * ItemArray; + DWORD ItemCount; // Number of items in the array + DWORD MaxItemCount; // Capacity of the array + bool bIsValidArray; +}; -// HOTS: 1957700 -int TGenericArray::LoadFragmentInfos(TByteStream & InStream) +class TBitEntryArray : public TGenericArray<DWORD> { - DWORD NumberOfBytes; - int nError; + public: - // Get and verify the number of items - nError = InStream.GetValue_ItemCount(NumberOfBytes, ItemCount, sizeof(NAME_FRAG)); - if(nError != ERROR_SUCCESS) - return nError; - - nError = InStream.GetArray_NameTable(&ArrayPointer, ItemCount); - if(nError != ERROR_SUCCESS) - return nError; + TBitEntryArray() : TGenericArray() + { + BitsPerEntry = 0; + EntryBitMask = 0; + TotalEntries = 0; + } - nError = InStream.SkipBytes((0 - (DWORD)NumberOfBytes) & 0x07); - if(nError != ERROR_SUCCESS) - return nError; + ~TBitEntryArray() + {} - return SetArrayValid(); -} + DWORD GetItem(DWORD EntryIndex) + { + DWORD dwItemIndex = (EntryIndex * BitsPerEntry) >> 0x05; + DWORD dwStartBit = (EntryIndex * BitsPerEntry) & 0x1F; + DWORD dwEndBit = dwStartBit + BitsPerEntry; + DWORD dwResult; -// HOTS: 195A220 -int TGenericArray::LoadStrings(TByteStream & InStream) -{ - DWORD NumberOfBytes; - int nError; + // If the end bit index is greater than 32, + // we also need to load from the next 32-bit item + if(dwEndBit > 0x20) + { + dwResult = (ItemArray[dwItemIndex + 1] << (0x20 - dwStartBit)) | (ItemArray[dwItemIndex] >> dwStartBit); + } + else + { + dwResult = ItemArray[dwItemIndex] >> dwStartBit; + } - // Get and verify the number of items - nError = InStream.GetValue_ItemCount(NumberOfBytes, ItemCount, sizeof(char)); - if(nError != ERROR_SUCCESS) - return nError; + // Now we also need to mask the result by the bit mask + return dwResult & EntryBitMask; + } - nError = InStream.GetArray_BYTES(&ArrayPointer, ItemCount); - if(nError != ERROR_SUCCESS) - return nError; + int LoadBitsFromStream(TByteStream & InStream) + { + ULONGLONG Value64 = 0; + int nError; - nError = InStream.SkipBytes((0 - (DWORD)NumberOfBytes) & 0x07); - if(nError != ERROR_SUCCESS) - return nError; + nError = LoadFromStream(InStream); + if(nError != ERROR_SUCCESS) + return nError; - return SetArrayValid(); -} + nError = InStream.GetValue<DWORD>(BitsPerEntry); + if(nError != ERROR_SUCCESS) + return nError; + if(BitsPerEntry > 0x20) + return ERROR_BAD_FORMAT; -// HOTS: 19581C0 -int TGenericArray::LoadDwordsArray_Copy(TByteStream & InStream) -{ - TGenericArray TempArray; - int nError; + nError = InStream.GetValue<DWORD>(EntryBitMask); + if(nError != ERROR_SUCCESS) + return nError; - nError = TempArray.LoadDwordsArray(InStream); - if(nError != ERROR_SUCCESS) - return nError; + nError = InStream.GetValue<ULONGLONG>(Value64); + if(nError != ERROR_SUCCESS) + return nError; + if(Value64 > 0xFFFFFFFF) + return ERROR_BAD_FORMAT; + TotalEntries = (DWORD)Value64; - CopyFrom(TempArray); - return ERROR_SUCCESS; -} + assert((BitsPerEntry * TotalEntries) / 32 <= ItemCount); + return ERROR_SUCCESS; + } -// HOTS: 1958250 -int TGenericArray::LoadTripletsArray_Copy(TByteStream & InStream) -{ - TGenericArray TempArray; - int nError; + DWORD BitsPerEntry; + DWORD EntryBitMask; + DWORD TotalEntries; +}; - nError = TempArray.LoadTripletsArray(InStream); - if(nError != ERROR_SUCCESS) - return nError; +//----------------------------------------------------------------------------- +// TSparseArray functions - CopyFrom(TempArray); - return ERROR_SUCCESS; -} +#define INDEX_TO_GROUP(val) (val >> 9) +#define GROUP_TO_INDEX(grp) (grp << 9) -// HOTS: 1958420 -int TGenericArray::LoadBytes_Copy(TByteStream & InStream) +// For each 0x200-th bit, this contains information about amount of "1" bits +typedef struct _BASEVALS { - TGenericArray TempArray; - int nError; + DWORD BaseValue200; // Item value of every 0x200-th item - nError = TempArray.LoadByteArray(InStream); - if(nError != ERROR_SUCCESS) - return nError; + DWORD AddValue40 : 7; // For each 0x40 items (above the base200), + DWORD AddValue80 : 8; // we have extra shortcut to the item value + DWORD AddValueC0 : 8; // that is to be added to BaseValue200 + DWORD AddValue100 : 9; + DWORD AddValue140 : 9; + DWORD AddValue180 : 9; + DWORD AddValue1C0 : 9; - CopyFrom(TempArray); - return 0; -} + DWORD __xalignment : 5; // Filling +} BASEVALS, *PBASEVALS; -// HOTS: 19584F0 -int TGenericArray::LoadFragmentInfos_Copy(TByteStream & InStream) +class TSparseArray { - TGenericArray TempArray; - int nError; - - nError = TempArray.LoadFragmentInfos(InStream); - if(nError != ERROR_SUCCESS) - return nError; + public: - CopyFrom(TempArray); - return ERROR_SUCCESS; -} + TSparseArray() + { + TotalItemCount = 0; + ValidItemCount = 0; + } -// HOTS: 195A360 -int TGenericArray::LoadStringsWithCopy(TByteStream & InStream) -{ - TGenericArray TempArray; - int nError; + // HOTS: 1958630 + int LoadFromStream(TByteStream & InStream) + { + DWORD total_count = 0; + DWORD valid_count = 0; + int nError; - nError = TempArray.LoadStrings(InStream); - if(nError != ERROR_SUCCESS) - return nError; + nError = ItemBits.LoadFromStream(InStream); + if(nError != ERROR_SUCCESS) + return nError; - CopyFrom(TempArray); - return ERROR_SUCCESS; -} + nError = InStream.GetValue<DWORD>(total_count); + if(nError != ERROR_SUCCESS) + return nError; + nError = InStream.GetValue<DWORD>(valid_count); + if(nError != ERROR_SUCCESS) + return nError; + if(valid_count > total_count) + return ERROR_FILE_CORRUPT; -//----------------------------------------------------------------------------- -// TBitEntryArray functions + TotalItemCount = total_count; + ValidItemCount = valid_count; -TBitEntryArray::TBitEntryArray() -{ - BitsPerEntry = 0; - EntryBitMask = 0; - TotalEntries = 0; -} + nError = BaseVals.LoadFromStream(InStream); + if(nError != ERROR_SUCCESS) + return nError; -TBitEntryArray::~TBitEntryArray() -{} + nError = IndexToItem0.LoadFromStream(InStream); + if(nError != ERROR_SUCCESS) + return nError; -// HOTS: 01957D20 -void TBitEntryArray::ExchangeWith(TBitEntryArray & Target) -{ - TBitEntryArray WorkBuff; + nError = IndexToItem1.LoadFromStream(InStream); + if(nError != ERROR_SUCCESS) + return nError; - WorkBuff = *this; - *this = Target; - Target = WorkBuff; -} + return ERROR_SUCCESS; + } -// HOTS: 1958580 -int TBitEntryArray::LoadFromStream(TByteStream & InStream) -{ - ARRAY_POINTER Pointer; - ULONGLONG Value = 0; - int nError; + // Returns true if the array is empty + bool IsEmpty() + { + return (TotalItemCount == 0); + } - nError = LoadDwordsArray_Copy(InStream); - if(nError != ERROR_SUCCESS) - return nError; + // Returns true if the item at n-th position is present + bool IsItemPresent(size_t index) + { + // (index >> 0x05) gives the DWORD, (1 << (ItemIndex & 0x1F)) gives the bit + return (ItemBits[index >> 0x05] & (1 << (index & 0x1F))) ? true : false; + } - nError = InStream.GetBytes(sizeof(DWORD), &Pointer); - if(nError != ERROR_SUCCESS) - return nError; + // Retrieves the value of the n-th item in the sparse array. + // Note that for items that are not present, the value is equal + // to the nearest lower present value + DWORD GetItemValueAt(size_t index) + { + BASEVALS & SetBitsCount = BaseVals[index >> 0x09]; + DWORD IntValue; + DWORD BitMask; - BitsPerEntry = Pointer.Uint32s[0]; - if(BitsPerEntry > 0x20) - return ERROR_BAD_FORMAT; + // + // Since we don't want to count bits for the entire array, + // there are item value shortcuts every 0x200 items, + // and then every 0x40 items above the 0x200 base + // - nError = InStream.GetBytes(sizeof(DWORD), &Pointer); - if(nError != ERROR_SUCCESS) - return nError; - EntryBitMask = Pointer.Uint32s[0]; + // 1) We have base value for every 0x200-th item + IntValue = SetBitsCount.BaseValue200; - nError = InStream.GetBytes(sizeof(ULONGLONG), &Pointer); - if(nError == ERROR_SUCCESS) - Value = Pointer.Int64Ptr[0]; - if(Value > 0xFFFFFFFF) - return ERROR_BAD_FORMAT; - TotalEntries = (DWORD)Value; + // 2) Add the base value for each 0x40-th item above the 0x200 base + switch(((index >> 0x06) & 0x07) - 1) + { + case 0: // Add the 1st value (7 bits) + IntValue += SetBitsCount.AddValue40; + break; - assert((BitsPerEntry * TotalEntries) / 32 <= ItemCount); - return ERROR_SUCCESS; -} + case 1: // Add the 2nd value (8 bits) + IntValue += SetBitsCount.AddValue80; + break; -// HOTS: 1959300 -int TBitEntryArray::LoadFromStream_Exchange(TByteStream & InStream) -{ - TBitEntryArray TempArray; - int nError; + case 2: // Add the 3rd value (8 bits) + IntValue += SetBitsCount.AddValueC0; + break; - nError = TempArray.LoadFromStream(InStream); - if(nError != ERROR_SUCCESS) - return nError; + case 3: // Add the 4th value (9 bits) + IntValue += SetBitsCount.AddValue100; + break; - ExchangeWith(TempArray); - return ERROR_SUCCESS; -} + case 4: // Add the 5th value (9 bits) + IntValue += SetBitsCount.AddValue140; + break; -//----------------------------------------------------------------------------- -// TStruct40 functions + case 5: // Add the 6th value (9 bits) + IntValue += SetBitsCount.AddValue180; + break; -TStruct40::TStruct40() -{ - ItemIndex = 0; - CharIndex = 0; - ItemCount = 0; - SearchPhase = CASC_SEARCH_INITIALIZING; -} + case 6: // Add the 7th value (9 bits) + IntValue += SetBitsCount.AddValue1C0; + break; + } -// HOTS: 19586B0 -void TStruct40::InitSearchBuffers() -{ - DWORD NewMaxItemCount; + // 3) Count the bits of the higher DWORD, if the index 0x20 - 0x30 above the 0x200 base + if(index & 0x20) + IntValue += GetNumberOfSetBits32(ItemBits[(index >> 0x05) - 1]); - array_00.ItemCount = 0; + // 4) Count the bits in the current DWORD (masked by bit index mask) + BitMask = (1 << (index & 0x1F)) - 1; + return IntValue + GetNumberOfSetBits32(ItemBits[index >> 0x05] & BitMask); + } - // HOTS: 19586BD - if(array_00.MaxItemCount < 0x40) + DWORD FindGroup_Items0(DWORD index) { - // HOTS: 19586C2 - NewMaxItemCount = 0x40; + // Setup the group range to search + DWORD minGroup = (IndexToItem0[INDEX_TO_GROUP(index) + 0]) >> 9; + DWORD maxGroup = (IndexToItem0[INDEX_TO_GROUP(index) + 1] + 0x1FF) >> 9; - if(array_00.MaxItemCount > 0x20) + // Search the groups and find the BASEVALS structure + // For spans less than 10 groups, use sequential search, otherwise binary search. + if ((maxGroup - minGroup) < 10) { - if(array_00.MaxItemCount <= 0x7FFFFFFF) - NewMaxItemCount = array_00.MaxItemCount + array_00.MaxItemCount; - else - NewMaxItemCount = CASC_MAX_ENTRIES(BYTE); + // HOTS: 1959CF7 + while (index >= GROUP_TO_INDEX(minGroup) - BaseVals[minGroup + 1].BaseValue200 + 0x200) + { + // HOTS: 1959D14 + minGroup++; + } } + else + { + // HOTS: 1959D2E + while ((minGroup + 1) < maxGroup) + { + // HOTS: 1959D38 + DWORD middleValue = (maxGroup + minGroup) >> 1; - array_00.SetMaxItems_CHARS(NewMaxItemCount); - } + if (index < (maxGroup << 0x09) - BaseVals[maxGroup].BaseValue200) + { + // HOTS: 01959D4B + maxGroup = middleValue; + } + else + { + // HOTS: 1959D50 + minGroup = middleValue; + } + } + } - // HOTS: 19586E1 - // Set the new item count - PathStops.sub_19583A0(0); + return minGroup; + } - if(PathStops.MaxItemCount < 4) + DWORD FindGroup_Items1(DWORD index) { - // HOTS: 19586F2 - NewMaxItemCount = 4; + DWORD groupIndex = (index >> 0x09); + DWORD startValue = IndexToItem1[groupIndex] >> 9; + DWORD nextValue = (IndexToItem1[groupIndex + 1] + 0x1FF) >> 9; - // HOTS: 19586EA - if(PathStops.MaxItemCount > 2) + // Find the BASEVALS structure which the start index belongs to + // For less than 10 values, use sequential search. Otherwise, use binary search + if ((nextValue - startValue) < 10) { - if(PathStops.MaxItemCount <= 0x6666666) - NewMaxItemCount = PathStops.MaxItemCount + PathStops.MaxItemCount; - else - NewMaxItemCount = CASC_MAX_ENTRIES(PATH_STOP); + // HOTS: 01959F94 + while (index >= BaseVals[startValue + 1].BaseValue200) + { + // HOTS: 1959FA3 + startValue++; + } } + else + { + // Binary search (HOTS: 1959FAD) + if ((startValue + 1) < nextValue) + { + // HOTS: 1959FB4 + DWORD middleValue = (nextValue + startValue) >> 1; - // HOTS: 195870B - PathStops.SetMaxItems_PATH_STOP(NewMaxItemCount); - } - - ItemIndex = 0; - CharIndex = 0; - ItemCount = 0; - SearchPhase = CASC_SEARCH_SEARCHING; -} - -//----------------------------------------------------------------------------- -// TSparseArray functions - -TSparseArray::TSparseArray() -{ - TotalItemCount = 0; - ValidItemCount = 0; -} - -// HOTS: 1957DA0 -void TSparseArray::ExchangeWith(TSparseArray & Target) -{ - TSparseArray WorkBuff; - - WorkBuff = *this; - *this = Target; - Target = WorkBuff; -} - -// HOTS: 1958630 -int TSparseArray::LoadFromStream(TByteStream & InStream) -{ - ARRAY_POINTER Pointer; - int nError; - - nError = ItemBits.LoadDwordsArray_Copy(InStream); - if(nError != ERROR_SUCCESS) - return nError; - - nError = InStream.GetBytes(sizeof(DWORD), &Pointer); - if(nError != ERROR_SUCCESS) - return nError; - TotalItemCount = Pointer.Uint32s[0]; - - nError = InStream.GetBytes(sizeof(DWORD), &Pointer); - if(nError != ERROR_SUCCESS) - return nError; - ValidItemCount = Pointer.Uint32s[0]; - - if(ValidItemCount > TotalItemCount) - return ERROR_FILE_CORRUPT; - - nError = BaseValues.LoadTripletsArray_Copy(InStream); - if(nError != ERROR_SUCCESS) - return nError; - - nError = ArrayDwords_38.LoadDwordsArray_Copy(InStream); - if(nError != ERROR_SUCCESS) - return nError; - - nError = ArrayDwords_50.LoadDwordsArray_Copy(InStream); - if(nError != ERROR_SUCCESS) - return nError; - - return ERROR_SUCCESS; -} + if (index < BaseVals[middleValue].BaseValue200) + { + // HOTS: 1959FC4 + nextValue = middleValue; + } + else + { + // HOTS: 1959FC8 + startValue = middleValue; + } + } + } -// HOTS: 1959380 -int TSparseArray::LoadFromStream_Exchange(TByteStream & InStream) -{ - TSparseArray NewStruct68; - int nError; + return startValue; + } - nError = NewStruct68.LoadFromStream(InStream); - if(nError != ERROR_SUCCESS) - return nError; + // Returns the value of Item0[index] (HOTS: 1959CB0) + DWORD GetItem0(DWORD index) + { + SETBITS zeroBits; + DWORD groupIndex; + DWORD dwordIndex; + DWORD itemIndex; + DWORD bitGroup; + DWORD edx = index; - ExchangeWith(NewStruct68); - return ERROR_SUCCESS; -} +#ifdef _DEBUG + //if (TotalItemCount > 0x200) + //{ + // FILE * fp = fopen("e:\\Ladik\\Appdir\\CascLib\\doc\\mndx-sparse-array.txt", "wt"); + // Dump(fp); + // fclose(fp); + //} +#endif -// HOTS: 1959B60 -DWORD TSparseArray::GetItemValue(DWORD ItemIndex) -{ - PTRIPLET pTriplet; - DWORD DwordIndex; - DWORD BaseValue; - DWORD BitMask; + // If the index is at begin of the group, we just return the start value + if ((index & 0x1FF) == 0) + return IndexToItem0[INDEX_TO_GROUP(index)]; - // - // Divide the low-8-bits index to four parts: - // - // |-----------------------|---|------------| - // | A (23 bits) | B | C | - // |-----------------------|---|------------| - // - // A (23-bits): Index to the table (60 bits per entry) - // - // Layout of the table entry: - // |--------------------------------|-------|--------|--------|---------|---------|---------|---------|-----| - // | Base Value | val[0]| val[1] | val[2] | val[3] | val[4] | val[5] | val[6] | - | - // | 32 bits | 7 bits| 8 bits | 8 bits | 9 bits | 9 bits | 9 bits | 9 bits |5bits| - // |--------------------------------|-------|--------|--------|---------|---------|---------|---------|-----| - // - // B (3 bits) : Index of the variable-bit value in the array (val[#], see above) - // - // C (32 bits): Number of bits to be checked (up to 0x3F bits). - // Number of set bits is then added to the values obtained from A and B + // Find the group where the index belongs to + groupIndex = FindGroup_Items0(index); - // Upper 23 bits contain index to the table - pTriplet = BaseValues.TripletArray + (ItemIndex >> 0x09); - BaseValue = pTriplet->BaseValue; + // HOTS: 1959D5F + edx += BaseVals[groupIndex].BaseValue200 - (groupIndex << 0x09); + dwordIndex = (groupIndex << 4); - // Next 3 bits contain the index to the VBR - switch(((ItemIndex >> 0x06) & 0x07) - 1) - { - case 0: // Add the 1st value (7 bits) - BaseValue += (pTriplet->Value2 & 0x7F); - break; + if (edx < 0x100 - BaseVals[groupIndex].AddValue100) + { + // HOTS: 1959D8C + if (edx < 0x80 - BaseVals[groupIndex].AddValue80) + { + // HOTS: 01959DA2 + if (edx >= 0x40 - BaseVals[groupIndex].AddValue40) + { + // HOTS: 01959DB7 + dwordIndex += 2; + edx = edx + BaseVals[groupIndex].AddValue40 - 0x40; + } + } + else + { + // HOTS: 1959DC0 + if (edx < 0xC0 - BaseVals[groupIndex].AddValueC0) + { + // HOTS: 1959DD3 + dwordIndex += 4; + edx = edx + BaseVals[groupIndex].AddValue80 - 0x80; + } + else + { + // HOTS: 1959DD3 + dwordIndex += 6; + edx = edx + BaseVals[groupIndex].AddValueC0 - 0xC0; + } + } + } + else + { + // HOTS: 1959DE8 + if (edx < 0x180 - BaseVals[groupIndex].AddValue180) + { + // HOTS: 01959E00 + if (edx < 0x140 - BaseVals[groupIndex].AddValue140) + { + // HOTS: 1959E11 + dwordIndex += 8; + edx = edx + BaseVals[groupIndex].AddValue100 - 0x100; + } + else + { + // HOTS: 1959E1D + dwordIndex += 10; + edx = edx + BaseVals[groupIndex].AddValue140 - 0x140; + } + } + else + { + // HOTS: 1959E29 + if (edx < 0x1C0 - BaseVals[groupIndex].AddValue1C0) + { + // HOTS: 1959E3D + dwordIndex += 12; + edx = edx + BaseVals[groupIndex].AddValue180 - 0x180; + } + else + { + // HOTS: 1959E49 + dwordIndex += 14; + edx = edx + BaseVals[groupIndex].AddValue1C0 - 0x1C0; + } + } + } - case 1: // Add the 2nd value (8 bits) - BaseValue += (pTriplet->Value2 >> 0x07) & 0xFF; - break; + // HOTS: 1959E53: + // Calculate the number of bits set in the value of "bitGroup" + bitGroup = ~ItemBits[dwordIndex]; + zeroBits = GetNumberOfSetBits(bitGroup); - case 2: // Add the 3rd value (8 bits) - BaseValue += (pTriplet->Value2 >> 0x0F) & 0xFF; - break; + if (edx >= zeroBits.u.Lower32) + { + // HOTS: 1959ea4 + bitGroup = ~ItemBits[++dwordIndex]; + edx = edx - zeroBits.u.Lower32; + zeroBits = GetNumberOfSetBits(bitGroup); + } - case 3: // Add the 4th value (9 bits) - BaseValue += (pTriplet->Value2 >> 0x17); - break; + // Re-calculate the item index + itemIndex = (dwordIndex << 0x05); - case 4: // Add the 5th value (9 bits) - BaseValue += (pTriplet->Value3 & 0x1FF); - break; + // HOTS: 1959eea + if (edx < zeroBits.u.Lower16) + { + // HOTS: 1959EFC + if (edx >= zeroBits.u.Lower08) + { + // HOTS: 1959F05 + bitGroup >>= 0x08; + itemIndex += 0x08; + edx -= zeroBits.u.Lower08; + } + } + else + { + // HOTS: 1959F0D + if (edx < zeroBits.u.Lower24) + { + // HOTS: 1959F19 + bitGroup >>= 0x10; + itemIndex += 0x10; + edx -= zeroBits.u.Lower16; + } + else + { + // HOTS: 1959F23 + bitGroup >>= 0x18; + itemIndex += 0x18; + edx -= zeroBits.u.Lower24; + } + } - case 5: // Add the 6th value (9 bits) - BaseValue += (pTriplet->Value3 >> 0x09) & 0x1FF; - break; + // HOTS: 1959f2b + edx = edx << 0x08; + bitGroup = bitGroup & 0xFF; - case 6: // Add the 7th value (9 bits) - BaseValue += (pTriplet->Value3 >> 0x12) & 0x1FF; - break; + // BUGBUG: Possible buffer overflow here. Happens when dwItemIndex >= 0x9C. + // The same happens in Heroes of the Storm (build 29049), so I am not sure + // if this is a bug or a case that never happens + assert((bitGroup + edx) < sizeof(table_1BA1818)); + return table_1BA1818[bitGroup + edx] + itemIndex; } - // - // Take the upper 27 bits as an index to DWORD array, take lower 5 bits - // as number of bits to mask. Then calculate number of set bits in the value - // masked value. - // - - // Get the index into the array of DWORDs - DwordIndex = (ItemIndex >> 0x05); - - // Add number of set bits in the masked value up to 0x3F bits - if(ItemIndex & 0x20) - BaseValue += GetNumbrOfSetBits32(ItemBits.Uint32Array[DwordIndex - 1]); - - BitMask = (1 << (ItemIndex & 0x1F)) - 1; - return BaseValue + GetNumbrOfSetBits32(ItemBits.Uint32Array[DwordIndex] & BitMask); -} + DWORD GetItem1(DWORD index) + { + SETBITS setBits; + DWORD distFromBase; + DWORD groupIndex; + DWORD dwordIndex; + DWORD itemIndex; + DWORD bitGroup; -//----------------------------------------------------------------------------- -// TNameIndexStruct functions + // If the index is at begin of the group, we just return the start value + if ((index & 0x1FF) == 0) + return IndexToItem1[INDEX_TO_GROUP(index)]; -// HOTS: 0195A290 -TNameIndexStruct::TNameIndexStruct() -{} + // Find the group where the index belongs to + groupIndex = FindGroup_Items1(index); -// HOTS: inlined -TNameIndexStruct::~TNameIndexStruct() -{} + // Calculate the base200 dword index (HOTS: 1959FD4) + distFromBase = index - BaseVals[groupIndex].BaseValue200; + dwordIndex = groupIndex << 0x04; -// HOTS: 195A180 -bool TNameIndexStruct::CheckNameFragment(TMndxFindResult * pStruct1C, DWORD dwFragOffs) -{ - TStruct40 * pStruct40 = pStruct1C->pStruct40; - const char * szPathFragment; - const char * szSearchMask; + // Calculate the dword index including the sub-checkpoint + if (distFromBase < BaseVals[groupIndex].AddValue100) + { + // HOTS: 1959FF1 + if (distFromBase < BaseVals[groupIndex].AddValue80) + { + // HOTS: 0195A000 + if (distFromBase >= BaseVals[groupIndex].AddValue40) + { + // HOTS: 195A007 + distFromBase = distFromBase - BaseVals[groupIndex].AddValue40; + dwordIndex += 2; + } + } + else + { + // HOTS: 195A00E + if (distFromBase < BaseVals[groupIndex].AddValueC0) + { + // HOTS: 195A01A + distFromBase = distFromBase - BaseVals[groupIndex].AddValue80; + dwordIndex += 4; + } + else + { + // HOTS: 195A01F + distFromBase = distFromBase - BaseVals[groupIndex].AddValueC0; + dwordIndex += 6; + } + } + } + else + { + // HOTS: 195A026 + if (distFromBase < BaseVals[groupIndex].AddValue180) + { + // HOTS: 195A037 + if (distFromBase < BaseVals[groupIndex].AddValue140) + { + // HOTS: 195A041 + distFromBase = distFromBase - BaseVals[groupIndex].AddValue100; + dwordIndex += 8; + } + else + { + // HOTS: 195A048 + distFromBase = distFromBase - BaseVals[groupIndex].AddValue140; + dwordIndex += 10; + } + } + else + { + // HOTS: 195A04D + if (distFromBase < BaseVals[groupIndex].AddValue1C0) + { + // HOTS: 195A05A + distFromBase = distFromBase - BaseVals[groupIndex].AddValue180; + dwordIndex += 12; + } + else + { + // HOTS: 195A061 + distFromBase = distFromBase - BaseVals[groupIndex].AddValue1C0; + dwordIndex += 14; + } + } + } - if(!Struct68.TotalItemCount) - { - // Get the offset of the fragment to compare. For convenience with pStruct40->CharIndex, - // subtract the CharIndex from the fragment offset - szPathFragment = (NameFragments.CharArray + dwFragOffs - pStruct40->CharIndex); - szSearchMask = pStruct1C->szSearchMask; + // HOTS: 195A066 + bitGroup = ItemBits[dwordIndex]; + setBits = GetNumberOfSetBits(bitGroup); - // Keep searching as long as the name matches with the fragment - while(szPathFragment[pStruct40->CharIndex] == szSearchMask[pStruct40->CharIndex]) + // Get total number of set bits in the bit group + if (distFromBase >= setBits.u.Lower32) { - // Move to the next character - pStruct40->CharIndex++; - - // Is it the end of the fragment or end of the path? - if(szPathFragment[pStruct40->CharIndex] == 0) - return true; - if(pStruct40->CharIndex >= pStruct1C->cchSearchMask) - return false; + // HOTS: 195A0B2 + bitGroup = ItemBits[++dwordIndex]; + distFromBase = distFromBase - setBits.u.Lower32; + setBits = GetNumberOfSetBits(bitGroup); } - return false; - } - else - { - // Get the offset of the fragment to compare. - szPathFragment = (const char *)(NameFragments.CharArray); - szSearchMask = pStruct1C->szSearchMask; + // Calculate the item index + itemIndex = (dwordIndex << 0x05); - // Keep searching as long as the name matches with the fragment - while(szPathFragment[dwFragOffs] == szSearchMask[pStruct40->CharIndex]) + // Get the number of set bits in the lower word (HOTS: 195A0F6) + if (distFromBase < setBits.u.Lower16) + { + // HOTS: 195A111 + if (distFromBase >= setBits.u.Lower08) + { + // HOTS: 195A111 + itemIndex = itemIndex + 0x08; + bitGroup = bitGroup >> 0x08; + distFromBase = distFromBase - setBits.u.Lower08; + } + } + else { - // Move to the next character - pStruct40->CharIndex++; - - // Is it the end of the fragment or end of the path? - if(Struct68.IsItemPresent(dwFragOffs++)) - return true; - if(dwFragOffs >= pStruct1C->cchSearchMask) - return false; + // HOTS: 195A119 + if (distFromBase < setBits.u.Lower24) + { + // HOTS: 195A125 + bitGroup = bitGroup >> 0x10; + itemIndex = itemIndex + 0x10; + distFromBase = distFromBase - setBits.u.Lower16; + } + else + { + // HOTS: 195A12F + bitGroup = bitGroup >> 0x18; + itemIndex = itemIndex + 0x18; + distFromBase = distFromBase - setBits.u.Lower24; + } } - return false; - } -} + bitGroup = bitGroup & 0xFF; + distFromBase = distFromBase << 0x08; -// HOTS: 195A570 -bool TNameIndexStruct::CheckAndCopyNameFragment(TMndxFindResult * pStruct1C, DWORD dwFragOffs) -{ - TStruct40 * pStruct40 = pStruct1C->pStruct40; - const char * szPathFragment; - const char * szSearchMask; + // BUGBUG: Potential buffer overflow + // Happens in Heroes of the Storm when index == 0x5B + assert((bitGroup + distFromBase) < sizeof(table_1BA1818)); + return table_1BA1818[bitGroup + distFromBase] + itemIndex; + } - if(!Struct68.TotalItemCount) +#ifdef _DEBUG + void Dump(FILE * fp) { - // Get the offset of the fragment to compare. For convenience with pStruct40->CharIndex, - // subtract the CharIndex from the fragment offset - szPathFragment = (const char *)(NameFragments.CharArray + dwFragOffs - pStruct40->CharIndex); - szSearchMask = pStruct1C->szSearchMask; + size_t * ArrayNormal; + size_t * ArrayInvert; + size_t IndexNormal = 0; + size_t IndexInvert = 0; - // Keep copying as long as we don't reach the end of the search mask - while(pStruct40->CharIndex < pStruct1C->cchSearchMask) + // Output numbers of set bits for every 0x200-th item + fprintf(fp, "Number of set bits for every 0x200-th index\n" + "========================================================\n" + " Index Base200h +40 +80 +C0 +100 +140 +180 +1C0\n" + "--------------------------------------------------------\n"); + for (size_t i = 0; i < BaseVals.ItemCount; i++) { - // HOTS: 195A5A0 - if(szPathFragment[pStruct40->CharIndex] != szSearchMask[pStruct40->CharIndex]) - return false; - - // HOTS: 195A5B7 - pStruct40->array_00.InsertOneItem_CHAR(szPathFragment[pStruct40->CharIndex]); - pStruct40->CharIndex++; - - if(szPathFragment[pStruct40->CharIndex] == 0) - return true; + fprintf(fp, "[%08zX]: %08x %04x %04x %04x %04x %04x %04x %04x\n", GROUP_TO_INDEX(i), BaseVals[i].BaseValue200, + BaseVals[i].AddValue40, + BaseVals[i].AddValue80, + BaseVals[i].AddValueC0, + BaseVals[i].AddValue100, + BaseVals[i].AddValue140, + BaseVals[i].AddValue180, + BaseVals[i].AddValue1C0); } + fprintf(fp, "\n"); - // Fixup the address of the fragment - szPathFragment += pStruct40->CharIndex; - - // HOTS: 195A660 - // Now we need to copy the rest of the fragment - while(szPathFragment[0] != 0) + // Output values of Item1 and Item0 for every 0x200-th index + fprintf(fp, "Item0 and Item1 for every 0x200-th index\n" + "========================================\n" + " Index Item0 Item1\n" + "-----------------------------\n"); + for (size_t i = 0; i < IndexToItem0.ItemCount; i++) { - pStruct40->array_00.InsertOneItem_CHAR(szPathFragment[0]); - szPathFragment++; + fprintf(fp, "[%08zX]: %08x %08x\n", GROUP_TO_INDEX(i), IndexToItem0[i], IndexToItem1[i]); } - } - else - { - // Get the offset of the fragment to compare - // HOTS: 195A6B7 - szPathFragment = NameFragments.CharArray; - szSearchMask = pStruct1C->szSearchMask; + fprintf(fp, "\n"); - // Keep copying as long as we don't reach the end of the search mask - while(dwFragOffs < pStruct1C->cchSearchMask) - { - if(szPathFragment[dwFragOffs] != szSearchMask[pStruct40->CharIndex]) - return false; - pStruct40->array_00.InsertOneItem_CHAR(szPathFragment[dwFragOffs]); - pStruct40->CharIndex++; + // Output values of Item1 and Item0 for every index + ArrayNormal = new size_t[TotalItemCount]; + ArrayInvert = new size_t[TotalItemCount]; + if (ArrayNormal && ArrayInvert) + { + // Invalidate both arrays + memset(ArrayNormal, 0xFF, TotalItemCount * sizeof(size_t)); + memset(ArrayInvert, 0xFF, TotalItemCount * sizeof(size_t)); - // Keep going as long as the given bit is not set - if(Struct68.IsItemPresent(dwFragOffs++)) - return true; - } + // Load the both arrays + for (size_t i = 0; i < TotalItemCount; i++) + { + if (IsItemPresent(i)) + ArrayNormal[IndexNormal++] = i; + else + ArrayInvert[IndexInvert++] = i; + } - // Fixup the address of the fragment - szPathFragment += dwFragOffs; + // Output both arrays + fprintf(fp, "Item0 and Item1 for every index\n" + "========================================\n" + " Index Item0 Item1\n" + "-----------------------------\n"); + for (size_t i = 0; i < TotalItemCount; i++) + { + char NormalValue[0x20]; + char InvertValue[0x20]; - // Now we need to copy the rest of the fragment - while(Struct68.IsItemPresent(dwFragOffs++) == 0) - { - // HOTS: 195A7A6 - pStruct40->array_00.InsertOneItem_CHAR(szPathFragment[0]); - szPathFragment++; + if (ArrayNormal[i] == MNDX_INVALID_SIZE_T && ArrayInvert[i] == MNDX_INVALID_SIZE_T) + break; + fprintf(fp, "[%08zX]: %8s %8s\n", i, DumpValue(InvertValue, _countof(InvertValue), ArrayInvert[i]), DumpValue(NormalValue, _countof(NormalValue), ArrayNormal[i])); + } + fprintf(fp, "\n"); } - } - return true; -} + // Free both arrays + delete[] ArrayNormal; + delete[] ArrayInvert; -// HOTS: 195A3F0 -void TNameIndexStruct::CopyNameFragment(TMndxFindResult * pStruct1C, DWORD dwFragOffs) -{ - TStruct40 * pStruct40 = pStruct1C->pStruct40; - const char * szPathFragment; - - // HOTS: 195A3FA - if(!Struct68.TotalItemCount) - { - // HOTS: 195A40C - szPathFragment = NameFragments.CharArray + dwFragOffs; - while(szPathFragment[0] != 0) + // Output array of all values + fprintf(fp, "Item List: Index -> Value\n==========================\n"); + for (size_t i = 0; i < TotalItemCount; i++) { - // Insert the character to the path being built - pStruct40->array_00.InsertOneItem_CHAR(*szPathFragment++); + if (IsItemPresent(i)) + { + fprintf(fp, "[%08zX]: %08x\n", i, GetItemValueAt(i)); + } + else + { + fprintf(fp, "[%08zX]: NOT PRESENT\n", i); + } } + fprintf(fp, "\n"); } - else - { - // HOTS: 195A4B3 - for(;;) - { - // Insert the character to the path being built - pStruct40->array_00.InsertOneItem_CHAR(NameFragments.CharArray[dwFragOffs]); - // Keep going as long as the given bit is not set - if(Struct68.IsItemPresent(dwFragOffs++)) - break; - } + char * DumpValue(char * szBuffer, size_t cchBuffer, size_t value) + { + CascStrPrintf(szBuffer, cchBuffer, (value != MNDX_INVALID_SIZE_T) ? "%08zX" : " - ", value); + return szBuffer; } -} - -// HOTS: 0195A300 -void TNameIndexStruct::ExchangeWith(TNameIndexStruct & Target) -{ - TNameIndexStruct WorkBuff; - - WorkBuff = *this; - *this = Target; - Target = WorkBuff; -} - -// HOTS: 0195A820 -int TNameIndexStruct::LoadFromStream(TByteStream & InStream) -{ - int nError; - - nError = NameFragments.LoadStringsWithCopy(InStream); - if(nError != ERROR_SUCCESS) - return nError; - - return Struct68.LoadFromStream_Exchange(InStream); -} - -// HOTS: 195A850 -int TNameIndexStruct::LoadFromStream_Exchange(TByteStream & InStream) -{ - TNameIndexStruct TempIndexStruct; - int nError; - - nError = TempIndexStruct.LoadFromStream(InStream); - if(nError != ERROR_SUCCESS) - return nError; +#endif - ExchangeWith(TempIndexStruct); - return ERROR_SUCCESS; -} + TGenericArray<DWORD> ItemBits; // A bit array for each item. 1 if the item is present. + size_t TotalItemCount; // Total number of items in the array + size_t ValidItemCount; // Number of present items in the array + TGenericArray<BASEVALS> BaseVals; // For each 0x200-th item, this contains the number of set bits up to that 0x200-th item + TGenericArray<DWORD> IndexToItem0; // Mapping of index to invert item. An "invert" item is an item whose bit in "ItemBits" is zero. + TGenericArray<DWORD> IndexToItem1; // Mapping of index to normal item. An "normal" item is an item whose bit in "ItemBits" is set. +}; //----------------------------------------------------------------------------- -// TStruct10 functions - -TStruct10::TStruct10() -{ - field_0 = 0x03; - field_4 = 0x200; - field_8 = 0x1000; - field_C = 0x20000; -} +// TStruct40 functions -// HOTS: inline -void TStruct10::CopyFrom(TStruct10 & Target) +class TStruct40 { - field_0 = Target.field_0; - field_4 = Target.field_4; - field_8 = Target.field_8; - field_C = Target.field_C; -} + public: -// HOTS: 1956FD0 -int TStruct10::sub_1956FD0(DWORD dwBitMask) -{ - switch(dwBitMask & 0xF80) + TStruct40() { - case 0x00: - field_4 = 0x200; - return ERROR_SUCCESS; - - case 0x80: - field_4 = 0x80; - return ERROR_SUCCESS; - - case 0x100: - field_4 = 0x100; - return ERROR_SUCCESS; - - case 0x200: - field_4 = 0x200; - return ERROR_SUCCESS; - - case 0x400: - field_4 = 0x400; - return ERROR_SUCCESS; - - case 0x800: - field_4 = 0x800; - return ERROR_SUCCESS; + NodeIndex = 0; + ItemCount = 0; + PathLength = 0; + SearchPhase = MNDX_SEARCH_INITIALIZING; } - return ERROR_INVALID_PARAMETER; -} - -// HOTS: 1957050 -int TStruct10::sub_1957050(DWORD dwBitMask) -{ - switch(dwBitMask & 0xF0000) + // HOTS: 19586B0 + void BeginSearch() { - case 0x00: - field_C = 0x20000; - return ERROR_SUCCESS; + // HOTS: 19586BD + PathBuffer.ItemCount = 0; + PathBuffer.SetMaxItemsIf(0x40); - case 0x10000: - field_C = 0x10000; - return ERROR_SUCCESS; + // HOTS: 19586E1 + // Set the new item count + PathStops.GrowArray(0); + PathStops.SetMaxItemsIf(4); - case 0x20000: - field_C = 0x20000; - return ERROR_SUCCESS; + PathLength = 0; + NodeIndex = 0; + ItemCount = 0; + SearchPhase = MNDX_SEARCH_SEARCHING; } - return ERROR_INVALID_PARAMETER; -} - -// HOTS: 19572E0 -int TStruct10::sub_19572E0(DWORD dwBitMask) -{ - DWORD dwSubMask; - int nError; + DWORD CalcHashValue(const char * szPath) + { + return (BYTE)(szPath[PathLength]) ^ (NodeIndex << 0x05) ^ NodeIndex; + } - if(dwBitMask & 0xFFF00000) - return ERROR_INVALID_PARAMETER; + TGenericArray<TPathStop> PathStops; // Array of path checkpoints + TGenericArray<char> PathBuffer; // Buffer for building a file name + DWORD NodeIndex; // ID of a path node being searched; starting with 0 + DWORD PathLength; // Length of the path in the PathBuffer + DWORD ItemCount; + DWORD SearchPhase; // 0 = initializing, 2 = searching, 4 = finished +}; - dwSubMask = dwBitMask & 0x7F; - if(dwSubMask) - field_0 = dwSubMask; +//----------------------------------------------------------------------------- +// Local functions - TMndxSearch - nError = sub_1956FD0(dwBitMask); - if(nError != ERROR_SUCCESS) - return nError; +class TMndxSearch +{ + public: - dwSubMask = dwBitMask & 0xF000; - if(dwSubMask == 0 || dwSubMask == 0x1000) + // HOTS: 01956EE0 + TMndxSearch() { - field_8 = 0x1000; - return sub_1957050(dwBitMask); + szSearchMask = NULL; + cchSearchMask = 0; + szFoundPath = NULL; + cchFoundPath = 0; + nIndex = 0; } - if(dwSubMask == 0x2000) + // HOTS: 01956F00 + ~TMndxSearch() + {} + + // HOTS: 01956E70 + int SetSearchMask( + const char * szNewSearchMask, + size_t cchNewSearchMask) { - field_8 = 0x2000; - return sub_1957050(dwBitMask); - } + if(szSearchMask == NULL && cchSearchMask != 0) + return ERROR_INVALID_PARAMETER; - return ERROR_INVALID_PARAMETER; -} + Struct40.SearchPhase = MNDX_SEARCH_INITIALIZING; -// HOTS: 1957800 -int TStruct10::sub_1957800(DWORD dwBitMask) -{ - TStruct10 TempStruct; - int nError; - - nError = TempStruct.sub_19572E0(dwBitMask); - if(nError != ERROR_SUCCESS) - return nError; + szSearchMask = szNewSearchMask; + cchSearchMask = cchNewSearchMask; + return ERROR_SUCCESS; + } - CopyFrom(TempStruct); - return ERROR_SUCCESS; -} + TStruct40 Struct40; + const char * szSearchMask; // Search mask without wildcards + size_t cchSearchMask; // Length of the search mask + const char * szFoundPath; // Found path name + size_t cchFoundPath; // Length of the found path name + DWORD nIndex; // Index of the file name +}; //----------------------------------------------------------------------------- -// TFileNameDatabase functions +// TPathFragmentTable class. This class implements table of the path fragments. +// These path fragments can either by terminated by zeros (ASCIIZ) +// or can be marked by the external "PathMarks" structure -// HOTS: 01958730 -TFileNameDatabase::TFileNameDatabase() -{ - NameFragIndexMask = 0; - field_214 = 0; -} - -// HOTS: inlined -void TFileNameDatabase::ExchangeWith(TFileNameDatabase & Target) +class TPathFragmentTable { - TFileNameDatabasePtr TempPtr; - DWORD dwTemp; - - Struct68_00.ExchangeWith(Target.Struct68_00); - FileNameIndexes.ExchangeWith(Target.FileNameIndexes); - Struct68_D0.ExchangeWith(Target.Struct68_D0); - - FrgmDist_LoBits.ExchangeWith(Target.FrgmDist_LoBits); - FrgmDist_HiBits.ExchangeWith(Target.FrgmDist_HiBits); - - IndexStruct_174.ExchangeWith(Target.IndexStruct_174); - - TempPtr = NextDB; - NextDB = Target.NextDB; - Target.NextDB = TempPtr; - - NameFragTable.ExchangeWith(Target.NameFragTable); + public: - dwTemp = NameFragIndexMask; - NameFragIndexMask = Target.NameFragIndexMask; - Target.NameFragIndexMask = dwTemp; + // HOTS: 0195A290 + TPathFragmentTable() + {} - dwTemp = field_214; - field_214 = Target.field_214; - Target.field_214 = dwTemp; + // HOTS: inlined + ~TPathFragmentTable() + {} - Struct10.CopyFrom(Target.Struct10); -} + // HOTS: 195A180 + bool ComparePathFragment(TMndxSearch * pSearch, size_t nFragmentOffset) + { + TStruct40 * pStruct40 = &pSearch->Struct40; -// HOTS: 1959CB0 -DWORD TFileNameDatabase::sub_1959CB0(DWORD dwItemIndex) -{ - PTRIPLET pTriplet; - DWORD dwKeyShifted = (dwItemIndex >> 9); - DWORD eax, ebx, ecx, edx, esi, edi; - - // If lower 9 is zero - edx = dwItemIndex; - if((edx & 0x1FF) == 0) - return Struct68_00.ArrayDwords_38.Uint32Array[dwKeyShifted]; - - eax = Struct68_00.ArrayDwords_38.Uint32Array[dwKeyShifted] >> 9; - esi = (Struct68_00.ArrayDwords_38.Uint32Array[dwKeyShifted + 1] + 0x1FF) >> 9; - dwItemIndex = esi; - - if((eax + 0x0A) >= esi) - { - // HOTS: 1959CF7 - pTriplet = Struct68_00.BaseValues.TripletArray + eax + 1; - edi = (eax << 0x09); - ebx = edi - pTriplet->BaseValue + 0x200; - while(edx >= ebx) + // Do we have path fragment separators in an external structure? + if(PathMarks.IsEmpty()) { - // HOTS: 1959D14 - edi += 0x200; - pTriplet++; + // Keep searching as long as the name matches with the fragment + while(PathFragments[nFragmentOffset] == pSearch->szSearchMask[pStruct40->PathLength]) + { + // Move to the next character + pStruct40->PathLength++; + nFragmentOffset++; - ebx = edi - pTriplet->BaseValue + 0x200; - eax++; + // Is it the end of the fragment or end of the path? + if(PathFragments[nFragmentOffset] == 0) + return true; + if(pStruct40->PathLength >= pSearch->cchSearchMask) + return false; + } + + return false; } - } - else - { - // HOTS: 1959D2E - while((eax + 1) < esi) + else { - // HOTS: 1959D38 - // ecx = Struct68_00.BaseValues.TripletArray; - esi = (esi + eax) >> 1; - ebx = (esi << 0x09) - Struct68_00.BaseValues.TripletArray[esi].BaseValue; - if(edx < ebx) + // Keep searching as long as the name matches with the fragment + while(PathFragments[nFragmentOffset] == pSearch->szSearchMask[pStruct40->PathLength]) { - // HOTS: 01959D4B - dwItemIndex = esi; - } - else - { - // HOTS: 1959D50 - eax = esi; - esi = dwItemIndex; + // Move to the next character + pStruct40->PathLength++; + + // Is it the end of the path fragment? + if(PathMarks.IsItemPresent(nFragmentOffset++)) + return true; + if(nFragmentOffset >= pSearch->cchSearchMask) + return false; } + + return false; } } - // HOTS: 1959D5F - pTriplet = Struct68_00.BaseValues.TripletArray + eax; - edx += pTriplet->BaseValue - (eax << 0x09); - edi = (eax << 4); - - eax = pTriplet->Value2; - ecx = (eax >> 0x17); - ebx = 0x100 - ecx; - if(edx < ebx) + // HOTS: 195A3F0 + void CopyPathFragment(TMndxSearch * pSearch, size_t nFragmentOffset) { - // HOTS: 1959D8C - ecx = ((eax >> 0x07) & 0xFF); - esi = 0x80 - ecx; - if(edx < esi) + TStruct40 * pStruct40 = &pSearch->Struct40; + + // Do we have path fragment separators in an external structure? + if (PathMarks.IsEmpty()) { - // HOTS: 01959DA2 - eax = eax & 0x7F; - ecx = 0x40 - eax; - if(edx >= ecx) + // HOTS: 195A40C + while (PathFragments[nFragmentOffset] != 0) { - // HOTS: 01959DB7 - edi += 2; - edx = edx + eax - 0x40; + // Insert the character to the path being built + pStruct40->PathBuffer.Insert(PathFragments[nFragmentOffset++]); } } else { - // HOTS: 1959DC0 - eax = (eax >> 0x0F) & 0xFF; - esi = 0xC0 - eax; - if(edx < esi) + // HOTS: 195A4B3 + while(!PathMarks.IsItemPresent(nFragmentOffset)) { - // HOTS: 1959DD3 - edi += 4; - edx = edx + ecx - 0x80; - } - else - { - // HOTS: 1959DD3 - edi += 6; - edx = edx + eax - 0xC0; + // Insert the character to the path being built + pStruct40->PathBuffer.Insert(PathFragments[nFragmentOffset++]); } } } - else + + // HOTS: 195A570 + bool CompareAndCopyPathFragment(TMndxSearch * pSearch, size_t nFragmentOffset) { - // HOTS: 1959DE8 - esi = pTriplet->Value3; - eax = ((esi >> 0x09) & 0x1FF); - ebx = 0x180 - eax; - if(edx < ebx) + TStruct40 * pStruct40 = &pSearch->Struct40; + + // Do we have path fragment separators in an external structure? + if(PathMarks.IsEmpty()) { - // HOTS: 01959E00 - esi = esi & 0x1FF; - eax = (0x140 - esi); - if(edx < eax) + // Keep copying as long as we don't reach the end of the search mask + while(pStruct40->PathLength < pSearch->cchSearchMask) { - // HOTS: 1959E11 - edi = edi + 8; - edx = edx + ecx - 0x100; + // HOTS: 195A5A0 + if(PathFragments[nFragmentOffset] != pSearch->szSearchMask[pStruct40->PathLength]) + return false; + + // HOTS: 195A5B7 + pStruct40->PathBuffer.Insert(PathFragments[nFragmentOffset++]); + pStruct40->PathLength++; + + // If we found the end of the fragment, return success + if(PathFragments[nFragmentOffset] == 0) + return true; } - else + + // HOTS: 195A660 + // Now we need to copy the rest of the fragment + while(PathFragments[nFragmentOffset] != 0) { - // HOTS: 1959E1D - edi = edi + 0x0A; - edx = edx + esi - 0x140; + pStruct40->PathBuffer.Insert(PathFragments[nFragmentOffset]); + nFragmentOffset++; } } else { - // HOTS: 1959E29 - esi = (esi >> 0x12) & 0x1FF; - ecx = (0x1C0 - esi); - if(edx < ecx) + // Keep copying as long as we don't reach the end of the search mask + while(nFragmentOffset < pSearch->cchSearchMask) { - // HOTS: 1959E3D - edi = edi + 0x0C; - edx = edx + eax - 0x180; + if(PathFragments[nFragmentOffset] != pSearch->szSearchMask[pStruct40->PathLength]) + return false; + + pStruct40->PathBuffer.Insert(PathFragments[nFragmentOffset]); + pStruct40->PathLength++; + + // If we found the end of the fragment, return success + if(PathMarks.IsItemPresent(nFragmentOffset++)) + return true; } - else + + // Now we need to copy the rest of the fragment + while(!PathMarks.IsItemPresent(nFragmentOffset)) { - // HOTS: 1959E49 - edi = edi + 0x0E; - edx = edx + esi - 0x1C0; + // HOTS: 195A7A6 + pStruct40->PathBuffer.Insert(PathFragments[nFragmentOffset++]); } } - } - // HOTS: 1959E53: - // Calculate the number of bits set in the value of "ecx" - ecx = ~Struct68_00.ItemBits.Uint32Array[edi]; - eax = GetNumberOfSetBits(ecx); - esi = eax >> 0x18; + return true; + } - if(edx >= esi) + // HOTS: 0195A820 + int LoadFromStream(TByteStream & InStream) { - // HOTS: 1959ea4 - ecx = ~Struct68_00.ItemBits.Uint32Array[++edi]; - edx = edx - esi; - eax = GetNumberOfSetBits(ecx); + int nError; + + nError = PathFragments.LoadFromStream(InStream); + if(nError != ERROR_SUCCESS) + return nError; + + return PathMarks.LoadFromStream(InStream); } - // HOTS: 1959eea - // ESI gets the number of set bits in the lower 16 bits of ECX - esi = (eax >> 0x08) & 0xFF; - edi = edi << 0x05; - if(edx < esi) + TGenericArray<char> PathFragments; + TSparseArray PathMarks; +}; + +//----------------------------------------------------------------------------- +// TStruct10 functions + +class TStruct10 +{ + public: + + TStruct10() { - // HOTS: 1959EFC - eax = eax & 0xFF; - if(edx >= eax) - { - // HOTS: 1959F05 - ecx >>= 0x08; - edi += 0x08; - edx -= eax; - } + field_0 = 0x03; + field_4 = 0x200; + field_8 = 0x1000; + field_C = 0x20000; } - else + + // HOTS: 1956FD0 + int sub_1956FD0(DWORD dwBitMask) { - // HOTS: 1959F0D - eax = (eax >> 0x10) & 0xFF; - if(edx < eax) + switch(dwBitMask & 0xF80) { - // HOTS: 1959F19 - ecx >>= 0x10; - edi += 0x10; - edx -= esi; - } - else - { - // HOTS: 1959F23 - ecx >>= 0x18; - edi += 0x18; - edx -= eax; - } - } - - // HOTS: 1959f2b - edx = edx << 0x08; - ecx = ecx & 0xFF; + case 0x00: + field_4 = 0x200; + return ERROR_SUCCESS; - // BUGBUG: Possible buffer overflow here. Happens when dwItemIndex >= 0x9C. - // The same happens in Heroes of the Storm (build 29049), so I am not sure - // if this is a bug or a case that never happens - assert((ecx + edx) < sizeof(table_1BA1818)); - return table_1BA1818[ecx + edx] + edi; -} + case 0x80: + field_4 = 0x80; + return ERROR_SUCCESS; -DWORD TFileNameDatabase::sub_1959F50(DWORD arg_0) -{ - PTRIPLET pTriplet; - PDWORD ItemArray; - DWORD eax, ebx, ecx, edx, esi, edi; + case 0x100: + field_4 = 0x100; + return ERROR_SUCCESS; - edx = arg_0; - eax = arg_0 >> 0x09; - if((arg_0 & 0x1FF) == 0) - return Struct68_00.ArrayDwords_50.Uint32Array[eax]; + case 0x200: + field_4 = 0x200; + return ERROR_SUCCESS; - ItemArray = Struct68_00.ArrayDwords_50.Uint32Array + eax; - eax = (ItemArray[0] >> 0x09); - edi = (ItemArray[1] + 0x1FF) >> 0x09; + case 0x400: + field_4 = 0x400; + return ERROR_SUCCESS; - if((eax + 0x0A) > edi) - { - // HOTS: 01959F94 - pTriplet = Struct68_00.BaseValues.TripletArray + eax + 1; - while(edx >= pTriplet->BaseValue) - { - // HOTS: 1959FA3 - pTriplet++; - eax++; + case 0x800: + field_4 = 0x800; + return ERROR_SUCCESS; } + + return ERROR_INVALID_PARAMETER; } - else + + // HOTS: 1957050 + int sub_1957050(DWORD dwBitMask) { - // Binary search - // HOTS: 1959FAD - if((eax + 1) < edi) + switch(dwBitMask & 0xF0000) { - // HOTS: 1959FB4 - esi = (edi + eax) >> 1; - if(edx < Struct68_00.BaseValues.TripletArray[esi].BaseValue) - { - // HOTS: 1959FC4 - edi = esi; - } - else - { - // HOTS: 1959FC8 - eax = esi; - } + case 0x00: + field_C = 0x20000; + return ERROR_SUCCESS; + + case 0x10000: + field_C = 0x10000; + return ERROR_SUCCESS; + + case 0x20000: + field_C = 0x20000; + return ERROR_SUCCESS; } + + return ERROR_INVALID_PARAMETER; } - // HOTS: 1959FD4 - pTriplet = Struct68_00.BaseValues.TripletArray + eax; - edx = edx - pTriplet->BaseValue; - edi = eax << 0x04; - eax = pTriplet->Value2; - ebx = (eax >> 0x17); - if(edx < ebx) + // HOTS: 19572E0 + int sub_19572E0(DWORD dwBitMask) { - // HOTS: 1959FF1 - esi = (eax >> 0x07) & 0xFF; - if(edx < esi) + DWORD dwSubMask; + int nError; + + if(dwBitMask & 0xFFF00000) + return ERROR_INVALID_PARAMETER; + + dwSubMask = dwBitMask & 0x7F; + if(dwSubMask) + field_0 = dwSubMask; + + nError = sub_1956FD0(dwBitMask); + if(nError != ERROR_SUCCESS) + return nError; + + dwSubMask = dwBitMask & 0xF000; + if(dwSubMask == 0 || dwSubMask == 0x1000) { - // HOTS: 0195A000 - eax = eax & 0x7F; - if(edx >= eax) - { - // HOTS: 195A007 - edi = edi + 2; - edx = edx - eax; - } + field_8 = 0x1000; + return sub_1957050(dwBitMask); } - else + + if(dwSubMask == 0x2000) { - // HOTS: 195A00E - eax = (eax >> 0x0F) & 0xFF; - if(edx < eax) - { - // HOTS: 195A01A - edi += 4; - edx = edx - esi; - } - else - { - // HOTS: 195A01F - edi += 6; - edx = edx - eax; - } + field_8 = 0x2000; + return sub_1957050(dwBitMask); } + + return ERROR_INVALID_PARAMETER; } - else + + // HOTS: 1957800 + int sub_1957800(DWORD dwBitMask) { - // HOTS: 195A026 - esi = pTriplet->Value3; - eax = (pTriplet->Value3 >> 0x09) & 0x1FF; - if(edx < eax) - { - // HOTS: 195A037 - esi = esi & 0x1FF; - if(edx < esi) - { - // HOTS: 195A041 - edi = edi + 8; - edx = edx - ebx; - } - else - { - // HOTS: 195A048 - edi = edi + 0x0A; - edx = edx - esi; - } - } - else - { - // HOTS: 195A04D - esi = (esi >> 0x12) & 0x1FF; - if(edx < esi) - { - // HOTS: 195A05A - edi = edi + 0x0C; - edx = edx - eax; - } - else - { - // HOTS: 195A061 - edi = edi + 0x0E; - edx = edx - esi; - } - } + return sub_19572E0(dwBitMask); } - // HOTS: 195A066 - esi = Struct68_00.ItemBits.Uint32Array[edi]; - eax = GetNumberOfSetBits(esi); - ecx = eax >> 0x18; + DWORD field_0; + DWORD field_4; + DWORD field_8; + DWORD field_C; +}; + +//----------------------------------------------------------------------------- +// TFileNameDatabase interface/implementation + +class TFileNameDatabase +{ + public: - if(edx >= ecx) + // HOTS: 01958730 + TFileNameDatabase() { - // HOTS: 195A0B2 - esi = Struct68_00.ItemBits.Uint32Array[++edi]; - edx = edx - ecx; - eax = GetNumberOfSetBits(esi); + HashTableMask = 0; + field_214 = 0; + pChildDB = NULL; } - // HOTS: 195A0F6 - ecx = (eax >> 0x08) & 0xFF; + ~TFileNameDatabase() + { + delete pChildDB; + } - edi = (edi << 0x05); - if(edx < ecx) + // Returns nonzero if the name fragment match is a single-char match + bool IsPathFragmentSingleChar(HASH_ENTRY * pHashEntry) { - // HOTS: 195A111 - eax = eax & 0xFF; - if(edx >= eax) - { - // HOTS: 195A111 - edi = edi + 0x08; - esi = esi >> 0x08; - edx = edx - eax; - } + return ((pHashEntry->FragmentOffset & 0xFFFFFF00) == 0xFFFFFF00); + } + + // Returns true if the given collision path fragment is a string (aka more than 1 char) + bool IsPathFragmentString(size_t index) + { + return CollisionHiBitsIndexes.IsItemPresent(index); } - else + + // HOTS: 1957350, inlined + DWORD GetPathFragmentOffset1(DWORD index_lobits) { - // HOTS: 195A119 - eax = (eax >> 0x10) & 0xFF; - if(edx < eax) + DWORD index_hibits = CollisionHiBitsIndexes.GetItemValueAt(index_lobits); + + return (HiBitsTable.GetItem(index_hibits) << 0x08) | LoBitsTable[index_lobits]; + } + + // Retrieves fragment_offset/subtable_index of the path fragment, with check for starting value + DWORD GetPathFragmentOffset2(DWORD & index_hibits, DWORD index_lobits) + { + // If the hi-bits index is invalid, we need to get its starting value + if (index_hibits == CASC_INVALID_INDEX) { - // HOTS: 195A125 - esi = esi >> 0x10; - edi = edi + 0x10; - edx = edx - ecx; +/* + printf("\n"); + for (DWORD i = 0; i < CollisionHiBitsIndexes.TotalItemCount; i++) + { + if (CollisionHiBitsIndexes.IsItemPresent(i)) + printf("[%02X] = %02X\n", i, CollisionHiBitsIndexes.GetIntValueAt(i)); + else + printf("[%02X] = NOT_PRESENT\n", i); + } +*/ + index_hibits = CollisionHiBitsIndexes.GetItemValueAt(index_lobits); } else { - // HOTS: 195A12F - esi = esi >> 0x18; - edi = edi + 0x18; - edx = edx - eax; + index_hibits++; } + + // Now we use both NodeIndex and HiBits index for retrieving the path fragment index + return (HiBitsTable.GetItem(index_hibits) << 0x08) | LoBitsTable[index_lobits]; } - esi = esi & 0xFF; - edx = edx << 0x08; + // HOTS: 1956DA0 + int Load(LPBYTE pbMarData, size_t cbMarData) + { + TByteStream ByteStream; + DWORD dwSignature; + int nError; - // BUGBUG: Potential buffer overflow - // Happens in Heroes of the Storm when arg_0 == 0x5B - assert((esi + edx) < sizeof(table_1BA1818)); - return table_1BA1818[esi + edx] + edi; -} + if(pbMarData == NULL && cbMarData != 0) + return ERROR_INVALID_PARAMETER; -// HOTS: 1957970 -bool TFileNameDatabase::CheckNextPathFragment(TMndxFindResult * pStruct1C) -{ - TStruct40 * pStruct40 = pStruct1C->pStruct40; - LPBYTE pbPathName = (LPBYTE)pStruct1C->szSearchMask; - DWORD CollisionIndex; - DWORD NameFragIndex; - DWORD SaveCharIndex; - DWORD HiBitsIndex; - DWORD FragOffs; - - // Calculate index of the next name fragment in the name fragment table - NameFragIndex = ((pStruct40->ItemIndex << 0x05) ^ pStruct40->ItemIndex ^ pbPathName[pStruct40->CharIndex]) & NameFragIndexMask; - - // Does the hash value match? - if(NameFragTable.NameFragArray[NameFragIndex].ItemIndex == pStruct40->ItemIndex) - { - // Check if there is single character match - if(IS_SINGLE_CHAR_MATCH(NameFragTable, NameFragIndex)) + nError = ByteStream.SetByteBuffer(pbMarData, cbMarData); + if(nError == ERROR_SUCCESS) { - pStruct40->ItemIndex = NameFragTable.NameFragArray[NameFragIndex].NextIndex; - pStruct40->CharIndex++; - return true; - } + // Get pointer to MAR signature + nError = ByteStream.GetValue<DWORD>(dwSignature); + if(nError != ERROR_SUCCESS) + return nError; - // Check if there is a name fragment match - if(NextDB.pDB != NULL) - { - if(!NextDB.pDB->sub_1957B80(pStruct1C, NameFragTable.NameFragArray[NameFragIndex].FragOffs)) - return false; - } - else - { - if(!IndexStruct_174.CheckNameFragment(pStruct1C, NameFragTable.NameFragArray[NameFragIndex].FragOffs)) - return false; + // Verify the signature + if(dwSignature != MNDX_MAR_SIGNATURE) + return ERROR_BAD_FORMAT; + + // HOTS: 1956E11 + nError = LoadFromStream(ByteStream); } - pStruct40->ItemIndex = NameFragTable.NameFragArray[NameFragIndex].NextIndex; - return true; + return nError; } - // - // Conflict: Multiple hashes give the same table index - // + // HOTS: 19584B0 + int SetChildDatabase(TFileNameDatabase * pNewDB) + { + if(pNewDB != NULL && pChildDB == pNewDB) + return ERROR_INVALID_PARAMETER; - // HOTS: 1957A0E - CollisionIndex = sub_1959CB0(pStruct40->ItemIndex) + 1; - if(!Struct68_00.IsItemPresent(CollisionIndex)) - return false; + if(pChildDB != NULL) + delete pChildDB; + pChildDB = pNewDB; + return ERROR_SUCCESS; + } - pStruct40->ItemIndex = (CollisionIndex - pStruct40->ItemIndex - 1); - HiBitsIndex = 0xFFFFFFFF; + // HOTS: 1957970 + bool ComparePathFragment(TMndxSearch * pSearch) + { + TStruct40 * pStruct40 = &pSearch->Struct40; + PHASH_ENTRY pHashEntry; + DWORD ColTableIndex; + DWORD HiBitsIndex; + DWORD NodeIndex; -// CascDumpSparseArray("E:\\casc-array-68.txt", &FileNameIndexes); -// CascDumpSparseArray("E:\\casc-array-D0.txt", &Struct68_D0); + // Calculate the item hash from the current char and fragment ID + NodeIndex = pStruct40->CalcHashValue(pSearch->szSearchMask) & HashTableMask; + pHashEntry = &HashTable[NodeIndex]; - // HOTS: 1957A41: - do - { - // HOTS: 1957A41 - // Check if the low 8 bits if the fragment offset contain a single character - // or an offset to a name fragment - if(Struct68_D0.IsItemPresent(pStruct40->ItemIndex)) + // Does the hash value ID match? + if(pHashEntry->NodeIndex == pStruct40->NodeIndex) { - if(HiBitsIndex == 0xFFFFFFFF) + // Check if there is single character match + if (!IsPathFragmentSingleChar(pHashEntry)) { - // HOTS: 1957A6C - HiBitsIndex = Struct68_D0.GetItemValue(pStruct40->ItemIndex); + // Check if there is a name fragment match + if (pChildDB != NULL) + { + if (!pChildDB->ComparePathFragmentByIndex(pSearch, pHashEntry->ChildTableIndex)) + return false; + } + else + { + if (!PathFragmentTable.ComparePathFragment(pSearch, pHashEntry->FragmentOffset)) + return false; + } } else { - // HOTS: 1957A7F - HiBitsIndex++; + pStruct40->PathLength++; } - // HOTS: 1957A83 - SaveCharIndex = pStruct40->CharIndex; + pStruct40->NodeIndex = pHashEntry->NextIndex; + return true; + } + + // + // Conflict: Multiple node IDs give the same table index + // - // Get the name fragment offset as combined value from lower 8 bits and upper bits - FragOffs = GetNameFragmentOffsetEx(pStruct40->ItemIndex, HiBitsIndex); + // HOTS: 1957A0E + ColTableIndex = CollisionTable.GetItem0(pStruct40->NodeIndex) + 1; + pStruct40->NodeIndex = (ColTableIndex - pStruct40->NodeIndex - 1); + HiBitsIndex = CASC_INVALID_INDEX; - // Compare the string with the fragment name database - if(NextDB.pDB != NULL) + // HOTS: 1957A41: + while(CollisionTable.IsItemPresent(ColTableIndex)) + { + // HOTS: 1957A41 + // Check if the low 8 bits if the fragment offset contain a single character + // or an offset to a name fragment + if(IsPathFragmentString(pStruct40->NodeIndex)) { - // HOTS: 1957AEC - if(NextDB.pDB->sub_1957B80(pStruct1C, FragOffs)) - return true; + DWORD FragmentOffset = GetPathFragmentOffset2(HiBitsIndex, pStruct40->NodeIndex); + DWORD SavePathLength = pStruct40->PathLength; // HOTS: 1957A83 + + // Do we have a child database? + if(pChildDB != NULL) + { + // HOTS: 1957AEC + if(pChildDB->ComparePathFragmentByIndex(pSearch, FragmentOffset)) + return true; + } + else + { + // HOTS: 1957AF7 + if(PathFragmentTable.ComparePathFragment(pSearch, FragmentOffset)) + return true; + } + + // HOTS: 1957B0E + // If there was partial match with the fragment, end the search + if(pStruct40->PathLength != SavePathLength) + return false; } else { - // HOTS: 1957AF7 - if(IndexStruct_174.CheckNameFragment(pStruct1C, FragOffs)) + // HOTS: 1957B1C + if(LoBitsTable[pStruct40->NodeIndex] == pSearch->szSearchMask[pStruct40->PathLength]) + { + pStruct40->PathLength++; return true; + } } - // HOTS: 1957B0E - // If there was partial match with the fragment, end the search - if(pStruct40->CharIndex != SaveCharIndex) - return false; - } - else - { - // HOTS: 1957B1C - if(FrgmDist_LoBits.ByteArray[pStruct40->ItemIndex] == pStruct1C->szSearchMask[pStruct40->CharIndex]) - { - pStruct40->CharIndex++; - return true; - } + // HOTS: 1957B32 + pStruct40->NodeIndex++; + ColTableIndex++; } - // HOTS: 1957B32 - pStruct40->ItemIndex++; - CollisionIndex++; + return false; } - while(Struct68_00.IsItemPresent(CollisionIndex)); - return false; -} - -// HOTS: 1957B80 -bool TFileNameDatabase::sub_1957B80(TMndxFindResult * pStruct1C, DWORD arg_4) -{ - TStruct40 * pStruct40 = pStruct1C->pStruct40; - PNAME_FRAG pNameEntry; - DWORD FragOffs; - DWORD eax, edi; - - edi = arg_4; - // HOTS: 1957B95 - for(;;) + // HOTS: 1957B80 + bool ComparePathFragmentByIndex(TMndxSearch * pSearch, DWORD TableIndex) { - pNameEntry = NameFragTable.NameFragArray + (edi & NameFragIndexMask); - if(edi == pNameEntry->NextIndex) + TStruct40 * pStruct40 = &pSearch->Struct40; + PHASH_ENTRY pHashEntry; + DWORD eax; + + // HOTS: 1957B95 + for (;;) { - // HOTS: 01957BB4 - if((pNameEntry->FragOffs & 0xFFFFFF00) != 0xFFFFFF00) + // Get the hasn table item + pHashEntry = &HashTable[TableIndex & HashTableMask]; + + // + if (TableIndex == pHashEntry->NextIndex) { - // HOTS: 1957BC7 - if(NextDB.pDB != NULL) + // HOTS: 01957BB4 + if (!IsPathFragmentSingleChar(pHashEntry)) { - // HOTS: 1957BD3 - if(!NextDB.pDB->sub_1957B80(pStruct1C, pNameEntry->FragOffs)) - return false; + // HOTS: 1957BC7 + if (pChildDB != NULL) + { + // HOTS: 1957BD3 + if (!pChildDB->ComparePathFragmentByIndex(pSearch, pHashEntry->ChildTableIndex)) + return false; + } + else + { + // HOTS: 1957BE0 + if (!PathFragmentTable.ComparePathFragment(pSearch, pHashEntry->FragmentOffset)) + return false; + } } else { - // HOTS: 1957BE0 - if(!IndexStruct_174.CheckNameFragment(pStruct1C, pNameEntry->FragOffs)) + // HOTS: 1957BEE + if (pSearch->szSearchMask[pStruct40->PathLength] != pHashEntry->SingleChar) return false; + pStruct40->PathLength++; } - } - else - { - // HOTS: 1957BEE - if(pStruct1C->szSearchMask[pStruct40->CharIndex] != (char)pNameEntry->FragOffs) - return false; - pStruct40->CharIndex++; - } - // HOTS: 1957C05 - edi = pNameEntry->ItemIndex; - if(edi == 0) - return true; + // HOTS: 1957C05 + TableIndex = pHashEntry->NodeIndex; + if (TableIndex == 0) + return true; - if(pStruct40->CharIndex >= pStruct1C->cchSearchMask) - return false; - } - else - { - // HOTS: 1957C30 - if(Struct68_D0.IsItemPresent(edi)) + if (pStruct40->PathLength >= pSearch->cchSearchMask) + return false; + } + else { - // HOTS: 1957C4C - if(NextDB.pDB != NULL) + // HOTS: 1957C30 + if (IsPathFragmentString(TableIndex)) { - // HOTS: 1957C58 - FragOffs = GetNameFragmentOffset(edi); - if(!NextDB.pDB->sub_1957B80(pStruct1C, FragOffs)) - return false; + DWORD FragmentOffset = GetPathFragmentOffset1(TableIndex); + + // HOTS: 1957C4C + if (pChildDB != NULL) + { + // HOTS: 1957C58 + if (!pChildDB->ComparePathFragmentByIndex(pSearch, FragmentOffset)) + return false; + } + else + { + // HOTS: 1957350 + if (!PathFragmentTable.ComparePathFragment(pSearch, FragmentOffset)) + return false; + } } else { - // HOTS: 1957350 - FragOffs = GetNameFragmentOffset(edi); - if(!IndexStruct_174.CheckNameFragment(pStruct1C, FragOffs)) + // HOTS: 1957C8E + if (LoBitsTable[TableIndex] != pSearch->szSearchMask[pStruct40->PathLength]) return false; - } - } - else - { - // HOTS: 1957C8E - if(FrgmDist_LoBits.ByteArray[edi] != pStruct1C->szSearchMask[pStruct40->CharIndex]) - return false; - pStruct40->CharIndex++; - } + pStruct40->PathLength++; + } - // HOTS: 1957CB2 - if(edi <= field_214) - return true; + // HOTS: 1957CB2 + if (TableIndex <= field_214) + return true; - if(pStruct40->CharIndex >= pStruct1C->cchSearchMask) - return false; + if (pStruct40->PathLength >= pSearch->cchSearchMask) + return false; - eax = sub_1959F50(edi); - edi = (eax - edi - 1); + eax = CollisionTable.GetItem1(TableIndex); + TableIndex = (eax - TableIndex - 1); + } } } -} -// HOTS: 1958D70 -void TFileNameDatabase::sub_1958D70(TMndxFindResult * pStruct1C, DWORD arg_4) -{ - TStruct40 * pStruct40 = pStruct1C->pStruct40; - PNAME_FRAG pNameEntry; - - // HOTS: 1958D84 - for(;;) + // HOTS: 1958D70 + void CopyPathFragmentByIndex(TMndxSearch * pSearch, DWORD TableIndex) { - pNameEntry = NameFragTable.NameFragArray + (arg_4 & NameFragIndexMask); - if(arg_4 == pNameEntry->NextIndex) + TStruct40 * pStruct40 = &pSearch->Struct40; + PHASH_ENTRY pHashEntry; + + // HOTS: 1958D84 + for (;;) { - // HOTS: 1958DA6 - if((pNameEntry->FragOffs & 0xFFFFFF00) != 0xFFFFFF00) + pHashEntry = &HashTable[TableIndex & HashTableMask]; + if (TableIndex == pHashEntry->NextIndex) { - // HOTS: 1958DBA - if(NextDB.pDB != NULL) + // HOTS: 1958DA6 + if (!IsPathFragmentSingleChar(pHashEntry)) { - NextDB.pDB->sub_1958D70(pStruct1C, pNameEntry->FragOffs); + // HOTS: 1958DBA + if (pChildDB != NULL) + { + pChildDB->CopyPathFragmentByIndex(pSearch, pHashEntry->ChildTableIndex); + } + else + { + PathFragmentTable.CopyPathFragment(pSearch, pHashEntry->FragmentOffset); + } } else { - IndexStruct_174.CopyNameFragment(pStruct1C, pNameEntry->FragOffs); + // HOTS: 1958DE7 + // Insert the low 8 bits to the path being built + pStruct40->PathBuffer.Insert(pHashEntry->SingleChar); } + + // HOTS: 1958E71 + TableIndex = pHashEntry->NodeIndex; + if (TableIndex == 0) + return; } else { - // HOTS: 1958DE7 - // Insert the low 8 bits to the path being built - pStruct40->array_00.InsertOneItem_CHAR((char)(pNameEntry->FragOffs & 0xFF)); - } - - // HOTS: 1958E71 - arg_4 = pNameEntry->ItemIndex; - if(arg_4 == 0) - return; - } - else - { - // HOTS: 1958E8E - if(Struct68_D0.IsItemPresent(arg_4)) - { - DWORD FragOffs; - - // HOTS: 1958EAF - FragOffs = GetNameFragmentOffset(arg_4); - if(NextDB.pDB != NULL) + // HOTS: 1958E8E + if (IsPathFragmentString(TableIndex)) { - NextDB.pDB->sub_1958D70(pStruct1C, FragOffs); + DWORD FragmentOffset = GetPathFragmentOffset1(TableIndex); + + // HOTS: 1958EAF + if (pChildDB != NULL) + { + pChildDB->CopyPathFragmentByIndex(pSearch, FragmentOffset); + } + else + { + PathFragmentTable.CopyPathFragment(pSearch, FragmentOffset); + } } else { - IndexStruct_174.CopyNameFragment(pStruct1C, FragOffs); + // HOTS: 1958F50 + // Insert one character to the path being built + pStruct40->PathBuffer.Insert(LoBitsTable[TableIndex]); } - } - else - { - // HOTS: 1958F50 - // Insert one character to the path being built - pStruct40->array_00.InsertOneItem_CHAR(FrgmDist_LoBits.CharArray[arg_4]); - } - // HOTS: 1958FDE - if(arg_4 <= field_214) - return; + // HOTS: 1958FDE + if (TableIndex <= field_214) + return; - arg_4 = 0xFFFFFFFF - arg_4 + sub_1959F50(arg_4); + TableIndex = 0xFFFFFFFF - TableIndex + CollisionTable.GetItem1(TableIndex); + } } } -} - -// HOTS: 1959010 -bool TFileNameDatabase::sub_1959010(TMndxFindResult * pStruct1C, DWORD arg_4) -{ - TStruct40 * pStruct40 = pStruct1C->pStruct40; - PNAME_FRAG pNameEntry; - // HOTS: 1959024 - for(;;) + // HOTS: 1958B00 + bool CompareAndCopyPathFragment(TMndxSearch * pSearch) { - pNameEntry = NameFragTable.NameFragArray + (arg_4 & NameFragIndexMask); - if(arg_4 == pNameEntry->NextIndex) + TStruct40 * pStruct40 = &pSearch->Struct40; + PHASH_ENTRY pHashEntry; + DWORD HiBitsIndex; + DWORD ColTableIndex; + DWORD TableIndex; +/* + FILE * fp = fopen("E:\\PathFragmentTable.txt", "wt"); + if (fp != NULL) { - // HOTS: 1959047 - if((pNameEntry->FragOffs & 0xFFFFFF00) != 0xFFFFFF00) + for (DWORD i = 0; i < HashTable.ItemCount; i++) { - // HOTS: 195905A - if(NextDB.pDB != NULL) - { - if(!NextDB.pDB->sub_1959010(pStruct1C, pNameEntry->FragOffs)) - return false; - } - else + FragOffs = HashTable[i].FragOffs; + fprintf(fp, "%02x ('%c') %08X %08X %08X", i, (0x20 <= i && i < 0x80) ? i : 0x20, HashTable[i].ItemIndex, HashTable[i].NextIndex, FragOffs); + + if(FragOffs != 0x00800000) { - if(!IndexStruct_174.CheckAndCopyNameFragment(pStruct1C, pNameEntry->FragOffs)) - return false; + if((FragOffs & 0xFFFFFF00) == 0xFFFFFF00) + fprintf(fp, " '%c'", (char)(FragOffs & 0xFF)); + else + fprintf(fp, " %s", &PathFragmentTable.PathFragments[FragOffs]); } - } - else - { - // HOTS: 1959092 - if((char)(pNameEntry->FragOffs & 0xFF) != pStruct1C->szSearchMask[pStruct40->CharIndex]) - return false; - - // Insert the low 8 bits to the path being built - pStruct40->array_00.InsertOneItem_CHAR((char)(pNameEntry->FragOffs & 0xFF)); - pStruct40->CharIndex++; + fprintf(fp, "\n"); } - // HOTS: 195912E - arg_4 = pNameEntry->ItemIndex; - if(arg_4 == 0) - return true; + fclose(fp); } - else +*/ + // Calculate the item hash from the current char and fragment ID + TableIndex = pStruct40->CalcHashValue(pSearch->szSearchMask) & HashTableMask; + pHashEntry = &HashTable[TableIndex]; + + // Does the hash value ID match? + if(pStruct40->NodeIndex == pHashEntry->NodeIndex) { - // HOTS: 1959147 - if(Struct68_D0.IsItemPresent(arg_4)) + // If the higher 24 bits are set, then the fragment is just one letter, + // contained directly in the table. + if(!IsPathFragmentSingleChar(pHashEntry)) { - DWORD FragOffs; - - // HOTS: 195917C - FragOffs = GetNameFragmentOffset(arg_4); - if(NextDB.pDB != NULL) + // HOTS: 1958B59 + if (pChildDB != NULL) { - if(!NextDB.pDB->sub_1959010(pStruct1C, FragOffs)) + if (!pChildDB->CompareAndCopyPathFragmentByIndex(pSearch, pHashEntry->ChildTableIndex)) return false; } else { - if(!IndexStruct_174.CheckAndCopyNameFragment(pStruct1C, FragOffs)) + if (!PathFragmentTable.CompareAndCopyPathFragment(pSearch, pHashEntry->FragmentOffset)) return false; } } else { - // HOTS: 195920E - if(FrgmDist_LoBits.CharArray[arg_4] != pStruct1C->szSearchMask[pStruct40->CharIndex]) - return false; - - // Insert one character to the path being built - pStruct40->array_00.InsertOneItem_CHAR(FrgmDist_LoBits.CharArray[arg_4]); - pStruct40->CharIndex++; - } - - // HOTS: 19592B6 - if(arg_4 <= field_214) - return true; - - arg_4 = 0xFFFFFFFF - arg_4 + sub_1959F50(arg_4); - } - - // HOTS: 19592D5 - if(pStruct40->CharIndex >= pStruct1C->cchSearchMask) - break; - } - - sub_1958D70(pStruct1C, arg_4); - return true; -} - -// HOTS: 1959460 -bool TFileNameDatabase::sub_1959460(TMndxFindResult * pStruct1C) -{ - TStruct40 * pStruct40 = pStruct1C->pStruct40; - PPATH_STOP pPathStop; - PATH_STOP PathStop; - DWORD NewMaxItemCount; - DWORD FragOffs; - DWORD edi; - - if(pStruct40->SearchPhase == CASC_SEARCH_FINISHED) - return false; - - if(pStruct40->SearchPhase != CASC_SEARCH_SEARCHING) - { - // HOTS: 1959489 - pStruct40->InitSearchBuffers(); - - // If the caller passed a part of the search path, we need to find that one - while(pStruct40->CharIndex < pStruct1C->cchSearchMask) - { - if(!sub_1958B00(pStruct1C)) - { - pStruct40->SearchPhase = CASC_SEARCH_FINISHED; - return false; + // HOTS: 1958B88 + pStruct40->PathBuffer.Insert(pHashEntry->SingleChar); + pStruct40->PathLength++; } - } - - // HOTS: 19594b0 - PathStop.ItemIndex = pStruct40->ItemIndex; - PathStop.field_4 = 0; - PathStop.field_8 = pStruct40->array_00.ItemCount; - PathStop.field_C = 0xFFFFFFFF; - PathStop.field_10 = 0xFFFFFFFF; - pStruct40->PathStops.InsertOneItem_PATH_STOP(PathStop); - pStruct40->ItemCount = 1; - if(FileNameIndexes.IsItemPresent(pStruct40->ItemIndex)) - { - pStruct1C->szFoundPath = pStruct40->array_00.FirstValid.Chars; - pStruct1C->cchFoundPath = pStruct40->array_00.ItemCount; - pStruct1C->FileNameIndex = FileNameIndexes.GetItemValue(pStruct40->ItemIndex); + // HOTS: 1958BCA + pStruct40->NodeIndex = pHashEntry->NextIndex; return true; } - } - // HOTS: 1959522 - for(;;) - { - // HOTS: 1959530 - if(pStruct40->ItemCount == pStruct40->PathStops.ItemCount) - { - PPATH_STOP pLastStop; - DWORD CollisionIndex; - - pLastStop = pStruct40->PathStops.FirstValid.PathStopPtr + pStruct40->PathStops.ItemCount - 1; - CollisionIndex = sub_1959CB0(pLastStop->ItemIndex) + 1; - - // Insert a new structure - PathStop.ItemIndex = CollisionIndex - pLastStop->ItemIndex - 1;; - PathStop.field_4 = CollisionIndex; - PathStop.field_8 = 0; - PathStop.field_C = 0xFFFFFFFF; - PathStop.field_10 = 0xFFFFFFFF; - pStruct40->PathStops.InsertOneItem_PATH_STOP(PathStop); - } - - // HOTS: 19595BD - pPathStop = pStruct40->PathStops.FirstValid.PathStopPtr + pStruct40->ItemCount; + // HOTS: 1958BE5 + ColTableIndex = CollisionTable.GetItem0(pStruct40->NodeIndex) + 1; + pStruct40->NodeIndex = (ColTableIndex - pStruct40->NodeIndex - 1); + HiBitsIndex = CASC_INVALID_INDEX; - // HOTS: 19595CC - if(Struct68_00.IsItemPresent(pPathStop->field_4++)) + // Keep searching while we have a valid collision table entry + while(CollisionTable.IsItemPresent(ColTableIndex)) { - // HOTS: 19595F2 - pStruct40->ItemCount++; - - if(Struct68_D0.IsItemPresent(pPathStop->ItemIndex)) + // If we have high bits in the the bit at NodeIndex is set, it means that there is fragment offset + // If not, the byte in LoBitsTable is the character + if(IsPathFragmentString(pStruct40->NodeIndex)) { - // HOTS: 1959617 - if(pPathStop->field_C == 0xFFFFFFFF) - pPathStop->field_C = Struct68_D0.GetItemValue(pPathStop->ItemIndex); - else - pPathStop->field_C++; + DWORD FragmentOffset = GetPathFragmentOffset2(HiBitsIndex, pStruct40->NodeIndex); + DWORD SavePathLength = pStruct40->PathLength; // HOTS: 1958C62 - // HOTS: 1959630 - FragOffs = GetNameFragmentOffsetEx(pPathStop->ItemIndex, pPathStop->field_C); - if(NextDB.pDB != NULL) + // Do we have a child database? + if(pChildDB != NULL) { - // HOTS: 1959649 - NextDB.pDB->sub_1958D70(pStruct1C, FragOffs); + // HOTS: 1958CCB + if(pChildDB->CompareAndCopyPathFragmentByIndex(pSearch, FragmentOffset)) + return true; } else { - // HOTS: 1959654 - IndexStruct_174.CopyNameFragment(pStruct1C, FragOffs); + // HOTS: 1958CD6 + if(PathFragmentTable.CompareAndCopyPathFragment(pSearch, FragmentOffset)) + return true; } + + // HOTS: 1958CED + if(SavePathLength != pStruct40->PathLength) + return false; } else { - // HOTS: 1959665 - // Insert one character to the path being built - pStruct40->array_00.InsertOneItem_CHAR(FrgmDist_LoBits.CharArray[pPathStop->ItemIndex]); + // HOTS: 1958CFB + if(LoBitsTable[pStruct40->NodeIndex] == pSearch->szSearchMask[pStruct40->PathLength]) + { + // HOTS: 1958D11 + pStruct40->PathBuffer.Insert(LoBitsTable[pStruct40->NodeIndex]); + pStruct40->PathLength++; + return true; + } } - // HOTS: 19596AE - pPathStop->field_8 = pStruct40->array_00.ItemCount; + // HOTS: 1958D11 + pStruct40->NodeIndex++; + ColTableIndex++; + } + + return false; + } + + // HOTS: 1959010 + bool CompareAndCopyPathFragmentByIndex(TMndxSearch * pSearch, DWORD TableIndex) + { + TStruct40 * pStruct40 = &pSearch->Struct40; + PHASH_ENTRY pHashEntry; - // HOTS: 19596b6 - if(FileNameIndexes.IsItemPresent(pPathStop->ItemIndex)) + // HOTS: 1959024 + for(;;) + { + pHashEntry = &HashTable[TableIndex & HashTableMask]; + if(TableIndex == pHashEntry->NextIndex) { - // HOTS: 19596D1 - if(pPathStop->field_10 == 0xFFFFFFFF) + // HOTS: 1959047 + if(!IsPathFragmentSingleChar(pHashEntry)) { - // HOTS: 19596D9 - pPathStop->field_10 = FileNameIndexes.GetItemValue(pPathStop->ItemIndex); + // HOTS: 195905A + if(pChildDB != NULL) + { + if(!pChildDB->CompareAndCopyPathFragmentByIndex(pSearch, pHashEntry->ChildTableIndex)) + return false; + } + else + { + if(!PathFragmentTable.CompareAndCopyPathFragment(pSearch, pHashEntry->FragmentOffset)) + return false; + } } else { - pPathStop->field_10++; + // HOTS: 1959092 + if(pHashEntry->SingleChar != pSearch->szSearchMask[pStruct40->PathLength]) + return false; + + // Insert the low 8 bits to the path being built + pStruct40->PathBuffer.Insert(pHashEntry->SingleChar); + pStruct40->PathLength++; } - // HOTS: 1959755 - pStruct1C->szFoundPath = pStruct40->array_00.FirstValid.Chars; - pStruct1C->cchFoundPath = pStruct40->array_00.ItemCount; - pStruct1C->FileNameIndex = pPathStop->field_10; - return true; - } - } - else - { - // HOTS: 19596E9 - if(pStruct40->ItemCount == 1) - { - pStruct40->SearchPhase = CASC_SEARCH_FINISHED; - return false; + // HOTS: 195912E + TableIndex = pHashEntry->NodeIndex; + if(TableIndex == 0) + return true; } - - // HOTS: 19596F5 - pPathStop = pStruct40->PathStops.FirstValid.PathStopPtr + pStruct40->ItemCount - 1; - pPathStop->ItemIndex++; - - pPathStop = pStruct40->PathStops.FirstValid.PathStopPtr + pStruct40->ItemCount - 2; - edi = pPathStop->field_8; - - if(edi > pStruct40->array_00.MaxItemCount) + else { - // HOTS: 1959717 - NewMaxItemCount = edi; - - if(pStruct40->array_00.MaxItemCount > (edi / 2)) + // HOTS: 1959147 + if(IsPathFragmentString(TableIndex)) { - if(pStruct40->array_00.MaxItemCount > 0x7FFFFFFF) + // HOTS: 195917C + DWORD FragmentOffset = GetPathFragmentOffset1(TableIndex); + + if(pChildDB != NULL) { - NewMaxItemCount = 0xFFFFFFFF; + if(!pChildDB->CompareAndCopyPathFragmentByIndex(pSearch, FragmentOffset)) + return false; } else { - NewMaxItemCount = pStruct40->array_00.MaxItemCount + pStruct40->array_00.MaxItemCount; + if(!PathFragmentTable.CompareAndCopyPathFragment(pSearch, FragmentOffset)) + return false; } } + else + { + // HOTS: 195920E + if(LoBitsTable[TableIndex] != pSearch->szSearchMask[pStruct40->PathLength]) + return false; - pStruct40->array_00.SetMaxItems_CHARS(NewMaxItemCount); - } + // Insert one character to the path being built + pStruct40->PathBuffer.Insert(LoBitsTable[TableIndex]); + pStruct40->PathLength++; + } - // HOTS: 1959749 - pStruct40->array_00.ItemCount = edi; - pStruct40->ItemCount--; - } - } -} + // HOTS: 19592B6 + if(TableIndex <= field_214) + return true; -// HOTS: 1958B00 -bool TFileNameDatabase::sub_1958B00(TMndxFindResult * pStruct1C) -{ - TStruct40 * pStruct40 = pStruct1C->pStruct40; - LPBYTE pbPathName = (LPBYTE)pStruct1C->szSearchMask; - DWORD CollisionIndex; - DWORD FragmentOffset; - DWORD SaveCharIndex; - DWORD ItemIndex; - DWORD FragOffs; - DWORD var_4; - - ItemIndex = pbPathName[pStruct40->CharIndex] ^ (pStruct40->ItemIndex << 0x05) ^ pStruct40->ItemIndex; - ItemIndex = ItemIndex & NameFragIndexMask; - if(pStruct40->ItemIndex == NameFragTable.NameFragArray[ItemIndex].ItemIndex) - { - // HOTS: 1958B45 - FragmentOffset = NameFragTable.NameFragArray[ItemIndex].FragOffs; - if((FragmentOffset & 0xFFFFFF00) == 0xFFFFFF00) - { - // HOTS: 1958B88 - pStruct40->array_00.InsertOneItem_CHAR((char)FragmentOffset); - pStruct40->ItemIndex = NameFragTable.NameFragArray[ItemIndex].NextIndex; - pStruct40->CharIndex++; - return true; - } + TableIndex = 0xFFFFFFFF - TableIndex + CollisionTable.GetItem1(TableIndex); + } - // HOTS: 1958B59 - if(NextDB.pDB != NULL) - { - if(!NextDB.pDB->sub_1959010(pStruct1C, FragmentOffset)) - return false; - } - else - { - if(!IndexStruct_174.CheckAndCopyNameFragment(pStruct1C, FragmentOffset)) - return false; + // HOTS: 19592D5 + if(pStruct40->PathLength >= pSearch->cchSearchMask) + break; } - // HOTS: 1958BCA - pStruct40->ItemIndex = NameFragTable.NameFragArray[ItemIndex].NextIndex; + CopyPathFragmentByIndex(pSearch, TableIndex); return true; } - // HOTS: 1958BE5 - CollisionIndex = sub_1959CB0(pStruct40->ItemIndex) + 1; - if(!Struct68_00.IsItemPresent(CollisionIndex)) - return false; - - pStruct40->ItemIndex = (CollisionIndex - pStruct40->ItemIndex - 1); - var_4 = 0xFFFFFFFF; - - // HOTS: 1958C20 - for(;;) + // HOTS: 1959460 + bool DoSearch(TMndxSearch * pSearch) { - if(Struct68_D0.IsItemPresent(pStruct40->ItemIndex)) + TStruct40 * pStruct40 = &pSearch->Struct40; + TPathStop * pPathStop; + DWORD edi; + + // Perform action based on the search phase + switch (pStruct40->SearchPhase) { - // HOTS: 1958C0E - if(var_4 == 0xFFFFFFFF) - { - // HOTS: 1958C4B - var_4 = Struct68_D0.GetItemValue(pStruct40->ItemIndex); - } - else + case MNDX_SEARCH_INITIALIZING: { - var_4++; - } + // HOTS: 1959489 + pStruct40->BeginSearch(); - // HOTS: 1958C62 - SaveCharIndex = pStruct40->CharIndex; + // If the caller passed a part of the search path, we need to find that one + while (pStruct40->PathLength < pSearch->cchSearchMask) + { + if (!CompareAndCopyPathFragment(pSearch)) + { + pStruct40->SearchPhase = MNDX_SEARCH_FINISHED; + return false; + } + } - FragOffs = GetNameFragmentOffsetEx(pStruct40->ItemIndex, var_4); - if(NextDB.pDB != NULL) - { - // HOTS: 1958CCB - if(NextDB.pDB->sub_1959010(pStruct1C, FragOffs)) - return true; - } - else - { - // HOTS: 1958CD6 - if(IndexStruct_174.CheckAndCopyNameFragment(pStruct1C, FragOffs)) + // HOTS: 19594b0 + TPathStop PathStop(pStruct40->NodeIndex, 0, pStruct40->PathBuffer.ItemCount); + pStruct40->PathStops.Insert(PathStop); + pStruct40->ItemCount = 1; + + if (FileNameIndexes.IsItemPresent(pStruct40->NodeIndex)) + { + pSearch->szFoundPath = &pStruct40->PathBuffer[0]; + pSearch->cchFoundPath = pStruct40->PathBuffer.ItemCount; + pSearch->nIndex = FileNameIndexes.GetItemValueAt(pStruct40->NodeIndex); return true; + } } + // No break here, go straight to the MNDX_SEARCH_SEARCHING - // HOTS: 1958CED - if(SaveCharIndex != pStruct40->CharIndex) - return false; - } - else - { - // HOTS: 1958CFB - if(FrgmDist_LoBits.ByteArray[pStruct40->ItemIndex] == pStruct1C->szSearchMask[pStruct40->CharIndex]) + case MNDX_SEARCH_SEARCHING: { - // HOTS: 1958D11 - pStruct40->array_00.InsertOneItem_CHAR(FrgmDist_LoBits.ByteArray[pStruct40->ItemIndex]); - pStruct40->CharIndex++; - return true; - } - } + // HOTS: 1959522 + for (;;) + { + // HOTS: 1959530 + if (pStruct40->ItemCount == pStruct40->PathStops.ItemCount) + { + TPathStop * pLastStop; + DWORD ColTableIndex; - // HOTS: 1958D11 - pStruct40->ItemIndex++; - CollisionIndex++; + pLastStop = &pStruct40->PathStops[pStruct40->PathStops.ItemCount - 1]; - if(!Struct68_00.IsItemPresent(CollisionIndex)) - break; - } + ColTableIndex = CollisionTable.GetItem0(pLastStop->LoBitsIndex) + 1; - return false; -} + // Insert a new structure + TPathStop PathStop(ColTableIndex - pLastStop->LoBitsIndex - 1, ColTableIndex, 0); + pStruct40->PathStops.Insert(PathStop); + } -// HOTS: 1957EF0 -bool TFileNameDatabase::FindFileInDatabase(TMndxFindResult * pStruct1C) -{ - TStruct40 * pStruct40 = pStruct1C->pStruct40; + // HOTS: 19595BD + pPathStop = &pStruct40->PathStops[pStruct40->ItemCount]; - pStruct40->ItemIndex = 0; - pStruct40->CharIndex = 0; - pStruct40->SearchPhase = CASC_SEARCH_INITIALIZING; + // HOTS: 19595CC + if (CollisionTable.IsItemPresent(pPathStop->field_4++)) + { + // HOTS: 19595F2 + pStruct40->ItemCount++; + + if (IsPathFragmentString(pPathStop->LoBitsIndex)) + { + DWORD FragmentOffset = GetPathFragmentOffset2(pPathStop->HiBitsIndex_PathFragment, pPathStop->LoBitsIndex); + + // HOTS: 1959630 + if (pChildDB != NULL) + { + // HOTS: 1959649 + pChildDB->CopyPathFragmentByIndex(pSearch, FragmentOffset); + } + else + { + // HOTS: 1959654 + PathFragmentTable.CopyPathFragment(pSearch, FragmentOffset); + } + } + else + { + // HOTS: 1959665 + // Insert one character to the path being built + pStruct40->PathBuffer.Insert(LoBitsTable[pPathStop->LoBitsIndex]); + } + + // HOTS: 19596AE + pPathStop->Count = pStruct40->PathBuffer.ItemCount; + + // HOTS: 19596b6 + if (FileNameIndexes.IsItemPresent(pPathStop->LoBitsIndex)) + { + // HOTS: 19596D1 + if (pPathStop->field_10 == 0xFFFFFFFF) + { + // HOTS: 19596D9 + pPathStop->field_10 = FileNameIndexes.GetItemValueAt(pPathStop->LoBitsIndex); + } + else + { + pPathStop->field_10++; + } + + // HOTS: 1959755 + pSearch->szFoundPath = &pStruct40->PathBuffer[0]; + pSearch->cchFoundPath = pStruct40->PathBuffer.ItemCount; + pSearch->nIndex = pPathStop->field_10; + return true; + } + } + else + { + // HOTS: 19596E9 + if (pStruct40->ItemCount == 1) + { + pStruct40->SearchPhase = MNDX_SEARCH_FINISHED; + return false; + } + + // HOTS: 19596F5 + pStruct40->PathStops[pStruct40->ItemCount - 1].LoBitsIndex++; + edi = pStruct40->PathStops[pStruct40->ItemCount - 2].Count; + pStruct40->PathBuffer.SetMaxItemsIf(edi); + + // HOTS: 1959749 + pStruct40->PathBuffer.ItemCount = edi; + pStruct40->ItemCount--; + } + } + } - if(pStruct1C->cchSearchMask > 0) - { - while(pStruct40->CharIndex < pStruct1C->cchSearchMask) - { - // HOTS: 01957F12 - if(!CheckNextPathFragment(pStruct1C)) - return false; + case MNDX_SEARCH_FINISHED: + break; } - } - // HOTS: 1957F26 - if(!FileNameIndexes.IsItemPresent(pStruct40->ItemIndex)) return false; + } - pStruct1C->szFoundPath = pStruct1C->szSearchMask; - pStruct1C->cchFoundPath = pStruct1C->cchSearchMask; - pStruct1C->FileNameIndex = FileNameIndexes.GetItemValue(pStruct40->ItemIndex); - return true; -} - -// HOTS: 1959790 -int TFileNameDatabase::LoadFromStream(TByteStream & InStream) -{ - DWORD dwBitMask; - int nError; - - nError = Struct68_00.LoadFromStream_Exchange(InStream); - if(nError != ERROR_SUCCESS) - return nError; + // HOTS: 1957EF0 + bool FindFileInDatabase(TMndxSearch * pSearch) + { + TStruct40 * pStruct40 = &pSearch->Struct40; - nError = FileNameIndexes.LoadFromStream_Exchange(InStream); - if(nError != ERROR_SUCCESS) - return nError; + pStruct40->NodeIndex = 0; + pStruct40->PathLength = 0; + pStruct40->SearchPhase = MNDX_SEARCH_INITIALIZING; - nError = Struct68_D0.LoadFromStream_Exchange(InStream); - if(nError != ERROR_SUCCESS) - return nError; - - // HOTS: 019597CD - nError = FrgmDist_LoBits.LoadBytes_Copy(InStream); - if(nError != ERROR_SUCCESS) - return nError; + if(pSearch->cchSearchMask > 0) + { + while(pStruct40->PathLength < pSearch->cchSearchMask) + { + // HOTS: 01957F12 + if(!ComparePathFragment(pSearch)) + return false; + } + } - nError = FrgmDist_HiBits.LoadFromStream_Exchange(InStream); - if(nError != ERROR_SUCCESS) - return nError; + // HOTS: 1957F26 + if(!FileNameIndexes.IsItemPresent(pStruct40->NodeIndex)) + return false; - // HOTS: 019597F5 - nError = IndexStruct_174.LoadFromStream_Exchange(InStream); - if(nError != ERROR_SUCCESS) - return nError; + pSearch->szFoundPath = pSearch->szSearchMask; + pSearch->cchFoundPath = pSearch->cchSearchMask; + pSearch->nIndex = FileNameIndexes.GetItemValueAt(pStruct40->NodeIndex); + return true; + } - // HOTS: 0195980A - if(Struct68_D0.ValidItemCount != 0 && IndexStruct_174.NameFragments.ItemCount == 0) + // HOTS: 1959790 + int LoadFromStream(TByteStream & InStream) { - TFileNameDatabase * pNextDB = new TFileNameDatabase; + DWORD dwBitMask; + int nError; - nError = NextDB.SetDatabase(pNextDB); + nError = CollisionTable.LoadFromStream(InStream); if(nError != ERROR_SUCCESS) return nError; - if(NextDB.pDB == NULL) - return ERROR_NOT_ENOUGH_MEMORY; - - nError = NextDB.pDB->LoadFromStream(InStream); + nError = FileNameIndexes.LoadFromStream(InStream); if(nError != ERROR_SUCCESS) return nError; - } - // HOTS: 0195986B - nError = NameFragTable.LoadFragmentInfos_Copy(InStream); - if(nError != ERROR_SUCCESS) - return nError; - - NameFragIndexMask = NameFragTable.ItemCount - 1; - - nError = InStream.GetValue_DWORD(field_214); - if(nError != ERROR_SUCCESS) - return nError; - - nError = InStream.GetValue_DWORD(dwBitMask); - if(nError != ERROR_SUCCESS) - return nError; - - return Struct10.sub_1957800(dwBitMask); -} - -// HOTS: 19598D0 -int TFileNameDatabase::LoadFromStream_Exchange(TByteStream & InStream) -{ - TFileNameDatabase TempDatabase; - ARRAY_POINTER Pointer; - DWORD dwSignature; - int nError; - - // Get pointer to MAR signature - nError = InStream.GetBytes(sizeof(DWORD), &Pointer); - if(nError != ERROR_SUCCESS) - return nError; - - // Verify the signature - dwSignature = Pointer.Uint32s[0]; - if(dwSignature != CASC_MAR_SIGNATURE) - return ERROR_BAD_FORMAT; - - nError = TempDatabase.LoadFromStream(InStream); - if(nError != ERROR_SUCCESS) - return nError; - - MarStream.ExchangeWith(InStream); - ExchangeWith(TempDatabase); - return ERROR_SUCCESS; -} - -//----------------------------------------------------------------------------- -// TFileNameDatabasePtr functions - -// HOTS: 01956D70 -TFileNameDatabasePtr::TFileNameDatabasePtr() -{ - pDB = NULL; -} - -TFileNameDatabasePtr::~TFileNameDatabasePtr() -{ - delete pDB; -} + nError = CollisionHiBitsIndexes.LoadFromStream(InStream); + if(nError != ERROR_SUCCESS) + return nError; -// HOTS: 1956C60 -int TFileNameDatabasePtr::FindFileInDatabase(TMndxFindResult * pStruct1C) -{ - int nError = ERROR_SUCCESS; + // HOTS: 019597CD + nError = LoBitsTable.LoadFromStream(InStream); + if(nError != ERROR_SUCCESS) + return nError; - if(pDB == NULL) - return ERROR_INVALID_PARAMETER; + nError = HiBitsTable.LoadBitsFromStream(InStream); + if(nError != ERROR_SUCCESS) + return nError; - nError = pStruct1C->CreateStruct40(); - if(nError != ERROR_SUCCESS) - return nError; + // HOTS: 019597F5 + nError = PathFragmentTable.LoadFromStream(InStream); + if(nError != ERROR_SUCCESS) + return nError; - if(!pDB->FindFileInDatabase(pStruct1C)) - nError = ERROR_FILE_NOT_FOUND; + // HOTS: 0195980A + if(CollisionHiBitsIndexes.ValidItemCount != 0 && PathFragmentTable.PathFragments.ItemCount == 0) + { + TFileNameDatabase * pNewDB; - pStruct1C->FreeStruct40(); - return nError; -} + pNewDB = new TFileNameDatabase; + if (pNewDB == NULL) + return ERROR_NOT_ENOUGH_MEMORY; -// HOTS: 1956CE0 -int TFileNameDatabasePtr::sub_1956CE0(TMndxFindResult * pStruct1C, bool * pbFindResult) -{ - int nError = ERROR_SUCCESS; + nError = SetChildDatabase(pNewDB); + if(nError != ERROR_SUCCESS) + return nError; - if(pDB == NULL) - return ERROR_INVALID_PARAMETER; + nError = pChildDB->LoadFromStream(InStream); + if(nError != ERROR_SUCCESS) + return nError; + } - // Create the pStruct40, if not initialized yet - if(pStruct1C->pStruct40 == NULL) - { - nError = pStruct1C->CreateStruct40(); + // HOTS: 0195986B + nError = HashTable.LoadFromStream(InStream); if(nError != ERROR_SUCCESS) return nError; - } - *pbFindResult = pDB->sub_1959460(pStruct1C); - return nError; -} + HashTableMask = HashTable.ItemCount - 1; -// HOTS: 1956D20 -int TFileNameDatabasePtr::GetFileNameCount(PDWORD PtrFileNameCount) -{ - if(pDB == NULL) - return ERROR_INVALID_PARAMETER; + nError = InStream.GetValue<DWORD>(field_214); + if(nError != ERROR_SUCCESS) + return nError; - PtrFileNameCount[0] = pDB->FileNameIndexes.ValidItemCount; - return ERROR_SUCCESS; -} + nError = InStream.GetValue<DWORD>(dwBitMask); + if(nError != ERROR_SUCCESS) + return nError; -// HOTS: 1956DA0 -int TFileNameDatabasePtr::CreateDatabase(LPBYTE pbMarData, DWORD cbMarData) -{ - TFileNameDatabase * pDatabase; - TByteStream ByteStream; - int nError; + return Struct10.sub_1957800(dwBitMask); + } - if(pbMarData == NULL && cbMarData != 0) - return ERROR_INVALID_PARAMETER; + TSparseArray CollisionTable; // Table of valid collisions, indexed by NodeIndex + TSparseArray FileNameIndexes; // Array of file name indexes + TSparseArray CollisionHiBitsIndexes; // Table of indexes of high bits (above 8 bits) for collisions - pDatabase = new TFileNameDatabase; - if(pDatabase != NULL) - { - nError = ByteStream.SetByteBuffer(pbMarData, cbMarData); - if(nError == ERROR_SUCCESS) - { - // HOTS: 1956E11 - nError = pDatabase->LoadFromStream_Exchange(ByteStream); - if(nError == ERROR_SUCCESS) - { - pDB = pDatabase; - return ERROR_SUCCESS; - } - } + // This pair of arrays serves for fast conversion from node index to FragmentOffset / FragmentChar + TGenericArray<BYTE> LoBitsTable; // Array of lower 8 bits of name fragment offset + TBitEntryArray HiBitsTable; // Array of upper x bits of name fragment offset - delete pDatabase; - return nError; - } - else - { - return ERROR_NOT_ENOUGH_MEMORY; - } -} + TPathFragmentTable PathFragmentTable; + TFileNameDatabase * pChildDB; -// HOTS: 19584B0 -int TFileNameDatabasePtr::SetDatabase(TFileNameDatabase * pNewDB) -{ - if(pNewDB != NULL && pDB == pNewDB) - return ERROR_INVALID_PARAMETER; + TGenericArray<HASH_ENTRY> HashTable; // Hash table for searching name fragments - if(pDB != NULL) - delete pDB; - pDB = pNewDB; - return ERROR_SUCCESS; -} + DWORD HashTableMask; // Mask to get hash table index from hash value + DWORD field_214; + TStruct10 Struct10; +}; //----------------------------------------------------------------------------- // Local functions - MAR file -// HOTS: 00E94180 -static void MAR_FILE_CreateDatabase(PMAR_FILE pMarFile) +class TMndxMarFile { - pMarFile->pDatabasePtr = new TFileNameDatabasePtr; - if(pMarFile->pDatabasePtr != NULL) - pMarFile->pDatabasePtr->CreateDatabase(pMarFile->pbMarData, pMarFile->cbMarData); -} + public: -static int MAR_FILE_SearchFile(PMAR_FILE pMarFile, TMndxFindResult * pStruct1C) -{ - return pMarFile->pDatabasePtr->FindFileInDatabase(pStruct1C); -} - -static void MAR_FILE_Destructor(PMAR_FILE pMarFile) -{ - if(pMarFile != NULL) + TMndxMarFile() { - if(pMarFile->pDatabasePtr != NULL) - delete pMarFile->pDatabasePtr; - if(pMarFile->pbMarData != NULL) - CASC_FREE(pMarFile->pbMarData); - - CASC_FREE(pMarFile); + pDatabase = NULL; + pbMarData = NULL; + cbMarData = 0; } -} - -//----------------------------------------------------------------------------- -// Package functions - -// TODO: When working, increment these values to lower number of (re)allocations -#define CASC_PACKAGES_INIT 0x10 -#define CASC_PACKAGES_DELTA 0x10 -static PCASC_MNDX_PACKAGES AllocatePackages(size_t nNameEntries, size_t nNameBufferMax) -{ - PCASC_MNDX_PACKAGES pPackages; - size_t cbToAllocate; - - // Allocate space - cbToAllocate = sizeof(CASC_MNDX_PACKAGES) + (nNameEntries * sizeof(CASC_MNDX_PACKAGE)) + nNameBufferMax; - pPackages = (PCASC_MNDX_PACKAGES)CASC_ALLOC(BYTE, cbToAllocate); - if(pPackages != NULL) + ~TMndxMarFile() { - // Fill the structure - memset(pPackages, 0, cbToAllocate); - - // Init the list entries - pPackages->szNameBuffer = (char *)(&pPackages->Packages[nNameEntries]); - pPackages->NameEntries = nNameEntries; - pPackages->NameBufferUsed = 0; - pPackages->NameBufferMax = nNameBufferMax; + if(pDatabase != NULL) + delete pDatabase; + CASC_FREE(pbMarData); } - return pPackages; -} - -static PCASC_MNDX_PACKAGES InsertToPackageList( - PCASC_MNDX_PACKAGES pPackages, - const char * szFileName, - size_t cchFileName, - size_t nPackageIndex) -{ - size_t nNewNameEntries = pPackages->NameEntries; - size_t nNewNameBufferMax = pPackages->NameBufferMax; - size_t cbToAllocate; - char * szNameBuffer; - - // Need to reallocate? - while(nPackageIndex >= nNewNameEntries) - nNewNameEntries = nNewNameEntries + CASC_PACKAGES_DELTA; - if((pPackages->NameBufferUsed + cchFileName + 1) > nNewNameBufferMax) - nNewNameBufferMax = nNewNameBufferMax + 0x1000; - - // If any of the two variables overflowed, we need to reallocate the name list - if(nNewNameEntries > pPackages->NameEntries || nNewNameBufferMax > pPackages->NameBufferMax) - { - PCASC_MNDX_PACKAGES pOldPackages = pPackages; - - // Allocate new name list - cbToAllocate = sizeof(CASC_MNDX_PACKAGES) + (nNewNameEntries * sizeof(CASC_MNDX_PACKAGE)) + nNewNameBufferMax; - pPackages = (PCASC_MNDX_PACKAGES)CASC_ALLOC(BYTE, cbToAllocate); - if(pPackages == NULL) - return NULL; - - // Copy the old entries - memset(pPackages, 0, cbToAllocate); - pPackages->szNameBuffer = szNameBuffer = (char *)(&pPackages->Packages[nNewNameEntries]); - memcpy(pPackages->szNameBuffer, pOldPackages->szNameBuffer, pOldPackages->NameBufferUsed); + // HOTS: 00E94180 + int LoadRootData(FILE_MAR_INFO & MarInfo, LPBYTE pbRootFile, LPBYTE pbRootEnd) + { + // Allocate the MAR data + pbMarData = CASC_ALLOC(BYTE, MarInfo.MarDataSize); + cbMarData = MarInfo.MarDataSize; + if(pbMarData == NULL) + return ERROR_NOT_ENOUGH_MEMORY; - // Copy the old entries - for(size_t i = 0; i < pOldPackages->NameEntries; i++) - { - if(pOldPackages->Packages[i].szFileName != NULL) - { - pPackages->Packages[i].szFileName = pPackages->szNameBuffer + (pOldPackages->Packages[i].szFileName - pOldPackages->szNameBuffer); - pPackages->Packages[i].nLength = pOldPackages->Packages[i].nLength; - } - } + // Capture the MAR data + if(!CaptureData(pbRootFile + MarInfo.MarDataOffset, pbRootEnd, pbMarData, cbMarData)) + return ERROR_FILE_CORRUPT; - // Fill the limits - pPackages->NameEntries = nNewNameEntries; - pPackages->NameBufferUsed = pOldPackages->NameBufferUsed; - pPackages->NameBufferMax = nNewNameBufferMax; + // Create the file name database + pDatabase = new TFileNameDatabase(); + if(pDatabase == NULL) + return ERROR_NOT_ENOUGH_MEMORY; - // Switch the name lists - CASC_FREE(pOldPackages); + return pDatabase->Load(pbMarData, cbMarData); } - // The slot is expected to be empty at the moment - assert(pPackages->Packages[nPackageIndex].szFileName == NULL); - assert(pPackages->Packages[nPackageIndex].nLength == 0); + // HOTS: 1956C60 + int SearchFile(TMndxSearch * pSearch) + { + int nError = ERROR_SUCCESS; - // Set the file name entry - szNameBuffer = pPackages->szNameBuffer + pPackages->NameBufferUsed; - pPackages->Packages[nPackageIndex].szFileName = szNameBuffer; - pPackages->Packages[nPackageIndex].nLength = cchFileName; - memcpy(szNameBuffer, szFileName, cchFileName); - pPackages->NameBufferUsed += (cchFileName + 1); - return pPackages; -} + if(pDatabase == NULL) + return ERROR_INVALID_PARAMETER; -static int LoadPackageNames(PCASC_MNDX_INFO pMndxInfo, PCASC_MNDX_PACKAGES * ppPackages) -{ - TMndxFindResult Struct1C; - PCASC_MNDX_PACKAGES pPackages = NULL; - PMAR_FILE pMarFile; + if(!pDatabase->FindFileInDatabase(pSearch)) + nError = ERROR_FILE_NOT_FOUND; - // Sanity checks - assert(pMndxInfo != NULL); + return nError; + } - // Prepare the file name search in the top level directory - pMarFile = pMndxInfo->pMarFile1; - Struct1C.SetSearchPath("", 0); + // HOTS: 1956CE0 + int DoSearch(TMndxSearch * pSearch, bool * pbFindResult) + { + int nError = ERROR_SUCCESS; - // Allocate initial name list structure - pPackages = AllocatePackages(CASC_PACKAGES_INIT, 0x1000); - if(pPackages == NULL) - return ERROR_NOT_ENOUGH_MEMORY; + if(pDatabase == NULL) + return ERROR_INVALID_PARAMETER; - // Keep searching as long as we find something - for(;;) - { - bool bFindResult = false; + *pbFindResult = pDatabase->DoSearch(pSearch); + return nError; + } - // Search the next file name - pMarFile->pDatabasePtr->sub_1956CE0(&Struct1C, &bFindResult); - if(bFindResult == false) - break; + // HOTS: 1956D20 + int GetFileNameCount(size_t * PtrFileNameCount) + { + if(pDatabase == NULL) + return ERROR_INVALID_PARAMETER; - // Insert the found name to the top level directory list - pPackages = InsertToPackageList(pPackages, Struct1C.szFoundPath, Struct1C.cchFoundPath, Struct1C.FileNameIndex); - if(pPackages == NULL) - return ERROR_NOT_ENOUGH_MEMORY; + PtrFileNameCount[0] = pDatabase->FileNameIndexes.ValidItemCount; + return ERROR_SUCCESS; } - // Give the packages to the caller - if(ppPackages != NULL) - ppPackages[0] = pPackages; - return ERROR_SUCCESS; -} +// protected: + TFileNameDatabase * pDatabase; + LPBYTE pbMarData; + size_t cbMarData; +}; //----------------------------------------------------------------------------- // Implementation of root file functions -struct TRootHandler_MNDX : public TRootHandler +typedef struct _FILE_MNDX_INFO { - CASC_MNDX_INFO MndxInfo; + BYTE RootFileName[MD5_HASH_SIZE]; // Name (aka MD5) of the root file + DWORD HeaderVersion; // Must be <= 2 + DWORD FormatVersion; + DWORD field_1C; + DWORD field_20; + DWORD MarInfoOffset; // Offset of the first MAR entry info + DWORD MarInfoCount; // Number of the MAR info entries + DWORD MarInfoSize; // Size of the MAR info entry + DWORD CKeyEntriesOffset; // Offset of the CKey entries, relative to begin of the root file + DWORD CKeyEntriesCount; // Number of CKeys (files) in the root file + DWORD FileNameCount; // Number of unique file names. More files with the same name in the different packages can exist + DWORD CKeyEntrySize; // Size of one CKey root entry + TMndxMarFile * MarFiles[MAR_COUNT]; // File name list for the packages - PCASC_ROOT_ENTRY_MNDX * ppValidEntries; - PCASC_ROOT_ENTRY_MNDX pMndxEntries; - PCASC_MNDX_PACKAGES pPackages; // Linear list of present packages -}; +} FILE_MNDX_INFO, *PFILE_MNDX_INFO; -PCASC_MNDX_PACKAGE FindMndxPackage(TRootHandler_MNDX * pRootHandler, const char * szFileName) +struct TMndxHandler { - PCASC_MNDX_PACKAGE pMatching = NULL; - PCASC_MNDX_PACKAGE pPackage; - size_t nMaxLength = 0; - size_t nLength = strlen(szFileName); - - // Packages must be loaded - assert(pRootHandler->pPackages != NULL); - pPackage = pRootHandler->pPackages->Packages; - - //FILE * fp = fopen("E:\\packages.txt", "wt"); - //for(size_t i = 0; i < hs->pPackages->NameEntries; i++, pPackage++) - //{ - // if(pPackage->szFileName != NULL) - // fprintf(fp, "%s\n", pPackage->szFileName); - //} - //fclose(fp); - - // Find the longest matching name - for(size_t i = 0; i < pRootHandler->pPackages->NameEntries; i++, pPackage++) - { - if(pPackage->szFileName != NULL && pPackage->nLength < nLength && pPackage->nLength > nMaxLength) - { - // Compare the package name - if(!strncmp(szFileName, pPackage->szFileName, pPackage->nLength)) - { - pMatching = pPackage; - nMaxLength = pPackage->nLength; - } - } - } + public: - // Give the package pointer or NULL if not found - return pMatching; -} + // + // Constructor and destructor + // -int SearchMndxInfo(TRootHandler_MNDX * pRootHandler, const char * szFileName, DWORD dwPackage, PCASC_ROOT_ENTRY_MNDX * ppRootEntry) -{ - PCASC_ROOT_ENTRY_MNDX pRootEntry; - PCASC_MNDX_INFO pMndxInfo = &pRootHandler->MndxInfo; - TMndxFindResult Struct1C; + TMndxHandler() + { + memset(this, 0, sizeof(TMndxHandler)); + } - // Search the database for the file name - if(pMndxInfo->bRootFileLoaded) + ~TMndxHandler() { - Struct1C.SetSearchPath(szFileName, strlen(szFileName)); + PMNDX_PACKAGE pPackage; + size_t i; - // Search the file name in the second MAR info (the one with stripped package names) - if(MAR_FILE_SearchFile(pMndxInfo->pMarFile2, &Struct1C) != ERROR_SUCCESS) - return ERROR_FILE_NOT_FOUND; + for(i = 0; i < MAR_COUNT; i++) + delete MndxInfo.MarFiles[i]; + CASC_FREE(FileNameIndexToCKeyIndex); + pCKeyEntries = NULL; - // The found MNDX index must fall into range of valid MNDX entries - if(Struct1C.FileNameIndex < pMndxInfo->MndxEntriesValid) + for(i = 0; i < Packages.ItemCount(); i++) { - // HOTS: E945F4 - pRootEntry = pRootHandler->ppValidEntries[Struct1C.FileNameIndex]; - while((pRootEntry->Flags & 0x00FFFFFF) != dwPackage) - { - // The highest bit serves as a terminator if set - if(pRootEntry->Flags & 0x80000000) - return ERROR_FILE_NOT_FOUND; - - pRootEntry++; - } - - // Give the root entry pointer to the caller - if(ppRootEntry != NULL) - ppRootEntry[0] = pRootEntry; - return ERROR_SUCCESS; + pPackage = (PMNDX_PACKAGE)Packages.ItemAt(i); + CASC_FREE(pPackage->szFileName); } + Packages.Free(); } - return ERROR_FILE_NOT_FOUND; -} - -static LPBYTE FillFindData(TRootHandler_MNDX * pRootHandler, TCascSearch * pSearch, TMndxFindResult * pStruct1C, PDWORD PtrFileSize) -{ - PCASC_ROOT_ENTRY_MNDX pRootEntry = NULL; - PCASC_MNDX_PACKAGE pPackage; - char * szStrippedPtr; - char szStrippedName[MAX_PATH+1]; - int nError; - - // Sanity check - assert(pStruct1C->cchFoundPath < MAX_PATH); - - // Fill the file name - memcpy(pSearch->szFileName, pStruct1C->szFoundPath, pStruct1C->cchFoundPath); - pSearch->szFileName[pStruct1C->cchFoundPath] = 0; - - // Fill the file size - pPackage = FindMndxPackage(pRootHandler, pSearch->szFileName); - if(pPackage == NULL) - return NULL; - - // Cut the package name off the full path - szStrippedPtr = pSearch->szFileName + pPackage->nLength; - while(szStrippedPtr[0] == '/') - szStrippedPtr++; - - // We need to convert the stripped name to lowercase, replacing backslashes with slashes - NormalizeFileName_LowerSlash(szStrippedName, szStrippedPtr, MAX_PATH); - - // Search the package - nError = SearchMndxInfo(pRootHandler, szStrippedName, (DWORD)(pPackage - pRootHandler->pPackages->Packages), &pRootEntry); - if(nError != ERROR_SUCCESS) - return NULL; - - // Give the file size - if(PtrFileSize != NULL) - PtrFileSize[0] = pRootEntry->FileSize; - return pRootEntry->EncodingKey; -} - -static int MndxHandler_Insert(TRootHandler_MNDX *, const char *, LPBYTE) -{ - return ERROR_NOT_SUPPORTED; -} - -static LPBYTE MndxHandler_Search(TRootHandler_MNDX * pRootHandler, TCascSearch * pSearch, PDWORD PtrFileSize, PDWORD /* PtrLocaleFlags */, PDWORD /* PtrFileDataId */) -{ - TMndxFindResult * pStruct1C = NULL; - PCASC_MNDX_INFO pMndxInfo = &pRootHandler->MndxInfo; - PMAR_FILE pMarFile = pMndxInfo->pMarFile3; - bool bFindResult = false; + // + // Helper functions + // - // If the first time, allocate the structure for the search result - if(pSearch->pRootContext == NULL) + static LPBYTE CaptureRootHeader(FILE_MNDX_HEADER & MndxHeader, LPBYTE pbRootPtr, LPBYTE pbRootEnd) { - // Create the new search structure - pStruct1C = new TMndxFindResult; - if(pStruct1C == NULL) + // Capture the root header + pbRootPtr = CaptureData(pbRootPtr, pbRootEnd, &MndxHeader, sizeof(FILE_MNDX_HEADER)); + if (pbRootPtr == NULL) return NULL; - // Setup the search mask - pStruct1C->SetSearchPath("", 0); - pSearch->pRootContext = pStruct1C; - } - - // Make shortcut for the search structure - assert(pSearch->pRootContext != NULL); - pStruct1C = (TMndxFindResult *)pSearch->pRootContext; - - // Keep searching - for(;;) - { - // Search the next file name (our code) - pMarFile->pDatabasePtr->sub_1956CE0(pStruct1C, &bFindResult); - if (bFindResult == false) + // Check signature and version + if (MndxHeader.Signature != CASC_MNDX_ROOT_SIGNATURE || MndxHeader.FormatVersion > 2 || MndxHeader.FormatVersion < 1) return NULL; - // If we have no wild mask, we found it - if (pSearch->szMask == NULL || pSearch->szMask[0] == 0) - break; - - // Copy the found name to the buffer - memcpy(pSearch->szFileName, pStruct1C->szFoundPath, pStruct1C->cchFoundPath); - pSearch->szFileName[pStruct1C->cchFoundPath] = 0; - if (CheckWildCard(pSearch->szFileName, pSearch->szMask)) - break; + // Passed + return pbRootPtr + sizeof(FILE_MNDX_HEADER); } - // Give the file size and encoding key - return FillFindData(pRootHandler, pSearch, pStruct1C, PtrFileSize); -} - -static void MndxHandler_EndSearch(TRootHandler_MNDX * /* pRootHandler */, TCascSearch * pSearch) -{ - if(pSearch != NULL) - delete (TMndxFindResult *)pSearch->pRootContext; - pSearch->pRootContext = NULL; -} - -static DWORD MndxHandler_GetFileId(TRootHandler_MNDX * /* pRootHandler */, const char * /* szFileName */) -{ - // Not implemented for HOTS - return 0; -} - -static LPBYTE MndxHandler_GetKey(TRootHandler_MNDX * pRootHandler, const char * szFileName) -{ - PCASC_ROOT_ENTRY_MNDX pRootEntry = NULL; - PCASC_MNDX_PACKAGE pPackage; - char * szStrippedName; - char szNormName[MAX_PATH+1]; - int nError; - - // Convert the file name to lowercase + slashes - NormalizeFileName_LowerSlash(szNormName, szFileName, MAX_PATH); - - // Find the package number - pPackage = FindMndxPackage(pRootHandler, szNormName); - if(pPackage == NULL) - return NULL; - - // Cut the package name off the full path - szStrippedName = szNormName + pPackage->nLength; - while(szStrippedName[0] == '/') - szStrippedName++; + int LoadPackageNames() + { + TMndxMarFile * pMarFile = MndxInfo.MarFiles[MAR_PACKAGE_NAMES]; + TMndxSearch Search; + PMNDX_PACKAGE pPackage; + size_t nPackageCount = 0x40; + bool bFindResult = false; + int nError; - // Find the root entry - nError = SearchMndxInfo(pRootHandler, szStrippedName, (DWORD)(pPackage - pRootHandler->pPackages->Packages), &pRootEntry); - if(nError != ERROR_SUCCESS || pRootEntry == NULL) - return NULL; + // Prepare the file name search in the top level directory + Search.SetSearchMask("", 0); - // Return the encoding key - return pRootEntry->EncodingKey; -} + // Allocate initial name list structure + pMarFile->GetFileNameCount(&nPackageCount); + nError = Packages.Create<MNDX_PACKAGE>(nPackageCount); + if(nError != ERROR_SUCCESS) + return nError; -static void MndxHandler_Close(TRootHandler_MNDX * pRootHandler) -{ - if(pRootHandler->MndxInfo.pMarFile1 != NULL) - MAR_FILE_Destructor(pRootHandler->MndxInfo.pMarFile1); - if(pRootHandler->MndxInfo.pMarFile2 != NULL) - MAR_FILE_Destructor(pRootHandler->MndxInfo.pMarFile2); - if(pRootHandler->MndxInfo.pMarFile3 != NULL) - MAR_FILE_Destructor(pRootHandler->MndxInfo.pMarFile3); - if(pRootHandler->ppValidEntries != NULL) - CASC_FREE(pRootHandler->ppValidEntries); - if(pRootHandler->pMndxEntries != NULL) - CASC_FREE(pRootHandler->pMndxEntries); - if(pRootHandler->pPackages != NULL) - CASC_FREE(pRootHandler->pPackages); - - CASC_FREE(pRootHandler); -} + // Reset the package array + Packages.Reset(); -//----------------------------------------------------------------------------- -// Public functions - MNDX info + // Keep searching as long as we find something + while(pMarFile->DoSearch(&Search, &bFindResult) == ERROR_SUCCESS && bFindResult) + { + // Insert new package to the array + assert(Search.nIndex < nPackageCount); + pPackage = (PMNDX_PACKAGE)Packages.InsertAt(Search.nIndex); + if (pPackage != NULL) + { + // The package mut not be initialized yet + assert(pPackage->szFileName == NULL); + + // Allocate space for the file name + pPackage->szFileName = CASC_ALLOC(char, Search.cchFoundPath + 1); + if (pPackage->szFileName == NULL) + return ERROR_NOT_ENOUGH_MEMORY; + + // Fill the package structure + memcpy(pPackage->szFileName, Search.szFoundPath, Search.cchFoundPath); + pPackage->szFileName[Search.cchFoundPath] = 0; + pPackage->nLength = Search.cchFoundPath; + pPackage->nIndex = Search.nIndex; + } + } -int RootHandler_CreateMNDX(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile) -{ - PFILE_MNDX_HEADER pMndxHeader = (PFILE_MNDX_HEADER)pbRootFile; - PCASC_MNDX_INFO pMndxInfo; - TRootHandler_MNDX * pRootHandler; - FILE_MAR_INFO MarInfo; - PMAR_FILE pMarFile; - LPBYTE pbRootFileEnd = pbRootFile + cbRootFile; - DWORD cbToAllocate; - DWORD dwFilePointer = 0; - DWORD i; - int nError = ERROR_SUCCESS; - - // Check signature and the other variables - if(pMndxHeader->Signature != CASC_MNDX_SIGNATURE || pMndxHeader->FormatVersion > 2 || pMndxHeader->FormatVersion < 1) - return ERROR_BAD_FORMAT; - - // Allocate the structure for the MNDX root file - hs->pRootHandler = pRootHandler = CASC_ALLOC(TRootHandler_MNDX, 1); - if(pRootHandler == NULL) - return ERROR_NOT_ENOUGH_MEMORY; - - // Fill-in the handler functions - memset(pRootHandler, 0, sizeof(TRootHandler_MNDX)); - pRootHandler->Insert = (ROOT_INSERT)MndxHandler_Insert; - pRootHandler->Search = (ROOT_SEARCH)MndxHandler_Search; - pRootHandler->EndSearch = (ROOT_ENDSEARCH)MndxHandler_EndSearch; - pRootHandler->GetKey = (ROOT_GETKEY)MndxHandler_GetKey; - pRootHandler->Close = (ROOT_CLOSE)MndxHandler_Close; - pRootHandler->GetFileId = (ROOT_GETFILEID)MndxHandler_GetFileId; - - pMndxInfo = &pRootHandler->MndxInfo; - - // Fill-in the flags - pRootHandler->dwRootFlags |= ROOT_FLAG_HAS_NAMES; - - // Copy the header into the MNDX info - pMndxInfo->HeaderVersion = pMndxHeader->HeaderVersion; - pMndxInfo->FormatVersion = pMndxHeader->FormatVersion; - dwFilePointer += sizeof(FILE_MNDX_HEADER); - - // Header version 2 has 2 extra fields that we need to load - if(pMndxInfo->HeaderVersion == 2) - { - if(!RootFileRead(pbRootFile + dwFilePointer, pbRootFileEnd, &pMndxInfo->field_1C, sizeof(DWORD) + sizeof(DWORD))) - return ERROR_FILE_CORRUPT; - dwFilePointer += sizeof(DWORD) + sizeof(DWORD); + // Give the packages to the caller + return ERROR_SUCCESS; } - // Load the rest of the file header - if(!RootFileRead(pbRootFile + dwFilePointer, pbRootFileEnd, &pMndxInfo->MarInfoOffset, 0x1C)) - return ERROR_FILE_CORRUPT; - - // Verify the structure - if(pMndxInfo->MarInfoCount > CASC_MAX_MAR_FILES || pMndxInfo->MarInfoSize != sizeof(FILE_MAR_INFO)) - return ERROR_FILE_CORRUPT; - - // Load all MAR infos - for(i = 0; i < pMndxInfo->MarInfoCount; i++) + int Load(const FILE_MNDX_HEADER & MndxHeader, LPBYTE pbRootFile, LPBYTE pbRootEnd) { - // Load the n-th MAR info - dwFilePointer = pMndxInfo->MarInfoOffset + (pMndxInfo->MarInfoSize * i); - if(!RootFileRead(pbRootFile + dwFilePointer, pbRootFileEnd, &MarInfo, sizeof(FILE_MAR_INFO))) - return ERROR_FILE_CORRUPT; + TMndxMarFile * pMarFile; + FILE_MAR_INFO MarInfo; + size_t nFilePointer = 0; + DWORD i; + int nError = ERROR_SUCCESS; - // Allocate MAR_FILE structure - pMarFile = CASC_ALLOC(MAR_FILE, 1); - if(pMarFile == NULL) - { - nError = ERROR_NOT_ENOUGH_MEMORY; - break; - } + // Copy the header into the MNDX info + MndxInfo.HeaderVersion = MndxHeader.HeaderVersion; + MndxInfo.FormatVersion = MndxHeader.FormatVersion; + nFilePointer += sizeof(FILE_MNDX_HEADER); - // Allocate space for the MAR data - pMarFile->pDatabasePtr = NULL; - pMarFile->pbMarData = CASC_ALLOC(BYTE, MarInfo.MarDataSize); - pMarFile->cbMarData = MarInfo.MarDataSize; - if(pMarFile->pbMarData == NULL) + // Header version 2 has 2 extra fields that we need to load + if(MndxInfo.HeaderVersion == 2) { - nError = ERROR_NOT_ENOUGH_MEMORY; - break; + if(!CaptureData(pbRootFile + nFilePointer, pbRootEnd, &MndxInfo.field_1C, sizeof(DWORD) + sizeof(DWORD))) + return ERROR_FILE_CORRUPT; + nFilePointer += sizeof(DWORD) + sizeof(DWORD); } - // Read the MAR data - if(!RootFileRead(pbRootFile + MarInfo.MarDataOffset, pbRootFileEnd, pMarFile->pbMarData, pMarFile->cbMarData)) + // Load the rest of the file header + if(!CaptureData(pbRootFile + nFilePointer, pbRootEnd, &MndxInfo.MarInfoOffset, 0x1C)) + return ERROR_FILE_CORRUPT; + + // Verify the structure + if(MndxInfo.MarInfoCount > MAR_COUNT || MndxInfo.MarInfoSize != sizeof(FILE_MAR_INFO)) + return ERROR_FILE_CORRUPT; + + // Load all MAR infos + for(i = 0; i < MndxInfo.MarInfoCount; i++) { - nError = ERROR_FILE_CORRUPT; - break; - } + // Capture the n-th MAR info + nFilePointer = MndxInfo.MarInfoOffset + (MndxInfo.MarInfoSize * i); + if(!CaptureData(pbRootFile + nFilePointer, pbRootEnd, &MarInfo, sizeof(FILE_MAR_INFO))) + return ERROR_FILE_CORRUPT; - // HOTS: 00E94FF1 - MAR_FILE_CreateDatabase(pMarFile); - if(i == 0) - pMndxInfo->pMarFile1 = pMarFile; - if(i == 1) - pMndxInfo->pMarFile2 = pMarFile; - if(i == 2) - pMndxInfo->pMarFile3 = pMarFile; - } + // Allocate MAR_FILE structure + pMarFile = new TMndxMarFile(); + if(pMarFile == NULL) + { + nError = ERROR_NOT_ENOUGH_MEMORY; + break; + } - // All three MAR files must be loaded - // HOTS: 00E9503B - if(nError == ERROR_SUCCESS) - { - if(pMndxInfo->pMarFile1 == NULL || pMndxInfo->pMarFile2 == NULL || pMndxInfo->pMarFile3 == NULL) - nError = ERROR_BAD_FORMAT; - if(pMndxInfo->MndxEntrySize != sizeof(CASC_ROOT_ENTRY_MNDX)) - nError = ERROR_BAD_FORMAT; - } + // Create the database from the MAR data + nError = pMarFile->LoadRootData(MarInfo, pbRootFile, pbRootEnd); + if(nError != ERROR_SUCCESS) + break; - // Load the complete array of MNDX entries - if(nError == ERROR_SUCCESS) - { - TFileNameDatabasePtr * pDbPtr = pMndxInfo->pMarFile2->pDatabasePtr; - DWORD FileNameCount; + // Assign the MAR file to the MNDX info structure + MndxInfo.MarFiles[i] = pMarFile; + } - nError = pDbPtr->GetFileNameCount(&FileNameCount); - if(nError == ERROR_SUCCESS && FileNameCount == pMndxInfo->MndxEntriesValid) + // All three MAR files must be loaded + // HOTS: 00E9503B + if(nError == ERROR_SUCCESS) { - cbToAllocate = pMndxInfo->MndxEntriesTotal * pMndxInfo->MndxEntrySize; - pRootHandler->pMndxEntries = (PCASC_ROOT_ENTRY_MNDX)CASC_ALLOC(BYTE, cbToAllocate); - if(pRootHandler->pMndxEntries != NULL) - { - if(!RootFileRead(pbRootFile + pMndxInfo->MndxEntriesOffset, pbRootFileEnd, pRootHandler->pMndxEntries, cbToAllocate)) - nError = ERROR_FILE_CORRUPT; - } - else - nError = ERROR_NOT_ENOUGH_MEMORY; + if(MndxInfo.MarFiles[MAR_PACKAGE_NAMES] == NULL || MndxInfo.MarFiles[MAR_STRIPPED_NAMES] == NULL || MndxInfo.MarFiles[MAR_FULL_NAMES] == NULL) + nError = ERROR_BAD_FORMAT; + if(MndxInfo.CKeyEntrySize != sizeof(MNDX_CKEY_ENTRY)) + nError = ERROR_BAD_FORMAT; } - else - nError = ERROR_FILE_CORRUPT; - } - // Pick the valid MNDX entries and put them to a separate array - if(nError == ERROR_SUCCESS) - { - assert(pMndxInfo->MndxEntriesValid <= pMndxInfo->MndxEntriesTotal); - pRootHandler->ppValidEntries = CASC_ALLOC(PCASC_ROOT_ENTRY_MNDX, pMndxInfo->MndxEntriesValid + 1); - if(pRootHandler->ppValidEntries != NULL) + // Load the array of Ckey entries. All present files are in the array, + // the same names (differentiated by package ID) are groupped together + if(nError == ERROR_SUCCESS) { - PCASC_ROOT_ENTRY_MNDX pRootEntry = pRootHandler->pMndxEntries; - DWORD ValidEntryCount = 1; // edx - DWORD nIndex1 = 0; + size_t CKeyEntriesSize; + size_t FileNameCount = 0; - // The first entry is always valid - pRootHandler->ppValidEntries[nIndex1++] = pRootHandler->pMndxEntries; + pMarFile = MndxInfo.MarFiles[MAR_STRIPPED_NAMES]; + nError = ERROR_FILE_CORRUPT; - // Put the remaining entries - for(i = 0; i < pMndxInfo->MndxEntriesTotal; i++, pRootEntry++) + // Capture the array of CKey entries + if(pMarFile->GetFileNameCount(&FileNameCount) == ERROR_SUCCESS && FileNameCount == MndxInfo.FileNameCount) { - if(ValidEntryCount > pMndxInfo->MndxEntriesValid) - break; - - if(pRootEntry->Flags & 0x80000000) + CKeyEntriesSize = MndxInfo.CKeyEntriesCount * MndxInfo.CKeyEntrySize; + if ((pbRootFile + MndxInfo.CKeyEntriesOffset + CKeyEntriesSize) <= pbRootEnd) { - pRootHandler->ppValidEntries[nIndex1++] = pRootEntry + 1; - ValidEntryCount++; + pCKeyEntries = (PMNDX_CKEY_ENTRY)(pbRootFile + MndxInfo.CKeyEntriesOffset); + nError = ERROR_SUCCESS; } } - - // Verify the final number of valid entries - if((ValidEntryCount - 1) != pMndxInfo->MndxEntriesValid) - nError = ERROR_BAD_FORMAT; } - else - nError = ERROR_NOT_ENOUGH_MEMORY; - } - // Load the MNDX packages - if(nError == ERROR_SUCCESS) - { - nError = LoadPackageNames(pMndxInfo, &pRootHandler->pPackages); - pMndxInfo->bRootFileLoaded = (nError == ERROR_SUCCESS); - } - -#if defined(_DEBUG) && defined(_X86_) && defined(CASCLIB_TEST) -// CascDumpNameFragTable("E:\\casc-name-fragment-table.txt", pMndxInfo->pMarFile1); -// CascDumpFileNames("E:\\casc-listfile.txt", pMndxInfo->pMarFile1); -// TestMndxRootFile(pRootHandler); -#endif + // Pick the CKey entries that are the first with a given name + if(nError == ERROR_SUCCESS) + { + assert(MndxInfo.FileNameCount <= MndxInfo.CKeyEntriesCount); + FileNameIndexToCKeyIndex = CASC_ALLOC(PMNDX_CKEY_ENTRY, MndxInfo.FileNameCount + 1); + if(FileNameIndexToCKeyIndex != NULL) + { + PMNDX_CKEY_ENTRY pRootEntry = pCKeyEntries; + DWORD nFileNameIndex = 0; - // Return the result - return nError; -} + // The first entry is always beginning of a file name group + FileNameIndexToCKeyIndex[nFileNameIndex++] = pRootEntry; -//---------------------------------------------------------------------------- -// Unit tests + // Get the remaining file name groups + for(i = 0; i < MndxInfo.CKeyEntriesCount; i++, pRootEntry++) + { + if (nFileNameIndex > MndxInfo.FileNameCount) + break; -#if defined(_DEBUG) && defined(_X86_) && defined(CASCLIB_TEST) -/* -extern "C" { - bool _cdecl sub_1958B00_x86(TFileNameDatabase * pDB, TMndxFindResult * pStruct1C); - DWORD _cdecl sub_19573D0_x86(TFileNameDatabase * pDB, DWORD arg_0, DWORD arg_4); - DWORD _cdecl sub_1957EF0_x86(TFileNameDatabase * pDB, TMndxFindResult * pStruct1C); - bool _cdecl sub_1959460_x86(TFileNameDatabase * pDB, TMndxFindResult * pStruct1C); - DWORD _cdecl GetItemValue_x86(TSparseArray * pStruct, DWORD dwKey); - DWORD _cdecl sub_1959CB0_x86(TFileNameDatabase * pDB, DWORD dwKey); - DWORD _cdecl sub_1959F50_x86(TFileNameDatabase * pDB, DWORD arg_0); -} + if (pRootEntry->Flags & MNDX_LAST_CKEY_ENTRY) + { + FileNameIndexToCKeyIndex[nFileNameIndex++] = pRootEntry + 1; + } + } -extern "C" void * allocate_zeroed_memory_x86(size_t bytes) -{ - void * ptr = CASC_ALLOC(BYTE, bytes); + // Verify the final number of file names + if ((nFileNameIndex - 1) != MndxInfo.FileNameCount) + nError = ERROR_BAD_FORMAT; + } + else + nError = ERROR_NOT_ENOUGH_MEMORY; + } - if(ptr != NULL) - memset(ptr, 0, bytes); - return ptr; -} + // Load the package names from the 0-th MAR file + if(nError == ERROR_SUCCESS) + { + nError = LoadPackageNames(); + } -extern "C" void free_memory_x86(void * ptr) -{ - if(ptr != NULL) - { - CASC_FREE(ptr); + return nError; } -} - -static int sub_1956CE0_x86(TFileNameDatabasePtr * pDatabasePtr, TMndxFindResult * pStruct1C, bool * pbFindResult) -{ - int nError = ERROR_SUCCESS; - - if(pDatabasePtr->pDB == NULL) - return ERROR_INVALID_PARAMETER; - // Create the pStruct40, if not initialized yet - if(pStruct1C->pStruct40 == NULL) + int LoadFileNames(TCascStorage * hs, CASC_FILE_TREE & FileTree) { - nError = pStruct1C->CreateStruct40(); - if(nError != ERROR_SUCCESS) - return nError; - } - - *pbFindResult = sub_1959460_x86(pDatabasePtr->pDB, pStruct1C); - return nError; -} + PCASC_CKEY_ENTRY pCKeyEntry; + PMNDX_CKEY_ENTRY pRootEntry; + PMNDX_CKEY_ENTRY pRootEnd = pCKeyEntries + MndxInfo.CKeyEntriesCount; + PMNDX_PACKAGE pPackage; + TMndxMarFile * pMarFile = MndxInfo.MarFiles[MAR_STRIPPED_NAMES]; + TMndxSearch Search; + char szFileName[MAX_PATH]; + bool bFindResult = false; + int nError; -static void TestFileSearch_SubStrings(PMAR_FILE pMarFile, char * szFileName, size_t nLength) -{ - TMndxFindResult Struct1C_1; - TMndxFindResult Struct1C_2; + // Setup the search mask + Search.SetSearchMask("", 0); -// if(strcmp(szFileName, "mods/heroes.stormmod/base.stormassets/assets/textures/storm_temp_war3_btnstatup.dds")) -// return; + // Keep searching ad long as we found something + while ((nError = pMarFile->DoSearch(&Search, &bFindResult)) == ERROR_SUCCESS && bFindResult) + { + // Sanity check + assert(Search.cchFoundPath < MAX_PATH); - // Perform search on anything, that is longer than 4 chars - while(nLength >= 4) - { - // Set a substring as search name - Struct1C_1.SetSearchPath(szFileName, nLength); - Struct1C_2.SetSearchPath(szFileName, nLength); - szFileName[nLength] = 0; + // The found file name index must fall into range of file names + if (Search.nIndex < MndxInfo.FileNameCount) + { + // Retrieve the first-in-group CKey entry of that name + pRootEntry = FileNameIndexToCKeyIndex[Search.nIndex]; - // Keep searching - for(;;) - { - bool bFindResult1 = false; - bool bFindResult2 = false; + // Now take all files of that name, prepend their package name and insert to file tree + while(pRootEntry < pRootEnd) + { + // Find the appropriate CKey entry in the central storage + pCKeyEntry = FindCKeyEntry_CKey(hs, pRootEntry->CKey); + if (pCKeyEntry != NULL) + { + size_t nPackageIndex = pRootEntry->Flags & 0x00FFFFFF; - // Search the next file name (orig HOTS code) - sub_1956CE0_x86(pMarFile->pDatabasePtr, &Struct1C_1, &bFindResult1); + // Retrieve the package for this entry + pPackage = (PMNDX_PACKAGE)Packages.ItemAt(nPackageIndex); + if (pPackage != NULL) + { + // Sanity check + assert(pPackage->nIndex == nPackageIndex); - // Search the next file name (our code) - pMarFile->pDatabasePtr->sub_1956CE0(&Struct1C_2, &bFindResult2); + // Merge the package name and file name + MakeFileName(szFileName, _countof(szFileName), pPackage, &Search); - // Check the result - assert(bFindResult1 == bFindResult2); - assert(Struct1C_1.cchFoundPath == Struct1C_1.cchFoundPath); - assert(Struct1C_1.FileNameIndex == Struct1C_2.FileNameIndex); - assert(strncmp(Struct1C_1.szFoundPath, Struct1C_2.szFoundPath, Struct1C_1.cchFoundPath) == 0); - assert(Struct1C_1.cchFoundPath < MAX_PATH); + // Insert the entry to the file tree + FileTree.InsertByName(pCKeyEntry, szFileName); + } + } - // Stop the search in case of failure - if(bFindResult1 == false || bFindResult2 == false) - break; + // Is this the last-in-group entry? + if (pRootEntry->Flags & MNDX_LAST_CKEY_ENTRY) + break; + pRootEntry++; + } + } } - // Free the search structures - Struct1C_1.FreeStruct40(); - Struct1C_2.FreeStruct40(); - nLength--; + return nError; } -} - -static void TestFindPackage(PMAR_FILE pMarFile, const char * szPackageName) -{ - TMndxFindResult Struct1C; - - // Search the database for the file name - Struct1C.SetSearchPath(szPackageName, strlen(szPackageName)); - - // Search the file name in the second MAR info (the one with stripped package names) - MAR_FILE_SearchFile(pMarFile, &Struct1C); -} -static void TestFileSearch(PMAR_FILE pMarFile, const char * szFileName) -{ - TMndxFindResult Struct1C_1; - TMndxFindResult Struct1C_2; - size_t nLength = strlen(szFileName); - char szNameBuff[MAX_PATH + 1]; - - // Set an empty path as search mask (?) - Struct1C_1.SetSearchPath(szFileName, nLength); - Struct1C_2.SetSearchPath(szFileName, nLength); + // + // Helper functions + // - // Keep searching - for(;;) + void MakeFileName(char * szBuffer, size_t cchBuffer, PMNDX_PACKAGE pPackage, TMndxSearch * pSearch) { - bool bFindResult1 = false; - bool bFindResult2 = false; - - // Search the next file name (orig HOTS code) - sub_1956CE0_x86(pMarFile->pDatabasePtr, &Struct1C_1, &bFindResult1); + char * szBufferEnd = szBuffer + cchBuffer - 1; - // Search the next file name (our code) - pMarFile->pDatabasePtr->sub_1956CE0(&Struct1C_2, &bFindResult2); - - assert(bFindResult1 == bFindResult2); - assert(Struct1C_1.cchFoundPath == Struct1C_1.cchFoundPath); - assert(Struct1C_1.FileNameIndex == Struct1C_2.FileNameIndex); - assert(strncmp(Struct1C_1.szFoundPath, Struct1C_2.szFoundPath, Struct1C_1.cchFoundPath) == 0); - assert(Struct1C_1.cchFoundPath < MAX_PATH); - - // Stop the search in case of failure - if(bFindResult1 == false || bFindResult2 == false) - break; - - // Printf the found file name - memcpy(szNameBuff, Struct1C_2.szFoundPath, Struct1C_2.cchFoundPath); - szNameBuff[Struct1C_2.cchFoundPath] = 0; -// printf("%s \r", szNameBuff); - - // Perform sub-searches on this string and its substrings that are longer than 4 chars -// TestFileSearch_SubStrings(pMarFile, szNameBuff, Struct1C_2.cchFoundPath); - } + // Buffer length check + assert((pPackage->nLength + 1 + pSearch->cchFoundPath + 1) < cchBuffer); - // Free the search structures - Struct1C_1.FreeStruct40(); - Struct1C_2.FreeStruct40(); -} - -static void TestMarFile(PMAR_FILE pMarFile, const char * szFileName, size_t nLength) -{ - TFileNameDatabase * pDB = pMarFile->pDatabasePtr->pDB; - DWORD dwFileNameIndex1 = 0xFFFFFFFF; - DWORD dwFileNameIndex2 = 0xFFFFFFFF; + // Copy the package name + if ((szBuffer + pPackage->nLength) < szBufferEnd) + { + memcpy(szBuffer, pPackage->szFileName, pPackage->nLength); + szBuffer += pPackage->nLength; + } - // Perform the search using original HOTS code - { - TMndxFindResult Struct1C; + // Append slash + if ((szBuffer + 1) < szBufferEnd) + *szBuffer++ = '/'; - Struct1C.CreateStruct40(); - Struct1C.SetSearchPath(szFileName, nLength); + // Append file name + if ((szBuffer + pSearch->cchFoundPath) < szBufferEnd) + { + memcpy(szBuffer, pSearch->szFoundPath, pSearch->cchFoundPath); + szBuffer += pSearch->cchFoundPath; + } - // Call the original HOTS function - sub_1957EF0_x86(pDB, &Struct1C); - dwFileNameIndex1 = Struct1C.FileNameIndex; + szBuffer[0] = 0; } - // Perform the search using our code - { - TMndxFindResult Struct1C; + protected: - Struct1C.CreateStruct40(); - Struct1C.SetSearchPath(szFileName, nLength); + FILE_MNDX_INFO MndxInfo; - // Call our function - pDB->FindFileInDatabase(&Struct1C); - dwFileNameIndex2 = Struct1C.FileNameIndex; - } + PMNDX_CKEY_ENTRY * FileNameIndexToCKeyIndex; + PMNDX_CKEY_ENTRY pCKeyEntries; + CASC_ARRAY Packages; // Linear list of present packages +}; - // Compare both - assert(dwFileNameIndex1 == dwFileNameIndex2); -} +//----------------------------------------------------------------------------- +// Handler definition for MNDX root file -static void TestMndxFunctions(PMAR_FILE pMarFile) +struct TRootHandler_MNDX : public TFileTreeRoot { - TFileNameDatabase * pDB = pMarFile->pDatabasePtr->pDB; + public: - // Exercise function sub_19573D0 - for(DWORD arg_0 = 0; arg_0 < 0x100; arg_0++) + TRootHandler_MNDX() : TFileTreeRoot(0) { - for(DWORD arg_4 = 0; arg_4 < 0x100; arg_4++) - { - DWORD dwResult1 = sub_19573D0_x86(pDB, arg_0, arg_4); - DWORD dwResult2 = pDB->GetNameFragmentOffsetEx(arg_0, arg_4); - - assert(dwResult1 == dwResult2); - } + // MNDX supports file names and CKeys + dwFeatures |= CASC_FEATURE_FILE_NAMES | CASC_FEATURE_ROOT_CKEY; } - // Exercise function GetItemValue - for(DWORD i = 0; i < 0x10000; i++) + int Load(TCascStorage * hs, const FILE_MNDX_HEADER & MndxHeader, LPBYTE pbRootFile, LPBYTE pbRootEnd) { - DWORD dwResult1 = GetItemValue_x86(&pDB->Struct68_D0, i); - DWORD dwResult2 = pDB->Struct68_D0.GetItemValue(i); + TMndxHandler Handler; + int nError; - assert(dwResult1 == dwResult2); - } - - // Exercise function sub_1959CB0 - for(DWORD i = 0; i < 0x9C; i++) - { - DWORD dwResult1 = sub_1959CB0_x86(pDB, i); - DWORD dwResult2 = pDB->sub_1959CB0(i); + // Load and parse the entire MNDX structure + nError = Handler.Load(MndxHeader, pbRootFile, pbRootEnd); + if (nError == ERROR_SUCCESS) + { + // Search all file names and insert them into the file tree + nError = Handler.LoadFileNames(hs, FileTree); + } - assert(dwResult1 == dwResult2); + return nError; } +}; - // Exercise function sub_1959F50 - for(DWORD i = 0; i < 0x40; i++) - { - DWORD dwResult1 = sub_1959F50_x86(pDB, i); - DWORD dwResult2 = pDB->sub_1959F50(i); - - assert(dwResult1 == dwResult2); - } -} +//----------------------------------------------------------------------------- +// Public functions - MNDX info -void TestMndxRootFile(PCASC_MNDX_INFO pMndxInfo) +int RootHandler_CreateMNDX(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile) { - size_t nLength; - char szFileName[MAX_PATH+1]; - void * pvListFile; - - // Exercise low level functions and compare their results - // with original code from Heroes of the Storm - TestMndxFunctions(pMndxInfo->pMarFile1); - TestMndxFunctions(pMndxInfo->pMarFile2); - TestMndxFunctions(pMndxInfo->pMarFile3); - - // Find a "mods" in the package array - TestFindPackage(pMndxInfo->pMarFile3, "mods/heroes.stormmod/base.stormassets/assets/textures/glow_green2.dds"); - TestMarFile(pMndxInfo->pMarFile3, "mods/heroes.stormmod/base.stormassets/assets/textures/glow_green2.dds", 69); + TRootHandler_MNDX * pRootHandler = NULL; + FILE_MNDX_HEADER MndxHeader; + LPBYTE pbRootEnd = pbRootFile + cbRootFile; + int nError = ERROR_BAD_FORMAT; - // Search the package MAR file aith a path shorter than a fragment - TestFileSearch(pMndxInfo->pMarFile1, "mods/heroes.s"); - - // Test the file search - TestFileSearch(pMndxInfo->pMarFile1, ""); - TestFileSearch(pMndxInfo->pMarFile2, ""); - TestFileSearch(pMndxInfo->pMarFile3, ""); - - // False file search - TestFileSearch(pMndxInfo->pMarFile2, "assets/textures/storm_temp_hrhu"); - - // Open the listfile stream and initialize the listfile cache - pvListFile = ListFile_OpenExternal(_T("e:\\Ladik\\Appdir\\CascLib\\listfile\\listfile-hots-29049.txt")); - if(pvListFile != NULL) + // Verify the header of the ROOT file + if(TMndxHandler::CaptureRootHeader(MndxHeader, pbRootFile, pbRootEnd) != NULL) { - // Check every file in the database - while((nLength = ListFile_GetNext(pvListFile, "*", szFileName, MAX_PATH)) != 0) + // Allocate the root handler object + pRootHandler = new TRootHandler_MNDX(); + if(pRootHandler != NULL) { - // Normalize the file name: ToLower + BackSlashToSlash - NormalizeFileName_LowerSlash(szFileName, szFileName, MAX_PATH); - - // Check the file with all three MAR files - TestMarFile(pMndxInfo->pMarFile1, szFileName, nLength); - TestMarFile(pMndxInfo->pMarFile2, szFileName, nLength); - TestMarFile(pMndxInfo->pMarFile3, szFileName, nLength); + // Load the root directory. If load failed, we free the object + nError = pRootHandler->Load(hs, MndxHeader, pbRootFile, pbRootEnd); + if(nError != ERROR_SUCCESS) + { + delete pRootHandler; + pRootHandler = NULL; + } } - - ListFile_Free(pvListFile); } + + // Assign the root directory (or NULL) and return error + hs->pRootHandler = pRootHandler; + return nError; } -*/ -#endif // defined(_DEBUG) && defined(_X86_) && defined(CASCLIB_TEST) diff --git a/dep/CascLib/src/CascRootFile_OW.cpp b/dep/CascLib/src/CascRootFile_OW.cpp new file mode 100644 index 00000000000..24f5af81b34 --- /dev/null +++ b/dep/CascLib/src/CascRootFile_OW.cpp @@ -0,0 +1,605 @@ +/*****************************************************************************/ +/* CascRootFile_Text.cpp Copyright (c) Ladislav Zezula 2017 */ +/*---------------------------------------------------------------------------*/ +/* Support for loading ROOT files in plain text */ +/*---------------------------------------------------------------------------*/ +/* Date Ver Who Comment */ +/* -------- ---- --- ------- */ +/* 28.10.15 1.00 Lad The first version of CascRootFile_Text.cpp */ +/*****************************************************************************/ + +#define __CASCLIB_SELF__ +#include "CascLib.h" +#include "CascCommon.h" + +//----------------------------------------------------------------------------- +// Structure definitions for CMF files + +#define MAX_LINE_ELEMENTS 8 + +typedef struct _CMF_HEADER_V3 +{ + DWORD BuildVersion; + DWORD Unknown0; + DWORD Unknown1; + DWORD Unknown2; + DWORD Unknown3; + DWORD DataCount; + DWORD Unknown4; + DWORD EntryCount; + DWORD Magic; +} CMF_HEADER_V3, *PCMF_HEADER_V3; + +typedef struct _CMF_HEADER_V2 +{ + DWORD BuildVersion; + DWORD Unknown0; + DWORD Unknown1; + DWORD Unknown2; + DWORD DataCount; + DWORD Unknown3; + DWORD EntryCount; + DWORD Magic; +} CMF_HEADER_V2, *PCMF_HEADER_V2; + +typedef struct _CMF_HEADER_V1 +{ + DWORD BuildVersion; + DWORD Unknown0; + DWORD DataCount; + DWORD Unknown1; + DWORD EntryCount; + DWORD Magic; +} CMF_HEADER_V1, *PCMF_HEADER_V1; + +//----------------------------------------------------------------------------- +// Structure definitions for APM files + +// In-memory format +typedef struct _APM_ENTRY +{ + DWORD Index; + ULONGLONG HashA; + ULONGLONG HashB; +} APM_ENTRY, *PAPM_ENTRY; + +// On-disk format, size = 0x14 +typedef struct _APM_ENTRY_V2 +{ + DWORD Index; + DWORD HashA_Lo; // Must split the hashes in order to make this structure properly aligned + DWORD HashA_Hi; + DWORD HashB_Lo; + DWORD HashB_Hi; +} APM_ENTRY_V2, *PAPM_ENTRY_V2; + +// On-disk format, size = 0x0C +typedef struct _APM_ENTRY_V1 +{ + DWORD Index; + DWORD HashA_Lo; // Must split the hashes in order to make this structure properly aligned + DWORD HashA_Hi; +} APM_ENTRY_V1, *PAPM_ENTRY_V1; + +// In-memory format +typedef struct _APM_PACKAGE_ENTRY +{ + ULONGLONG PackageGUID; // 077 file + ULONGLONG Unknown1; + DWORD Unknown2; + DWORD Unknown3; + ULONGLONG Unknown4; +} APM_PACKAGE_ENTRY, *PAPM_PACKAGE_ENTRY; + +// On-disk format +typedef struct _APM_PACKAGE_ENTRY_V2 +{ + ULONGLONG PackageGUID; // 077 file + ULONGLONG Unknown1; + DWORD Unknown2; + DWORD Unknown3; + ULONGLONG Unknown4; +} APM_PACKAGE_ENTRY_V2, *PAPM_PACKAGE_ENTRY_V2; + +// On-disk format +typedef struct _APM_PACKAGE_ENTRY_V1 +{ + ULONGLONG EntryPointGUID; // virtual most likely + ULONGLONG PrimaryGUID; // real + ULONGLONG SecondaryGUID; // real + ULONGLONG Key; // encryption + ULONGLONG PackageGUID; // 077 file + ULONGLONG Unknown1; + DWORD Unknown2; +} APM_PACKAGE_ENTRY_V1, *PAPM_PACKAGE_ENTRY_V1; + +typedef struct _APM_HEADER_V3 +{ + ULONGLONG BuildNumber; // Build number of the game + ULONGLONG ZeroValue1; + DWORD ZeroValue2; + DWORD PackageCount; + DWORD ZeroValue3; + DWORD EntryCount; + DWORD Checksum; + + // Followed by the array of APM_ENTRY (count is in "EntryCount") + // Followed by the array of APM_PACKAGE (count is in "PackageCount") + +} APM_HEADER_V3, *PAPM_HEADER_V3; + +typedef struct _APM_HEADER_V2 +{ + ULONGLONG BuildNumber; // Build number of the game + ULONGLONG ZeroValue1; + DWORD PackageCount; + DWORD ZeroValue2; + DWORD EntryCount; + DWORD Checksum; + + // Followed by the array of APM_ENTRY (count is in "EntryCount") + // Followed by the array of APM_PACKAGE (count is in "PackageCount") + +} APM_HEADER_V2, *PAPM_HEADER_V2; + +typedef struct _APM_HEADER_V1 +{ + ULONGLONG BuildNumber; // Build number of the game + DWORD BuildVersion; + DWORD PackageCount; + DWORD EntryCount; + DWORD Checksum; + + // Followed by the array of APM_ENTRY (count is in "EntryCount") + // Followed by the array of APM_PACKAGE (count is in "PackageCount") + +} APM_HEADER_V1, *PAPM_HEADER_V1; + +//----------------------------------------------------------------------------- +// Handler classes + +/* +struct TCmfFile +{ + TCmfFile() + { + memset(this, 0, sizeof(TCmfFile)); + } + + LPBYTE CaptureHeader(LPBYTE pbCmfData, LPBYTE pbCmfEnd) + { + DWORD BuildNumber = *(PDWORD)pbCmfData; + + // Check the newest header version + if(BuildNumber >= 45104 && BuildNumber != 45214) + { + PCMF_HEADER_V3 pHeader3 = (PCMF_HEADER_V3)pbCmfData; + + if ((LPBYTE)(pHeader3 + 1) > pbCmfEnd) + return NULL; + + BuildVersion = pHeader3->BuildVersion; + DataCount = pHeader3->DataCount; + EntryCount = pHeader3->EntryCount; + Magic = pHeader3->Magic; + return (LPBYTE)(pHeader3 + 1); + } + + else if(BuildNumber >= 39028) + { + // TODO + assert(false); + return NULL; + } + + else + { + // TODO + assert(false); + return NULL; + } + } + + DWORD BuildVersion; + DWORD DataCount; + DWORD EntryCount; + DWORD Magic; +}; + +struct TApmFile +{ + TApmFile() + { + memset(this, 0, sizeof(TApmFile)); + } + + ~TApmFile() + { + CASC_FREE(pApmPackages); + CASC_FREE(pApmEntries); + } + + LPBYTE CaptureHeader(LPBYTE pbApmData, LPBYTE pbApmEnd) + { + // Check the data size for the largest possible header size + if((pbApmData + sizeof(APM_HEADER_V3)) < pbApmEnd) + { + // Try the version 3 + PAPM_HEADER_V3 pApmFile3 = (PAPM_HEADER_V3)(pbApmData); + if(pApmFile3->ZeroValue1 == 0 && pApmFile3->ZeroValue2 == 0 && pApmFile3->PackageCount && pApmFile3->EntryCount && pApmFile3->Checksum) + { + BuildNumber = pApmFile3->BuildNumber; + PackageCount = pApmFile3->PackageCount; + EntryCount = pApmFile3->EntryCount; + Checksum = pApmFile3->Checksum; + return pbApmData + 0x24; + } + + // Try the version 2 + PAPM_HEADER_V2 pApmFile2 = (PAPM_HEADER_V2)(pbApmData); + if(pApmFile2->ZeroValue1 == 0 && pApmFile2->PackageCount && pApmFile2->EntryCount && pApmFile2->Checksum) + { + BuildNumber = pApmFile2->BuildNumber; + PackageCount = pApmFile2->PackageCount; + EntryCount = pApmFile2->EntryCount; + Checksum = pApmFile2->Checksum; + return pbApmData + 0x20; + } + + // Try the version 1 (build 24919) + PAPM_HEADER_V1 pApmHeader1 = (PAPM_HEADER_V1)(pbApmData); + if(pApmHeader1->BuildVersion != 0 && pApmHeader1->PackageCount && pApmHeader1->EntryCount && pApmHeader1->Checksum) + { + BuildNumber = pApmHeader1->BuildNumber; + PackageCount = pApmHeader1->PackageCount; + EntryCount = pApmHeader1->EntryCount; + Checksum = pApmHeader1->Checksum; + return pbApmData + 0x18; + } + } + + return NULL; + } + + LPBYTE CaptureArrayOfEntries(LPBYTE pbArrayOfEntries, LPBYTE pbApmEnd) + { + // Allocate array of entries + pApmEntries = CASC_ALLOC(APM_ENTRY, EntryCount); + if(pApmEntries != NULL) + { + // The newest format + if(BuildNumber > 45104 && BuildNumber != 45214) + { + PAPM_ENTRY_V2 pEntry2 = (PAPM_ENTRY_V2)pbArrayOfEntries; + LPBYTE pbEntriesEnd = (LPBYTE)(pEntry2 + EntryCount); + + if(pbEntriesEnd <= pbApmEnd) + { + for(DWORD i = 0; i < EntryCount; i++) + { + pApmEntries[i].Index = pEntry2->Index; + pApmEntries[i].HashA = MAKE_OFFSET64(pEntry2->HashA_Hi, pEntry2->HashA_Lo); + pApmEntries[i].HashB = MAKE_OFFSET64(pEntry2->HashB_Hi, pEntry2->HashB_Lo); + } + + return pbEntriesEnd; + } + } + else + { + PAPM_ENTRY_V1 pEntry1 = (PAPM_ENTRY_V1)pbArrayOfEntries; + LPBYTE pbEntriesEnd = (LPBYTE)(pEntry1 + EntryCount); + + if(pbEntriesEnd <= pbApmEnd) + { + for(DWORD i = 0; i < EntryCount; i++) + { + pApmEntries[i].Index = pEntry1->Index; + pApmEntries[i].HashA = MAKE_OFFSET64(pEntry1->HashA_Hi, pEntry1->HashA_Lo); + pApmEntries[i].HashB = 0; + } + + return pbEntriesEnd; + } + } + } + + return NULL; + } + + LPBYTE CapturePackageEntries(LPBYTE pbArrayOfEntries, LPBYTE pbApmEnd) + { + // Allocate array of entries + pApmPackages = CASC_ALLOC(APM_PACKAGE_ENTRY, PackageCount); + if(pApmPackages != NULL) + { + // Zero the entire array + memset(pApmPackages, 0, PackageCount * sizeof(APM_PACKAGE_ENTRY)); + + // The newest format + if(BuildNumber > 45104 && BuildNumber != 45214) + { + PAPM_PACKAGE_ENTRY_V2 pEntry2 = (PAPM_PACKAGE_ENTRY_V2)pbArrayOfEntries; + LPBYTE pbEntriesEnd = (LPBYTE)(pEntry2 + PackageCount); + + if(pbEntriesEnd <= pbApmEnd) + { + for(DWORD i = 0; i < PackageCount; i++) + { + pApmPackages[i].PackageGUID = pEntry2[i].PackageGUID; + pApmPackages[i].Unknown1 = pEntry2[i].Unknown1; + pApmPackages[i].Unknown2 = pEntry2[i].Unknown2; + pApmPackages[i].Unknown3 = pEntry2[i].Unknown3; + pApmPackages[i].Unknown4 = pEntry2[i].Unknown4; + } + + return pbEntriesEnd; + } + } + else + { + PAPM_PACKAGE_ENTRY_V1 pEntry1 = (PAPM_PACKAGE_ENTRY_V1)pbArrayOfEntries; + LPBYTE pbEntriesEnd = (LPBYTE)(pEntry1 + PackageCount); + + if(pbEntriesEnd <= pbApmEnd) + { + for(DWORD i = 0; i < PackageCount; i++) + { + // TODO!!! + pApmPackages[i].PackageGUID = pEntry1->PackageGUID; + } + + return pbEntriesEnd; + } + } + } + + return NULL; + } + + PAPM_ENTRY pApmEntries; + PAPM_PACKAGE_ENTRY pApmPackages; + ULONGLONG BuildNumber; + DWORD PackageCount; + DWORD EntryCount; + DWORD Checksum; + size_t HeaderSize; + + // Followed by the array of APM_ENTRY (count is in "EntryCount") + // Followed by the array of APM_PACKAGE (count is in "PackageCount") + +}; +*/ + +//----------------------------------------------------------------------------- +// Handler definition for OVERWATCH root file + +// +// ------------------------------------- +// Overwatch ROOT file (build 24919): +// ------------------------------------- +// #MD5|CHUNK_ID|FILENAME|INSTALLPATH +// FE3AD8A77EEF77B383DF4929AED816FD|0|RetailClient/GameClientApp.exe|GameClientApp.exe +// 5EDDEFECA544B6472C5CD52BE63BC02F|0|RetailClient/Overwatch Launcher.exe|Overwatch Launcher.exe +// 6DE09F0A67F33F874F2DD8E2AA3B7AAC|0|RetailClient/ca-bundle.crt|ca-bundle.crt +// 99FE9EB6A4BB20209202F8C7884859D9|0|RetailClient/ortp_x64.dll|ortp_x64.dll +// +// ------------------------------------- +// Overwatch ROOT file (build 47161): +// ------------------------------------- +// #FILEID|MD5|CHUNK_ID|PRIORITY|MPRIORITY|FILENAME|INSTALLPATH +// RetailClient/Overwatch.exe|807F96661280C07E762A8C129FEBDA6F|0|0|255|RetailClient/Overwatch.exe|Overwatch.exe +// RetailClient/Overwatch Launcher.exe|5EDDEFECA544B6472C5CD52BE63BC02F|0|0|255|RetailClient/Overwatch Launcher.exe|Overwatch Launcher.exe +// RetailClient/ortp_x64.dll|7D1B5DEC267480F3E8DAD6B95143A59C|0|0|255|RetailClient/ortp_x64.dll|ortp_x64.dll +// + +struct TRootHandler_OW : public TFileTreeRoot +{ + TRootHandler_OW() : TFileTreeRoot(0) + { + // We have file names and return CKey as result of search + dwFeatures |= (CASC_FEATURE_FILE_NAMES | CASC_FEATURE_ROOT_CKEY); + } +/* + bool IsManifestFolderName(const char * szFileName, const char * szManifestFolder, size_t nLength) + { + if(!_strnicmp(szFileName, szManifestFolder, nLength)) + { + return (szFileName[nLength] == '\\' || szFileName[nLength] == '/'); + } + return false; + } + + bool IsApmFileName(const char * szFileName) + { + const char * szExtension; + + if(IsManifestFolderName(szFileName, "Manifest", 8) || IsManifestFolderName(szFileName, "TactManifest", 12)) + { + szExtension = GetFileExtension(szFileName); + if(!_stricmp(szExtension, ".apm")) + { + return true; + } + } + + return false; + } + + int LoadApmFile(TCascStorage * hs, CONTENT_KEY & CKey, const char * szFileName) + { + TApmFile ApmFile; + LPBYTE pbApmData; + DWORD cbApmData = 0; + int nError = ERROR_BAD_FORMAT; + + pbApmData = LoadInternalFileToMemory(hs, CKey.Value, CASC_OPEN_BY_CKEY, &cbApmData); + if(pbApmData != NULL) + { + LPBYTE pbApmEnd = pbApmData + cbApmData; + LPBYTE pbApmPtr = pbApmData; + + pbApmPtr = ApmFile.CaptureHeader(pbApmPtr, pbApmEnd); + if(pbApmPtr == NULL) + return ERROR_BAD_FORMAT; + + // Read the array of entries + pbApmPtr = ApmFile.CaptureArrayOfEntries(pbApmPtr, pbApmEnd); + if(pbApmPtr == NULL) + return ERROR_BAD_FORMAT; + + // Read the array of package entries + pbApmPtr = ApmFile.CapturePackageEntries(pbApmPtr, pbApmEnd); + if(pbApmPtr == NULL) + return ERROR_BAD_FORMAT; + + CASC_FREE(pbApmData); + } + + return nError; + } + + static int LoadCmfFile(TCascStorage * hs, CONTENT_KEY & CKey, const char * szFileName) + { + TCmfFile CmfFile; + LPBYTE pbCmfData; + DWORD cbCmfData = 0; + + int nError = ERROR_BAD_FORMAT; + + pbCmfData = LoadInternalFileToMemory(hs, CKey.Value, CASC_OPEN_BY_CKEY, &cbCmfData); + if(pbCmfData != NULL) + { + LPBYTE pbCmfEnd = pbCmfData + cbCmfData; + LPBYTE pbCmfPtr = pbCmfData; + + // Capture the CMF header + pbCmfPtr = CmfFile.CaptureHeader(pbCmfPtr, pbCmfEnd); + if(pbCmfPtr == NULL) + return ERROR_BAD_FORMAT; + +// if(CmfFile.Magic >= 0x636D6614) +// DecryptCmfFile( + + CASC_FREE(pbCmfData); + } + + return nError; + } +*/ + int Load(TCascStorage * hs, CASC_CSV & Csv, size_t nFileNameIndex, size_t nCKeyIndex) + { + PCASC_CKEY_ENTRY pCKeyEntry; +// size_t ApmFiles[0x80]; +// size_t nApmFiles = 0; + BYTE CKey[MD5_HASH_SIZE]; + + CASCLIB_UNUSED(hs); + + // Keep loading every line until there is something + while(Csv.LoadNextLine()) + { + const CASC_CSV_COLUMN & FileName = Csv[CSV_ZERO][nFileNameIndex]; + const CASC_CSV_COLUMN & CKeyStr = Csv[CSV_ZERO][nCKeyIndex]; + + // Retrieve the file name and the content key + if(FileName.szValue && CKeyStr.szValue && CKeyStr.nLength == MD5_STRING_SIZE) + { + // Convert the string CKey to binary + if(ConvertStringToBinary(CKeyStr.szValue, MD5_STRING_SIZE, CKey) == ERROR_SUCCESS) + { + // Find the item in the tree + if((pCKeyEntry = FindCKeyEntry_CKey(hs, CKey)) != NULL) + { + // Insert the file name and the CKey into the tree + FileTree.InsertByName(pCKeyEntry, FileName.szValue); + + // If the file name is actually an asset, we need to parse that asset and load files in it +// if(IsApmFileName(szFileName)) +// { +// ApmFiles[nApmFiles++] = FileTree_IndexOf(&pRootHandler->FileTree, pFileNode1); +// } + } + } + } + } +/* + // Load all CMF+APM files + if(nError == ERROR_SUCCESS) + { + for(size_t i = 0; i < nApmFiles; i++) + { + char szApmFile[MAX_PATH + 1]; + char szCmfFile[MAX_PATH + 1]; + + // Get the n-th item and its name + pFileNode1 = (PCASC_FILE_NODE)FileTree_PathAt(&pRootHandler->FileTree, szApmFile, MAX_PATH, ApmFiles[i]); + if(pFileNode1 == NULL) + break; + + if(strcmp(szApmFile, "TactManifest\\Win_SPWin_RDEV_LenUS_EExt.apm")) + continue; + + // Get the name of thew CMF file + CascStrCopy(szCmfFile, _countof(szCmfFile), szApmFile); + CascStrCopy((char *)GetFileExtension(szCmfFile), 5, ".cmf"); + pFileNode2 = (PCASC_FILE_NODE)FileTree_Find(&pRootHandler->FileTree, szCmfFile); + if(pFileNode2 == NULL) + break; + + // Create the map of CMF entries + nError = LoadCmfFile(hs, pFileNode2->CKey, szCmfFile); + if(nError != ERROR_SUCCESS) + break; + + } + } +*/ + return ERROR_SUCCESS; + } +}; + +//----------------------------------------------------------------------------- +// Public functions + +// TODO: There is way more files in the Overwatch CASC storage than present in the ROOT file. +int RootHandler_CreateOverwatch(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile) +{ + TRootHandler_OW * pRootHandler = NULL; + CASC_CSV Csv(0, true); + size_t Indices[2]; + int nError; + + // Load the ROOT file + nError = Csv.Load(pbRootFile, cbRootFile); + if(nError == ERROR_SUCCESS) + { + // Retrieve the indices of the file name and MD5 columns + Indices[0] = Csv.GetColumnIndex("FILENAME"); + Indices[1] = Csv.GetColumnIndex("MD5"); + + // If both indices were found OK, then load the root file + if(Indices[0] != CSV_INVALID_INDEX && Indices[1] != CSV_INVALID_INDEX) + { + pRootHandler = new TRootHandler_OW(); + if (pRootHandler != NULL) + { + // Load the root directory. If load failed, we free the object + nError = pRootHandler->Load(hs, Csv, Indices[0], Indices[1]); + if (nError != ERROR_SUCCESS) + { + delete pRootHandler; + pRootHandler = NULL; + } + } + } + else + { + nError = ERROR_BAD_FORMAT; + } + } + + // Assign the root directory (or NULL) and return error + hs->pRootHandler = pRootHandler; + return nError; +} diff --git a/dep/CascLib/src/CascRootFile_Ovr.cpp b/dep/CascLib/src/CascRootFile_Ovr.cpp deleted file mode 100644 index 05ce13bd67a..00000000000 --- a/dep/CascLib/src/CascRootFile_Ovr.cpp +++ /dev/null @@ -1,213 +0,0 @@ -/*****************************************************************************/ -/* CascRootFile_Ovr.cpp Copyright (c) Ladislav Zezula 2015 */ -/*---------------------------------------------------------------------------*/ -/* Support for loading Overwatch ROOT file */ -/*---------------------------------------------------------------------------*/ -/* Date Ver Who Comment */ -/* -------- ---- --- ------- */ -/* 28.10.15 1.00 Lad The first version of CascRootFile_Ovr.cpp */ -/*****************************************************************************/ - -#define __CASCLIB_SELF__ -#include "CascLib.h" -#include "CascCommon.h" - -//----------------------------------------------------------------------------- -// Structure definitions for Overwatch root file - -typedef struct _CASC_FILE_ENTRY -{ - ENCODING_KEY EncodingKey; // Encoding key - ULONGLONG FileNameHash; // File name hash - DWORD dwFileName; // Offset of the file name in the name cache -} CASC_FILE_ENTRY, *PCASC_FILE_ENTRY; - -struct TRootHandler_Ovr : public TRootHandler -{ - // Linear global list of file entries - DYNAMIC_ARRAY FileTable; - - // Linear global list of names - DYNAMIC_ARRAY FileNames; - - // Global map of FileName -> FileEntry - PCASC_MAP pRootMap; -}; - -//----------------------------------------------------------------------------- -// Local functions - -static int InsertFileEntry( - TRootHandler_Ovr * pRootHandler, - const char * szFileName, - LPBYTE pbEncodingKey) -{ - PCASC_FILE_ENTRY pFileEntry; - size_t nLength = strlen(szFileName); - - // Attempt to insert the file name to the global buffer - szFileName = (char *)Array_Insert(&pRootHandler->FileNames, szFileName, nLength + 1); - if(szFileName == NULL) - return ERROR_NOT_ENOUGH_MEMORY; - - // Attempt to insert the entry to the array of file entries - pFileEntry = (PCASC_FILE_ENTRY)Array_Insert(&pRootHandler->FileTable, NULL, 1); - if(pFileEntry == NULL) - return ERROR_NOT_ENOUGH_MEMORY; - - // Fill the file entry - pFileEntry->EncodingKey = *(PENCODING_KEY)pbEncodingKey; - pFileEntry->FileNameHash = CalcFileNameHash(szFileName); - pFileEntry->dwFileName = (DWORD)Array_IndexOf(&pRootHandler->FileNames, szFileName); - - // Insert the file entry to the map - assert(Map_FindObject(pRootHandler->pRootMap, &pFileEntry->FileNameHash, NULL) == NULL); - Map_InsertObject(pRootHandler->pRootMap, pFileEntry, &pFileEntry->FileNameHash); - return ERROR_SUCCESS; -} - -//----------------------------------------------------------------------------- -// Implementation of Overwatch root file - -static int OvrHandler_Insert( - TRootHandler_Ovr * pRootHandler, - const char * szFileName, - LPBYTE pbEncodingKey) -{ - return InsertFileEntry(pRootHandler, szFileName, pbEncodingKey); -} - -static LPBYTE OvrHandler_Search(TRootHandler_Ovr * pRootHandler, TCascSearch * pSearch, PDWORD /* PtrFileSize */, PDWORD /* PtrLocaleFlags */, PDWORD /* PtrFileDataId */) -{ - PCASC_FILE_ENTRY pFileEntry; - - // Are we still inside the root directory range? - while(pSearch->IndexLevel1 < pRootHandler->FileTable.ItemCount) - { - // Retrieve the file item - pFileEntry = (PCASC_FILE_ENTRY)Array_ItemAt(&pRootHandler->FileTable, pSearch->IndexLevel1); - strcpy(pSearch->szFileName, (char *)Array_ItemAt(&pRootHandler->FileNames, pFileEntry->dwFileName)); - - // Prepare the pointer to the next search - pSearch->IndexLevel1++; - return pFileEntry->EncodingKey.Value; - } - - // No more entries - return NULL; -} - -static void OvrHandler_EndSearch(TRootHandler_Ovr * /* pRootHandler */, TCascSearch * /* pSearch */) -{ - // Do nothing -} - -static LPBYTE OvrHandler_GetKey(TRootHandler_Ovr * pRootHandler, const char * szFileName) -{ - ULONGLONG FileNameHash = CalcFileNameHash(szFileName); - - return (LPBYTE)Map_FindObject(pRootHandler->pRootMap, &FileNameHash, NULL); -} - -static DWORD OvrHandler_GetFileId(TRootHandler_Ovr * /* pRootHandler */, const char * /* szFileName */) -{ - // Not implemented for Overwatch - return 0; -} - -static void OvrHandler_Close(TRootHandler_Ovr * pRootHandler) -{ - if(pRootHandler != NULL) - { - // Free the file map - if(pRootHandler->pRootMap) - Map_Free(pRootHandler->pRootMap); - pRootHandler->pRootMap = NULL; - - // Free the array of the file names and file items - Array_Free(&pRootHandler->FileTable); - Array_Free(&pRootHandler->FileNames); - - // Free the root file itself - CASC_FREE(pRootHandler); - } -} - -//----------------------------------------------------------------------------- -// Public functions - -int RootHandler_CreateOverwatch(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile) -{ - TRootHandler_Ovr * pRootHandler; - ENCODING_KEY KeyBuffer; - QUERY_KEY EncodingKey = {KeyBuffer.Value, MD5_HASH_SIZE}; - void * pTextFile; - size_t nLength; - char szOneLine[0x200]; - char szFileName[MAX_PATH+1]; - DWORD dwFileCountMax = (DWORD)hs->pEncodingMap->TableSize; - int nFileNameIndex; - int nError = ERROR_SUCCESS; - - // Allocate the root handler object - hs->pRootHandler = pRootHandler = CASC_ALLOC(TRootHandler_Ovr, 1); - if(pRootHandler == NULL) - return ERROR_NOT_ENOUGH_MEMORY; - - // Fill-in the handler functions - memset(pRootHandler, 0, sizeof(TRootHandler_Ovr)); - pRootHandler->Insert = (ROOT_INSERT)OvrHandler_Insert; - pRootHandler->Search = (ROOT_SEARCH)OvrHandler_Search; - pRootHandler->EndSearch = (ROOT_ENDSEARCH)OvrHandler_EndSearch; - pRootHandler->GetKey = (ROOT_GETKEY)OvrHandler_GetKey; - pRootHandler->Close = (ROOT_CLOSE)OvrHandler_Close; - pRootHandler->GetFileId = (ROOT_GETFILEID)OvrHandler_GetFileId; - - // Fill-in the flags - pRootHandler->dwRootFlags |= ROOT_FLAG_HAS_NAMES; - - // Allocate the linear array of file entries - nError = Array_Create(&pRootHandler->FileTable, CASC_FILE_ENTRY, 0x10000); - if(nError != ERROR_SUCCESS) - return nError; - - // Allocate the buffer for the file names - nError = Array_Create(&pRootHandler->FileNames, char, 0x10000); - if(nError != ERROR_SUCCESS) - return nError; - - // Create map of ROOT_ENTRY -> FileEntry - pRootHandler->pRootMap = Map_Create(dwFileCountMax, sizeof(ULONGLONG), FIELD_OFFSET(CASC_FILE_ENTRY, FileNameHash)); - if(pRootHandler->pRootMap == NULL) - return ERROR_NOT_ENOUGH_MEMORY; - - // Parse the ROOT file - pTextFile = ListFile_FromBuffer(pbRootFile, cbRootFile); - if(pTextFile != NULL) - { - // Get the initial line, containing variable names - nLength = ListFile_GetNextLine(pTextFile, szOneLine, _maxchars(szOneLine)); - - // Determine the index of the "FILENAME" variable - nError = GetRootVariableIndex(szOneLine, szOneLine + nLength, "FILENAME", &nFileNameIndex); - if(nError == ERROR_SUCCESS) - { - // Parse the next lines - while((nLength = ListFile_GetNextLine(pTextFile, szOneLine, _maxchars(szOneLine))) > 0) - { - // Parse the line - nError = ParseRootFileLine(szOneLine, szOneLine + nLength, nFileNameIndex, &EncodingKey, szFileName, _maxchars(szFileName)); - if(nError == ERROR_SUCCESS) - { - InsertFileEntry(pRootHandler, szFileName, KeyBuffer.Value); - } - } - } - - // Free the listfile - ListFile_Free(pTextFile); - } - - // Succeeded - return nError; -} diff --git a/dep/CascLib/src/CascRootFile_SC1.cpp b/dep/CascLib/src/CascRootFile_SC1.cpp deleted file mode 100644 index a795cfd8d96..00000000000 --- a/dep/CascLib/src/CascRootFile_SC1.cpp +++ /dev/null @@ -1,214 +0,0 @@ -/*****************************************************************************/ -/* CascRootFile_SC1.cpp Copyright (c) Ladislav Zezula 2017 */ -/*---------------------------------------------------------------------------*/ -/* Support for loading Starcraft 1 ROOT file */ -/*---------------------------------------------------------------------------*/ -/* Date Ver Who Comment */ -/* -------- ---- --- ------- */ -/* 28.10.15 1.00 Lad The first version of CascRootFile_SC1.cpp */ -/*****************************************************************************/ - -#define __CASCLIB_SELF__ -#include "CascLib.h" -#include "CascCommon.h" - -//----------------------------------------------------------------------------- -// Structure definitions for Overwatch root file - -typedef struct _CASC_FILE_ENTRY -{ - ENCODING_KEY EncodingKey; // Encoding key - ULONGLONG FileNameHash; // File name hash - DWORD dwFileName; // Offset of the file name in the name cache -} CASC_FILE_ENTRY, *PCASC_FILE_ENTRY; - -struct TRootHandler_SC1 : public TRootHandler -{ - // Linear global list of file entries - DYNAMIC_ARRAY FileTable; - - // Linear global list of names - DYNAMIC_ARRAY FileNames; - - // Global map of FileName -> FileEntry - PCASC_MAP pRootMap; -}; - -//----------------------------------------------------------------------------- -// Local functions - -static int InsertFileEntry( - TRootHandler_SC1 * pRootHandler, - const char * szFileName, - LPBYTE pbEncodingKey) -{ - PCASC_FILE_ENTRY pFileEntry; - size_t nLength = strlen(szFileName); - - // Attempt to insert the file name to the global buffer - szFileName = (char *)Array_Insert(&pRootHandler->FileNames, szFileName, nLength + 1); - if(szFileName == NULL) - return ERROR_NOT_ENOUGH_MEMORY; - - // Attempt to insert the entry to the array of file entries - pFileEntry = (PCASC_FILE_ENTRY)Array_Insert(&pRootHandler->FileTable, NULL, 1); - if(pFileEntry == NULL) - return ERROR_NOT_ENOUGH_MEMORY; - - // Fill the file entry - pFileEntry->EncodingKey = *(PENCODING_KEY)pbEncodingKey; - pFileEntry->FileNameHash = CalcFileNameHash(szFileName); - pFileEntry->dwFileName = (DWORD)Array_IndexOf(&pRootHandler->FileNames, szFileName); - - // Insert the file entry to the map - assert(Map_FindObject(pRootHandler->pRootMap, &pFileEntry->FileNameHash, NULL) == NULL); - Map_InsertObject(pRootHandler->pRootMap, pFileEntry, &pFileEntry->FileNameHash); - return ERROR_SUCCESS; -} - -//----------------------------------------------------------------------------- -// Implementation of Overwatch root file - -static int SC1Handler_Insert( - TRootHandler_SC1 * pRootHandler, - const char * szFileName, - LPBYTE pbEncodingKey) -{ - return InsertFileEntry(pRootHandler, szFileName, pbEncodingKey); -} - -static LPBYTE SC1Handler_Search(TRootHandler_SC1 * pRootHandler, TCascSearch * pSearch, PDWORD /* PtrFileSize */, PDWORD /* PtrLocaleFlags */, PDWORD /* PtrFileDataId */) -{ - PCASC_FILE_ENTRY pFileEntry; - - // Are we still inside the root directory range? - while(pSearch->IndexLevel1 < pRootHandler->FileTable.ItemCount) - { - // Retrieve the file item - pFileEntry = (PCASC_FILE_ENTRY)Array_ItemAt(&pRootHandler->FileTable, pSearch->IndexLevel1); - - // Prepare the pointer to the next search - pSearch->IndexLevel1++; - - char *filename = (char *)Array_ItemAt(&pRootHandler->FileNames, pFileEntry->dwFileName); - if (CheckWildCard(filename, pSearch->szMask)) { - strcpy(pSearch->szFileName, filename); - return pFileEntry->EncodingKey.Value; - } - } - - // No more entries - return NULL; -} - -static void SC1Handler_EndSearch(TRootHandler_SC1 * /* pRootHandler */, TCascSearch * /* pSearch */) -{ - // Do nothing -} - -static LPBYTE SC1Handler_GetKey(TRootHandler_SC1 * pRootHandler, const char * szFileName) -{ - ULONGLONG FileNameHash = CalcFileNameHash(szFileName); - - return (LPBYTE)Map_FindObject(pRootHandler->pRootMap, &FileNameHash, NULL); -} - -static DWORD SC1Handler_GetFileId(TRootHandler_SC1 * /* pRootHandler */, const char * /* szFileName */) -{ - // Not implemented for Overwatch - return 0; -} - -static void SC1Handler_Close(TRootHandler_SC1 * pRootHandler) -{ - if(pRootHandler != NULL) - { - // Free the file map - if(pRootHandler->pRootMap) - Map_Free(pRootHandler->pRootMap); - pRootHandler->pRootMap = NULL; - - // Free the array of the file names and file items - Array_Free(&pRootHandler->FileTable); - Array_Free(&pRootHandler->FileNames); - - // Free the root file itself - CASC_FREE(pRootHandler); - } -} - -//----------------------------------------------------------------------------- -// Public functions - -int RootHandler_CreateSC1(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile) -{ - TRootHandler_SC1 * pRootHandler; - ENCODING_KEY KeyBuffer; - QUERY_KEY EncodingKey = {KeyBuffer.Value, MD5_HASH_SIZE}; - void * pTextFile; - size_t nLength; - char szOneLine[0x200]; - DWORD dwFileCountMax = (DWORD)hs->pEncodingMap->TableSize; - int nError = ERROR_SUCCESS; - - // Allocate the root handler object - hs->pRootHandler = pRootHandler = CASC_ALLOC(TRootHandler_SC1, 1); - if(pRootHandler == NULL) - return ERROR_NOT_ENOUGH_MEMORY; - - // Fill-in the handler functions - memset(pRootHandler, 0, sizeof(TRootHandler_SC1)); - pRootHandler->Insert = (ROOT_INSERT)SC1Handler_Insert; - pRootHandler->Search = (ROOT_SEARCH)SC1Handler_Search; - pRootHandler->EndSearch = (ROOT_ENDSEARCH)SC1Handler_EndSearch; - pRootHandler->GetKey = (ROOT_GETKEY)SC1Handler_GetKey; - pRootHandler->Close = (ROOT_CLOSE)SC1Handler_Close; - pRootHandler->GetFileId = (ROOT_GETFILEID)SC1Handler_GetFileId; - - // Fill-in the flags - pRootHandler->dwRootFlags |= ROOT_FLAG_HAS_NAMES; - - // Allocate the linear array of file entries - nError = Array_Create(&pRootHandler->FileTable, CASC_FILE_ENTRY, 0x10000); - if(nError != ERROR_SUCCESS) - return nError; - - // Allocate the buffer for the file names - nError = Array_Create(&pRootHandler->FileNames, char, 0x10000); - if(nError != ERROR_SUCCESS) - return nError; - - // Create map of ROOT_ENTRY -> FileEntry - pRootHandler->pRootMap = Map_Create(dwFileCountMax, sizeof(ULONGLONG), FIELD_OFFSET(CASC_FILE_ENTRY, FileNameHash)); - if(pRootHandler->pRootMap == NULL) - return ERROR_NOT_ENOUGH_MEMORY; - - // Parse the ROOT file - pTextFile = ListFile_FromBuffer(pbRootFile, cbRootFile); - if(pTextFile != NULL) - { - // Parse the next lines - while((nLength = ListFile_GetNextLine(pTextFile, szOneLine, _maxchars(szOneLine))) > 0) - { - LPSTR szEncodingKey; - BYTE EncodingKey[MD5_HASH_SIZE]; - - szEncodingKey = strchr(szOneLine, _T('|')); - if(szEncodingKey != NULL) - { - // Split the name and encoding key - *szEncodingKey++ = 0; - - // Insert the entry to the map - ConvertStringToBinary(szEncodingKey, MD5_STRING_SIZE, EncodingKey); - InsertFileEntry(pRootHandler, szOneLine, EncodingKey); - } - } - - // Free the listfile - ListFile_Free(pTextFile); - } - - // Succeeded - return nError; -} diff --git a/dep/CascLib/src/CascRootFile_TVFS.cpp b/dep/CascLib/src/CascRootFile_TVFS.cpp new file mode 100644 index 00000000000..b115a215037 --- /dev/null +++ b/dep/CascLib/src/CascRootFile_TVFS.cpp @@ -0,0 +1,634 @@ +/*****************************************************************************/ +/* CascRootFile_TVFS.cpp Copyright (c) Ladislav Zezula 2018 */ +/*---------------------------------------------------------------------------*/ +/* ROOT handler for TACT VFS manifest format (root) */ +/* Note: TACT = Trusted Application Content Transfer */ +/*---------------------------------------------------------------------------*/ +/* Date Ver Who Comment */ +/* -------- ---- --- ------- */ +/* 24.05.18 1.00 Lad The first version of CascRootFile_TVFS.cpp */ +/*****************************************************************************/ + +#define __CASCLIB_SELF__ +#include "CascLib.h" +#include "CascCommon.h" + +//----------------------------------------------------------------------------- +// Local defines + +#define TVFS_FLAG_INCLUDE_CKEY 0x0001 // Include C-key in content file record +#define TVFS_FLAG_WRITE_SUPPORT 0x0002 // Write support. Include a table of encoding specifiers. This is required for writing files to the underlying storage. This bit is implied by the patch-support bit +#define TVFS_FLAG_PATCH_SUPPORT 0x0004 // Patch support. Include patch records in the content file records. +#define TVFS_FLAG_LOWERCASE_MANIFEST 0x0008 // Lowercase manifest. All paths in the path table have been converted to ASCII lowercase (i.e. [A-Z] converted to [a-z]) + +#define TVFS_PTE_PATH_SEPARATOR_PRE 0x0001 // There is path separator before the name +#define TVFS_PTE_PATH_SEPARATOR_POST 0x0002 // There is path separator after the name +#define TVFS_PTE_NODE_VALUE 0x0004 // The NodeValue in path table entry is valid + +#define TVFS_FOLDER_NODE 0x80000000 // Highest bit is set if a file node is a folder +#define TVFS_FOLDER_SIZE_MASK 0x7FFFFFFF // Mask to get length of the folder + +//----------------------------------------------------------------------------- +// Local structures + +// In-memory layout of the TVFS file header +typedef struct _TVFS_DIRECTORY_HEADER +{ + DWORD Signature; // Must be CASC_TVFS_ROOT_SIGNATURE + BYTE FormatVersion; // Version of the format. Should be 1. + BYTE HeaderSize; // Size of the header, in bytes + BYTE EKeySize; // Size of an E-Key. TACT uses 9-byte E-keys + BYTE PatchKeySize; // Size of a patch key. TACT uses 9-byte P-keys + DWORD Flags; // Flags. See TVFS_FLAG_XXX + + // Followed by the offset table (variable length) + DWORD PathTableOffset; // Offset of the path table + DWORD PathTableSize; // Size of the path table + DWORD VfsTableOffset; // Offset of the VFS table + DWORD VfsTableSize; // Size of the VFS table + DWORD CftTableOffset; // Offset of the container file table + DWORD CftTableSize; // Size of the container file table + USHORT MaxDepth; // The maximum depth of the path prefix tree stored in the path table + DWORD EstTableOffset; // The offset of the encoding specifier table. Only if the write-support bit is set in the header flag + DWORD EstTableSize; // The size of the encoding specifier table. Only if the write-support bit is set in the header flag + + DWORD CftOffsSize; // Byte length of the offset in the Content File Table entry + DWORD EstOffsSize; // Byte length of the offset in the Encoding Specifier Table entry + + LPBYTE pbDirectoryData; // Pointer to the begin of directory data + LPBYTE pbDirectoryEnd; // Pointer to the end of directory data + +// LPBYTE pbPathFileTable; // Begin and end of the path table +// LPBYTE pbPathTableEnd; + +// LPBYTE pbVfsFileTable; // Begin and end of the VFS file table +// LPBYTE pbVfsTableEnd; + +// LPBYTE pbCftFileTable; // Begin and end of the content file table +// LPBYTE pbCftTableEnd; + +} TVFS_DIRECTORY_HEADER, *PTVFS_DIRECTORY_HEADER; + +/* +// Minimum size of a valid path table entry. 1 byte + 1-byte name + 1 byte + DWORD +#define TVFS_HEADER_LENGTH FIELD_OFFSET(TVFS_DIRECTORY_HEADER, CftOffsSize) + +// Minimum size of a valid path table entry. 1 byte + 1-byte name + 1 byte + DWORD +#define TVFS_MIN_PATH_ENTRY (1 + 1 + 1 + sizeof(DWORD)) + +// Minimum size of the VFS entry (SpanCount + FileOffset + SpanLength + CftOffset) +#define TVFS_MIN_VFS_ENTRY (1 + sizeof(DWORD) + sizeof(DWORD) + 1) + +// Minimum size of the Content File Table entry (CASC_EKEY_SIZE + EncodedSize + ContentSize) +#define TVFS_MIN_CFT_ENTRY (CASC_EKEY_SIZE + sizeof(DWORD) + sizeof(DWORD)) + +// Minimum size of the TVFS folder data +#define TVFS_MIN_FILE_SIZE (TVFS_HEADER_LENGTH + TVFS_MIN_PATH_ENTRY + TVFS_MIN_VFS_ENTRY + TVFS_MIN_CFT_ENTRY) + +// Maximum estimated file table. Empirically set to 8 MB, increase if needed. +#define TVFS_MAX_FILE_SIZE 0x00800000 +*/ + +// In-memory layout of the path table entry +typedef struct _TVFS_PATH_TABLE_ENTRY +{ + LPBYTE pbNamePtr; // Pointer to the begin of the node name + LPBYTE pbNameEnd; // Pointer to the end of the file name + DWORD NodeFlags; // TVFS_PTE_XXX + DWORD NodeValue; // Node value +} TVFS_PATH_TABLE_ENTRY, *PTVFS_PATH_TABLE_ENTRY; + +//----------------------------------------------------------------------------- +// Handler definition for TVFS root file + +//static FILE * fp = NULL; + +// Structure for the root handler +struct TRootHandler_TVFS : public TFileTreeRoot +{ + public: + + TRootHandler_TVFS() : TFileTreeRoot(0) + { + // TVFS supports file names, but DOESN'T support CKeys. + dwFeatures |= CASC_FEATURE_FILE_NAMES; + dwNestLevel = 0; + } + + // Returns size of "container file table offset" fiels in the VFS. + // - If the container file table is larger than 0xffffff bytes, it's 4 bytes + // - If the container file table is larger than 0xffff bytes, it's 3 bytes + // - If the container file table is larger than 0xff bytes, it's 2 bytes + // - If the container file table is smaller than 0xff bytes, it's 1 byte + static DWORD GetOffsetFieldSize(DWORD dwTableSize) + { + if(dwTableSize > 0xffffff) + return 4; + if(dwTableSize > 0xffff) + return 3; + if(dwTableSize > 0xff) + return 2; + return 1; + } + + bool PathBuffer_AddChar(PATH_BUFFER & PathBuffer, char chOneChar) + { + if(PathBuffer.szPtr >= PathBuffer.szEnd) + return false; + + *PathBuffer.szPtr++ = chOneChar; + *PathBuffer.szPtr = 0; + return true; + } + + bool PathBuffer_AddString(PATH_BUFFER & PathBuffer, LPBYTE pbNamePtr, LPBYTE pbNameEnd) + { + size_t nLength = (pbNameEnd - pbNamePtr); + + // Check whether we have enough space + if ((PathBuffer.szPtr + nLength) > PathBuffer.szEnd) + return false; + + // Copy the node name + memcpy(PathBuffer.szPtr, pbNamePtr, nLength); + PathBuffer.szPtr += nLength; + return true; + } + + bool PathBuffer_AppendNode(PATH_BUFFER & PathBuffer, TVFS_PATH_TABLE_ENTRY & PathEntry) + { + // Append the prefix separator, if needed + if (PathEntry.NodeFlags & TVFS_PTE_PATH_SEPARATOR_PRE) + PathBuffer_AddChar(PathBuffer, '/'); + + // Append the name fragment, if any + if (PathEntry.pbNameEnd > PathEntry.pbNamePtr) + PathBuffer_AddString(PathBuffer, PathEntry.pbNamePtr, PathEntry.pbNameEnd); + + // Append the postfix separator, if needed + if (PathEntry.NodeFlags & TVFS_PTE_PATH_SEPARATOR_POST) + PathBuffer_AddChar(PathBuffer, '/'); + + // Always end the buffer with zero + PathBuffer.szPtr[0] = 0; + return true; + } + + static int CaptureDirectoryHeader(TVFS_DIRECTORY_HEADER & DirHeader, LPBYTE pbDataPtr, LPBYTE pbDataEnd) + { + // Fill the header structure with zeros + memset(&DirHeader, 0, sizeof(TVFS_DIRECTORY_HEADER)); + DirHeader.pbDirectoryData = pbDataPtr; + DirHeader.pbDirectoryEnd = pbDataEnd; + + // Capture the signature + pbDataPtr = CaptureInteger32(pbDataPtr, pbDataEnd, &DirHeader.Signature); + if(pbDataPtr == NULL || DirHeader.Signature != CASC_TVFS_ROOT_SIGNATURE) + return ERROR_BAD_FORMAT; + + // Capture the other four integers + pbDataPtr = CaptureByteArray(pbDataPtr, pbDataEnd, 4, &DirHeader.FormatVersion); + if(pbDataPtr == NULL || DirHeader.FormatVersion != 1 || DirHeader.EKeySize != 9 || DirHeader.PatchKeySize != 9 || DirHeader.HeaderSize < 8) + return ERROR_BAD_FORMAT; + + // Capture the rest + pbDataPtr = CaptureByteArray(pbDataPtr, pbDataEnd, DirHeader.HeaderSize - FIELD_OFFSET(TVFS_DIRECTORY_HEADER, Flags), (LPBYTE)(&DirHeader.Flags)); + if(pbDataPtr == NULL) + return ERROR_BAD_FORMAT; + + // Swap the header values + DirHeader.Flags = ConvertBytesToInteger_4_LE((LPBYTE)(&DirHeader.Flags)); + + // Swap the offset table values + DirHeader.PathTableOffset = ConvertBytesToInteger_4((LPBYTE)(&DirHeader.PathTableOffset)); + DirHeader.PathTableSize = ConvertBytesToInteger_4((LPBYTE)(&DirHeader.PathTableSize)); + DirHeader.VfsTableOffset = ConvertBytesToInteger_4((LPBYTE)(&DirHeader.VfsTableOffset)); + DirHeader.VfsTableSize = ConvertBytesToInteger_4((LPBYTE)(&DirHeader.VfsTableSize)); + DirHeader.CftTableOffset = ConvertBytesToInteger_4((LPBYTE)(&DirHeader.CftTableOffset)); + DirHeader.CftTableSize = ConvertBytesToInteger_4((LPBYTE)(&DirHeader.CftTableSize)); + DirHeader.MaxDepth = (USHORT)ConvertBytesToInteger_2((LPBYTE)(&DirHeader.MaxDepth)); + DirHeader.EstTableOffset = ConvertBytesToInteger_4((LPBYTE)(&DirHeader.EstTableOffset)); + DirHeader.EstTableSize = ConvertBytesToInteger_4((LPBYTE)(&DirHeader.EstTableSize)); + + // Determine size of file table offsets + DirHeader.CftOffsSize = GetOffsetFieldSize(DirHeader.CftTableSize); + DirHeader.EstOffsSize = GetOffsetFieldSize(DirHeader.EstTableSize); + + // Capture the path table +// DirHeader.pbPathFileTable = pbDirectory + DirHeader.PathTableOffset; +// DirHeader.pbPathTableEnd = pbDirectory + DirHeader.PathTableOffset + DirHeader.PathTableSize; +// if(DirHeader.pbPathTableEnd > pbDataEnd) +// return ERROR_BAD_FORMAT; + + // Capture the VFS file table +// DirHeader.pbVfsFileTable = pbDirectory + DirHeader.VfsTableOffset; +// DirHeader.pbVfsTableEnd = pbDirectory + DirHeader.VfsTableOffset + DirHeader.VfsTableSize; +// if(DirHeader.pbVfsTableEnd > pbDataEnd) +// return ERROR_BAD_FORMAT; + + // Capture the container file table +// DirHeader.pbCftFileTable = pbDirectory + DirHeader.CftTableOffset; +// DirHeader.pbCftTableEnd = pbDirectory + DirHeader.CftTableOffset + DirHeader.CftTableSize; +// if(DirHeader.pbCftTableEnd > pbDataEnd) +// return ERROR_BAD_FORMAT; + + return ERROR_SUCCESS; + } + + int CaptureVfsSpanEntries(TVFS_DIRECTORY_HEADER & DirHeader, PENCODED_KEY pEKey, PDWORD PtrSpanSize, DWORD dwVfsOffset) + { + LPBYTE pbVfsFileTable = DirHeader.pbDirectoryData + DirHeader.VfsTableOffset; + LPBYTE pbVfsFileEntry = pbVfsFileTable + dwVfsOffset; + LPBYTE pbVfsFileEnd = pbVfsFileTable + DirHeader.VfsTableSize; + LPBYTE pbCftFileTable; + LPBYTE pbCftFileEntry; + LPBYTE pbCftFileEnd; + LPBYTE pbTemp = NULL; + size_t ItemSize = sizeof(DWORD) + sizeof(DWORD) + DirHeader.CftOffsSize; + DWORD dwCftOffset; + DWORD dwSpanCount; + DWORD dwSpanSize; + + // Get the number of span entries + if(!(pbVfsFileTable <= pbVfsFileEntry && pbVfsFileEntry <= pbVfsFileEnd)) + return ERROR_INVALID_PARAMETER; + dwSpanCount = *pbVfsFileEntry++; + + // 1 - 224 = valid file, 225-254 = other file, 255 = deleted file + // We will ignore all files with unsupported span count + if(dwSpanCount == 0 || dwSpanCount > 224) + return ERROR_BAD_FORMAT; + + // So far we've only saw entries with 1 span. + // Need to test files with multiple spans. Ignore such files for now. + assert(dwSpanCount == 1); + + // Capture the array of span items + if(CaptureArray_(pbVfsFileEntry, pbVfsFileEnd, &pbTemp, ItemSize, dwSpanCount) == NULL) + return ERROR_BAD_FORMAT; + + // + // Structure of the span entry: + // (4bytes): Offset into the referenced file (big endian) + // (4bytes): Size of the span (big endian) + // (?bytes): Offset into Container File Table. Length depends on container file table size + // + + // Get the offset to the Container File Table + dwCftOffset = ConvertBytesToInteger_X(pbVfsFileEntry + sizeof(DWORD) + sizeof(DWORD), DirHeader.CftOffsSize); + dwSpanSize = ConvertBytesToInteger_4(pbVfsFileEntry + sizeof(DWORD)); + + // Go to the Container File Table and fetch the EKey from there + pbCftFileTable = DirHeader.pbDirectoryData + DirHeader.CftTableOffset; + pbCftFileEntry = pbCftFileTable + dwCftOffset; + pbCftFileEnd = pbCftFileTable + DirHeader.CftTableSize; + if((pbCftFileEntry + DirHeader.EKeySize) > pbCftFileEnd) + return ERROR_BAD_FORMAT; + + // Give the pointer to the EKey + memcpy(pEKey->Value, pbCftFileEntry, DirHeader.EKeySize); + PtrSpanSize[0] = dwSpanSize; + return ERROR_SUCCESS; + } + + // + // Structure of the path table entry: + // (1byte) 0x00 (optional) - means that there will be prefix path separator + // (1byte) File name length + // (?byte) File name + // (1byte) 0x00 (optional) - means that there will be postfix path separator + // (1byte) 0xFF (optional) - node value identifier + // (4byte) - node value + // + // Note: The path "data\archive\maps\file.bmp" could be cut into nodes like: + // data\0 (or data with subdirectory) + // arc + // hive\0 + // maps\0 (or folder data) + // file.bmp + // + + LPBYTE CapturePathEntry(TVFS_PATH_TABLE_ENTRY & PathEntry, LPBYTE pbPathTablePtr, LPBYTE pbPathTableEnd) + { + // Reset the path entry structure + PathEntry.pbNamePtr = pbPathTablePtr; + PathEntry.pbNameEnd = pbPathTablePtr; + PathEntry.NodeFlags = 0; + PathEntry.NodeValue = 0; + + // Zero before the name means prefix path separator + if (pbPathTablePtr < pbPathTableEnd && pbPathTablePtr[0] == 0) + { + PathEntry.NodeFlags |= TVFS_PTE_PATH_SEPARATOR_PRE; + pbPathTablePtr++; + } + + // Capture the length of the name fragment + if (pbPathTablePtr < pbPathTableEnd && pbPathTablePtr[0] != 0xFF) + { + // Capture length of the name fragment + size_t nLength = *pbPathTablePtr++; + + if ((pbPathTablePtr + nLength) > pbPathTableEnd) + return NULL; + PathEntry.pbNamePtr = pbPathTablePtr; + PathEntry.pbNameEnd = pbPathTablePtr + nLength; + pbPathTablePtr += nLength; + } + + // Zero after the name means postfix path separator + if (pbPathTablePtr < pbPathTableEnd && pbPathTablePtr[0] == 0) + { + PathEntry.NodeFlags |= TVFS_PTE_PATH_SEPARATOR_POST; + pbPathTablePtr++; + } + + if (pbPathTablePtr < pbPathTableEnd) + { + // Check for node value + if (pbPathTablePtr[0] == 0xFF) + { + if ((pbPathTablePtr + 1 + sizeof(DWORD)) > pbPathTableEnd) + return NULL; + PathEntry.NodeValue = ConvertBytesToInteger_4(pbPathTablePtr + 1); + PathEntry.NodeFlags |= TVFS_PTE_NODE_VALUE; + pbPathTablePtr = pbPathTablePtr + 1 + sizeof(DWORD); + } + + // Non-0xFF after the name means path separator after + else + { + PathEntry.NodeFlags |= TVFS_PTE_PATH_SEPARATOR_POST; + assert(pbPathTablePtr[0] != 0); + } + } + + return pbPathTablePtr; + } + + bool IsVfsFileEKey(TCascStorage * hs, ENCODED_KEY & EKey, size_t EKeyLength) + { + PCASC_CKEY_ENTRY pCKeyEntry; + size_t ItemCount = hs->VfsRootList.ItemCount(); + + // Search the array + for (size_t i = 0; i < ItemCount; i++) + { + pCKeyEntry = (PCASC_CKEY_ENTRY)hs->VfsRootList.ItemAt(i); + if (pCKeyEntry != NULL) + { + if (!memcmp(pCKeyEntry->EKey, EKey.Value, EKeyLength)) + return true; + } + } + + // Not found in the VFS list + return false; + } + + // This function verifies whether a file is actually a sub-directory. + // If yes, it contains just another "TVFS" virtual file system, just like the ROOT file. + int IsVfsSubDirectory(TCascStorage * hs, TVFS_DIRECTORY_HEADER & DirHeader, TVFS_DIRECTORY_HEADER & SubHeader, ENCODED_KEY & EKey, DWORD dwFileSize) + { + PCASC_CKEY_ENTRY pCKeyEntry; + LPBYTE pbVfsData = NULL; + DWORD cbVfsData = dwFileSize; + int nError = ERROR_BAD_FORMAT; + + // Verify whether the EKey is in the list of VFS root files + if(IsVfsFileEKey(hs, EKey, DirHeader.EKeySize)) + { + // Locate the CKey entry + if((pCKeyEntry = FindCKeyEntry_EKey(hs, EKey.Value)) != NULL) + { + // Load the entire file into memory + pbVfsData = LoadInternalFileToMemory(hs, pCKeyEntry, &cbVfsData); + if (pbVfsData && cbVfsData) + { + // Capture the file folder. This also serves as test + nError = CaptureDirectoryHeader(SubHeader, pbVfsData, pbVfsData + cbVfsData); + if (nError == ERROR_SUCCESS) + return nError; + + // Clear the captured header + memset(&SubHeader, 0, sizeof(TVFS_DIRECTORY_HEADER)); + CASC_FREE(pbVfsData); + } + } + } + + return nError; + } + + void InsertRootVfsEntry(TCascStorage * hs, LPBYTE pbCKey, const char * szFormat, size_t nIndex) + { + PCASC_CKEY_ENTRY pCKeyEntry; + char szFileName[0x20]; + + // The CKey entry must exist + if((pCKeyEntry = FindCKeyEntry_CKey(hs, pbCKey)) != NULL) + { + CascStrPrintf(szFileName, _countof(szFileName), szFormat, nIndex); + Insert(szFileName, pCKeyEntry); + } + } + + DWORD ParsePathFileTable(TCascStorage * hs, TVFS_DIRECTORY_HEADER & DirHeader, PATH_BUFFER & PathBuffer, LPBYTE pbPathTablePtr, LPBYTE pbPathTableEnd) + { + TVFS_DIRECTORY_HEADER SubHeader; + TVFS_PATH_TABLE_ENTRY PathEntry; + PCASC_CKEY_ENTRY pCKeyEntry; + ENCODED_KEY EKey; + char * szSavePathPtr = PathBuffer.szPtr; + DWORD dwSpanSize = 0; + int nError; + + // Prepare the EKey structure to be filled with zeros + memset(&EKey, 0, sizeof(ENCODED_KEY)); + + // Parse the file table + while(pbPathTablePtr < pbPathTableEnd) + { + // Capture the single path table entry + pbPathTablePtr = CapturePathEntry(PathEntry, pbPathTablePtr, pbPathTableEnd); + if(pbPathTablePtr == NULL) + return ERROR_BAD_FORMAT; + + // Append the node name to the total path. Also add backslash, if it's a folder + PathBuffer_AppendNode(PathBuffer, PathEntry); + + // Folder component + if (PathEntry.NodeFlags & TVFS_PTE_NODE_VALUE) + { + // If the TVFS_FOLDER_NODE is set, then the path node is a directory, + // with its data immediately following the path node. Lower 31 bits of NodeValue + // contain the length of the directory (including the NodeValue!) + if (PathEntry.NodeValue & TVFS_FOLDER_NODE) + { + LPBYTE pbDirectoryEnd = pbPathTablePtr + (PathEntry.NodeValue & TVFS_FOLDER_SIZE_MASK) - sizeof(DWORD); + + // Check the available data + assert((PathEntry.NodeValue & TVFS_FOLDER_SIZE_MASK) >= sizeof(DWORD)); + + // Recursively call the folder parser on the same file + nError = ParsePathFileTable(hs, DirHeader, PathBuffer, pbPathTablePtr, pbDirectoryEnd); + if (nError != ERROR_SUCCESS) + return nError; + + // Skip the directory data + pbPathTablePtr = pbDirectoryEnd; + } + else + { + // Capture the VFS and Container Table Entry in order to get the file EKey + nError = CaptureVfsSpanEntries(DirHeader, &EKey, &dwSpanSize, PathEntry.NodeValue); + if (nError != ERROR_SUCCESS) + return nError; + + // We need to check whether this is another TVFS directory file + if (IsVfsSubDirectory(hs, DirHeader, SubHeader, EKey, dwSpanSize) == ERROR_SUCCESS) + { + // Add colon (':') + PathBuffer_AddChar(PathBuffer, ':'); + + // Insert the file to the file tree + if((pCKeyEntry = FindCKeyEntry_EKey(hs, EKey.Value)) != NULL) + { + // The file content size should already be there + assert(pCKeyEntry->ContentSize == dwSpanSize); + FileTree.InsertByName(pCKeyEntry, PathBuffer.szBegin); + } + + ParseDirectoryData(hs, SubHeader, PathBuffer); + CASC_FREE(SubHeader.pbDirectoryData); + } + else + { +// if (fp != NULL) +// { +// fwrite(PathBuffer.szBegin, 1, (PathBuffer.szPtr - PathBuffer.szBegin), fp); +// fprintf(fp, "\n"); +// } + + // Insert the file to the file tree + if((pCKeyEntry = FindCKeyEntry_EKey(hs, EKey.Value)) != NULL) + { + // If the file content is not there, supply it now + if(pCKeyEntry->ContentSize == CASC_INVALID_SIZE) + pCKeyEntry->ContentSize = dwSpanSize; + FileTree.InsertByName(pCKeyEntry, PathBuffer.szBegin); + } + } + } + + // Reset the position of the path buffer + PathBuffer.szPtr = szSavePathPtr; + PathBuffer.szPtr[0] = 0; + } + } + + // Return the total number of entries + return ERROR_SUCCESS; + } + + int ParseDirectoryData(TCascStorage * hs, TVFS_DIRECTORY_HEADER & DirHeader, PATH_BUFFER & PathBuffer) + { + LPBYTE pbRootDirectory = DirHeader.pbDirectoryData + DirHeader.PathTableOffset; + LPBYTE pbRootDirPtr = pbRootDirectory; + LPBYTE pbRootDirEnd = pbRootDirPtr + DirHeader.PathTableSize; + DWORD dwNodeValue = 0; + + // Most usually, there is a root directory in the folder + if((pbRootDirPtr + 1 + sizeof(DWORD)) < pbRootDirEnd) + { + // + // The structure of the root directory + // ----------------------------------- + // 1byte 0xFF + // 4bytes NodeValue (BigEndian). The most significant bit is set + // - Lower 31 bits contain length of the directory data, including NodeValue + // + + if(pbRootDirPtr[0] == 0xFF) + { + // Get the NodeValue and check its highest bit + if(CaptureInteger32_BE(pbRootDirPtr + 1, pbRootDirEnd, &dwNodeValue) == NULL || (dwNodeValue & TVFS_FOLDER_NODE) == 0) + return ERROR_BAD_FORMAT; + + // Get the range of the root directory + pbRootDirEnd = pbRootDirPtr + 1 + (dwNodeValue & TVFS_FOLDER_SIZE_MASK); + pbRootDirPtr = pbRootDirPtr + 1 + sizeof(DWORD); + + // Check the directory + if(pbRootDirEnd > (pbRootDirectory + DirHeader.PathTableSize)) + return ERROR_BAD_FORMAT; + } + } + + // Now go parse the path file table + return ParsePathFileTable(hs, DirHeader, PathBuffer, pbRootDirPtr, pbRootDirEnd); + } + + int Load(TCascStorage * hs, TVFS_DIRECTORY_HEADER & RootHeader) + { +// PCASC_CKEY_ENTRY pCKeyEntry; + PATH_BUFFER PathBuffer; + char szPathBuffer[MAX_PATH]; + + // Initialize the path buffer + memset(szPathBuffer, 0, sizeof(szPathBuffer)); + PathBuffer.szBegin = + PathBuffer.szPtr = szPathBuffer; + PathBuffer.szEnd = szPathBuffer + MAX_PATH; + + // Save the length of the key + FileTree.SetKeyLength(RootHeader.EKeySize); + + // Insert the main VFS root file as named entry + InsertRootVfsEntry(hs, hs->VfsRoot.CKey, "vfs-root", 0); + + // Insert all VFS roots folders as files + //for(size_t i = 0; i < hs->VfsRootList.ItemCount(); i++) + //{ + // pCKeyEntry = (PCASC_CKEY_ENTRY)hs->VfsRootList.ItemAt(i); + // InsertRootVfsEntry(hs, pCKeyEntry->CKey, "vfs-%u", i+1); + //} + + // Parse the entire directory data + return ParseDirectoryData(hs, RootHeader, PathBuffer); + } + + DWORD dwNestLevel; +}; + +//----------------------------------------------------------------------------- +// Public functions - TVFS root + +int RootHandler_CreateTVFS(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile) +{ + TRootHandler_TVFS * pRootHandler = NULL; + TVFS_DIRECTORY_HEADER RootHeader; + int nError; + + // Capture the entire root directory + nError = TRootHandler_TVFS::CaptureDirectoryHeader(RootHeader, pbRootFile, pbRootFile + cbRootFile); + if(nError == ERROR_SUCCESS) + { + // Allocate the root handler object + pRootHandler = new TRootHandler_TVFS(); + if(pRootHandler != NULL) + { + // Load the root directory. If load failed, we free the object + nError = pRootHandler->Load(hs, RootHeader); + if(nError != ERROR_SUCCESS) + { + delete pRootHandler; + pRootHandler = NULL; + } + } + } + + // Assign the root directory (or NULL) and return error + hs->pRootHandler = pRootHandler; + return nError; +} diff --git a/dep/CascLib/src/CascRootFile_Text.cpp b/dep/CascLib/src/CascRootFile_Text.cpp new file mode 100644 index 00000000000..e78b0bf086f --- /dev/null +++ b/dep/CascLib/src/CascRootFile_Text.cpp @@ -0,0 +1,121 @@ +/*****************************************************************************/ +/* CascRootFile_Text.cpp Copyright (c) Ladislav Zezula 2017 */ +/*---------------------------------------------------------------------------*/ +/* Support for generic ROOT handler with mapping of FileName -> CKey */ +/*---------------------------------------------------------------------------*/ +/* Date Ver Who Comment */ +/* -------- ---- --- ------- */ +/* 28.10.15 1.00 Lad The first version of CascRootFile_Text.cpp */ +/*****************************************************************************/ + +#define __CASCLIB_SELF__ +#include "CascLib.h" +#include "CascCommon.h" + +//----------------------------------------------------------------------------- +// Handler definitions for Starcraft I root file + +struct TRootHandler_SC1 : public TFileTreeRoot +{ + public: + + TRootHandler_SC1() : TFileTreeRoot(0) + { + // We have file names and return CKey as result of search + dwFeatures |= (CASC_FEATURE_FILE_NAMES | CASC_FEATURE_ROOT_CKEY); + } + + static bool IsRootFile(LPBYTE pbRootFile, DWORD cbRootFile) + { + CASC_CSV Csv(1, false); + size_t nColumns; + bool bResult = false; + + // Get the first line from the listfile + if(Csv.Load(pbRootFile, cbRootFile) == ERROR_SUCCESS) + { + // There must be 2 or 3 elements + nColumns = Csv[CSV_ZERO].GetColumnCount(); + if (nColumns == 2 || nColumns == 3) + { + const CASC_CSV_COLUMN & FileName = Csv[CSV_ZERO][CSV_ZERO]; + const CASC_CSV_COLUMN & CKeyStr = Csv[CSV_ZERO][1]; + + bResult = (FileName.szValue && CKeyStr.szValue && CKeyStr.nLength == MD5_STRING_SIZE); + } + } + + // We need to reset the listfile to the begin position + return bResult; + } + + int Load(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile) + { + PCASC_CKEY_ENTRY pCKeyEntry; + CASC_CSV Csv(0, false); + BYTE CKey[MD5_HASH_SIZE]; + int nError; + + // Parse the ROOT file first in order to see whether we have the correct format + nError = Csv.Load(pbRootFile, cbRootFile); + if(nError == ERROR_SUCCESS) + { + // Parse all lines + while(Csv.LoadNextLine()) + { + const CASC_CSV_COLUMN & FileName = Csv[CSV_ZERO][CSV_ZERO]; + const CASC_CSV_COLUMN & CKeyStr = Csv[CSV_ZERO][1]; + + // Convert the CKey to binary + if(ConvertStringToBinary(CKeyStr.szValue, MD5_STRING_SIZE, CKey) == ERROR_SUCCESS) + { + // Verify whether it is a known entry + if((pCKeyEntry = FindCKeyEntry_CKey(hs, CKey)) != NULL) + { + // Insert the FileName+CKey to the file tree + FileTree.InsertByName(pCKeyEntry, FileName.szValue); + } + } + } + } + + return nError; + } +}; + +//----------------------------------------------------------------------------- +// Public functions + +// +// Starcraft ROOT file is a text file with the following format: +// HD2/portraits/NBluCrit/NLCFID01.webm|c2795b120592355d45eba9cdc37f691e +// locales/enUS/Assets/campaign/EXPZerg/Zerg08/staredit/wav/zovtra01.ogg|316b0274bf2dabaa8db60c3ff1270c85 +// locales/zhCN/Assets/sound/terran/ghost/tghdth01.wav|6637ed776bd22089e083b8b0b2c0374c +// + +int RootHandler_CreateStarcraft1(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile) +{ + TRootHandler_SC1 * pRootHandler = NULL; + int nError = ERROR_BAD_FORMAT; + + // Verify whether this looks like a Starcraft I root file + if(TRootHandler_SC1::IsRootFile(pbRootFile, cbRootFile)) + { + // Allocate the root handler object + pRootHandler = new TRootHandler_SC1(); + if(pRootHandler != NULL) + { + // Load the root directory. If load failed, we free the object + nError = pRootHandler->Load(hs, pbRootFile, cbRootFile); + if(nError != ERROR_SUCCESS) + { + delete pRootHandler; + pRootHandler = NULL; + } + } + } + + // Assign the root directory (or NULL) and return error + hs->pRootHandler = pRootHandler; + return nError; +} diff --git a/dep/CascLib/src/CascRootFile_WoW.cpp b/dep/CascLib/src/CascRootFile_WoW.cpp new file mode 100644 index 00000000000..780220bbe40 --- /dev/null +++ b/dep/CascLib/src/CascRootFile_WoW.cpp @@ -0,0 +1,481 @@ +/*****************************************************************************/ +/* CascRootFile_WoW.cpp Copyright (c) Ladislav Zezula 2014 */ +/*---------------------------------------------------------------------------*/ +/* Storage functions for CASC */ +/* Note: WoW offsets refer to WoW.exe 6.0.3.19116 (32-bit) */ +/* SHA1: c10e9ffb7d040a37a356b96042657e1a0c95c0dd */ +/*---------------------------------------------------------------------------*/ +/* Date Ver Who Comment */ +/* -------- ---- --- ------- */ +/* 29.04.14 1.00 Lad The first version of CascRootFile_WoW.cpp */ +/*****************************************************************************/ + +#define __CASCLIB_SELF__ +#include "CascLib.h" +#include "CascCommon.h" + +//----------------------------------------------------------------------------- +// Local structures + +#define ROOT_SEARCH_PHASE_INITIALIZING 0 +#define ROOT_SEARCH_PHASE_LISTFILE 1 +#define ROOT_SEARCH_PHASE_NAMELESS 2 +#define ROOT_SEARCH_PHASE_FINISHED 3 + +// Known dwRegion values returned from sub_661316 (7.0.3.22210 x86 win), also referred by lua GetCurrentRegion +#define WOW_REGION_US 0x01 +#define WOW_REGION_KR 0x02 +#define WOW_REGION_EU 0x03 +#define WOW_REGION_TW 0x04 +#define WOW_REGION_CN 0x05 + +typedef enum _ROOT_FORMAT +{ + RootFormatWoW6x, // WoW 6.x - 8.1.x + RootFormatWoW82 // WoW 8.2 or newer +} ROOT_FORMAT, *PROOT_FORMAT; + +// ROOT file header, since 8.2 +typedef struct _FILE_ROOT_HEADER_82 +{ + DWORD Signature; // Must be CASC_WOW82_ROOT_SIGNATURE + DWORD TotalFiles; + DWORD FilesWithNameHash; +} FILE_ROOT_HEADER_82, *PFILE_ROOT_HEADER_82; + +// On-disk version of root group. A root group contains a group of file +// with the same locale and file flags +typedef struct _FILE_ROOT_GROUP_HEADER +{ + DWORD NumberOfFiles; // Number of entries + DWORD ContentFlags; + DWORD LocaleFlags; // File locale mask (CASC_LOCALE_XXX) + + // Followed by a block of file data IDs (count: NumberOfFiles) + // Followed by the MD5 and file name hash (count: NumberOfFiles) + +} FILE_ROOT_GROUP_HEADER, *PFILE_ROOT_GROUP_HEADER; + +// On-disk version of root entry. Only present in versions 6.x - 8.1.xx +// Each root entry represents one file in the CASC storage +// In WoW 8.2 and newer, CKey and FileNameHash are split into separate arrays +// and FileNameHash is optional +typedef struct _FILE_ROOT_ENTRY +{ + CONTENT_KEY CKey; // MD5 of the file + ULONGLONG FileNameHash; // Jenkins hash of the file name + +} FILE_ROOT_ENTRY, *PFILE_ROOT_ENTRY; + +typedef struct _FILE_ROOT_GROUP +{ + FILE_ROOT_GROUP_HEADER Header; + PDWORD FileDataIds; // Pointer to the array of File Data IDs + + PFILE_ROOT_ENTRY pRootEntries; // Valid for WoW 6.x - 8.1.x + PCONTENT_KEY pCKeyEntries; // Valid for WoW 8.2 or newer + PULONGLONG pHashes; // Valid for WoW 8.2 or newer (optional) + +} FILE_ROOT_GROUP, *PFILE_ROOT_GROUP; + +//----------------------------------------------------------------------------- +// TRootHandler_WoW interface / implementation + +#define FTREE_FLAGS_WOW (FTREE_FLAG_USE_DATA_ID | FTREE_FLAG_USE_LOCALE_FLAGS | FTREE_FLAG_USE_CONTENT_FLAGS) + +struct TRootHandler_WoW : public TFileTreeRoot +{ + public: + + TRootHandler_WoW(ROOT_FORMAT RFormat, DWORD HashlessFileCount) : TFileTreeRoot(FTREE_FLAGS_WOW) + { + // Turn off the "we know file names" bit + FileCounterHashless = HashlessFileCount; + FileCounter = 0; + RootFormat = RFormat; + + // Update the flags based on format + switch(RootFormat) + { + case RootFormatWoW6x: + dwFeatures |= CASC_FEATURE_ROOT_CKEY | CASC_FEATURE_FNAME_HASHES | CASC_FEATURE_FILE_DATA_IDS | CASC_FEATURE_LOCALE_FLAGS | CASC_FEATURE_CONTENT_FLAGS; + break; + + case RootFormatWoW82: + dwFeatures |= CASC_FEATURE_ROOT_CKEY | CASC_FEATURE_FNAME_HASHES_OPTIONAL | CASC_FEATURE_FILE_DATA_IDS | CASC_FEATURE_LOCALE_FLAGS | CASC_FEATURE_CONTENT_FLAGS; + break; + } + } + + static LPBYTE CaptureRootHeader(FILE_ROOT_HEADER_82 & RootHeader, LPBYTE pbRootPtr, LPBYTE pbRootEnd) + { + // Validate the root file header + if((pbRootPtr + sizeof(FILE_ROOT_HEADER_82)) >= pbRootEnd) + return NULL; + memcpy(&RootHeader, pbRootPtr, sizeof(FILE_ROOT_HEADER_82)); + + // Verify the root file header + if(RootHeader.Signature != CASC_WOW82_ROOT_SIGNATURE) + return NULL; + if(RootHeader.FilesWithNameHash > RootHeader.TotalFiles) + return NULL; + + return pbRootPtr + sizeof(FILE_ROOT_HEADER_82); + } + + LPBYTE CaptureRootGroup(FILE_ROOT_GROUP & RootGroup, LPBYTE pbRootPtr, LPBYTE pbRootEnd) + { + // Reset the entire root group structure + memset(&RootGroup, 0, sizeof(FILE_ROOT_GROUP)); + + // Validate the locale block header + if((pbRootPtr + sizeof(FILE_ROOT_GROUP_HEADER)) >= pbRootEnd) + return NULL; + memcpy(&RootGroup.Header, pbRootPtr, sizeof(FILE_ROOT_GROUP_HEADER)); + pbRootPtr = pbRootPtr + sizeof(FILE_ROOT_GROUP_HEADER); + + // Validate the array of file data IDs + if((pbRootPtr + (sizeof(DWORD) * RootGroup.Header.NumberOfFiles)) >= pbRootEnd) + return NULL; + RootGroup.FileDataIds = (PDWORD)pbRootPtr; + pbRootPtr = pbRootPtr + (sizeof(DWORD) * RootGroup.Header.NumberOfFiles); + + // Add the number of files in this block to the number of files loaded + FileCounter += RootGroup.Header.NumberOfFiles; + + // Validate the array of root entries + switch(RootFormat) + { + case RootFormatWoW6x: + if((pbRootPtr + (sizeof(FILE_ROOT_ENTRY) * RootGroup.Header.NumberOfFiles)) > pbRootEnd) + return NULL; + RootGroup.pRootEntries = (PFILE_ROOT_ENTRY)pbRootPtr; + + // Return the position of the next block + return pbRootPtr + (sizeof(FILE_ROOT_ENTRY) * RootGroup.Header.NumberOfFiles); + + case RootFormatWoW82: + + // Verify the position of array of CONTENT_KEY + if((pbRootPtr + (sizeof(CONTENT_KEY) * RootGroup.Header.NumberOfFiles)) > pbRootEnd) + return NULL; + RootGroup.pCKeyEntries = (PCONTENT_KEY)pbRootPtr; + pbRootPtr = pbRootPtr + (sizeof(CONTENT_KEY) * RootGroup.Header.NumberOfFiles); + + // Also include array of file hashes + if(FileCounter > FileCounterHashless) + { + if((pbRootPtr + (sizeof(ULONGLONG) * RootGroup.Header.NumberOfFiles)) > pbRootEnd) + return NULL; + RootGroup.pHashes = (PULONGLONG)pbRootPtr; + pbRootPtr = pbRootPtr + (sizeof(ULONGLONG) * RootGroup.Header.NumberOfFiles); + } + + return pbRootPtr; + + default: + return NULL; + } + } + + int ParseWowRootFile_AddFiles_6x(TCascStorage * hs, FILE_ROOT_GROUP & RootGroup) + { + PFILE_ROOT_ENTRY pRootEntry = RootGroup.pRootEntries; + PCASC_CKEY_ENTRY pCKeyEntry; + DWORD FileDataId = 0; + + // Sanity check + assert(RootGroup.pRootEntries != NULL); + + // WoW.exe (build 19116): Blocks with zero files are skipped + for(DWORD i = 0; i < RootGroup.Header.NumberOfFiles; i++, pRootEntry++) + { + // Set the file data ID + FileDataId = FileDataId + RootGroup.FileDataIds[i]; +// BREAKIF(FileDataId == 2823765); + + // Find the item in the central storage. Insert it to the tree + if((pCKeyEntry = FindCKeyEntry_CKey(hs, pRootEntry->CKey.Value)) != NULL) + { + if(pRootEntry->FileNameHash != 0) + { + FileTree.InsertByHash(pCKeyEntry, pRootEntry->FileNameHash, FileDataId, RootGroup.Header.LocaleFlags, RootGroup.Header.ContentFlags); + } + else + { + FileTree.InsertById(pCKeyEntry, FileDataId, RootGroup.Header.LocaleFlags, RootGroup.Header.ContentFlags); + } + } + + // Update the file data ID + assert((FileDataId + 1) > FileDataId); + FileDataId++; + } + + return ERROR_SUCCESS; + } + + int ParseWowRootFile_AddFiles_82(TCascStorage * hs, FILE_ROOT_GROUP & RootGroup) + { + PCASC_CKEY_ENTRY pCKeyEntry; + PCONTENT_KEY pCKey = RootGroup.pCKeyEntries; + DWORD FileDataId = 0; + + // Sanity check + assert(RootGroup.pCKeyEntries != NULL); + + // WoW.exe (build 19116): Blocks with zero files are skipped + for(DWORD i = 0; i < RootGroup.Header.NumberOfFiles; i++, pCKey++) + { + // Set the file data ID + FileDataId = FileDataId + RootGroup.FileDataIds[i]; + + // Find the item in the central storage. Insert it to the tree + if((pCKeyEntry = FindCKeyEntry_CKey(hs, pCKey->Value)) != NULL) + { + // If we know the file name hash, we're gonna insert it by hash AND file data id. + // If we don't know the hash, we're gonna insert it just by file data id. + if(RootGroup.pHashes != NULL && RootGroup.pHashes[i] != 0) + { + FileTree.InsertByHash(pCKeyEntry, RootGroup.pHashes[i], FileDataId, RootGroup.Header.LocaleFlags, RootGroup.Header.ContentFlags); + } + else + { + FileTree.InsertById(pCKeyEntry, FileDataId, RootGroup.Header.LocaleFlags, RootGroup.Header.ContentFlags); + } + } + + // Update the file data ID + assert((FileDataId + 1) > FileDataId); + FileDataId++; + } + + return ERROR_SUCCESS; + } + + int ParseWowRootFile_Level2( + TCascStorage * hs, + LPBYTE pbRootPtr, + LPBYTE pbRootEnd, + DWORD dwLocaleMask, + BYTE bOverrideLowViolence, + BYTE bAudioLocale) + { + FILE_ROOT_GROUP RootBlock; + + // Reset the total file counter + FileCounter = 0; + + // Now parse the root file + while(pbRootPtr < pbRootEnd) + { + // Validate the file locale block + pbRootPtr = CaptureRootGroup(RootBlock, pbRootPtr, pbRootEnd); + if(pbRootPtr == NULL) + return ERROR_BAD_FORMAT; + + // WoW.exe (build 19116): Entries with flag 0x100 set are skipped + if(RootBlock.Header.ContentFlags & CASC_CFLAG_DONT_LOAD) + continue; + + // WoW.exe (build 19116): Entries with flag 0x80 set are skipped if overrideArchive CVAR is set to FALSE (which is by default in non-chinese clients) + if((RootBlock.Header.ContentFlags & CASC_CFLAG_LOW_VIOLENCE) && bOverrideLowViolence == 0) + continue; + + // WoW.exe (build 19116): Entries with (flags >> 0x1F) not equal to bAudioLocale are skipped + if((RootBlock.Header.ContentFlags >> 0x1F) != bAudioLocale) + continue; + + // WoW.exe (build 19116): Locales other than defined mask are skipped too + if((RootBlock.Header.LocaleFlags & dwLocaleMask) == 0) + continue; + + // Now call the custom function + switch(RootFormat) + { + case RootFormatWoW82: + ParseWowRootFile_AddFiles_82(hs, RootBlock); + break; + + case RootFormatWoW6x: + ParseWowRootFile_AddFiles_6x(hs, RootBlock); + break; + + default: + return ERROR_NOT_SUPPORTED; + } + } + + return ERROR_SUCCESS; + } + + /* + #define CASC_LOCALE_BIT_ENUS 0x01 + #define CASC_LOCALE_BIT_KOKR 0x02 + #define CASC_LOCALE_BIT_RESERVED 0x03 + #define CASC_LOCALE_BIT_FRFR 0x04 + #define CASC_LOCALE_BIT_DEDE 0x05 + #define CASC_LOCALE_BIT_ZHCN 0x06 + #define CASC_LOCALE_BIT_ESES 0x07 + #define CASC_LOCALE_BIT_ZHTW 0x08 + #define CASC_LOCALE_BIT_ENGB 0x09 + #define CASC_LOCALE_BIT_ENCN 0x0A + #define CASC_LOCALE_BIT_ENTW 0x0B + #define CASC_LOCALE_BIT_ESMX 0x0C + #define CASC_LOCALE_BIT_RURU 0x0D + #define CASC_LOCALE_BIT_PTBR 0x0E + #define CASC_LOCALE_BIT_ITIT 0x0F + #define CASC_LOCALE_BIT_PTPT 0x10 + + // dwLocale is obtained from a WOW_LOCALE_* to CASC_LOCALE_BIT_* mapping (sub_6615D0 in 7.0.3.22210 x86 win) + // because (ENUS, ENGB) and (PTBR, PTPT) pairs share the same value on WOW_LOCALE_* enum + // dwRegion is used to distinguish them + if(dwRegion == WOW_REGION_EU) + { + // Is this english version of WoW? + if(dwLocale == CASC_LOCALE_BIT_ENUS) + { + LoadWowRootFileLocales(hs, pbRootPtr, cbRootFile, CASC_LOCALE_ENGB, bOverrideArchive, bAudioLocale); + LoadWowRootFileLocales(hs, pbRootPtr, cbRootFile, CASC_LOCALE_ENUS, bOverrideArchive, bAudioLocale); + return ERROR_SUCCESS; + } + + // Is this portuguese version of WoW? + if(dwLocale == CASC_LOCALE_BIT_PTBR) + { + LoadWowRootFileLocales(hs, pbRootPtr, cbRootFile, CASC_LOCALE_PTPT, bOverrideArchive, bAudioLocale); + LoadWowRootFileLocales(hs, pbRootPtr, cbRootFile, CASC_LOCALE_PTBR, bOverrideArchive, bAudioLocale); + } + } + else + LoadWowRootFileLocales(hs, pbRootPtr, cbRootFile, (1 << dwLocale), bOverrideArchive, bAudioLocale); + */ + + int ParseWowRootFile_Level1( + TCascStorage * hs, + LPBYTE pbRootPtr, + LPBYTE pbRootEnd, + DWORD dwLocaleMask, + BYTE bAudioLocale) + { + int nError; + + // Load the locale as-is + nError = ParseWowRootFile_Level2(hs, pbRootPtr, pbRootEnd, dwLocaleMask, false, bAudioLocale); + if (nError != ERROR_SUCCESS) + return nError; + + // If we wanted enGB, we also load enUS for the missing files + if(dwLocaleMask == CASC_LOCALE_ENGB) + ParseWowRootFile_Level2(hs, pbRootPtr, pbRootEnd, CASC_LOCALE_ENUS, false, bAudioLocale); + + if(dwLocaleMask == CASC_LOCALE_PTPT) + ParseWowRootFile_Level2(hs, pbRootPtr, pbRootEnd, CASC_LOCALE_PTBR, false, bAudioLocale); + + return ERROR_SUCCESS; + } + + // WoW.exe: 004146C7 (BuildManifest::Load) + int Load(TCascStorage * hs, LPBYTE pbRootPtr, LPBYTE pbRootEnd, DWORD dwLocaleMask) + { + int nError; + + nError = ParseWowRootFile_Level1(hs, pbRootPtr, pbRootEnd, dwLocaleMask, 0); + if (nError == ERROR_SUCCESS) + nError = ParseWowRootFile_Level1(hs, pbRootPtr, pbRootEnd, dwLocaleMask, 1); + + return nError; + } + + // Search for files + PCASC_CKEY_ENTRY Search(TCascSearch * pSearch, PCASC_FIND_DATA pFindData) + { + // If we have a listfile, we'll feed the listfile entries to the file tree + if(pSearch->pCache != NULL && pSearch->bListFileUsed == false) + { + PCASC_FILE_NODE pFileNode; + ULONGLONG FileNameHash; + DWORD FileDataId = CASC_INVALID_ID; + char szFileName[MAX_PATH]; + + if(RootFormat == RootFormatWoW82) + { + // Keep going through the listfile + while(ListFile_GetNext(pSearch->pCache, szFileName, _countof(szFileName), &FileDataId)) + { + // Try to find the file node by file data id + pFileNode = FileTree.FindById(FileDataId); + if(pFileNode != NULL && pFileNode->NameLength == 0) + { + FileTree.SetNodeFileName(pFileNode, szFileName); + } + } + } + else + { + // Keep going through the listfile + while(ListFile_GetNextLine(pSearch->pCache, szFileName, MAX_PATH)) + { + // Calculate the hash of the file name + FileNameHash = CalcFileNameHash(szFileName); + + // Try to find the file node by file name hash + pFileNode = FileTree.Find(FileNameHash); + if(pFileNode != NULL && pFileNode->NameLength == 0) + { + FileTree.SetNodeFileName(pFileNode, szFileName); + } + } + } + pSearch->bListFileUsed = true; + } + + // Let the file tree root give us the file names + return TFileTreeRoot::Search(pSearch, pFindData); + } + + ROOT_FORMAT RootFormat; // Root file format + DWORD FileCounterHashless; // Number of files for which we don't have hash. Meaningless for WoW before 8.2 + DWORD FileCounter; // Counter of loaded files. Only used during loading of ROOT file +}; + +//----------------------------------------------------------------------------- +// Public functions + +int RootHandler_CreateWoW(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile, DWORD dwLocaleMask) +{ + TRootHandler_WoW * pRootHandler = NULL; + FILE_ROOT_HEADER_82 RootHeader; + ROOT_FORMAT RootFormat = RootFormatWoW6x; + LPBYTE pbRootEnd = pbRootFile + cbRootFile; + LPBYTE pbRootPtr; + DWORD FileCounterHashless = 0; + int nError = ERROR_BAD_FORMAT; + + // Check for the new format (World of Warcraft 8.2, build 30170) + pbRootPtr = TRootHandler_WoW::CaptureRootHeader(RootHeader, pbRootFile, pbRootEnd); + if(pbRootPtr != NULL) + { + FileCounterHashless = RootHeader.TotalFiles - RootHeader.FilesWithNameHash; + RootFormat = RootFormatWoW82; + pbRootFile = pbRootPtr; + } + + // Create the WOW handler + pRootHandler = new TRootHandler_WoW(RootFormat, FileCounterHashless); + if(pRootHandler != NULL) + { + // Load the root directory. If load failed, we free the object + nError = pRootHandler->Load(hs, pbRootFile, pbRootEnd, dwLocaleMask); + if(nError != ERROR_SUCCESS) + { + delete pRootHandler; + pRootHandler = NULL; + } + } + + // Assign the root directory (or NULL) and return error + hs->pRootHandler = pRootHandler; + return nError; +} + diff --git a/dep/CascLib/src/CascRootFile_WoW6.cpp b/dep/CascLib/src/CascRootFile_WoW6.cpp deleted file mode 100644 index 74805d07620..00000000000 --- a/dep/CascLib/src/CascRootFile_WoW6.cpp +++ /dev/null @@ -1,595 +0,0 @@ -/*****************************************************************************/ -/* CascOpenStorage.cpp Copyright (c) Ladislav Zezula 2014 */ -/*---------------------------------------------------------------------------*/ -/* Storage functions for CASC */ -/* Note: WoW6 offsets refer to WoW.exe 6.0.3.19116 (32-bit) */ -/* SHA1: c10e9ffb7d040a37a356b96042657e1a0c95c0dd */ -/*---------------------------------------------------------------------------*/ -/* Date Ver Who Comment */ -/* -------- ---- --- ------- */ -/* 29.04.14 1.00 Lad The first version of CascOpenStorage.cpp */ -/*****************************************************************************/ - -#define __CASCLIB_SELF__ -#include "CascLib.h" -#include "CascCommon.h" - -//----------------------------------------------------------------------------- -// Local structures - -#define ROOT_SEARCH_PHASE_INITIALIZING 0 -#define ROOT_SEARCH_PHASE_LISTFILE 1 -#define ROOT_SEARCH_PHASE_NAMELESS 2 -#define ROOT_SEARCH_PHASE_FINISHED 2 - -// On-disk version of locale block -typedef struct _FILE_LOCALE_BLOCK -{ - DWORD NumberOfFiles; // Number of entries - DWORD Flags; - DWORD Locales; // File locale mask (CASC_LOCALE_XXX) - - // Followed by a block of 32-bit integers (count: NumberOfFiles) - // Followed by the MD5 and file name hash (count: NumberOfFiles) - -} FILE_LOCALE_BLOCK, *PFILE_LOCALE_BLOCK; - -// On-disk version of root entry -typedef struct _FILE_ROOT_ENTRY -{ - ENCODING_KEY EncodingKey; // MD5 of the file - ULONGLONG FileNameHash; // Jenkins hash of the file name - -} FILE_ROOT_ENTRY, *PFILE_ROOT_ENTRY; - - -typedef struct _CASC_ROOT_BLOCK -{ - PFILE_LOCALE_BLOCK pLocaleBlockHdr; // Pointer to the locale block - PDWORD FileDataIds; // Pointer to the array of File Data IDs - PFILE_ROOT_ENTRY pRootEntries; - -} CASC_ROOT_BLOCK, *PCASC_ROOT_BLOCK; - -// Root file entry for CASC storages without MNDX root file (World of Warcraft 6.0+) -// Does not match to the in-file structure of the root entry -typedef struct _CASC_FILE_ENTRY -{ - ENCODING_KEY EncodingKey; // File encoding key (MD5) - ULONGLONG FileNameHash; // Jenkins hash of the file name - DWORD FileDataId; // File Data Index - DWORD Locales; // Locale flags of the file - -} CASC_FILE_ENTRY, *PCASC_FILE_ENTRY; - -struct TRootHandler_WoW6 : public TRootHandler -{ - // Linear global list of file entries - DYNAMIC_ARRAY FileTable; - DYNAMIC_ARRAY FileDataIdLookupTable; - - // Global map of FileName -> FileEntry - PCASC_MAP pRootMap; - - // For counting files - DWORD dwTotalFileCount; -}; - -// Prototype for root file parsing routine -typedef int (*PARSE_ROOT)(TRootHandler_WoW6 * pRootHandler, PCASC_ROOT_BLOCK pBlockInfo); - -//----------------------------------------------------------------------------- -// Local functions - -static bool IsFileDataIdName(const char * szFileName) -{ - BYTE BinaryValue[4]; - - // File name must begin with "File", case insensitive - if(AsciiToUpperTable_BkSlash[szFileName[0]] == 'F' && - AsciiToUpperTable_BkSlash[szFileName[1]] == 'I' && - AsciiToUpperTable_BkSlash[szFileName[2]] == 'L' && - AsciiToUpperTable_BkSlash[szFileName[3]] == 'E') - { - // Then, 8 hexadecimal digits must follow - if(ConvertStringToBinary(szFileName + 4, 8, BinaryValue) == ERROR_SUCCESS) - { - // Must be followed by an extension or end-of-string - return (szFileName[0x0C] == 0 || szFileName[0x0C] == '.'); - } - } - - return false; -} - -static int FileDataIdCompare(const void *, const void * pvFile1, const void * pvFile2) -{ - return ((PCASC_FILE_ENTRY)pvFile1)->FileDataId - ((PCASC_FILE_ENTRY)pvFile2)->FileDataId; -} - -// Search by FileDataId -PCASC_FILE_ENTRY FindRootEntry(DYNAMIC_ARRAY & FileTable, DWORD FileDataId) -{ - PCASC_FILE_ENTRY* pStartEntry = (PCASC_FILE_ENTRY*)FileTable.ItemArray; - PCASC_FILE_ENTRY* pMidlEntry; - PCASC_FILE_ENTRY* pEndEntry = pStartEntry + FileTable.ItemCount - 1; - int nResult; - - // Perform binary search on the table - while(pStartEntry < pEndEntry) - { - // Calculate the middle of the interval - pMidlEntry = pStartEntry + ((pEndEntry - pStartEntry) / 2); - - // Did we find it? - nResult = (int)FileDataId - (int)(*pMidlEntry)->FileDataId; - if(nResult == 0) - return *pMidlEntry; - - // Move the interval to the left or right - (nResult < 0) ? pEndEntry = pMidlEntry : pStartEntry = pMidlEntry + 1; - } - - return NULL; -} - -// Search by file name hash -// Also used in CascSearchFile -PCASC_FILE_ENTRY FindRootEntry(PCASC_MAP pRootMap, const char * szFileName, DWORD * PtrTableIndex) -{ - // Calculate the HASH value of the normalized file name - ULONGLONG FileNameHash = CalcFileNameHash(szFileName); - - // Perform the hash search - return (PCASC_FILE_ENTRY)Map_FindObject(pRootMap, &FileNameHash, PtrTableIndex); -} - -LPBYTE VerifyLocaleBlock(PCASC_ROOT_BLOCK pBlockInfo, LPBYTE pbFilePointer, LPBYTE pbFileEnd) -{ - // Validate the file locale block - pBlockInfo->pLocaleBlockHdr = (PFILE_LOCALE_BLOCK)pbFilePointer; - pbFilePointer = (LPBYTE)(pBlockInfo->pLocaleBlockHdr + 1); - if(pbFilePointer > pbFileEnd) - return NULL; - - // Validate the array of 32-bit integers - pBlockInfo->FileDataIds = (PDWORD)pbFilePointer; - pbFilePointer = (LPBYTE)(pBlockInfo->FileDataIds + pBlockInfo->pLocaleBlockHdr->NumberOfFiles); - if(pbFilePointer > pbFileEnd) - return NULL; - - // Validate the array of root entries - pBlockInfo->pRootEntries = (PFILE_ROOT_ENTRY)pbFilePointer; - pbFilePointer = (LPBYTE)(pBlockInfo->pRootEntries + pBlockInfo->pLocaleBlockHdr->NumberOfFiles); - if(pbFilePointer > pbFileEnd) - return NULL; - - // Return the position of the next block - return pbFilePointer; -} - -static int ParseRoot_CountFiles( - TRootHandler_WoW6 * pRootHandler, - PCASC_ROOT_BLOCK pRootBlock) -{ - // Add the file count to the total file count - pRootHandler->dwTotalFileCount += pRootBlock->pLocaleBlockHdr->NumberOfFiles; - return ERROR_SUCCESS; -} - -static int ParseRoot_AddRootEntries( - TRootHandler_WoW6 * pRootHandler, - PCASC_ROOT_BLOCK pRootBlock) -{ - PCASC_FILE_ENTRY pFileEntry; - DWORD dwFileDataId = 0; - - // Sanity checks - assert(pRootHandler->FileTable.ItemArray != NULL); - assert(pRootHandler->FileTable.ItemCountMax != 0); - assert(pRootHandler->FileDataIdLookupTable.ItemArray != NULL); - assert(pRootHandler->FileDataIdLookupTable.ItemCountMax != 0); - - // WoW.exe (build 19116): Blocks with zero files are skipped - for(DWORD i = 0; i < pRootBlock->pLocaleBlockHdr->NumberOfFiles; i++) - { - // Create new entry, with overflow check - if(pRootHandler->FileTable.ItemCount >= pRootHandler->FileTable.ItemCountMax) - return ERROR_INSUFFICIENT_BUFFER; - pFileEntry = (PCASC_FILE_ENTRY)Array_Insert(&pRootHandler->FileTable, NULL, 1); - - if (pRootHandler->FileDataIdLookupTable.ItemCount >= pRootHandler->FileDataIdLookupTable.ItemCountMax) - return ERROR_INSUFFICIENT_BUFFER; - Array_Insert(&pRootHandler->FileDataIdLookupTable, &pFileEntry, 1); - - // (004147A3) Prepare the CASC_FILE_ENTRY structure - pFileEntry->FileNameHash = pRootBlock->pRootEntries[i].FileNameHash; - pFileEntry->FileDataId = dwFileDataId + pRootBlock->FileDataIds[i]; - pFileEntry->Locales = pRootBlock->pLocaleBlockHdr->Locales; - pFileEntry->EncodingKey = pRootBlock->pRootEntries[i].EncodingKey; - - // Also, insert the entry to the map - Map_InsertObject(pRootHandler->pRootMap, pFileEntry, &pFileEntry->FileNameHash); - - // Update the local File Data Id - assert((pFileEntry->FileDataId + 1) > pFileEntry->FileDataId); - dwFileDataId = pFileEntry->FileDataId + 1; - - // Move to the next root entry - pFileEntry++; - } - - return ERROR_SUCCESS; -} - -static int ParseWowRootFileInternal( - TRootHandler_WoW6 * pRootHandler, - PARSE_ROOT pfnParseRoot, - LPBYTE pbRootFile, - LPBYTE pbRootFileEnd, - DWORD dwLocaleMask, - BYTE bOverrideArchive, - BYTE bAudioLocale) -{ - CASC_ROOT_BLOCK RootBlock; - - // Now parse the root file - while(pbRootFile < pbRootFileEnd) - { - // Validate the file locale block - pbRootFile = VerifyLocaleBlock(&RootBlock, pbRootFile, pbRootFileEnd); - if(pbRootFile == NULL) - break; - - // WoW.exe (build 19116): Entries with flag 0x100 set are skipped - if(RootBlock.pLocaleBlockHdr->Flags & 0x100) - continue; - - // WoW.exe (build 19116): Entries with flag 0x80 set are skipped if overrideArchive CVAR is set to FALSE (which is by default in non-chinese clients) - if((RootBlock.pLocaleBlockHdr->Flags & 0x80) && bOverrideArchive == 0) - continue; - - // WoW.exe (build 19116): Entries with (flags >> 0x1F) not equal to bAudioLocale are skipped - if((RootBlock.pLocaleBlockHdr->Flags >> 0x1F) != bAudioLocale) - continue; - - // WoW.exe (build 19116): Locales other than defined mask are skipped too - if((RootBlock.pLocaleBlockHdr->Locales & dwLocaleMask) == 0) - continue; - - // Now call the custom function - pfnParseRoot(pRootHandler, &RootBlock); - } - - return ERROR_SUCCESS; -} - -/* -// known dwRegion values returned from sub_661316 (7.0.3.22210 x86 win), also referred by lua GetCurrentRegion -#define WOW_REGION_US 0x01 -#define WOW_REGION_KR 0x02 -#define WOW_REGION_EU 0x03 -#define WOW_REGION_TW 0x04 -#define WOW_REGION_CN 0x05 - -#define WOW_LOCALE_ENUS 0x00 -#define WOW_LOCALE_KOKR 0x01 -#define WOW_LOCALE_FRFR 0x02 -#define WOW_LOCALE_DEDE 0x03 -#define WOW_LOCALE_ZHCN 0x04 -#define WOW_LOCALE_ZHTW 0x05 -#define WOW_LOCALE_ESES 0x06 -#define WOW_LOCALE_ESMX 0x07 -#define WOW_LOCALE_RURU 0x08 -#define WOW_LOCALE_PTBR 0x0A -#define WOW_LOCALE_ITIT 0x0B - - // dwLocale is obtained from a WOW_LOCALE_* to CASC_LOCALE_BIT_* mapping (sub_6615D0 in 7.0.3.22210 x86 win) - // because (ENUS, ENGB) and (PTBR, PTPT) pairs share the same value on WOW_LOCALE_* enum - // dwRegion is used to distinguish them - if(dwRegion == WOW_REGION_EU) - { - // Is this english version of WoW? - if(dwLocale == CASC_LOCALE_BIT_ENUS) - { - LoadWowRootFileLocales(hs, pbRootFile, cbRootFile, CASC_LOCALE_ENGB, bOverrideArchive, bAudioLocale); - LoadWowRootFileLocales(hs, pbRootFile, cbRootFile, CASC_LOCALE_ENUS, bOverrideArchive, bAudioLocale); - return ERROR_SUCCESS; - } - - // Is this portuguese version of WoW? - if(dwLocale == CASC_LOCALE_BIT_PTBR) - { - LoadWowRootFileLocales(hs, pbRootFile, cbRootFile, CASC_LOCALE_PTPT, bOverrideArchive, bAudioLocale); - LoadWowRootFileLocales(hs, pbRootFile, cbRootFile, CASC_LOCALE_PTBR, bOverrideArchive, bAudioLocale); - } - } - else - LoadWowRootFileLocales(hs, pbRootFile, cbRootFile, (1 << dwLocale), bOverrideArchive, bAudioLocale); -*/ - -static int ParseWowRootFile2( - TRootHandler_WoW6 * pRootHandler, - PARSE_ROOT pfnParseRoot, - LPBYTE pbRootFile, - LPBYTE pbRootFileEnd, - DWORD dwLocaleMask, - BYTE bAudioLocale) -{ - // Load the locale as-is - ParseWowRootFileInternal(pRootHandler, pfnParseRoot, pbRootFile, pbRootFileEnd, dwLocaleMask, false, bAudioLocale); - - // If we wanted enGB, we also load enUS for the missing files - if(dwLocaleMask == CASC_LOCALE_ENGB) - ParseWowRootFileInternal(pRootHandler, pfnParseRoot, pbRootFile, pbRootFileEnd, CASC_LOCALE_ENUS, false, bAudioLocale); - - if(dwLocaleMask == CASC_LOCALE_PTPT) - ParseWowRootFileInternal(pRootHandler, pfnParseRoot, pbRootFile, pbRootFileEnd, CASC_LOCALE_PTBR, false, bAudioLocale); - - return ERROR_SUCCESS; -} - -// WoW.exe: 004146C7 (BuildManifest::Load) -static int ParseWowRootFile( - TRootHandler_WoW6 * pRootHandler, - PARSE_ROOT pfnParseRoot, - LPBYTE pbRootFile, - LPBYTE pbRootFileEnd, - DWORD dwLocaleMask) -{ - ParseWowRootFile2(pRootHandler, pfnParseRoot, pbRootFile, pbRootFileEnd, dwLocaleMask, 0); - ParseWowRootFile2(pRootHandler, pfnParseRoot, pbRootFile, pbRootFileEnd, dwLocaleMask, 1); - return ERROR_SUCCESS; -} - -//----------------------------------------------------------------------------- -// Implementation of WoW6 root file - -static int WowHandler_Insert( - TRootHandler_WoW6 * pRootHandler, - const char * szFileName, - LPBYTE pbEncodingKey) -{ - PCASC_FILE_ENTRY pFileEntry; - DWORD FileDataId = 0; - - // Don't let the number of items to overflow - if(pRootHandler->FileTable.ItemCount >= pRootHandler->FileTable.ItemCountMax) - return ERROR_NOT_ENOUGH_MEMORY; - - if (pRootHandler->FileDataIdLookupTable.ItemCount >= pRootHandler->FileDataIdLookupTable.ItemCountMax) - return ERROR_NOT_ENOUGH_MEMORY; - - // Insert the item to the linear file list - pFileEntry = (PCASC_FILE_ENTRY)Array_Insert(&pRootHandler->FileTable, NULL, 1); - if(pFileEntry != NULL) - { - Array_Insert(&pRootHandler->FileDataIdLookupTable, &pFileEntry, 1); - - // Get the file data ID of the previous item (0 if this is the first one) - if(pRootHandler->FileTable.ItemCount > 1) - FileDataId = pFileEntry[-1].FileDataId; - - // Fill-in the new entry - pFileEntry->EncodingKey = *(PENCODING_KEY)pbEncodingKey; - pFileEntry->FileNameHash = CalcFileNameHash(szFileName); - pFileEntry->FileDataId = FileDataId + 1; - pFileEntry->Locales = CASC_LOCALE_ALL; - - // Verify collisions (debug version only) - assert(Map_FindObject(pRootHandler->pRootMap, &pFileEntry->FileNameHash, NULL) == NULL); - - // Insert the entry to the map - Map_InsertObject(pRootHandler->pRootMap, pFileEntry, &pFileEntry->FileNameHash); - } - - return ERROR_SUCCESS; -} - -static LPBYTE WowHandler_Search( - TRootHandler_WoW6 * pRootHandler, - TCascSearch * pSearch, - PDWORD /* PtrFileSize */, - PDWORD PtrLocaleFlags, - PDWORD PtrFileDataId) -{ - PCASC_FILE_ENTRY pFileEntry; - - // Only if we have a listfile - if(pSearch->pCache != NULL) - { - // Keep going through the listfile - while(ListFile_GetNext(pSearch->pCache, pSearch->szMask, pSearch->szFileName, MAX_PATH)) - { - // Find the root entry - pFileEntry = FindRootEntry(pRootHandler->pRootMap, pSearch->szFileName, NULL); - if(pFileEntry != NULL) - { - // Give the caller the locale mask - if(PtrLocaleFlags != NULL) - PtrLocaleFlags[0] = pFileEntry->Locales; - if(PtrFileDataId != NULL) - PtrFileDataId[0] = pFileEntry->FileDataId; - return pFileEntry->EncodingKey.Value; - } - } - } - - // No more files - return NULL; -} - -static LPBYTE WowHandler_GetKey(TRootHandler_WoW6 * pRootHandler, const char * szFileName) -{ - PCASC_FILE_ENTRY pFileEntry; - DWORD FileDataId; - BYTE FileDataIdLE[4]; - - // Open by FileDataId. The file name must be as following: - // File########.unk, where '#' are hexa-decimal numbers (case insensitive). - // Extension is ignored in that case - if(IsFileDataIdName(szFileName)) - { - ConvertStringToBinary(szFileName + 4, 8, FileDataIdLE); - FileDataId = ConvertBytesToInteger_4(FileDataIdLE); - - pFileEntry = FindRootEntry(pRootHandler->FileDataIdLookupTable, FileDataId); - } - else - { - // Find by the file name hash - pFileEntry = FindRootEntry(pRootHandler->pRootMap, szFileName, NULL); - } - - return (pFileEntry != NULL) ? pFileEntry->EncodingKey.Value : NULL; -} - -static void WowHandler_EndSearch(TRootHandler_WoW6 * /* pRootHandler */, TCascSearch * pSearch) -{ - if(pSearch->pRootContext != NULL) - CASC_FREE(pSearch->pRootContext); - pSearch->pRootContext = NULL; -} - -static DWORD WowHandler_GetFileId(TRootHandler_WoW6 * pRootHandler, const char * szFileName) -{ - PCASC_FILE_ENTRY pFileEntry; - - // Find by the file name hash - pFileEntry = FindRootEntry(pRootHandler->pRootMap, szFileName, NULL); - return (pFileEntry != NULL) ? pFileEntry->FileDataId : 0; -} - -static void WowHandler_Close(TRootHandler_WoW6 * pRootHandler) -{ - if(pRootHandler != NULL) - { - Array_Free(&pRootHandler->FileTable); - Array_Free(&pRootHandler->FileDataIdLookupTable); - Map_Free(pRootHandler->pRootMap); - CASC_FREE(pRootHandler); - } -} - -#ifdef _DEBUG -static void TRootHandlerWoW6_Dump( - TCascStorage * hs, - TDumpContext * dc, // Pointer to an opened file - LPBYTE pbRootFile, - DWORD cbRootFile, - const TCHAR * szListFile, - int nDumpLevel) -{ - PCASC_ENCODING_ENTRY pEncodingEntry; - CASC_ROOT_BLOCK BlockInfo; - PLISTFILE_MAP pListMap; - QUERY_KEY EncodingKey; - LPBYTE pbRootFileEnd = pbRootFile + cbRootFile; - LPBYTE pbFilePointer; - char szOneLine[0x100]; - DWORD i; - - // Create the listfile map - pListMap = ListFile_CreateMap(szListFile); - - // Dump the root entries - for(pbFilePointer = pbRootFile; pbFilePointer <= pbRootFileEnd; ) - { - // Validate the root block - pbFilePointer = VerifyLocaleBlock(&BlockInfo, pbFilePointer, pbRootFileEnd); - if(pbFilePointer == NULL) - break; - - // Dump the locale block - dump_print(dc, "Flags: %08X Locales: %08X NumberOfFiles: %u\n" - "=========================================================\n", - BlockInfo.pLocaleBlockHdr->Flags, - BlockInfo.pLocaleBlockHdr->Locales, - BlockInfo.pLocaleBlockHdr->NumberOfFiles); - - // Dump the hashes and encoding keys - for(i = 0; i < BlockInfo.pLocaleBlockHdr->NumberOfFiles; i++) - { - // Dump the entry - dump_print(dc, "%08X %08X-%08X %s %s\n", - (DWORD)(BlockInfo.FileDataIds[i]), - (DWORD)(BlockInfo.pRootEntries[i].FileNameHash >> 0x20), - (DWORD)(BlockInfo.pRootEntries[i].FileNameHash), - StringFromMD5(BlockInfo.pRootEntries[i].EncodingKey.Value, szOneLine), - ListFile_FindName(pListMap, BlockInfo.pRootEntries[i].FileNameHash)); - - // Find the encoding entry in the encoding table - if(nDumpLevel >= DUMP_LEVEL_ENCODING_FILE) - { - EncodingKey.pbData = BlockInfo.pRootEntries[i].EncodingKey.Value; - EncodingKey.cbData = MD5_HASH_SIZE; - pEncodingEntry = FindEncodingEntry(hs, &EncodingKey, NULL); - CascDumpEncodingEntry(hs, dc, pEncodingEntry, nDumpLevel); - } - } - - // Put extra newline - dump_print(dc, "\n"); - } - - ListFile_FreeMap(pListMap); -} -#endif - -//----------------------------------------------------------------------------- -// Public functions - -int RootHandler_CreateWoW6(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile, DWORD dwLocaleMask) -{ - TRootHandler_WoW6 * pRootHandler; - LPBYTE pbRootFileEnd = pbRootFile + cbRootFile; - int nError; - - // Verify the size - if(pbRootFile == NULL || cbRootFile <= sizeof(PFILE_LOCALE_BLOCK)) - nError = ERROR_FILE_CORRUPT; - - // Allocate the root handler object - hs->pRootHandler = pRootHandler = CASC_ALLOC(TRootHandler_WoW6, 1); - if(pRootHandler == NULL) - return ERROR_NOT_ENOUGH_MEMORY; - - // Fill-in the handler functions - memset(pRootHandler, 0, sizeof(TRootHandler_WoW6)); - pRootHandler->Insert = (ROOT_INSERT)WowHandler_Insert; - pRootHandler->Search = (ROOT_SEARCH)WowHandler_Search; - pRootHandler->EndSearch = (ROOT_ENDSEARCH)WowHandler_EndSearch; - pRootHandler->GetKey = (ROOT_GETKEY)WowHandler_GetKey; - pRootHandler->Close = (ROOT_CLOSE)WowHandler_Close; - pRootHandler->GetFileId = (ROOT_GETFILEID)WowHandler_GetFileId; - -#ifdef _DEBUG - pRootHandler->Dump = TRootHandlerWoW6_Dump; // Support for ROOT file dump -#endif // _DEBUG - - // Count the files that are going to be loaded - ParseWowRootFile(pRootHandler, ParseRoot_CountFiles, pbRootFile, pbRootFileEnd, dwLocaleMask); - pRootHandler->dwTotalFileCount += CASC_EXTRA_FILES; - - // Create linear table that will contain all root items - nError = Array_Create(&pRootHandler->FileTable, CASC_FILE_ENTRY, pRootHandler->dwTotalFileCount); - if(nError != ERROR_SUCCESS) - return nError; - - // Create sorted table that will contain all root items to lookup by FileDataId - nError = Array_Create(&pRootHandler->FileDataIdLookupTable, PCASC_FILE_ENTRY, pRootHandler->dwTotalFileCount); - if (nError != ERROR_SUCCESS) - return nError; - - // Create the map of FileHash ->FileEntry - pRootHandler->pRootMap = Map_Create(pRootHandler->dwTotalFileCount, sizeof(ULONGLONG), FIELD_OFFSET(CASC_FILE_ENTRY, FileNameHash)); - if(pRootHandler->pRootMap == NULL) - return ERROR_NOT_ENOUGH_MEMORY; - - // Parse the root file again and insert all files to the map - ParseWowRootFile(pRootHandler, ParseRoot_AddRootEntries, pbRootFile, pbRootFileEnd, dwLocaleMask); - - // Sort entries by FileDataId for searches - qsort_pointer_array((void**)pRootHandler->FileDataIdLookupTable.ItemArray, pRootHandler->FileDataIdLookupTable.ItemCount, &FileDataIdCompare, NULL); - return ERROR_SUCCESS; -} diff --git a/dep/CascLib/src/CascStructs.h b/dep/CascLib/src/CascStructs.h new file mode 100644 index 00000000000..f67da810c9e --- /dev/null +++ b/dep/CascLib/src/CascStructs.h @@ -0,0 +1,255 @@ +/*****************************************************************************/ +/* CascStructs.h Copyright (c) Ladislav Zezula 2019 */ +/*---------------------------------------------------------------------------*/ +/* On-disk structures for CASC storages */ +/*---------------------------------------------------------------------------*/ +/* Date Ver Who Comment */ +/* -------- ---- --- ------- */ +/* 28.04.19 1.00 Lad The first version of CascStructs.h */ +/*****************************************************************************/ + +#ifndef __CASC_STRUCTS_H__ +#define __CASC_STRUCTS_H__ + +//----------------------------------------------------------------------------- +// Common definitions + +#define CASC_INDEX_COUNT 0x10 // Number of index files +#define CASC_CKEY_SIZE 0x10 // Size of the content key +#define CASC_EKEY_SIZE 0x09 // Size of the encoded key +#define CASC_MAX_DATA_FILES 0x100 // Maximum number of data files + +//----------------------------------------------------------------------------- +// The index files structures + +#define FILE_INDEX_PAGE_SIZE 0x200 // Number of bytes in one page of EKey items + +// Structure describing the 32-bit block size and 32-bit Jenkins hash of the block +typedef struct _BLOCK_SIZE_AND_HASH +{ + DWORD cbBlockSize; + DWORD dwBlockHash; + +} BLOCK_SIZE_AND_HASH, *PBLOCK_SIZE_AND_HASH; + +// Checksum describing a block in the index file (v2) +typedef struct _FILE_INDEX_GUARDED_BLOCK +{ + DWORD BlockSize; + DWORD BlockHash; + +} FILE_INDEX_GUARDED_BLOCK, *PFILE_INDEX_GUARDED_BLOCK; + +// Structure of the header of the index files version 1 +typedef struct _FILE_INDEX_HEADER_V1 +{ + USHORT IndexVersion; // Must be 0x05 + BYTE BucketIndex; // The bucket index of this file; should be the same as the first byte of the hex filename. + BYTE align_3; + DWORD field_4; + ULONGLONG field_8; + ULONGLONG SegmentSize; // Size of one data segment (aka data.### file) + BYTE EncodedSizeLength; // Length, in bytes, of the EncodedSize in the EKey entry + BYTE StorageOffsetLength; // Length, in bytes, of the StorageOffset field in the EKey entry + BYTE EKeyLength; // Length of the encoded key (bytes) + BYTE FileOffsetBits; // Number of bits of the archive file offset in StorageOffset field. Rest is data segment index + DWORD EKeyCount1; + DWORD EKeyCount2; + DWORD KeysHash1; + DWORD KeysHash2; + DWORD HeaderHash; +} FILE_INDEX_HEADER_V1, *PFILE_INDEX_HEADER_V1; + +typedef struct _FILE_INDEX_HEADER_V2 +{ + USHORT IndexVersion; // Must be 0x07 + BYTE BucketIndex; // The bucket index of this file; should be the same as the first byte of the hex filename. + BYTE ExtraBytes; // Unknown; must be 0 + BYTE EncodedSizeLength; // Length, in bytes, of the EncodedSize in the EKey entry + BYTE StorageOffsetLength; // Length, in bytes, of the StorageOffset field in the EKey entry + BYTE EKeyLength; // Length of the encoded key (bytes) + BYTE FileOffsetBits; // Number of bits of the archive file offset in StorageOffset field. Rest is data segment index + ULONGLONG SegmentSize; // Size of one data segment (aka data.### file) + +} FILE_INDEX_HEADER_V2, *PFILE_INDEX_HEADER_V2; + +// The EKey entry from the ".idx" files. Note that the lengths are optional and controlled by the FILE_INDEX_HEADER_Vx +typedef struct _FILE_EKEY_ENTRY +{ + BYTE EKey[CASC_EKEY_SIZE]; // The first 9 bytes of the encoded key + BYTE FileOffsetBE[5]; // Index of data file and offset within (big endian). + BYTE EncodedSize[4]; // Encoded size (big endian). This is the size of encoded header, all file frame headers and all file frames +} FILE_EKEY_ENTRY, *PFILE_EKEY_ENTRY; + +//----------------------------------------------------------------------------- +// The archive index (md5.index) files structures +// https://wowdev.wiki/TACT#CDN_File_Organization + +template <int CHKSUM_LENGTH> +struct FILE_INDEX_FOOTER +{ + BYTE TocHash[MD5_HASH_SIZE]; // Client tries to read with 0x10, then backs off in size when smaller + BYTE Version; // Version of the index header + BYTE Reserved[2]; // Length, in bytes, of the file offset field + BYTE PageSizeKB; // Length, in kilobytes, of the index page + BYTE OffsetBytes; // Normally 4 for archive indices, 6 for group indices, and 0 for loose file indices + BYTE SizeBytes; // Normally 4 + BYTE EKeySizeBytes; // Normally 16 + BYTE FooterHashBytes; // Normally 8, <= 0x10 + BYTE ElementCount[4]; // BigEndian in _old_ versions (e.g. 18179) + BYTE FooterHash[CHKSUM_LENGTH]; +}; + +//----------------------------------------------------------------------------- +// The ENCODING manifest structures +// +// The ENCODING file is in the form of: +// * File header. Fixed length. +// * Encoding Specification (ESpec) in the string form. Length is stored in FILE_ENCODING_HEADER::ESpecBlockSize +// https://wowdev.wiki/CASC#Encoding +// https://wowdev.wiki/TACT#Encoding_table +// + +#define FILE_MAGIC_ENCODING 0x4E45 // 'EN' + +// File header of the ENCODING manifest +typedef struct _FILE_ENCODING_HEADER +{ + USHORT Magic; // FILE_MAGIC_ENCODING ('EN') + BYTE Version; // Expected to be 1 by CascLib + BYTE CKeyLength; // The content key length in ENCODING file. Usually 0x10 + BYTE EKeyLength; // The encoded key length in ENCODING file. Usually 0x10 + BYTE CKeyPageSize[2]; // Size of the CKey page, in KB (big-endian) + BYTE EKeyPageSize[2]; // Size of the EKey page, in KB (big-endian) + BYTE CKeyPageCount[4]; // Number of CKey pages in the table (big endian) + BYTE EKeyPageCount[4]; // Number of EKey pages in the table (big endian) + BYTE field_11; // Asserted to be zero by the agent + BYTE ESpecBlockSize[4]; // Size of the ESpec string block + +} FILE_ENCODING_HEADER, *PFILE_ENCODING_HEADER; + +// Page header of the ENCODING manifest +typedef struct _FILE_CKEY_PAGE +{ + BYTE FirstKey[MD5_HASH_SIZE]; // The first CKey/EKey in the segment + BYTE SegmentHash[MD5_HASH_SIZE]; // MD5 hash of the entire segment + +} FILE_CKEY_PAGE, *PFILE_CKEY_PAGE; + +// Single entry in the page +typedef struct _FILE_CKEY_ENTRY +{ + USHORT EKeyCount; // Number of EKeys + BYTE ContentSize[4]; // Content file size (big endian) + BYTE CKey[CASC_CKEY_SIZE]; // Content key. This is MD5 of the file content + BYTE EKey[CASC_CKEY_SIZE]; // Encoded key. This is (trimmed) MD5 hash of the file header, containing MD5 hashes of all the logical blocks of the file + +} FILE_CKEY_ENTRY, *PFILE_CKEY_ENTRY; + +typedef struct _FILE_ESPEC_ENTRY +{ + BYTE ESpecKey[MD5_HASH_SIZE]; // The ESpec key of the file + BYTE ESpecIndexBE[4]; // Index of ESPEC entry, assuming zero-terminated strings (big endian) + BYTE FileSizeBE[5]; // Size of the encoded version of the file (big endian) + +} FILE_ESPEC_ENTRY, *PFILE_ESPEC_ENTRY; + +//----------------------------------------------------------------------------- +// The DOWNLOAD manifest structures +// +// See https://wowdev.wiki/TACT#Download_manifest +// + +#define FILE_MAGIC_DOWNLOAD 0x4C44 // 'DL' + +// File header of the DOWNLOAD manifest +typedef struct _FILE_DOWNLOAD_HEADER +{ + USHORT Magic; // FILE_MAGIC_DOWNLOAD ('DL') + BYTE Version; // Expected to be 1 by CascLib + BYTE EKeyLength; // The content key length in DOWNLOAD file. Expected to be 0x10 + BYTE EntryHasChecksum; // If nonzero, then the entry has checksum. + BYTE EntryCount[4]; // Number of entries (big-endian) + BYTE TagCount[2]; // Number of tag entries (big endian) + + // Version 2 or newer + BYTE FlagByteSize; // Number of flag bytes + + // Verion 3 or newer + BYTE BasePriority; + BYTE Unknown2[3]; + +} FILE_DOWNLOAD_HEADER, *PFILE_DOWNLOAD_HEADER; + +typedef struct _FILE_DOWNLOAD_ENTRY +{ + BYTE EKey[MD5_HASH_SIZE]; // Encoding key (variable length) + BYTE FileSize[5]; // File size + BYTE Priority; + + // DWORD Checksum [optional] + // BYTE Flags; + +} FILE_DOWNLOAD_ENTRY, *PFILE_DOWNLOAD_ENTRY; + +//----------------------------------------------------------------------------- +// The INSTALL manifest structures +// +// See https://wowdev.wiki/TACT#Install_manifest +// + +#define FILE_MAGIC_INSTALL 0x4E49 // 'IN' + +// File header of the INSTALL manifest +typedef struct _FILE_INSTALL_HEADER +{ + USHORT Magic; // FILE_MAGIC_INSTALL ('DL') + BYTE Version; // Expected to be 1 by CascLib + BYTE EKeyLength; // The content key length in INSTALL file. Expected to be 0x10 + BYTE TagCount[2]; // Number of tag entries (big endian) + BYTE EntryCount[4]; // Number of entries (big-endian) + +} FILE_INSTALL_HEADER, *PFILE_INSTALL_HEADER; + +//----------------------------------------------------------------------------- +// Data file structures + +#define BLTE_HEADER_SIGNATURE 0x45544C42 // 'BLTE' header in the data files +#define BLTE_HEADER_DELTA 0x1E // Distance of BLTE header from begin of the header area +#define MAX_ENCODED_HEADER 0x1000 // Starting size for the frame headers + +typedef struct _BLTE_HEADER +{ + BYTE Signature[4]; // Must be "BLTE" + BYTE HeaderSize[4]; // Header size in bytes (big endian) + BYTE MustBe0F; // Must be 0x0F. Optional, only if HeaderSize != 0 + BYTE FrameCount[3]; // Frame count (big endian). Optional, only if HeaderSize != 0 +} BLTE_HEADER, *PBLTE_HEADER; + +typedef struct _BLTE_ENCODED_HEADER +{ + // Header span. + ENCODED_KEY EKey; // Encoded key of the data beginning with "BLTE" (byte-reversed) + DWORD EncodedSize; // Encoded size of the data data beginning with "BLTE" (little endian) + BYTE field_14; // Seems to be 1 if the header span has no data + BYTE field_15; // Hardcoded to zero (Agent.exe 2.15.0.6296: 01370000->0148E2AA) + BYTE JenkinsHash[4]; // Jenkins hash (hashlittle2) of the preceding fields (EKey + EncodedSize + field_14 + field_15) (little endian) + BYTE Checksum[4]; // Checksum of the previous part. See "VerifyHeaderSpan()" for more information. + + // BLTE header. Always present. + BYTE Signature[4]; // Must be "BLTE" + BYTE HeaderSize[4]; // Header size in bytes (big endian) + BYTE MustBe0F; // Must be 0x0F. Optional, only if HeaderSize != 0 + BYTE FrameCount[3]; // Frame count (big endian). Optional, only if HeaderSize != 0 +} BLTE_ENCODED_HEADER, *PBLTE_ENCODED_HEADER; + +typedef struct _BLTE_FRAME +{ + BYTE EncodedSize[4]; // Encoded frame size (big endian) + BYTE ContentSize[4]; // Content frame size (big endian) + CONTENT_KEY FrameHash; // Hash of the encoded frame + +} BLTE_FRAME, *PBLTE_FRAME; + +#endif // __CASC_STRUCTS_H__ + diff --git a/dep/CascLib/src/DllMain.c b/dep/CascLib/src/DllMain.c new file mode 100644 index 00000000000..f7d0ce3063d --- /dev/null +++ b/dep/CascLib/src/DllMain.c @@ -0,0 +1,24 @@ +/*****************************************************************************/ +/* DllMain.c Copyright (c) Ladislav Zezula 2015 */ +/*---------------------------------------------------------------------------*/ +/* Description: DllMain for the CascLib.dll library */ +/*---------------------------------------------------------------------------*/ +/* Date Ver Who Comment */ +/* -------- ---- --- ------- */ +/* 26.10.15 1.00 Lad The first version of DllMain.c */ +/*****************************************************************************/ + +#define WIN32_LEAN_AND_MEAN +#include <windows.h> + +//----------------------------------------------------------------------------- +// DllMain + +BOOL WINAPI DllMain(HINSTANCE hInst, DWORD dwReason, LPVOID lpReserved) +{ + UNREFERENCED_PARAMETER(hInst); + UNREFERENCED_PARAMETER(dwReason); + UNREFERENCED_PARAMETER(lpReserved); + + return TRUE; +} diff --git a/dep/CascLib/src/common/Array.h b/dep/CascLib/src/common/Array.h new file mode 100644 index 00000000000..1dc96b7be8e --- /dev/null +++ b/dep/CascLib/src/common/Array.h @@ -0,0 +1,208 @@ +/*****************************************************************************/ +/* Array.h Copyright (c) Ladislav Zezula 2015 */ +/*---------------------------------------------------------------------------*/ +/* Common array implementation */ +/*---------------------------------------------------------------------------*/ +/* Date Ver Who Comment */ +/* -------- ---- --- ------- */ +/* 30.10.15 1.00 Lad The first version of DynamicArray.h */ +/* 10.08.18 1.00 Lad CLASS-ified, renamed to Array.h */ +/*****************************************************************************/ + +#ifndef __CASC_ARRAY_H__ +#define __CASC_ARRAY_H__ + +//----------------------------------------------------------------------------- +// Structures + +class CASC_ARRAY +{ + public: + + CASC_ARRAY() + { + m_pItemArray = NULL; + m_ItemCountMax = 0; + m_ItemCount = 0; + m_ItemSize = 0; + } + + ~CASC_ARRAY() + { + Free(); + } + + // Creates an array with a custom element type + template<typename TYPE> + int Create(size_t ItemCountMax) + { + return Create(sizeof(TYPE), ItemCountMax); + } + + // Creates an array with a custom element size + int Create(size_t ItemSize, size_t ItemCountMax) + { + // Create the array + if ((m_pItemArray = CASC_ALLOC(BYTE, ItemSize * ItemCountMax)) == NULL) + return ERROR_NOT_ENOUGH_MEMORY; + + m_ItemCountMax = ItemCountMax; + m_ItemCount = 0; + m_ItemSize = ItemSize; + return ERROR_SUCCESS; + } + + // Inserts one or more items; returns pointer to the first inserted item + void * Insert(size_t NewItemCount) + { + void * pNewItems; + + // Try to enlarge the buffer, if needed + if (!EnlargeArray(m_ItemCount + NewItemCount)) + return NULL; + pNewItems = m_pItemArray + (m_ItemCount * m_ItemSize); + + // Increment the size of the array + m_ItemCount += NewItemCount; + + // Return pointer to the new item + return pNewItems; + } + + // Inserts one or more items; returns pointer to the first inserted item + void * Insert(const void * NewItems, size_t NewItemCount) + { + void * pNewItem = Insert(NewItemCount); + + // Copy the item(s) to the array, if any + if (pNewItem && NewItems) + memcpy(pNewItem, NewItems, (NewItemCount * m_ItemSize)); + return pNewItem; + } + + // Returns an item at a given index + void * ItemAt(size_t ItemIndex) + { + return (ItemIndex < m_ItemCount) ? (m_pItemArray + (ItemIndex * m_ItemSize)) : NULL; + } + + void * LastItem() + { + return m_pItemArray + (m_ItemCount * m_ItemSize); + } + + // Inserts an item at a given index. If there is not enough items in the array, + // the array will be enlarged. Should any gaps to be created, the function will zero them + void * InsertAt(size_t ItemIndex) + { + LPBYTE pbLastItem; + LPBYTE pbNewItem; + + // Make sure we have array large enough + if(!EnlargeArray(ItemIndex + 1)) + return NULL; + + // Get the items range + pbLastItem = m_pItemArray + (m_ItemCount * m_ItemSize); + pbNewItem = m_pItemArray + (ItemIndex * m_ItemSize); + m_ItemCount = CASCLIB_MAX(m_ItemCount, ItemIndex+1); + + // If we inserted an item past the current end, we need to clear the items in-between + if (pbNewItem > pbLastItem) + { + memset(pbLastItem, 0, (pbNewItem - pbLastItem)); + m_ItemCount = ItemIndex + 1; + } + + return pbNewItem; + } + + // Returns index of an item + size_t IndexOf(const void * pItem) + { + LPBYTE pbItem = (LPBYTE)pItem; + + assert((m_pItemArray <= pbItem) && (pbItem <= m_pItemArray + (m_ItemCount * m_ItemSize))); + assert(((pbItem - m_pItemArray) % m_ItemSize) == 0); + + return ((pbItem - m_pItemArray) / m_ItemSize); + } + + void * ItemArray() + { + return m_pItemArray; + } + + size_t ItemCount() + { + return m_ItemCount; + } + + size_t ItemCountMax() + { + return m_ItemCountMax; + } + + size_t ItemSize() + { + return m_ItemSize; + } + + bool IsInitialized() + { + return (m_pItemArray && m_ItemCountMax); + } + + // Invalidates the entire array, but keeps memory allocated + void Reset() + { + memset(m_pItemArray, 0, m_ItemCountMax * m_ItemSize); + m_ItemCount = 0; + } + + // Frees the array + void Free() + { + CASC_FREE(m_pItemArray); + m_ItemCountMax = m_ItemCount = m_ItemSize = 0; + } + + protected: + + bool EnlargeArray(size_t NewItemCount) + { + LPBYTE NewItemArray; + size_t ItemCountMax; + + // We expect the array to be already allocated + assert(m_pItemArray != NULL); + assert(m_ItemCountMax != 0); + + // Shall we enlarge the table? + if (NewItemCount > m_ItemCountMax) + { + // Calculate new table size + ItemCountMax = m_ItemCountMax; + while (ItemCountMax < NewItemCount) + ItemCountMax = ItemCountMax << 1; + + // Allocate new table + NewItemArray = CASC_REALLOC(BYTE, m_pItemArray, (ItemCountMax * m_ItemSize)); + if (NewItemArray == NULL) + return false; + + // Set the new table size + m_ItemCountMax = ItemCountMax; + m_pItemArray = NewItemArray; + } + + return true; + } + + LPBYTE m_pItemArray; // Pointer to item array + size_t m_ItemCountMax; // Maximum item count + size_t m_ItemCount; // Current item count + size_t m_ItemSize; // Size of an item +}; + +#endif // __CASC_ARRAY__ diff --git a/dep/CascLib/src/common/Common.cpp b/dep/CascLib/src/common/Common.cpp index a0455b7c659..d545f52f84a 100644 --- a/dep/CascLib/src/common/Common.cpp +++ b/dep/CascLib/src/common/Common.cpp @@ -65,40 +65,230 @@ unsigned char IntToHexChar[] = "0123456789abcdef"; // GetLastError/SetLastError support for non-Windows platform #ifndef PLATFORM_WINDOWS -static int nLastError = ERROR_SUCCESS; +static DWORD dwLastError = ERROR_SUCCESS; -int GetLastError() +DWORD GetLastError() { - return nLastError; + return dwLastError; } -void SetLastError(int nError) +void SetLastError(DWORD dwErrCode) { - nLastError = nError; + dwLastError = dwErrCode; } #endif //----------------------------------------------------------------------------- -// String manipulation +// Overloaded "new" and "delete" operators -void CopyString(char * szTarget, const char * szSource, size_t cchLength) +void * operator new(size_t size) { - memcpy(szTarget, szSource, cchLength); - szTarget[cchLength] = 0; + return CASC_ALLOC(BYTE, size); } -void CopyString(wchar_t * szTarget, const char * szSource, size_t cchLength) +void * operator new[](size_t size) { - mbstowcs(szTarget, szSource, cchLength); - szTarget[cchLength] = 0; + return CASC_ALLOC(BYTE, size); } -void CopyString(char * szTarget, const wchar_t * szSource, size_t cchLength) +void operator delete(void * ptr) { - wcstombs(szTarget, szSource, cchLength); - szTarget[cchLength] = 0; + CASC_FREE(ptr); } +void operator delete[](void * ptr) +{ + CASC_FREE(ptr); +} + +// For some reason, VS2015 needs this +void operator delete(void * ptr, size_t) +{ + CASC_FREE(ptr); +} + +//----------------------------------------------------------------------------- +// Linear data stream manipulation + +LPBYTE CaptureInteger32(LPBYTE pbDataPtr, LPBYTE pbDataEnd, PDWORD PtrValue) +{ + // Is there enough data? + if((pbDataPtr + sizeof(DWORD)) > pbDataEnd) + return NULL; + + // Give data + PtrValue[0] = *(PDWORD)pbDataPtr; + + // Return the pointer to data following after the integer + return pbDataPtr + sizeof(DWORD); +} + +LPBYTE CaptureInteger32_BE(LPBYTE pbDataPtr, LPBYTE pbDataEnd, PDWORD PtrValue) +{ + // Is there enough data? + if((pbDataPtr + sizeof(DWORD)) > pbDataEnd) + return NULL; + + // Convert data from Little endian to + PtrValue[0] = ConvertBytesToInteger_4(pbDataPtr); + + // Return the pointer to data following after the integer + return pbDataPtr + sizeof(DWORD); +} + +LPBYTE CaptureByteArray(LPBYTE pbDataPtr, LPBYTE pbDataEnd, size_t nLength, LPBYTE pbOutput) +{ + // Is there enough data? + if((pbDataPtr + nLength) > pbDataEnd) + return NULL; + + // Give data + memcpy(pbOutput, pbDataPtr, nLength); + + // Return the pointer to data following after the integer + return pbDataPtr + nLength; +} + +LPBYTE CaptureContentKey(LPBYTE pbDataPtr, LPBYTE pbDataEnd, PCONTENT_KEY * PtrCKey) +{ + // Is there enough data? + if((pbDataPtr + sizeof(CONTENT_KEY)) > pbDataEnd) + return NULL; + + // Give data + PtrCKey[0] = (PCONTENT_KEY)pbDataPtr; + + // Return the pointer to data following after the integer + return pbDataPtr + sizeof(CONTENT_KEY); +} + +LPBYTE CaptureArray_(LPBYTE pbDataPtr, LPBYTE pbDataEnd, LPBYTE * PtrArray, size_t ItemSize, size_t ItemCount) +{ + size_t ArraySize = ItemSize * ItemCount; + + // Is there enough data? + if((pbDataPtr + ArraySize) > pbDataEnd) + return NULL; + + // Give data + PtrArray[0] = pbDataPtr; + + // Return the pointer to data following after the array + return pbDataPtr + ArraySize; +} + +//----------------------------------------------------------------------------- +// String copying and conversion + +void CascStrCopy(char * szTarget, size_t cchTarget, const char * szSource, size_t cchSource) +{ + size_t cchToCopy; + + if (cchTarget > 0) + { + // Make sure we know the length + if (cchSource == -1) + cchSource = strlen(szSource); + cchToCopy = CASCLIB_MIN((cchTarget - 1), cchSource); + + // Copy the string + memcpy(szTarget, szSource, cchToCopy); + szTarget[cchToCopy] = 0; + } +} + +void CascStrCopy(char * szTarget, size_t cchTarget, const wchar_t * szSource, size_t cchSource) +{ + size_t cchToCopy; + + if (cchTarget > 0) + { + // Make sure we know the length + if (cchSource == -1) + cchSource = wcslen(szSource); + cchToCopy = CASCLIB_MIN((cchTarget - 1), cchSource); + + wcstombs(szTarget, szSource, cchToCopy); + szTarget[cchToCopy] = 0; + } +} + +void CascStrCopy(wchar_t * szTarget, size_t cchTarget, const char * szSource, size_t cchSource) +{ + size_t cchToCopy; + + if (cchTarget > 0) + { + // Make sure we know the length + if (cchSource == -1) + cchSource = strlen(szSource); + cchToCopy = CASCLIB_MIN((cchTarget - 1), cchSource); + + mbstowcs(szTarget, szSource, cchToCopy); + szTarget[cchToCopy] = 0; + } +} + +void CascStrCopy(wchar_t * szTarget, size_t cchTarget, const wchar_t * szSource, size_t cchSource) +{ + size_t cchToCopy; + + if (cchTarget > 0) + { + // Make sure we know the length + if (cchSource == -1) + cchSource = wcslen(szSource); + cchToCopy = CASCLIB_MIN((cchTarget - 1), cchSource); + + memcpy(szTarget, szSource, cchToCopy * sizeof(wchar_t)); + szTarget[cchToCopy] = 0; + } +} + +//----------------------------------------------------------------------------- +// Safe version of s(w)printf + +size_t CascStrPrintf(char * buffer, size_t nCount, const char * format, ...) +{ + char * buffend; + va_list argList; + + // Start the argument list + va_start(argList, format); + +#ifdef PLATFORM_WINDOWS + StringCchVPrintfExA(buffer, nCount, &buffend, NULL, 0, format, argList); +#else + buffend = buffer + vsnprintf(buffer, nCount, format, argList); +#endif + + // End the argument list + va_end(argList); + return (buffend - buffer); +} + +size_t CascStrPrintf(wchar_t * buffer, size_t nCount, const wchar_t * format, ...) +{ + wchar_t * buffend; + va_list argList; + + // Start the argument list + va_start(argList, format); + +#ifdef PLATFORM_WINDOWS + StringCchVPrintfExW(buffer, nCount, &buffend, NULL, 0, format, argList); +#else + buffend = buffer + vswprintf(buffer, nCount, format, argList); +#endif + + // End the argument list + va_end(argList); + return (buffend - buffer); +} + +//----------------------------------------------------------------------------- +// String allocation + char * CascNewStr(const char * szString, size_t nCharsToReserve) { char * szNewString = NULL; @@ -137,102 +327,144 @@ wchar_t * CascNewStr(const wchar_t * szString, size_t nCharsToReserve) return szNewString; } -TCHAR * CascNewStrFromAnsi(const char * szBegin, const char * szEnd) +template <typename XCHAR> +TCHAR * AppendPathFragment(TCHAR * szBuffer, TCHAR * szBufferEnd, const XCHAR * szPath, char chSeparator, bool bFirstFragment = false) { - TCHAR * szNewString = NULL; - - // Only if the entry is valid - if(szBegin != NULL && szEnd > szBegin) + // The "Path" must not be empty + if(szPath && szPath[0]) { - // Allocate and copy the string - szNewString = CASC_ALLOC(TCHAR, (szEnd - szBegin + 1)); - if(szNewString != NULL) - CopyString(szNewString, szBegin, (szEnd - szBegin)); + // Append the path separator after the first fragment + if(szBuffer < szBufferEnd && bFirstFragment == false) + { + if(szBuffer[-1] != chSeparator) + { + *szBuffer++ = chSeparator; + } + } + + // Copy the sub path + while(szBuffer < szBufferEnd && szPath[0] != 0) + { + // If there is a path separator, we skip it (all of them) and put single separator there + if(szPath[0] == '\\' || szPath[0] == '/') + { + while(szPath[0] == '\\' || szPath[0] == '/') + szPath++; + *szBuffer++ = chSeparator; + } + else + { + *szBuffer++ = *szPath++; + } + } + + // Append end of string + szBuffer[0] = 0; } - // Return the string - return szNewString; + return szBuffer; } -TCHAR * CombinePath(const TCHAR * szDirectory, const TCHAR * szSubDir) +TCHAR * GetLastPathPart(TCHAR * szWorkPath) { - TCHAR * szFullPath = NULL; - TCHAR * szPathPtr; - size_t nLength1 = 0; - size_t nLength2 = 0; + size_t nLength = _tcslen(szWorkPath); - // Calculate lengths of each part - if(szDirectory != NULL) - { - // Get the length of the directory - nLength1 = _tcslen(szDirectory); + // Go one character back + if(nLength > 0) + nLength--; - // Cut all ending backslashes - while(nLength1 > 0 && (szDirectory[nLength1 - 1] == _T('\\') || szDirectory[nLength1 - 1] == _T('/'))) - nLength1--; - } + // Cut ending (back)slashes, if any + while(nLength > 0 && (szWorkPath[nLength] == _T('\\') || szWorkPath[nLength] == _T('/'))) + nLength--; - if(szSubDir != NULL) + // Cut the last path part + while(nLength > 0) { - // Cut all leading backslashes - while(szSubDir[0] == _T(PATH_SEPARATOR)) - szSubDir++; - - // Get the length of the subdir - nLength2 = _tcslen(szSubDir); - - // Cut all ending backslashes - while(nLength2 > 0 && szSubDir[nLength2 - 1] == _T(PATH_SEPARATOR)) - nLength2--; - } - - // Allocate space for the full path - szFullPath = szPathPtr = CASC_ALLOC(TCHAR, nLength1 + nLength2 + 2); - if(szFullPath != NULL) - { - // Copy the directory - if(szDirectory != NULL && nLength1 != 0) + // End of path? + if(szWorkPath[nLength] == _T('\\') || szWorkPath[nLength] == _T('/')) { - memcpy(szPathPtr, szDirectory, (nLength1 * sizeof(TCHAR))); - szPathPtr += nLength1; + return szWorkPath + nLength; } - // Copy the sub-directory - if(szSubDir != NULL && nLength2 != 0) - { - // Append backslash to the previous one - if(szPathPtr > szFullPath) - *szPathPtr++ = _T(PATH_SEPARATOR); + // Go one character back + nLength--; + } - // Copy the string - memcpy(szPathPtr, szSubDir, (nLength2 * sizeof(TCHAR))); - szPathPtr += nLength2; - } + return NULL; +} - // Terminate the string - szPathPtr[0] = 0; - } +bool CutLastPathPart(TCHAR * szWorkPath) +{ + // Get the last part of the path + szWorkPath = GetLastPathPart(szWorkPath); + if(szWorkPath == NULL) + return false; - return szFullPath; + szWorkPath[0] = 0; + return true; } -TCHAR * CombinePathAndString(const TCHAR * szPath, const char * szString, size_t nLength) +TCHAR * CombinePath(const TCHAR * szDirectory, const TCHAR * szSubDir) { + TCHAR * szFullPathEnd; TCHAR * szFullPath = NULL; - TCHAR * szSubDir; + TCHAR * szPathPtr; + size_t nLength1 = (szDirectory != NULL) ? _tcslen(szDirectory) : 0; + size_t nLength2 = (szSubDir != NULL) ? _tcslen(szSubDir) : 0; - // Create the subdir string - szSubDir = CASC_ALLOC(TCHAR, nLength + 1); - if(szSubDir != NULL) + // Allocate the entire buffer + szFullPath = szPathPtr = CASC_ALLOC(TCHAR, nLength1 + nLength2 + 2); + szFullPathEnd = szFullPath + nLength1 + nLength2 + 1; + if(szFullPath != NULL) { - CopyString(szSubDir, szString, nLength); - szFullPath = CombinePath(szPath, szSubDir); - CASC_FREE(szSubDir); + szPathPtr = AppendPathFragment(szPathPtr, szFullPathEnd, szDirectory, PATH_SEP_CHAR, true); + szPathPtr = AppendPathFragment(szPathPtr, szFullPathEnd, szSubDir, PATH_SEP_CHAR); } return szFullPath; } +size_t CombineFilePath(TCHAR * szBuffer, size_t nMaxChars, const TCHAR * szPath, const TCHAR * szSubPath1, const TCHAR * szSubPath2) +{ + TCHAR * szSaveBuffer = szBuffer; + TCHAR * szBufferEnd = szBuffer + nMaxChars - 1; + + // Append all three parts and return length + szBuffer = AppendPathFragment(szBuffer, szBufferEnd, szPath, PATH_SEP_CHAR, true); + szBuffer = AppendPathFragment(szBuffer, szBufferEnd, szSubPath1, PATH_SEP_CHAR); + szBuffer = AppendPathFragment(szBuffer, szBufferEnd, szSubPath2, PATH_SEP_CHAR); + return (szBuffer - szSaveBuffer); +} + +size_t CombineUrlPath(TCHAR * szBuffer, size_t nMaxChars, const TCHAR * szHost, const TCHAR * szSubPath1, const TCHAR * szSubPath2) +{ + TCHAR * szSaveBuffer = szBuffer; + TCHAR * szBufferEnd = szBuffer + nMaxChars - 1; + + // Append all three parts and return length + szBuffer = AppendPathFragment(szBuffer, szBufferEnd, szHost, '/', true); + szBuffer = AppendPathFragment(szBuffer, szBufferEnd, szSubPath1, '/'); + szBuffer = AppendPathFragment(szBuffer, szBufferEnd, szSubPath2, '/'); + return (szBuffer - szSaveBuffer); +} + +size_t CreateCascSubdirectoryName(TCHAR * szBuffer, size_t nMaxChars, const TCHAR * szSubDir, const TCHAR * szExtension, LPBYTE pbEKey) +{ + TCHAR * szSaveBuffer = szBuffer; + TCHAR * szBufferEnd = szBuffer + nMaxChars - 1; + char szHashSubPath[0x80]; + char szHashText[MD5_STRING_SIZE+1]; + + // Prepare the subpath + StringFromBinary(pbEKey, MD5_HASH_SIZE, szHashText); + CascStrPrintf(szHashSubPath, _countof(szHashSubPath), "%02x/%02x/%s", pbEKey[0], pbEKey[1], szHashText); + + szBuffer = AppendPathFragment(szBuffer, szBufferEnd, szSubDir, '/', true); + szBuffer = AppendPathFragment(szBuffer, szBufferEnd, szHashSubPath, '/'); + szBuffer = AppendPathFragment(szBuffer, szBufferEnd, szExtension, '/', true); + return (szBuffer - szSaveBuffer); +} + size_t NormalizeFileName(const unsigned char * NormTable, char * szNormName, const char * szFileName, size_t cchMaxChars) { char * szNormNameEnd = szNormName + cchMaxChars; @@ -257,19 +489,26 @@ size_t NormalizeFileName_LowerSlash(char * szNormName, const char * szFileName, return NormalizeFileName(AsciiToLowerTable_Slash, szNormName, szFileName, cchMaxChars); } -ULONGLONG CalcFileNameHash(const char * szFileName) +ULONGLONG CalcNormNameHash(const char * szNormName, size_t nLength) { - char szNormName[MAX_PATH+1]; uint32_t dwHashHigh = 0; uint32_t dwHashLow = 0; + + // Calculate the HASH value of the normalized file name + hashlittle2(szNormName, nLength, &dwHashHigh, &dwHashLow); + return ((ULONGLONG)dwHashHigh << 0x20) | dwHashLow; +} + +ULONGLONG CalcFileNameHash(const char * szFileName) +{ + char szNormName[MAX_PATH+1]; size_t nLength; // Normalize the file name - convert to uppercase, slashes to backslashes nLength = NormalizeFileName_UpperBkSlash(szNormName, szFileName, MAX_PATH); - // Calculate the HASH value of the normalized file name - hashlittle2(szNormName, nLength, &dwHashHigh, &dwHashLow); - return ((ULONGLONG)dwHashHigh << 0x20) | dwHashLow; + // Calculate hash from the normalized name + return CalcNormNameHash(szNormName, nLength); } int ConvertDigitToInt32(const TCHAR * szString, PDWORD PtrValue) @@ -373,13 +612,16 @@ char * StringFromBinary(LPBYTE pbBinary, size_t cbBinary, char * szBuffer) { char * szSaveBuffer = szBuffer; - // Convert the string to the array of MD5 - // Copy the blob data as text - for(size_t i = 0; i < cbBinary; i++) + // Verify the binary pointer + if(pbBinary && cbBinary) { - *szBuffer++ = IntToHexChar[pbBinary[0] >> 0x04]; - *szBuffer++ = IntToHexChar[pbBinary[0] & 0x0F]; - pbBinary++; + // Convert the string to the array of MD5 + // Copy the blob data as text + for(size_t i = 0; i < cbBinary; i++) + { + *szBuffer++ = IntToHexChar[pbBinary[i] >> 0x04]; + *szBuffer++ = IntToHexChar[pbBinary[i] & 0x0F]; + } } // Terminate the string @@ -395,39 +637,51 @@ char * StringFromMD5(LPBYTE md5, char * szBuffer) //----------------------------------------------------------------------------- // File name utilities -const wchar_t * GetPlainFileName(const wchar_t * szFileName) +bool IsFileDataIdName(const char * szFileName, DWORD & FileDataId) { - const wchar_t * szPlainName = szFileName; + BYTE BinaryValue[4]; - while(*szFileName != 0) + // File name must begin with "File", case insensitive + if(AsciiToUpperTable_BkSlash[szFileName[0]] == 'F' && + AsciiToUpperTable_BkSlash[szFileName[1]] == 'I' && + AsciiToUpperTable_BkSlash[szFileName[2]] == 'L' && + AsciiToUpperTable_BkSlash[szFileName[3]] == 'E') { - if(*szFileName == '\\' || *szFileName == '/') - szPlainName = szFileName + 1; - szFileName++; + // Then, 8 hexadecimal digits must follow + if(ConvertStringToBinary(szFileName + 4, 8, BinaryValue) == ERROR_SUCCESS) + { + // Must be followed by an extension or end-of-string + if(szFileName[0x0C] == 0 || szFileName[0x0C] == '.') + { + FileDataId = ConvertBytesToInteger_4(BinaryValue); + return (FileDataId != CASC_INVALID_ID); + } + } } - return szPlainName; + return false; } -const char * GetPlainFileName(const char * szFileName) +bool IsFileCKeyEKeyName(const char * szFileName, LPBYTE PtrKeyBuffer) { - const char * szPlainName = szFileName; + size_t nLength = strlen(szFileName); - while(*szFileName != 0) + if(nLength == MD5_STRING_SIZE) { - if(*szFileName == '\\' || *szFileName == '/') - szPlainName = szFileName + 1; - szFileName++; + if(ConvertStringToBinary(szFileName, MD5_STRING_SIZE, PtrKeyBuffer) == ERROR_SUCCESS) + { + return true; + } } - return szPlainName; + return false; } -bool CheckWildCard(const char * szString, const char * szWildCard) +bool CascCheckWildCard(const char * szString, const char * szWildCard) { const char * szWildCardPtr; - for(;;) + while(szWildCard && szWildCard[0]) { // If there is '?' in the wildcard, we skip one char while(szWildCard[0] == '?') @@ -455,7 +709,7 @@ bool CheckWildCard(const char * szString, const char * szWildCard) if(AsciiToUpperTable_BkSlash[szWildCardPtr[0]] == AsciiToUpperTable_BkSlash[szString[0]]) { - if(CheckWildCard(szString, szWildCardPtr)) + if(CascCheckWildCard(szString, szWildCardPtr)) return true; } } @@ -476,244 +730,43 @@ bool CheckWildCard(const char * szString, const char * szWildCard) return (szString[0] == 0) ? true : false; } } + return true; } //----------------------------------------------------------------------------- // Hashing functions -bool IsValidMD5(LPBYTE pbMd5) +bool CascIsValidMD5(LPBYTE pbMd5) { - BYTE BitSummary = 0; + PDWORD Int32Array = (PDWORD)pbMd5; - // The MD5 is considered invalid of it is zeroed - BitSummary |= pbMd5[0x00] | pbMd5[0x01] | pbMd5[0x02] | pbMd5[0x03] | pbMd5[0x04] | pbMd5[0x05] | pbMd5[0x06] | pbMd5[0x07]; - BitSummary |= pbMd5[0x08] | pbMd5[0x09] | pbMd5[0x0A] | pbMd5[0x0B] | pbMd5[0x0C] | pbMd5[0x0D] | pbMd5[0x0E] | pbMd5[0x0F]; - return (BitSummary != 0); + // The MD5 is considered invalid if it is zeroed + return (Int32Array[0] | Int32Array[1] | Int32Array[2] | Int32Array[3]) ? true : false; } -bool VerifyDataBlockHash(void * pvDataBlock, DWORD cbDataBlock, LPBYTE expected_md5) +bool CascVerifyDataBlockHash(void * pvDataBlock, DWORD cbDataBlock, LPBYTE expected_md5) { - hash_state md5_state; + MD5_CTX md5_ctx; BYTE md5_digest[MD5_HASH_SIZE]; // Don't verify the block if the MD5 is not valid. - if(!IsValidMD5(expected_md5)) + if(!CascIsValidMD5(expected_md5)) return true; // Calculate the MD5 of the data block - md5_init(&md5_state); - md5_process(&md5_state, (unsigned char *)pvDataBlock, cbDataBlock); - md5_done(&md5_state, md5_digest); + MD5_Init(&md5_ctx); + MD5_Update(&md5_ctx, pvDataBlock, cbDataBlock); + MD5_Final(md5_digest, &md5_ctx); // Does the MD5's match? return (memcmp(md5_digest, expected_md5, MD5_HASH_SIZE) == 0); } -void CalculateDataBlockHash(void * pvDataBlock, DWORD cbDataBlock, LPBYTE md5_hash) -{ - hash_state md5_state; - - md5_init(&md5_state); - md5_process(&md5_state, (unsigned char *)pvDataBlock, cbDataBlock); - md5_done(&md5_state, md5_hash); -} - -//----------------------------------------------------------------------------- -// We have our own qsort implementation, optimized for using array of pointers - -#define STKSIZ (8*sizeof(void*) - 2) - -#define SWAP_ENTRIES(index1, index2) \ -{ \ - temp = base[index1]; \ - base[index1] = base[index2]; \ - base[index2] = temp; \ -} - -void qsort_pointer_array(void ** base, size_t num, int (*compare)(const void *, const void *, const void *), const void * context) +void CascCalculateDataBlockHash(void * pvDataBlock, DWORD cbDataBlock, LPBYTE md5_hash) { - size_t lo, hi; /* ends of sub-array currently sorting */ - size_t mid; /* points to middle of subarray */ - size_t loguy, higuy; /* traveling pointers for partition step */ - size_t size; /* size of the sub-array */ - size_t lostk[STKSIZ], histk[STKSIZ]; - void * temp; - int stkptr; /* stack for saving sub-array to be processed */ - - /* validation section */ - assert(base != NULL); - assert(compare != NULL); - - if (num < 2) - return; /* nothing to do */ - - stkptr = 0; /* initialize stack */ - - lo = 0; - hi = (num-1); /* initialize limits */ - - /* this entry point is for pseudo-recursion calling: setting - lo and hi and jumping to here is like recursion, but stkptr is - preserved, locals aren't, so we preserve stuff on the stack */ -recurse: - - size = (hi - lo) + 1; /* number of el's to sort */ - - /* First we pick a partitioning element. The efficiency of the - algorithm demands that we find one that is approximately the median - of the values, but also that we select one fast. We choose the - median of the first, middle, and last elements, to avoid bad - performance in the face of already sorted data, or data that is made - up of multiple sorted runs appended together. Testing shows that a - median-of-three algorithm provides better performance than simply - picking the middle element for the latter case. */ - - mid = lo + (size / 2); /* find middle element */ - - /* Sort the first, middle, last elements into order */ - if (compare(context, base[lo], base[mid]) > 0) { - SWAP_ENTRIES(lo, mid); - } - if (compare(context, base[lo], base[hi]) > 0) { - SWAP_ENTRIES(lo, hi); - } - if (compare(context, base[mid], base[hi]) > 0) { - SWAP_ENTRIES(mid, hi); - } - - /* We now wish to partition the array into three pieces, one consisting - of elements <= partition element, one of elements equal to the - partition element, and one of elements > than it. This is done - below; comments indicate conditions established at every step. */ - - loguy = lo; - higuy = hi; - - /* Note that higuy decreases and loguy increases on every iteration, - so loop must terminate. */ - for (;;) { - /* lo <= loguy < hi, lo < higuy <= hi, - A[i] <= A[mid] for lo <= i <= loguy, - A[i] > A[mid] for higuy <= i < hi, - A[hi] >= A[mid] */ - - /* The doubled loop is to avoid calling comp(mid,mid), since some - existing comparison funcs don't work when passed the same - value for both pointers. */ - - if (mid > loguy) { - do { - loguy ++; - } while (loguy < mid && compare(context, base[loguy], base[mid]) <= 0); - } - if (mid <= loguy) { - do { - loguy ++; - } while (loguy <= hi && compare(context, base[loguy], base[mid]) <= 0); - } - - /* lo < loguy <= hi+1, A[i] <= A[mid] for lo <= i < loguy, - either loguy > hi or A[loguy] > A[mid] */ - - do { - higuy --; - } while (higuy > mid && compare(context, base[higuy], base[mid]) > 0); - - /* lo <= higuy < hi, A[i] > A[mid] for higuy < i < hi, - either higuy == lo or A[higuy] <= A[mid] */ - - if (higuy < loguy) - break; - - /* if loguy > hi or higuy == lo, then we would have exited, so - A[loguy] > A[mid], A[higuy] <= A[mid], - loguy <= hi, higuy > lo */ - - SWAP_ENTRIES(loguy, higuy); - - /* If the partition element was moved, follow it. Only need - to check for mid == higuy, since before the swap, - A[loguy] > A[mid] implies loguy != mid. */ - - if (mid == higuy) - mid = loguy; - - /* A[loguy] <= A[mid], A[higuy] > A[mid]; so condition at top - of loop is re-established */ - } + MD5_CTX md5_ctx; - /* A[i] <= A[mid] for lo <= i < loguy, - A[i] > A[mid] for higuy < i < hi, - A[hi] >= A[mid] - higuy < loguy - implying: - higuy == loguy-1 - or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid] */ - - /* Find adjacent elements equal to the partition element. The - doubled loop is to avoid calling comp(mid,mid), since some - existing comparison funcs don't work when passed the same value - for both pointers. */ - - higuy ++; - if (mid < higuy) { - do { - higuy --; - } while (higuy > mid && compare(context, base[higuy], base[mid]) == 0); - } - if (mid >= higuy) { - do { - higuy --; - } while (higuy > lo && compare(context, base[higuy], base[mid]) == 0); - } - - /* OK, now we have the following: - higuy < loguy - lo <= higuy <= hi - A[i] <= A[mid] for lo <= i <= higuy - A[i] == A[mid] for higuy < i < loguy - A[i] > A[mid] for loguy <= i < hi - A[hi] >= A[mid] */ - - /* We've finished the partition, now we want to sort the subarrays - [lo, higuy] and [loguy, hi]. - We do the smaller one first to minimize stack usage. - We only sort arrays of length 2 or more.*/ - - if ( higuy - lo >= hi - loguy ) { - if (lo < higuy) { - lostk[stkptr] = lo; - histk[stkptr] = higuy; - ++stkptr; - } /* save big recursion for later */ - - if (loguy < hi) { - lo = loguy; - goto recurse; /* do small recursion */ - } - } - else { - if (loguy < hi) { - lostk[stkptr] = loguy; - histk[stkptr] = hi; - ++stkptr; /* save big recursion for later */ - } - - if (lo < higuy) { - hi = higuy; - goto recurse; /* do small recursion */ - } - } - - /* We have sorted the array, except for any pending sorts on the stack. - Check if there are any, and do them. */ - - --stkptr; - if (stkptr >= 0) { - lo = lostk[stkptr]; - hi = histk[stkptr]; - goto recurse; /* pop subarray from stack */ - } - else - return; /* all subarrays done */ + MD5_Init(&md5_ctx); + MD5_Update(&md5_ctx, pvDataBlock, cbDataBlock); + MD5_Final(md5_hash, &md5_ctx); } diff --git a/dep/CascLib/src/common/Common.h b/dep/CascLib/src/common/Common.h index 484276a3bd7..c7f189b91ac 100644 --- a/dep/CascLib/src/common/Common.h +++ b/dep/CascLib/src/common/Common.h @@ -21,6 +21,76 @@ #define ALIGN_TO_SIZE(x, a) (((x) + (a)-1) & ~((a)-1)) #endif +// Prevent problems with CRT "min" and "max" functions, +// as they are not defined on all platforms +#define CASCLIB_MIN(a, b) ((a < b) ? a : b) +#define CASCLIB_MAX(a, b) ((a > b) ? a : b) +#define CASCLIB_UNUSED(p) ((void)(p)) + +//----------------------------------------------------------------------------- +// Common structures + +// Structure for static content key (CKey) and encoded key (EKey) +// The CKey is a MD5 hash of the file data. +// The EKey is (shortened) MD5 hash of the file header, which contains MD5 hashes of all the logical blocks of the file. +typedef struct _CONTENT_KEY +{ + BYTE Value[MD5_HASH_SIZE]; // MD5 of the file + +} CONTENT_KEY, *PCONTENT_KEY, ENCODED_KEY, *PENCODED_KEY; + +// Helper structure for merging file paths +typedef struct _PATH_BUFFER +{ + char * szBegin; + char * szPtr; + char * szEnd; +} PATH_BUFFER, *PPATH_BUFFER; + +//----------------------------------------------------------------------------- +// Basic structure used by all CascLib objects to describe a single entry +// in the CASC storage. Each entry represents one physical file +// in the storage. Note that the file may be present under several file names. + +// Flags for CASC_CKEY_ENTRY::Flags +#define CASC_CE_FILE_IS_LOCAL 0x00000001 // The file is available locally. Keep this flag to have value of 1 +#define CASC_CE_HAS_CKEY 0x00000002 // The CKey is present in the entry +#define CASC_CE_HAS_EKEY 0x00000004 // The EKey is present, at least partial one +#define CASC_CE_HAS_EKEY_PARTIAL 0x00000008 // The EKey is only partial, padded by zeros. Always used with CASC_CE_HAS_EKEY +#define CASC_CE_IN_ENCODING 0x00000010 // Present in the ENCODING manifest +#define CASC_CE_IN_DOWNLOAD 0x00000020 // Present in the DOWNLOAD manifest +#define CASC_CE_FOLDER_ENTRY 0x00000040 // This CKey entry is a folder + +// In-memory representation of a single entry. +struct CASC_CKEY_ENTRY +{ + CASC_CKEY_ENTRY() + { + Init(); + } + + void Init(void) + { + memset(this, 0, sizeof(CASC_CKEY_ENTRY)); + StorageOffset = CASC_INVALID_OFFS64; + EncodedSize = CASC_INVALID_SIZE; + ContentSize = CASC_INVALID_SIZE; + } + + BYTE CKey[MD5_HASH_SIZE]; // Content key of the full length + BYTE EKey[MD5_HASH_SIZE]; // Encoded key of the full length + ULONGLONG StorageOffset; // Linear offset over the entire storage. 0 if not present + ULONGLONG TagBitMask; // Bitmap for the tags. 0 ig tags are not supported + DWORD EncodedSize; // Encoded size of the file. 0 if not supported + DWORD ContentSize; // Content size of the file. 0 if not supported + DWORD Flags; // See CASC_CE_XXX + USHORT RefCount; // This is the number of file names referencing this entry + BYTE Priority; // Download priority + BYTE Alignment; + +}; +typedef CASC_CKEY_ENTRY *PCASC_CKEY_ENTRY; + //----------------------------------------------------------------------------- // Conversion tables @@ -29,23 +99,198 @@ extern unsigned char AsciiToUpperTable_BkSlash[256]; extern unsigned char IntToHexChar[]; //----------------------------------------------------------------------------- -// String manipulation +// Memory management +// +// We use our own macros for allocating/freeing memory. If you want +// to redefine them, please keep the following rules: +// +// - The memory allocation must return NULL if not enough memory +// (i.e not to throw exception) +// - The allocating function does not need to fill the allocated buffer with zeros +// - The reallocating function must support NULL as the previous block +// - Memory freeing function must check for NULL pointer and do nothing if so +// + +#define CASC_REALLOC(type, ptr, count) (type *)realloc(ptr, (count) * sizeof(type)) +#define CASC_ALLOC(type, count) (type *)malloc((count) * sizeof(type)) + +template <typename T> +void CASC_FREE(T *& ptr) +{ + if (ptr != NULL) + free(ptr); + ptr = NULL; +} + +//----------------------------------------------------------------------------- +// Overloaded "new" and "delete" operators + +void * operator new(size_t size); +void * operator new[](size_t size); +void operator delete(void * ptr); +void operator delete[](void * ptr); +void operator delete(void * ptr, size_t); // For some reason, VS2015 needs this + +//----------------------------------------------------------------------------- +// Big endian number manipulation + +inline DWORD ConvertBytesToInteger_2(LPBYTE ValueAsBytes) +{ + USHORT Value = 0; + + Value = (Value << 0x08) | ValueAsBytes[0]; + Value = (Value << 0x08) | ValueAsBytes[1]; + + return Value; +} + +inline DWORD ConvertBytesToInteger_3(LPBYTE ValueAsBytes) +{ + DWORD Value = 0; + + Value = (Value << 0x08) | ValueAsBytes[0]; + Value = (Value << 0x08) | ValueAsBytes[1]; + Value = (Value << 0x08) | ValueAsBytes[2]; + + return Value; +} + +inline DWORD ConvertBytesToInteger_4(LPBYTE ValueAsBytes) +{ + DWORD Value = 0; + + Value = (Value << 0x08) | ValueAsBytes[0]; + Value = (Value << 0x08) | ValueAsBytes[1]; + Value = (Value << 0x08) | ValueAsBytes[2]; + Value = (Value << 0x08) | ValueAsBytes[3]; + + return Value; +} + +// Converts the variable-size big-endian into integer +inline DWORD ConvertBytesToInteger_X(LPBYTE ValueAsBytes, DWORD dwByteSize) +{ + DWORD Value = 0; + + if(dwByteSize > 0) + Value = (Value << 0x08) | ValueAsBytes[0]; + if(dwByteSize > 1) + Value = (Value << 0x08) | ValueAsBytes[1]; + if(dwByteSize > 2) + Value = (Value << 0x08) | ValueAsBytes[2]; + if(dwByteSize > 3) + Value = (Value << 0x08) | ValueAsBytes[3]; + + return Value; +} + +inline DWORD ConvertBytesToInteger_4_LE(LPBYTE ValueAsBytes) +{ + DWORD Value = 0; + + Value = (Value << 0x08) | ValueAsBytes[3]; + Value = (Value << 0x08) | ValueAsBytes[2]; + Value = (Value << 0x08) | ValueAsBytes[1]; + Value = (Value << 0x08) | ValueAsBytes[0]; + + return Value; +} + +// Read the 40-bit big-endian offset into ULONGLONG +inline ULONGLONG ConvertBytesToInteger_5(LPBYTE ValueAsBytes) +{ + ULONGLONG Value = 0; + + Value = (Value << 0x08) | ValueAsBytes[0]; + Value = (Value << 0x08) | ValueAsBytes[1]; + Value = (Value << 0x08) | ValueAsBytes[2]; + Value = (Value << 0x08) | ValueAsBytes[3]; + Value = (Value << 0x08) | ValueAsBytes[4]; + + return Value; +} + +inline void ConvertIntegerToBytes_4(DWORD Value, LPBYTE ValueAsBytes) +{ + ValueAsBytes[0] = (Value >> 0x18) & 0xFF; + ValueAsBytes[1] = (Value >> 0x10) & 0xFF; + ValueAsBytes[2] = (Value >> 0x08) & 0xFF; + ValueAsBytes[3] = (Value >> 0x00) & 0xFF; +} + +inline void ConvertIntegerToBytes_4_LE(DWORD Value, LPBYTE ValueAsBytes) +{ + ValueAsBytes[0] = (Value >> 0x00) & 0xFF; + ValueAsBytes[1] = (Value >> 0x08) & 0xFF; + ValueAsBytes[2] = (Value >> 0x10) & 0xFF; + ValueAsBytes[3] = (Value >> 0x18) & 0xFF; +} + +// Faster than memset(Buffer, 0, 0x10) +inline void ZeroMemory16(void * Buffer) +{ + PDWORD PtrBuffer = (PDWORD)Buffer; + + PtrBuffer[0] = 0; + PtrBuffer[1] = 0; + PtrBuffer[2] = 0; + PtrBuffer[3] = 0; +} + +// Faster than memcpy(Target, Source, 0x10) +inline void CopyMemory16(void * Target, void * Source) +{ + PDWORD PtrTarget = (PDWORD)Target; + PDWORD PtrSource = (PDWORD)Source; + + PtrTarget[0] = PtrSource[0]; + PtrTarget[1] = PtrSource[1]; + PtrTarget[2] = PtrSource[2]; + PtrTarget[3] = PtrSource[3]; +} + +//----------------------------------------------------------------------------- +// Linear data stream manipulation -void CopyString(char * szTarget, const char * szSource, size_t cchLength); -void CopyString(wchar_t * szTarget, const char * szSource, size_t cchLength); -void CopyString(char * szTarget, const wchar_t * szSource, size_t cchLength); +LPBYTE CaptureInteger32(LPBYTE pbDataPtr, LPBYTE pbDataEnd, PDWORD PtrValue); +LPBYTE CaptureInteger32_BE(LPBYTE pbDataPtr, LPBYTE pbDataEnd, PDWORD PtrValue); +LPBYTE CaptureByteArray(LPBYTE pbDataPtr, LPBYTE pbDataEnd, size_t nLength, LPBYTE pbOutput); +LPBYTE CaptureContentKey(LPBYTE pbDataPtr, LPBYTE pbDataEnd, PCONTENT_KEY * PtrCKey); +LPBYTE CaptureArray_(LPBYTE pbDataPtr, LPBYTE pbDataEnd, LPBYTE * PtrArray, size_t ItemSize, size_t ItemCount); -char * CascNewStr(const char * szString, size_t nCharsToReserve); -wchar_t * CascNewStr(const wchar_t * szString, size_t nCharsToReserve); +#define CaptureArray(pbDataPtr, pbDataEnd, PtrArray, type, count) CaptureArray_(pbDataPtr, pbDataEnd, PtrArray, sizeof(type), count) -TCHAR * CascNewStrFromAnsi(const char * szBegin, const char * szEnd); +//----------------------------------------------------------------------------- +// String copying and conversion + +void CascStrCopy(char * szTarget, size_t cchTarget, const char * szSource, size_t cchSource = -1); +void CascStrCopy(char * szTarget, size_t cchTarget, const wchar_t * szSource, size_t cchSource = -1); +void CascStrCopy(wchar_t * szTarget, size_t cchTarget, const char * szSource, size_t cchSource = -1); +void CascStrCopy(wchar_t * szTarget, size_t cchTarget, const wchar_t * szSource, size_t cchSource = -1); + +//----------------------------------------------------------------------------- +// Safe version of s(w)printf + +size_t CascStrPrintf(char * buffer, size_t nCount, const char * format, ...); +size_t CascStrPrintf(wchar_t * buffer, size_t nCount, const wchar_t * format, ...); + +//----------------------------------------------------------------------------- +// String allocation + +char * CascNewStr(const char * szString, size_t nCharsToReserve = 0); +wchar_t * CascNewStr(const wchar_t * szString, size_t nCharsToReserve = 0); TCHAR * CombinePath(const TCHAR * szPath, const TCHAR * szSubDir); -TCHAR * CombinePathAndString(const TCHAR * szPath, const char * szString, size_t nLength); +size_t CombineFilePath(TCHAR * szBuffer, size_t nMaxChars, const TCHAR * szPath, const TCHAR * szSubPath1, const TCHAR * szSubPath2 = NULL); +size_t CombineUrlPath(TCHAR * szBuffer, size_t nMaxChars, const TCHAR * szHost, const TCHAR * szSubPath1, const TCHAR * szSubPath2 = NULL); +TCHAR * GetLastPathPart(TCHAR * szWorkPath); +bool CutLastPathPart(TCHAR * szWorkPath); +size_t CreateCascSubdirectoryName(TCHAR * szBuffer, size_t nMaxChars, const TCHAR * szSubDir, const TCHAR * szExtension, LPBYTE pbEKey); size_t NormalizeFileName_UpperBkSlash(char * szNormName, const char * szFileName, size_t cchMaxChars); size_t NormalizeFileName_LowerSlash(char * szNormName, const char * szFileName, size_t cchMaxChars); +ULONGLONG CalcNormNameHash(const char * szNormName, size_t nLength); ULONGLONG CalcFileNameHash(const char * szFileName); int ConvertDigitToInt32(const TCHAR * szString, PDWORD PtrValue); @@ -56,20 +301,81 @@ char * StringFromBinary(LPBYTE pbBinary, size_t cbBinary, char * szBuffer); char * StringFromMD5(LPBYTE md5, char * szBuffer); //----------------------------------------------------------------------------- +// Structure query key + +struct QUERY_KEY +{ + QUERY_KEY() + { + pbData = NULL; + cbData = 0; + } + + ~QUERY_KEY() + { + CASC_FREE(pbData); + cbData = 0; + } + + LPBYTE pbData; + size_t cbData; +}; +typedef QUERY_KEY *PQUERY_KEY; + +//----------------------------------------------------------------------------- // File name utilities -bool CheckWildCard(const char * szString, const char * szWildCard); -const wchar_t * GetPlainFileName(const wchar_t * szFileName); -const char * GetPlainFileName(const char * szFileName); +// Retrieves the pointer to plain name +template <typename XCHAR> +const XCHAR * GetPlainFileName(const XCHAR * szFileName) +{ + const XCHAR * szPlainName = szFileName; + + while(*szFileName != 0) + { + if(*szFileName == '\\' || *szFileName == '/') + szPlainName = szFileName + 1; + szFileName++; + } + + return szPlainName; +} + +// Retrieves the pointer to file extension +template <typename XCHAR> +const XCHAR * GetFileExtension(const XCHAR * szFileName) +{ + const XCHAR * szExtension = NULL; + + // We need to start searching from the plain name + // Avoid: C:\$RECYCLE.BIN\File.ext + szFileName = GetPlainFileName(szFileName); + + // Find the last dot in the plain file name + while(szFileName[0] != 0) + { + if(szFileName[0] == '.') + szExtension = szFileName; + szFileName++; + } + + // If not found, return the end of the file name + return (XCHAR *)((szExtension != NULL) ? szExtension : szFileName); +} + +bool IsFileDataIdName(const char * szFileName, DWORD & FileDataId); +bool IsFileCKeyEKeyName(const char * szFileName, LPBYTE PtrKeyBuffer); + +bool CascCheckWildCard(const char * szString, const char * szWildCard); //----------------------------------------------------------------------------- // Hashing functions ULONGLONG HashStringJenkins(const char * szFileName); -bool IsValidMD5(LPBYTE pbMd5); -void CalculateDataBlockHash(void * pvDataBlock, DWORD cbDataBlock, LPBYTE md5_hash); -bool VerifyDataBlockHash(void * pvDataBlock, DWORD cbDataBlock, LPBYTE expected_md5); +bool CascIsValidMD5(LPBYTE pbMd5); +void CascCalculateDataBlockHash(void * pvDataBlock, DWORD cbDataBlock, LPBYTE md5_hash); +bool CascVerifyDataBlockHash(void * pvDataBlock, DWORD cbDataBlock, LPBYTE expected_md5); //----------------------------------------------------------------------------- // Scanning a directory diff --git a/dep/CascLib/src/common/Csv.cpp b/dep/CascLib/src/common/Csv.cpp new file mode 100644 index 00000000000..24b654daa86 --- /dev/null +++ b/dep/CascLib/src/common/Csv.cpp @@ -0,0 +1,370 @@ +/*****************************************************************************/ +/* Csv.cpp Copyright (c) Ladislav Zezula 2019 */ +/*---------------------------------------------------------------------------*/ +/* Implementation for the CSV handler class */ +/*---------------------------------------------------------------------------*/ +/* Date Ver Who Comment */ +/* -------- ---- --- ------- */ +/* 24.05.19 1.00 Lad Created */ +/*****************************************************************************/ + +#define __CASCLIB_SELF__ +#include "../CascLib.h" +#include "../CascCommon.h" + +//----------------------------------------------------------------------------- +// Local variables + +static const CASC_CSV_LINE NullLine; +#define NullColumn NullLine.Columns[0]; + +//----------------------------------------------------------------------------- +// Local functions + +static char * NextLine(char * szLine) +{ + // Find the end of the line + while(szLine[0] != 0 && szLine[0] != 0x0A && szLine[0] != 0x0D) + szLine++; + + // Terminate the line + while(szLine[0] == 0x0A || szLine[0] == 0x0D) + *szLine++ = 0; + + // If there's an end-of-string, it's over + return (szLine[0] != 0) ? szLine : NULL; +} + +static char * NextColumn(char * szColumn) +{ + // Find the end of the column + while(szColumn[0] != 0 && szColumn[0] != '|') + szColumn++; + + // Terminate the column + if (szColumn[0] == '|') + { + *szColumn++ = 0; + return szColumn; + } + + // If there's an end-of-string, it's over + return NULL; +} + +static size_t CalcHashValue(const char * szString) +{ + size_t dwHash = 0x7EEE7EEE; + + // Hash the string itself + while(szString[0] != 0) + { + dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ szString[0]; + szString++; + } + + // Return the hash limited by the table size + return dwHash; +} + +static BYTE HashToIndex(size_t dwHashValue) +{ + return (BYTE)(dwHashValue & (CSV_HASH_TABLE_SIZE - 1)); +} + +//----------------------------------------------------------------------------- +// Class for CSV line + +CASC_CSV_LINE::CASC_CSV_LINE() +{ + m_pParent = NULL; + m_nColumns = 0; +} + +CASC_CSV_LINE::~CASC_CSV_LINE() +{} + +bool CASC_CSV_LINE::SetLine(CASC_CSV * pParent, char * szCsvLine) +{ + char * szCsvColumn; + size_t nHdrColumns = 0; + size_t nColumns = 0; + + // Reset the number of column to zero + m_pParent = pParent; + m_nColumns = 0; + + // Parse each column + while(szCsvLine != NULL && nColumns < CSV_MAX_COLUMNS) + { + // Get current line and the next one + szCsvColumn = szCsvLine; + szCsvLine = NextColumn(szCsvLine); + + // Save the current line + Columns[nColumns].szValue = szCsvColumn; + Columns[nColumns].nLength = strlen(szCsvColumn); + nColumns++; + } + + // Columns overflow + if(nColumns >= CSV_MAX_COLUMNS) + { + assert(false); + return false; + } + + // If the parent has header lines, then the number of columns must match + // In the case of mismatched column count, ignore the line + nHdrColumns = pParent->GetHeaderColumns(); + if(nHdrColumns != 0 && nColumns != nHdrColumns) + return false; + + // All OK + m_nColumns = nColumns; + return true; +} + +const CASC_CSV_COLUMN & CASC_CSV_LINE::operator[](const char * szColumnName) const +{ + size_t nIndex; + + // The column must have a hash table + if(m_pParent != NULL) + { + nIndex = m_pParent->GetColumnIndex(szColumnName); + if(nIndex != CSV_INVALID_INDEX && nIndex < m_nColumns) + { + return Columns[nIndex]; + } + } + + return NullColumn; +} + +const CASC_CSV_COLUMN & CASC_CSV_LINE::operator[](size_t nIndex) const +{ + return (nIndex < m_nColumns) ? Columns[nIndex] : NullColumn; +} + +//----------------------------------------------------------------------------- +// Class for CSV object + +CASC_CSV::CASC_CSV(size_t nLinesMax, bool bHasHeader) +{ + // Initialize the class variables + memset(HashTable, 0xFF, sizeof(HashTable)); + m_szCsvFile = NULL; + m_szCsvPtr = NULL; + m_nCsvFile = 0; + m_nLines = 0; + m_bHasHeader = bHasHeader; + + // Nonzero number of lines means a finite CSV handler. The CSV will be loaded at once. + // Zero means that the user needs to call LoadNextLine() and then the line data + if(nLinesMax != 0) + { + m_pLines = new CASC_CSV_LINE[nLinesMax]; + m_nLinesMax = nLinesMax; + m_bHasAllLines = true; + } + else + { + m_pLines = new CASC_CSV_LINE[1]; + m_nLinesMax = 1; + m_bHasAllLines = false; + } +} + +CASC_CSV::~CASC_CSV() +{ + if(m_pLines != NULL) + delete[] m_pLines; + if(m_szCsvFile != NULL) + delete [] m_szCsvFile; + m_szCsvFile = NULL; +} + +int CASC_CSV::Load(const TCHAR * szFileName) +{ + DWORD cbFileData = 0; + int nError = ERROR_SUCCESS; + + m_szCsvFile = (char *)LoadFileToMemory(szFileName, &cbFileData); + if (m_szCsvFile != NULL) + { + // There is one extra byte reserved by LoadFileToMemory, so we can put zero there + m_szCsvFile[cbFileData] = 0; + m_szCsvPtr = m_szCsvFile; + m_nCsvFile = cbFileData; + + // Parse the data + nError = ParseCsvData() ? ERROR_SUCCESS : ERROR_BAD_FORMAT; + } + else + { + nError = GetLastError(); + } + + return nError; +} + +int CASC_CSV::Load(LPBYTE pbData, size_t cbData) +{ + int nError = ERROR_NOT_ENOUGH_MEMORY; + + m_szCsvFile = new char[cbData + 1]; + if (m_szCsvFile != NULL) + { + // Copy the entire data and terminate them with zero + memcpy(m_szCsvFile, pbData, cbData); + m_szCsvFile[cbData] = 0; + m_szCsvPtr = m_szCsvFile; + m_nCsvFile = cbData; + + // Parse the data + nError = ParseCsvData() ? ERROR_SUCCESS : ERROR_BAD_FORMAT; + } + + return nError; +} + +bool CASC_CSV::LoadNextLine() +{ + bool bResult = false; + + // Only endless CSV handler can do this + if(m_bHasAllLines == false) + { + // A few checks + assert(m_pLines != NULL); + assert(m_nLinesMax == 1); + + // Reset the current line and load it + bResult = LoadNextLine(m_pLines[0]); + m_nLines = (bResult) ? 1 : 0; + } + + return bResult; +} + +bool CASC_CSV::InitializeHashTable() +{ + // Create the hash table of HeaderText -> ColumnIndex + for(size_t i = 0; i < Header.GetColumnCount(); i++) + { + // Calculate the start slot and the current slot + size_t nStartIndex = HashToIndex(CalcHashValue(Header[i].szValue)); + size_t nHashIndex = nStartIndex; + + // Go as long as there is not a free space + while(HashTable[nHashIndex] != 0xFF) + { + nHashIndex = HashToIndex(nHashIndex + 1); + } + + // Set the slot + HashTable[nHashIndex] = (BYTE)i; + } + + return true; +} + +bool CASC_CSV::LoadNextLine(CASC_CSV_LINE & Line) +{ + // Overwatch ROOT's header begins with "#" + if(m_szCsvPtr == m_szCsvFile && m_szCsvPtr[0] == '#') + m_szCsvPtr++; + + // Parse the entire line + while(m_szCsvPtr != NULL && m_szCsvPtr[0] != 0) + { + char * szCsvLine = m_szCsvPtr; + + // Get the next line + m_szCsvPtr = NextLine(m_szCsvPtr); + + // Initialize the line + if (Line.SetLine(this, szCsvLine)) + return true; + } + + // End-of-file found + return false; +} + +bool CASC_CSV::ParseCsvData() +{ + // Sanity checks + assert(m_nLines == 0); + + // If we have header, then parse it and set the pointer to the next line + if(m_bHasHeader) + { + // Load the current line to the header + if (!LoadNextLine(Header)) + return false; + + // Initialize the hash table + if(!InitializeHashTable()) + return false; + } + + // Are we supposed to load all lines? + if(m_bHasAllLines) + { + // Parse each line + for(size_t i = 0; i < m_nLinesMax; i++) + { + if(!LoadNextLine(m_pLines[i])) + break; + m_nLines++; + } + } + + return true; +} + +const CASC_CSV_COLUMN & CASC_CSV::operator[](const char * szColumnName) const +{ + if (m_pLines == NULL || m_nLines == 0) + return NullColumn; + return m_pLines[0][GetColumnIndex(szColumnName)]; +} + +const CASC_CSV_LINE & CASC_CSV::operator[](size_t nIndex) const +{ + if (m_pLines == NULL || nIndex >= m_nLines) + return NullLine; + return m_pLines[nIndex]; +} + +size_t CASC_CSV::GetHeaderColumns() const +{ + return (m_bHasHeader) ? Header.GetColumnCount() : 0; +} + +size_t CASC_CSV::GetColumnIndex(const char * szColumnName) const +{ + if(m_bHasHeader) + { + // Calculate the start slot and the current slot + size_t nStartIndex = HashToIndex(CalcHashValue(szColumnName)); + size_t nHashIndex = nStartIndex; + size_t nIndex; + + // Go as long as there is not a free space + while((nIndex = HashTable[nHashIndex]) != 0xFF) + { + // Compare the string + if(!strcmp(Header[nIndex].szValue, szColumnName)) + return nIndex; + + // Move to the next column + nHashIndex = HashToIndex(nHashIndex + 1); + } + } + + return CSV_INVALID_INDEX; +} + diff --git a/dep/CascLib/src/common/Csv.h b/dep/CascLib/src/common/Csv.h new file mode 100644 index 00000000000..2138255e74e --- /dev/null +++ b/dep/CascLib/src/common/Csv.h @@ -0,0 +1,105 @@ +/*****************************************************************************/ +/* Csv.h Copyright (c) Ladislav Zezula 2019 */ +/*---------------------------------------------------------------------------*/ +/* Interface for the CSV handler class */ +/*---------------------------------------------------------------------------*/ +/* Date Ver Who Comment */ +/* -------- ---- --- ------- */ +/* 24.05.19 1.00 Lad Created */ +/*****************************************************************************/ + +#ifndef __CSV_H__ +#define __CSV_H__ + +//----------------------------------------------------------------------------- +// Defines + +#define CSV_INVALID_INDEX ((size_t)(-1)) +#define CSV_ZERO ((size_t)(0)) // Use Csv[0][CSV_ZERO] instead of ambiguous Csv[0][0] +#define CSV_MAX_COLUMNS 0x10 +#define CSV_HASH_TABLE_SIZE 0x80 + +//----------------------------------------------------------------------------- +// Class for CSV line + +class CASC_CSV; + +struct CASC_CSV_COLUMN +{ + CASC_CSV_COLUMN() + { + szValue = NULL; + nLength = 0; + } + + const char * szValue; + size_t nLength; +}; + +class CASC_CSV_LINE +{ + public: + + CASC_CSV_LINE(); + ~CASC_CSV_LINE(); + + bool SetLine(CASC_CSV * pParent, char * szLine); + + const CASC_CSV_COLUMN & operator[](const char * szColumnName) const; + const CASC_CSV_COLUMN & operator[](size_t nIndex) const; + + size_t GetColumnCount() const + { + return m_nColumns; + } + + protected: + + friend class CASC_CSV; + + CASC_CSV * m_pParent; + CASC_CSV_COLUMN Columns[CSV_MAX_COLUMNS]; + size_t m_nColumns; +}; + +class CASC_CSV +{ + public: + + CASC_CSV(size_t nLinesMax, bool bHasHeader); + ~CASC_CSV(); + + int Load(LPBYTE pbData, size_t cbData); + int Load(const TCHAR * szFileName); + bool LoadNextLine(); + + const CASC_CSV_COLUMN & operator[](const char * szColumnName) const; + const CASC_CSV_LINE & operator[](size_t nIndex) const; + + size_t GetHeaderColumns() const; + size_t GetColumnIndex(const char * szColumnName) const; + + size_t GetLineCount() const + { + return m_nLines; + } + + protected: + + bool InitializeHashTable(); + bool LoadNextLine(CASC_CSV_LINE & Line); + bool ParseCsvData(); + + CASC_CSV_LINE * m_pLines; + CASC_CSV_LINE Header; + BYTE HashTable[CSV_HASH_TABLE_SIZE]; + char * m_szCsvFile; + char * m_szCsvPtr; + size_t m_nCsvFile; + size_t m_nLinesMax; + size_t m_nLines; + bool m_bHasHeader; + bool m_bHasAllLines; +}; + +#endif // __CSV_H__ diff --git a/dep/CascLib/src/common/Directory.cpp b/dep/CascLib/src/common/Directory.cpp index c4091095859..463881f3f9c 100644 --- a/dep/CascLib/src/common/Directory.cpp +++ b/dep/CascLib/src/common/Directory.cpp @@ -38,6 +38,20 @@ bool DirectoryExists(const TCHAR * szDirectory) return false; } +bool MakeDirectory(const TCHAR * szDirectory) +{ +#ifdef PLATFORM_WINDOWS + + BOOL bResult = CreateDirectory(szDirectory, NULL); + return (bResult) ? true : false; + +#else + + return (mkdir(szDirectory, 0755) == 0); + +#endif +} + int ScanIndexDirectory( const TCHAR * szIndexPath, INDEX_FILE_FOUND pfnOnFileFound, diff --git a/dep/CascLib/src/common/Directory.h b/dep/CascLib/src/common/Directory.h index ae97dca3d76..739f0612e54 100644 --- a/dep/CascLib/src/common/Directory.h +++ b/dep/CascLib/src/common/Directory.h @@ -18,6 +18,8 @@ typedef bool (*INDEX_FILE_FOUND)(const TCHAR * szFileName, PDWORD IndexArray, PD bool DirectoryExists(const TCHAR * szDirectory); +bool MakeDirectory(const TCHAR * szDirectory); + int ScanIndexDirectory( const TCHAR * szIndexPath, INDEX_FILE_FOUND pfnOnFileFound, diff --git a/dep/CascLib/src/common/DumpContext.cpp b/dep/CascLib/src/common/DumpContext.cpp deleted file mode 100644 index 8783ff201ba..00000000000 --- a/dep/CascLib/src/common/DumpContext.cpp +++ /dev/null @@ -1,153 +0,0 @@ -/*****************************************************************************/ -/* DumpContext.cpp Copyright (c) Ladislav Zezula 2015 */ -/*---------------------------------------------------------------------------*/ -/* Implementation of dump context */ -/*---------------------------------------------------------------------------*/ -/* Date Ver Who Comment */ -/* -------- ---- --- ------- */ -/* 16.03.15 1.00 Lad Created */ -/*****************************************************************************/ - -#define __CASCLIB_SELF__ -#include "../CascLib.h" -#include "../CascCommon.h" - -//----------------------------------------------------------------------------- -// Local functions - -static TCHAR * FormatFileName(TCascStorage * hs, const TCHAR * szNameFormat) -{ - TCHAR * szFileName; - TCHAR * szSrc; - TCHAR * szTrg; - - // Create copy of the file name - szFileName = szSrc = szTrg = CascNewStr(szNameFormat, 0); - if(szFileName != NULL) - { - // Format the file name - while(szSrc[0] != 0) - { - if(szSrc[0] == _T('%')) - { - // Replace "%build%" with a build number - if(!_tcsncmp(szSrc, _T("%build%"), 7)) - { - szTrg += _stprintf(szTrg, _T("%u"), hs->dwBuildNumber); - szSrc += 7; - continue; - } - } - - // Just copy the character - *szTrg++ = *szSrc++; - } - - // Terminate the target file name - szTrg[0] = 0; - } - - return szFileName; -} - -//----------------------------------------------------------------------------- -// Public functions - -TDumpContext * CreateDumpContext(TCascStorage * hs, const TCHAR * szNameFormat) -{ - TDumpContext * dc; - TCHAR * szFileName; - - // Validate the storage handle - if(hs != NULL) - { - // Calculate the number of bytes needed for dump context - dc = CASC_ALLOC(TDumpContext, 1); - if(dc != NULL) - { - // Initialize the dump context - memset(dc, 0, sizeof(TDumpContext)); - - // Format the real file name - szFileName = FormatFileName(hs, szNameFormat); - if(szFileName != NULL) - { - // Create the file - dc->pStream = FileStream_CreateFile(szFileName, 0); - if(dc->pStream != NULL) - { - // Initialize buffers - dc->pbBufferBegin = - dc->pbBufferPtr = dc->DumpBuffer; - dc->pbBufferEnd = dc->DumpBuffer + CASC_DUMP_BUFFER_SIZE; - - // Success - CASC_FREE(szFileName); - return dc; - } - - // File create failed --> delete the file name - CASC_FREE(szFileName); - } - - // Free the dump context - CASC_FREE(dc); - } - } - - return NULL; -} - -int dump_print(TDumpContext * dc, const char * szFormat, ...) -{ - va_list argList; - char szBuffer[0x200]; - int nLength = 0; - - // Only if the dump context is valid - if(dc != NULL) - { - // Print the buffer using sprintf - va_start(argList, szFormat); - nLength = vsprintf(szBuffer, szFormat, argList); - assert(nLength < 0x200); - va_end(argList); - - // Copy the string. Replace "\n" with "\n\r" - for(int i = 0; i < nLength; i++) - { - // Flush the buffer, if needed - if((dc->pbBufferPtr + 2) >= dc->pbBufferEnd) - { - FileStream_Write(dc->pStream, NULL, dc->pbBufferBegin, (DWORD)(dc->pbBufferPtr - dc->pbBufferBegin)); - dc->pbBufferPtr = dc->pbBufferBegin; - } - - // Copy the char - if(szBuffer[i] == 0x0A) - *dc->pbBufferPtr++ = 0x0D; - *dc->pbBufferPtr++ = szBuffer[i]; - } - } - - return nLength; -} - -int dump_close(TDumpContext * dc) -{ - // Only if the dump context is valid - if(dc != NULL) - { - // Flush the dump context if there are some data - if(dc->pbBufferPtr > dc->pbBufferBegin) - FileStream_Write(dc->pStream, NULL, dc->pbBufferBegin, (DWORD)(dc->pbBufferPtr - dc->pbBufferBegin)); - dc->pbBufferPtr = dc->pbBufferBegin; - - // Free the file stream and the entire context - if(dc->pStream != NULL) - FileStream_Close(dc->pStream); - CASC_FREE(dc); - } - - return 0; -} diff --git a/dep/CascLib/src/common/DumpContext.h b/dep/CascLib/src/common/DumpContext.h deleted file mode 100644 index 6f725f5b942..00000000000 --- a/dep/CascLib/src/common/DumpContext.h +++ /dev/null @@ -1,38 +0,0 @@ -/*****************************************************************************/ -/* DumpContext.h Copyright (c) Ladislav Zezula 2015 */ -/*---------------------------------------------------------------------------*/ -/* Interface for TDumpContext */ -/*---------------------------------------------------------------------------*/ -/* Date Ver Who Comment */ -/* -------- ---- --- ------- */ -/* 16.03.15 1.00 Lad Created */ -/*****************************************************************************/ - -#ifndef __DUMP_CONTEXT_H__ -#define __DUMP_CONTEXT_H__ - -//----------------------------------------------------------------------------- -// Defines - -// Size of the buffer for the dump context -#define CASC_DUMP_BUFFER_SIZE 0x10000 - -// Structure for dump context -struct TDumpContext -{ - TFileStream * pStream; // Pointer to the open stream - LPBYTE pbBufferBegin; // Begin of the dump buffer - LPBYTE pbBufferPtr; // Current dump buffer pointer - LPBYTE pbBufferEnd; // End of the dump buffer - - BYTE DumpBuffer[CASC_DUMP_BUFFER_SIZE]; // Dump buffer -}; - -//----------------------------------------------------------------------------- -// Dump context functions - -TDumpContext * CreateDumpContext(struct _TCascStorage * hs, const TCHAR * szNameFormat); -int dump_print(TDumpContext * dc, const char * szFormat, ...); -int dump_close(TDumpContext * dc); - -#endif // __DUMP_CONTEXT_H__ diff --git a/dep/CascLib/src/common/DynamicArray.cpp b/dep/CascLib/src/common/DynamicArray.cpp deleted file mode 100644 index e744fbe3912..00000000000 --- a/dep/CascLib/src/common/DynamicArray.cpp +++ /dev/null @@ -1,101 +0,0 @@ -/*****************************************************************************/ -/* DynamicArray.cpp Copyright (c) Ladislav Zezula 2015 */ -/*---------------------------------------------------------------------------*/ -/* Description: */ -/*---------------------------------------------------------------------------*/ -/* Date Ver Who Comment */ -/* -------- ---- --- ------- */ -/* 30.10.15 1.00 Lad The first version of DynamicArray.cpp */ -/*****************************************************************************/ - -#define __CASCLIB_SELF__ -#include "../CascLib.h" -#include "../CascCommon.h" - -//----------------------------------------------------------------------------- -// Local functions - -static bool EnlargeArray(PDYNAMIC_ARRAY pArray, size_t NewItemCount) -{ - char * NewItemArray; - size_t ItemCountMax; - - // We expect the array to be already allocated - assert(pArray->ItemArray != NULL); - assert(pArray->ItemCountMax != 0); - - // Shall we enlarge the table? - if(NewItemCount > pArray->ItemCountMax) - { - // Calculate new table size - ItemCountMax = pArray->ItemCountMax; - while(ItemCountMax < NewItemCount) - ItemCountMax = ItemCountMax << 1; - - // Allocate new table - NewItemArray = CASC_REALLOC(char, pArray->ItemArray, pArray->ItemSize * ItemCountMax); - if(NewItemArray == NULL) - return false; - - // Set the new table size - pArray->ItemCountMax = ItemCountMax; - pArray->ItemArray = NewItemArray; - } - - return true; -} - -//----------------------------------------------------------------------------- -// Public functions - -int Array_Create_(PDYNAMIC_ARRAY pArray, size_t ItemSize, size_t ItemCountMax) -{ - pArray->ItemArray = CASC_ALLOC(char, (ItemSize * ItemCountMax)); - if(pArray->ItemArray == NULL) - return ERROR_NOT_ENOUGH_MEMORY; - - pArray->ItemCountMax = ItemCountMax; - pArray->ItemCount = 0; - pArray->ItemSize = ItemSize; - return ERROR_SUCCESS; -} - -void * Array_Insert(PDYNAMIC_ARRAY pArray, const void * NewItems, size_t NewItemCount) -{ - char * NewItemPtr; - - // Try to enlarge the buffer, if needed - if(!EnlargeArray(pArray, pArray->ItemCount + NewItemCount)) - return NULL; - NewItemPtr = pArray->ItemArray + (pArray->ItemCount * pArray->ItemSize); - - // Copy the old item(s), if any - if(NewItems != NULL) - memcpy(NewItemPtr, NewItems, (NewItemCount * pArray->ItemSize)); - - // Increment the size of the array - pArray->ItemCount += NewItemCount; - return NewItemPtr; -} - -void * Array_ItemAt(PDYNAMIC_ARRAY pArray, size_t ItemIndex) -{ - assert(ItemIndex < pArray->ItemCount); - return pArray->ItemArray + (ItemIndex * pArray->ItemSize); -} - -size_t Array_IndexOf(PDYNAMIC_ARRAY pArray, const void * ArrayPtr) -{ - char * ArrayItem = (char *)ArrayPtr; - - assert(pArray->ItemArray <= ArrayItem && ArrayItem <= pArray->ItemArray + (pArray->ItemCount * pArray->ItemSize)); - return ((ArrayItem - pArray->ItemArray) / pArray->ItemSize); -} - -void Array_Free(PDYNAMIC_ARRAY pArray) -{ - if(pArray != NULL && pArray->ItemArray != NULL) - { - CASC_FREE(pArray->ItemArray); - } -} diff --git a/dep/CascLib/src/common/DynamicArray.h b/dep/CascLib/src/common/DynamicArray.h deleted file mode 100644 index 11cefacdcc4..00000000000 --- a/dep/CascLib/src/common/DynamicArray.h +++ /dev/null @@ -1,37 +0,0 @@ -/*****************************************************************************/ -/* DynamicArray.h Copyright (c) Ladislav Zezula 2015 */ -/*---------------------------------------------------------------------------*/ -/* Common array implementation */ -/*---------------------------------------------------------------------------*/ -/* Date Ver Who Comment */ -/* -------- ---- --- ------- */ -/* 30.10.15 1.00 Lad The first version of DynamicArray.h */ -/*****************************************************************************/ - -#ifndef __DYNAMIC_ARRAY_H__ -#define __DYNAMIC_ARRAY_H__ - -//----------------------------------------------------------------------------- -// Structures - -typedef struct _DYNAMIC_ARRAY -{ - char * ItemArray; // Pointer to items - size_t ItemCountMax; // Current number of items - size_t ItemCount; // Total size of the buffer - size_t ItemSize; // Size of the single item - -} DYNAMIC_ARRAY, *PDYNAMIC_ARRAY; - -//----------------------------------------------------------------------------- -// Functions for managing the array - -int Array_Create_(PDYNAMIC_ARRAY pArray, size_t ItemSize, size_t ItemCountMax); -void * Array_Insert(PDYNAMIC_ARRAY pArray, const void * NewItems, size_t NewItemCount); -void * Array_ItemAt(PDYNAMIC_ARRAY pArray, size_t ItemIndex); -size_t Array_IndexOf(PDYNAMIC_ARRAY pArray, const void * ArrayPtr); -void Array_Free(PDYNAMIC_ARRAY pArray); - -#define Array_Create(pArray, type, ItemCountMax) Array_Create_(pArray, sizeof(type), ItemCountMax) - -#endif // __DYNAMIC_ARRAY__ diff --git a/dep/CascLib/src/common/FileStream.cpp b/dep/CascLib/src/common/FileStream.cpp index 22d7fceb4c2..845e793a6fa 100644 --- a/dep/CascLib/src/common/FileStream.cpp +++ b/dep/CascLib/src/common/FileStream.cpp @@ -219,10 +219,24 @@ static bool BaseFile_Read( #endif // Increment the current file position by number of bytes read - // If the number of bytes read doesn't match to required amount, return false pStream->Base.File.FilePos = ByteOffset + dwBytesRead; - if(dwBytesRead != dwBytesToRead) - SetLastError(ERROR_HANDLE_EOF); + + // If the number of bytes read doesn't match to required amount, return false + // However, Blizzard's CASC handlers read encoded data so that if less than expected + // was read, then they fill the rest with zeros + if(dwBytesRead < dwBytesToRead) + { + if(pStream->dwFlags & STREAM_FLAG_FILL_MISSING) + { + memset((LPBYTE)pvBuffer + dwBytesRead, 0, (dwBytesToRead - dwBytesRead)); + dwBytesRead = dwBytesToRead; + } + else + { + SetLastError(ERROR_HANDLE_EOF); + } + } + return (dwBytesRead == dwBytesToRead); } @@ -597,22 +611,26 @@ static bool BaseHttp_Open(TFileStream * pStream, const TCHAR * szFileName, DWORD { #ifdef PLATFORM_WINDOWS + INTERNET_PORT ServerPort = INTERNET_DEFAULT_HTTP_PORT; HINTERNET hRequest; DWORD dwTemp = 0; bool bFileAvailable = false; int nError = ERROR_SUCCESS; - // Keep compiler happy - dwStreamFlags = dwStreamFlags; + // Check alternate ports + if(dwStreamFlags & STREAM_FLAG_USE_PORT_1119) + { + ServerPort = 1119; + } - // Don't connect to the internet + // Don't download if we are not connected to the internet if(!InternetGetConnectedState(&dwTemp, 0)) nError = GetLastError(); // Initiate the connection to the internet if(nError == ERROR_SUCCESS) { - pStream->Base.Http.hInternet = InternetOpen(_T("CascLib HTTP archive reader"), + pStream->Base.Http.hInternet = InternetOpen(_T("agent/2.17.2.6700"), INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, @@ -631,7 +649,7 @@ static bool BaseHttp_Open(TFileStream * pStream, const TCHAR * szFileName, DWORD szFileName = BaseHttp_ExtractServerName(szFileName, szServerName); pStream->Base.Http.hConnect = InternetConnect(pStream->Base.Http.hInternet, szServerName, - INTERNET_DEFAULT_HTTP_PORT, + ServerPort, NULL, NULL, INTERNET_SERVICE_HTTP, @@ -651,26 +669,41 @@ static bool BaseHttp_Open(TFileStream * pStream, const TCHAR * szFileName, DWORD if(HttpSendRequest(hRequest, NULL, 0, NULL, 0)) { ULONGLONG FileTime = 0; + LPTSTR szEndPtr; + TCHAR szStatusCode[0x10]; + DWORD dwStatusCode = 404; DWORD dwFileSize = 0; - DWORD dwDataSize; + DWORD dwDataSize = sizeof(szStatusCode); DWORD dwIndex = 0; - // Check if the archive has Last Modified field - dwDataSize = sizeof(ULONGLONG); - if(HttpQueryInfo(hRequest, HTTP_QUERY_LAST_MODIFIED | HTTP_QUERY_FLAG_SYSTEMTIME, &FileTime, &dwDataSize, &dwIndex)) - pStream->Base.Http.FileTime = FileTime; + // Check whether the file exists + if (HttpQueryInfo(hRequest, HTTP_QUERY_STATUS_CODE, szStatusCode, &dwDataSize, &dwIndex)) + dwStatusCode = _tcstoul(szStatusCode, &szEndPtr, 10); - // Verify if the server supports random access - dwDataSize = sizeof(DWORD); - if(HttpQueryInfo(hRequest, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, &dwFileSize, &dwDataSize, &dwIndex)) + // Copare the statuc code + if (dwStatusCode == 200) { - if(dwFileSize != 0) + // Check if the archive has Last Modified field + dwDataSize = sizeof(ULONGLONG); + if (HttpQueryInfo(hRequest, HTTP_QUERY_LAST_MODIFIED | HTTP_QUERY_FLAG_SYSTEMTIME, &FileTime, &dwDataSize, &dwIndex)) + pStream->Base.Http.FileTime = FileTime; + + // Verify if the server supports random access + dwDataSize = sizeof(DWORD); + if (HttpQueryInfo(hRequest, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, &dwFileSize, &dwDataSize, &dwIndex)) { - pStream->Base.Http.FileSize = dwFileSize; - pStream->Base.Http.FilePos = 0; - bFileAvailable = true; + if (dwFileSize != 0) + { + pStream->Base.Http.FileSize = dwFileSize; + pStream->Base.Http.FilePos = 0; + bFileAvailable = true; + } } } + else + { + nError = ERROR_FILE_NOT_FOUND; + } } InternetCloseHandle(hRequest); } @@ -681,6 +714,7 @@ static bool BaseHttp_Open(TFileStream * pStream, const TCHAR * szFileName, DWORD if(bFileAvailable == false) { pStream->BaseClose(pStream); + SetLastError(nError); return false; } @@ -723,7 +757,7 @@ static bool BaseHttp_Read( { // Add range request to the HTTP headers // http://www.clevercomponents.com/articles/article015/resuming.asp - _stprintf(szRangeRequest, _T("Range: bytes=%u-%u"), (unsigned int)dwStartOffset, (unsigned int)dwEndOffset); + CascStrPrintf(szRangeRequest, _countof(szRangeRequest), _T("Range: bytes=%u-%u"), (unsigned int)dwStartOffset, (unsigned int)dwEndOffset); HttpAddRequestHeaders(hRequest, szRangeRequest, 0xFFFFFFFF, HTTP_ADDREQ_FLAG_ADD_IF_NEW); // Send the request to the server @@ -963,9 +997,7 @@ static bool BlockStream_GetPos(TFileStream * pStream, ULONGLONG * pByteOffset) static void BlockStream_Close(TBlockStream * pStream) { // Free the data map, if any - if(pStream->FileBitmap != NULL) - CASC_FREE(pStream->FileBitmap); - pStream->FileBitmap = NULL; + CASC_FREE(pStream->FileBitmap); // Call the base class for closing the stream pStream->BaseClose(pStream); @@ -1026,7 +1058,7 @@ static TFileStream * AllocateFileStream( if(pStream != NULL) { // Zero the entire structure - memset(pStream, 0, StreamSize); + memset(pStream, 0, StreamSize + FileNameSize + sizeof(TCHAR)); pStream->pMaster = pMaster; pStream->dwFlags = dwStreamFlags; @@ -1344,7 +1376,10 @@ static TFileStream * FlatStream_Open(const TCHAR * szFileName, DWORD dwStreamFla // Create new empty stream pStream = (TBlockStream *)AllocateFileStream(szFileName, sizeof(TBlockStream), dwStreamFlags); if(pStream == NULL) + { + SetLastError(ERROR_NOT_ENOUGH_MEMORY); return NULL; + } // Do we have a master stream? if(pStream->pMaster != NULL) @@ -1661,7 +1696,7 @@ static void PartStream_Close(TBlockStream * pStream) // Make sure that the header is properly BSWAPed BSWAP_ARRAY32_UNSIGNED(&PartHeader, sizeof(PART_FILE_HEADER)); - sprintf(PartHeader.GameBuildNumber, "%u", (unsigned int)pStream->BuildNumber); + CascStrPrintf(PartHeader.GameBuildNumber, _countof(PartHeader.GameBuildNumber), "%u", (unsigned int)pStream->BuildNumber); // Write the part header pStream->BaseWrite(pStream, &ByteOffset, &PartHeader, sizeof(PART_FILE_HEADER)); @@ -1755,7 +1790,6 @@ static bool PartStream_CreateMirror(TBlockStream * pStream) return true; } - static TFileStream * PartStream_Open(const TCHAR * szFileName, DWORD dwStreamFlags) { TBlockStream * pStream; @@ -2193,9 +2227,7 @@ static void Block4Stream_Close(TBlockStream * pStream) } // Free the data map, if any - if(pStream->FileBitmap != NULL) - CASC_FREE(pStream->FileBitmap); - pStream->FileBitmap = NULL; + CASC_FREE(pStream->FileBitmap); // Do not call the BaseClose function, // we closed all handles already @@ -2246,7 +2278,7 @@ static TFileStream * Block4Stream_Open(const TCHAR * szFileName, DWORD dwStreamF for(int nSuffix = 0; nSuffix < 30; nSuffix++) { // Open the n-th file - _stprintf(szNameBuff, _T("%s.%u"), pStream->szFileName, nSuffix); + CascStrPrintf(szNameBuff, (nNameLength + 4), _T("%s.%u"), pStream->szFileName, nSuffix); if(!pStream->BaseOpen(pStream, szNameBuff, dwBaseFlags)) break; @@ -2368,7 +2400,6 @@ TFileStream * FileStream_CreateFile( // File create failed, delete the stream CASC_FREE(pStream); - pStream = NULL; } // Return the stream diff --git a/dep/CascLib/src/common/FileStream.h b/dep/CascLib/src/common/FileStream.h index 1c72619e393..a2b0c5b9f7d 100644 --- a/dep/CascLib/src/common/FileStream.h +++ b/dep/CascLib/src/common/FileStream.h @@ -28,6 +28,8 @@ #define STREAM_FLAG_READ_ONLY 0x00000100 // Stream is read only #define STREAM_FLAG_WRITE_SHARE 0x00000200 // Allow write sharing when open for write #define STREAM_FLAG_USE_BITMAP 0x00000400 // If the file has a file bitmap, load it and use it +#define STREAM_FLAG_FILL_MISSING 0x00000800 // If less than expected was read from the file, fill the missing part with zeros +#define STREAM_FLAG_USE_PORT_1119 0x00001000 // For HTTP streams, use port 1119 #define STREAM_OPTIONS_MASK 0x0000FF00 // Mask for stream options #define STREAM_PROVIDERS_MASK 0x000000FF // Mask to get stream providers @@ -101,6 +103,12 @@ typedef void (*BLOCK_SAVEMAP)( struct TFileStream * pStream // Pointer to a block-oriented stream ); +typedef void (WINAPI * STREAM_DOWNLOAD_CALLBACK)( + void * pvUserData, + ULONGLONG ByteOffset, + DWORD dwTotalBytes + ); + //----------------------------------------------------------------------------- // Local structures - partial file structure and bitmap footer diff --git a/dep/CascLib/src/common/FileTree.cpp b/dep/CascLib/src/common/FileTree.cpp new file mode 100644 index 00000000000..f753c25f263 --- /dev/null +++ b/dep/CascLib/src/common/FileTree.cpp @@ -0,0 +1,684 @@ +/*****************************************************************************/ +/* FileTree.cpp Copyright (c) Ladislav Zezula 2018 */ +/*---------------------------------------------------------------------------*/ +/* Common implementation of a file tree object for various ROOt file formats */ +/*---------------------------------------------------------------------------*/ +/* Date Ver Who Comment */ +/* -------- ---- --- ------- */ +/* 29.05.18 1.00 Lad The first version of FileTree.cpp */ +/*****************************************************************************/ + +#define __CASCLIB_SELF__ +#include "../CascLib.h" +#include "../CascCommon.h" + +//----------------------------------------------------------------------------- +// Local defines + +#define START_ITEM_COUNT 0x4000 + +inline DWORD GET_NODE_INT32(void * node, size_t offset) +{ + PDWORD PtrValue = (PDWORD)((LPBYTE)node + offset); + + return PtrValue[0]; +} + +inline void SET_NODE_INT32(void * node, size_t offset, DWORD value) +{ + PDWORD PtrValue = (PDWORD)((LPBYTE)node + offset); + + PtrValue[0] = value; +} +/* +static bool CompareFileNode(void * pvObject, void * pvUserData) +{ + PCASC_COMPARE_CONTEXT pCtx = (PCASC_COMPARE_CONTEXT)pvUserData; + PCASC_FILE_TREE pFileTree = (PCASC_FILE_TREE)pCtx->pThis; + PCASC_FILE_NODE pFileNode = (PCASC_FILE_NODE)pvObject; + char szFullPath[MAX_PATH]; + + // First of all, the name hash must match + if(pFileNode->FileNameHash == pCtx->FileNameHash) + { + // Then also compare the full path name + pFileTree->PathAt(szFullPath, _countof(szFullPath), pFileNode); + if(!_stricmp(szFullPath, pCtx->szFileName)) + { + return true; + } + } + + return false; +} +*/ +//----------------------------------------------------------------------------- +// Protected functions + +// Inserts a new file node to the file tree. +// If the pointer to file node array changes, the function also rebuilds all maps +PCASC_FILE_NODE CASC_FILE_TREE::InsertNew(PCASC_CKEY_ENTRY pCKeyEntry) +{ + PCASC_FILE_NODE pFileNode; + + // Create a brand new node + pFileNode = InsertNew(); + if(pFileNode != NULL) + { + // Initialize the file node's CKeyEntry + pFileNode->pCKeyEntry = pCKeyEntry; + + // Don't insert the node into any of the arrays here. + // That is the caller's responsibility + } + + return pFileNode; +} + +PCASC_FILE_NODE CASC_FILE_TREE::InsertNew() +{ + PCASC_FILE_NODE pFileNode; + void * SaveItemArray = NodeTable.ItemArray(); // We need to save the array pointers. If it changes, we must rebuild both maps + + // Create a brand new node + pFileNode = (PCASC_FILE_NODE)NodeTable.Insert(1); + if(pFileNode != NULL) + { + // Initialize the file node + pFileNode->FileNameHash = 0; + pFileNode->pCKeyEntry = NULL; + pFileNode->Parent = 0; + pFileNode->NameIndex = 0; + pFileNode->NameLength = 0; + pFileNode->Flags = 0; + + // We need to supply a file data id for the new entry, otherwise the rebuilding function + // will use the uninitialized one + SetExtras(pFileNode, CASC_INVALID_ID, CASC_INVALID_ID, CASC_INVALID_ID); + + // If the array pointer changed or we are close to the size of the array, we need to rebuild the maps + if(NodeTable.ItemArray() != SaveItemArray || (NodeTable.ItemCount() * 3 / 2) > NameMap.HashTableSize()) + { + // Rebuild both maps. Note that rebuilding also inserts all items to the maps, so no need to insert them here + if(!RebuildNameMaps()) + { + pFileNode = NULL; + assert(false); + } + } + } + + return pFileNode; +} + +// Insert the node to the map of FileNameHash -> CASC_FILE_NODE +bool CASC_FILE_TREE::InsertToHashTable(PCASC_FILE_NODE pFileNode) +{ + bool bResult = false; + + // Insert the file node to the table + if(pFileNode->FileNameHash != 0) + bResult = NameMap.InsertObject(pFileNode, &pFileNode->FileNameHash); + return bResult; +} + +// Inserts the file node to the array of file data ids +bool CASC_FILE_TREE::InsertToIdTable(PCASC_FILE_NODE pFileNode) +{ + PCASC_FILE_NODE * RefElement; + DWORD FileDataId = CASC_INVALID_ID; + + if(FileDataIds.IsInitialized()) + { + // Retrieve the file data id + GetExtras(pFileNode, &FileDataId, NULL, NULL); + if(FileDataId != CASC_INVALID_ID) + { + // Sanity check + assert(FileDataId < 0x10000000); + + // Insert the element to the array + RefElement = (PCASC_FILE_NODE *)FileDataIds.InsertAt(FileDataId); + if(RefElement != NULL) + { + RefElement[0] = pFileNode; + return true; + } + } + } + + return false; +} + +bool CASC_FILE_TREE::SetNodePlainName(PCASC_FILE_NODE pFileNode, const char * szPlainName, const char * szPlainNameEnd) +{ + char * szNodeName; + size_t nLength = (szPlainNameEnd - szPlainName); + + // Insert all chars to the name array + szNodeName = (char *)NameTable.Insert(nLength); + if(szNodeName != NULL) + { + // Copy the plain name to the node. Do not include the string terminator + memcpy(szNodeName, szPlainName, nLength); + + // Supply the file name to the file node + pFileNode->NameIndex = (DWORD)NameTable.IndexOf(szNodeName); + pFileNode->NameLength = (USHORT)nLength; + return true; + } + + return false; +} + +bool CASC_FILE_TREE::SetKeyLength(DWORD aKeyLength) +{ + if(aKeyLength > MD5_HASH_SIZE) + return false; + KeyLength = aKeyLength; + return true; +} + +DWORD CASC_FILE_TREE::GetNextFileDataId() +{ + if(FileDataIds.IsInitialized()) + return (DWORD)(FileDataIds.ItemCount() + 1); + return CASC_INVALID_ID; +} + +bool CASC_FILE_TREE::RebuildNameMaps() +{ + PCASC_FILE_NODE pFileNode; + size_t nMaxItems = NodeTable.ItemCountMax(); + + // Free the map of "FullName -> CASC_FILE_NODE" + NameMap.Free(); + + // Create new map map "FullName -> CASC_FILE_NODE" + if(NameMap.Create(nMaxItems, sizeof(ULONGLONG), FIELD_OFFSET(CASC_FILE_NODE, FileNameHash)) != ERROR_SUCCESS) + return false; + + // Reset the entire array, but keep the buffer allocated + FileDataIds.Reset(); + + // Parse all items and insert them to the map + for(size_t i = 0; i < NodeTable.ItemCount(); i++) + { + // Retrieve the n-th object + pFileNode = (PCASC_FILE_NODE)NodeTable.ItemAt(i); + if(pFileNode != NULL) + { + // Insert it to the map "FileNameHash -> CASC_FILE_NODE" + if(pFileNode->FileNameHash != 0) + InsertToHashTable(pFileNode); + + // Insert it to the array "FileDataId -> CASC_FILE_NODE" + if(FileDataIds.IsInitialized()) + InsertToIdTable(pFileNode); + } + } + + return true; +} + +//----------------------------------------------------------------------------- +// Public functions + +int CASC_FILE_TREE::Create(DWORD Flags) +{ + PCASC_FILE_NODE pRootNode; + size_t FileNodeSize = FIELD_OFFSET(CASC_FILE_NODE, ExtraValues); + int nError; + + // Initialize the file tree + memset(this, 0, sizeof(CASC_FILE_TREE)); + KeyLength = MD5_HASH_SIZE; + + // Shall we use the data ID in the tree node? + if(Flags & FTREE_FLAG_USE_DATA_ID) + { + // Set the offset of the file data id in the entry + FileDataIdOffset = FileNodeSize; + FileNodeSize += sizeof(DWORD); + + // Create the array for FileDataId -> CASC_FILE_NODE + nError = FileDataIds.Create<PCASC_FILE_NODE>(START_ITEM_COUNT); + if(nError != ERROR_SUCCESS) + return nError; + } + + // Shall we use the locale ID in the tree node? + if(Flags & FTREE_FLAG_USE_LOCALE_FLAGS) + { + LocaleFlagsOffset = FileNodeSize; + FileNodeSize += sizeof(DWORD); + } + + if(Flags & FTREE_FLAG_USE_CONTENT_FLAGS) + { + ContentFlagsOffset = FileNodeSize; + FileNodeSize += sizeof(DWORD); + } + + // Align the file node size to 8 bytes + FileNodeSize = ALIGN_TO_SIZE(FileNodeSize, 8); + + // Initialize the dynamic array + nError = NodeTable.Create(FileNodeSize, START_ITEM_COUNT); + if(nError == ERROR_SUCCESS) + { + // Create the dynamic array that will hold the node names + nError = NameTable.Create<char>(START_ITEM_COUNT); + if(nError == ERROR_SUCCESS) + { + // Insert the first "root" node, without name + pRootNode = (PCASC_FILE_NODE)NodeTable.Insert(1); + if(pRootNode != NULL) + { + // Initialize the node + memset(pRootNode, 0, NodeTable.ItemSize()); + pRootNode->Parent = CASC_INVALID_INDEX; + pRootNode->NameIndex = CASC_INVALID_INDEX; + pRootNode->Flags = CFN_FLAG_FOLDER; + SetExtras(pRootNode, CASC_INVALID_ID, CASC_INVALID_ID, CASC_INVALID_ID); + } + } + } + + // Create both maps + if(!RebuildNameMaps()) + nError = ERROR_NOT_ENOUGH_MEMORY; + return nError; +} + +void CASC_FILE_TREE::Free() +{ + // Free both arrays + NodeTable.Free(); + NameTable.Free(); + FileDataIds.Free(); + + // Free the name map + NameMap.Free(); + + // Zero the object + memset(this, 0, sizeof(CASC_FILE_TREE)); +} + +PCASC_FILE_NODE CASC_FILE_TREE::InsertByName(PCASC_CKEY_ENTRY pCKeyEntry, const char * szFileName, DWORD FileDataId, DWORD LocaleFlags, DWORD ContentFlags) +{ + CASC_COMPARE_CONTEXT CmpCtx; + PCASC_FILE_NODE pFileNode; + + // Sanity checks + assert(szFileName != NULL && szFileName[0] != 0); + assert(pCKeyEntry != NULL); + + // Calculate the file name hash + CmpCtx.FileNameHash = CalcFileNameHash(szFileName); +// CmpCtx.szFileName = szFileName; +// CmpCtx.pThis = this; + + // Do nothing if the file name is there already. +// pFileNode = (PCASC_FILE_NODE)NameMap.FindObjectEx(CompareFileNode, &CmpCtx); + pFileNode = (PCASC_FILE_NODE)NameMap.FindObject(&CmpCtx.FileNameHash); + if(pFileNode == NULL) + { + // Insert new item + pFileNode = InsertNew(pCKeyEntry); + if(pFileNode != NULL) + { + // Supply the name hash + pFileNode->FileNameHash = CmpCtx.FileNameHash; + + // Set the file data id and the extra values + SetExtras(pFileNode, FileDataId, LocaleFlags, ContentFlags); + + // Insert the file node to the hash map + InsertToHashTable(pFileNode); + + // Also make sure that it's in the file data id table, if the table is initialized + InsertToIdTable(pFileNode); + + // Set the file name of the new file node. This also increments the number of references + SetNodeFileName(pFileNode, szFileName); + + // If we created a new node, we need to increment the reference count + assert(pCKeyEntry->RefCount != 0xFFFF); + pCKeyEntry->RefCount++; + } + } + + return pFileNode; +} + +PCASC_FILE_NODE CASC_FILE_TREE::InsertByHash(PCASC_CKEY_ENTRY pCKeyEntry, ULONGLONG FileNameHash, DWORD FileDataId, DWORD LocaleFlags, DWORD ContentFlags) +{ + PCASC_FILE_NODE pFileNode; + + // Sanity checks + assert(FileDataIds.IsInitialized()); + assert(FileDataId != CASC_INVALID_ID); + assert(FileNameHash != 0); + assert(pCKeyEntry != NULL); + + // Insert the node to the tree by file data id + pFileNode = InsertById(pCKeyEntry, FileDataId, LocaleFlags, ContentFlags); + if(pFileNode != NULL) + { + // Supply the name hash + pFileNode->FileNameHash = FileNameHash; + + // Insert the file node to the hash map + InsertToHashTable(pFileNode); + } + + return pFileNode; +} + +PCASC_FILE_NODE CASC_FILE_TREE::InsertById(PCASC_CKEY_ENTRY pCKeyEntry, DWORD FileDataId, DWORD LocaleFlags, DWORD ContentFlags) +{ + PCASC_FILE_NODE pFileNode; + + // Sanity checks + assert(FileDataIds.IsInitialized()); + assert(FileDataId != CASC_INVALID_ID); + assert(pCKeyEntry != NULL); + + // Check whether the file data id exists in the array of file data ids + if((pFileNode = FindById(FileDataId)) == NULL) + { + // Insert the new file node + pFileNode = InsertNew(pCKeyEntry); + if(pFileNode != NULL) + { + // Set the file data id and the extra values + SetExtras(pFileNode, FileDataId, LocaleFlags, ContentFlags); + + // Insert the file node to the FileDataId array + InsertToIdTable(pFileNode); + + // Increment the number of references + pCKeyEntry->RefCount++; + } + } + + // Return the new or old node + return pFileNode; +} + +PCASC_FILE_NODE CASC_FILE_TREE::ItemAt(size_t nItemIndex) +{ + return (PCASC_FILE_NODE)NodeTable.ItemAt(nItemIndex); +} + +PCASC_FILE_NODE CASC_FILE_TREE::PathAt(char * szBuffer, size_t cchBuffer, size_t nItemIndex) +{ + PCASC_FILE_NODE pFileNode = NULL; + + // If we have FileDataId, then we need to enumerate the files by FileDataId + if(FileDataIds.IsInitialized()) + pFileNode = *(PCASC_FILE_NODE *)FileDataIds.ItemAt(nItemIndex); + else + pFileNode = (PCASC_FILE_NODE)NodeTable.ItemAt(nItemIndex); + + // Construct the entire path + PathAt(szBuffer, cchBuffer, pFileNode); + return pFileNode; +} + +size_t CASC_FILE_TREE::PathAt(char * szBuffer, size_t cchBuffer, PCASC_FILE_NODE pFileNode) +{ + PCASC_FILE_NODE pParentNode; + const char * szNamePtr; + char * szSaveBuffer = szBuffer; + char * szBufferEnd = szBuffer + cchBuffer - 1; + + if(pFileNode != NULL && pFileNode->Parent != CASC_INVALID_INDEX) + { + // Copy all parents + pParentNode = (PCASC_FILE_NODE)NodeTable.ItemAt(pFileNode->Parent); + if(pParentNode != NULL) + { + // Query the parent and move the buffer + szBuffer = szBuffer + PathAt(szBuffer, cchBuffer, pParentNode); + } + + // Retrieve the node name + szNamePtr = (const char *)NameTable.ItemAt(pFileNode->NameIndex); + + // Check whether we have enough space + if((szBuffer + pFileNode->NameLength) < szBufferEnd) + { + // Copy the path part + memcpy(szBuffer, szNamePtr, pFileNode->NameLength); + szBuffer += pFileNode->NameLength; + + // Append backslash + if((pFileNode->Flags & CFN_FLAG_FOLDER) && ((szBuffer + 1) < szBufferEnd)) + { + *szBuffer++ = (pFileNode->Flags & CFN_FLAG_MOUNT_POINT) ? ':' : '\\'; + } + } + } + + // Terminate buffer with zero + szBuffer[0] = 0; + + // Return length of the copied string + return (szBuffer - szSaveBuffer); +} + +PCASC_FILE_NODE CASC_FILE_TREE::Find(const char * szFullPath, DWORD FileDataId, PCASC_FIND_DATA pFindData) +{ + PCASC_FILE_NODE pFileNode = NULL; + ULONGLONG FileNameHash; + + // Can we search by FileDataId? + if(FileDataIds.IsInitialized() && (FileDataId != CASC_INVALID_ID || IsFileDataIdName(szFullPath, FileDataId))) + { + pFileNode = FindById(FileDataId); + } + else + { + if(szFullPath != NULL && szFullPath[0] != 0) + { + FileNameHash = CalcFileNameHash(szFullPath); + pFileNode = (PCASC_FILE_NODE)NameMap.FindObject(&FileNameHash); + } + } + + // Did we find anything? + if(pFileNode != NULL && pFindData != NULL) + { + GetExtras(pFileNode, &pFindData->dwFileDataId, &pFindData->dwLocaleFlags, &pFindData->dwContentFlags); + pFindData->bCanOpenByName = (pFileNode->FileNameHash != 0); + pFindData->bCanOpenByDataId = (FileDataIdOffset != 0); + } + + return pFileNode; +} + +PCASC_FILE_NODE CASC_FILE_TREE::Find(PCASC_CKEY_ENTRY pCKeyEntry) +{ + PCASC_FILE_NODE pFileNode; + + for(size_t i = 0; i < NodeTable.ItemCount(); i++) + { + pFileNode = (PCASC_FILE_NODE)NodeTable.ItemAt(i); + if((pFileNode->Flags & (CFN_FLAG_FOLDER | CFN_FLAG_MOUNT_POINT)) == 0) + { + if(pFileNode->pCKeyEntry == pCKeyEntry) + return pFileNode; + } + } + + return NULL; +} + +PCASC_FILE_NODE CASC_FILE_TREE::Find(ULONGLONG FileNameHash) +{ + return (PCASC_FILE_NODE)NameMap.FindObject(&FileNameHash); +} + +PCASC_FILE_NODE CASC_FILE_TREE::FindById(DWORD FileDataId) +{ + PCASC_FILE_NODE * RefElement; + PCASC_FILE_NODE pFileNode = NULL; + + if(FileDataId != CASC_INVALID_ID && FileDataIds.IsInitialized()) + { + // Insert the element to the array + RefElement = (PCASC_FILE_NODE *)FileDataIds.ItemAt(FileDataId); + if(RefElement != NULL) + { + pFileNode = RefElement[0]; + } + } + + return pFileNode; +} + +bool CASC_FILE_TREE::SetNodeFileName(PCASC_FILE_NODE pFileNode, const char * szFileName) +{ + ULONGLONG FileNameHash = 0; + PCASC_FILE_NODE pFolderNode = NULL; + const char * szNodeBegin = szFileName; + char szPathBuffer[MAX_PATH+1]; + size_t nFileNode = NodeTable.IndexOf(pFileNode); + size_t i; + DWORD Parent = 0; + + // Sanity checks + assert(szFileName != NULL && szFileName[0] != 0); + assert(pFileNode->pCKeyEntry != NULL); + + // Traverse the entire path. For each subfolder, we insert an appropriate fake entry + for(i = 0; szFileName[i] != 0; i++) + { + char chOneChar = szFileName[i]; + + // Is there a path separator? + // Note: Warcraft III paths may contain "mount points". + // Example: "frFR-War3Local.mpq:Maps/FrozenThrone/Campaign/NightElfX06Interlude.w3x:war3map.j" + if(chOneChar == '\\' || chOneChar == '/' || chOneChar == ':') + { + // Calculate hash of the file name up to the end of the node name + FileNameHash = CalcNormNameHash(szPathBuffer, i); + + // If the entry is not there yet, create new one + if((pFolderNode = Find(FileNameHash)) == NULL) + { + // Insert new entry to the tree + pFolderNode = InsertNew(); + if(pFolderNode == NULL) + return false; + + // Populate the file entry + pFolderNode->FileNameHash = FileNameHash; + pFolderNode->Parent = Parent; + pFolderNode->Flags |= (chOneChar == ':') ? CFN_FLAG_MOUNT_POINT : 0; + pFolderNode->Flags |= CFN_FLAG_FOLDER; + + // Set the node sub name to the node + SetNodePlainName(pFolderNode, szNodeBegin, szFileName + i); + + // Insert the entry to the name map + InsertToHashTable(pFolderNode); + } + + // Move the parent to the current node + Parent = (DWORD)NodeTable.IndexOf(pFolderNode); + + // Move the begin of the node after the separator + szNodeBegin = szFileName + i + 1; + } + + // Copy the next character, even if it was slash/backslash before + szPathBuffer[i] = AsciiToUpperTable_BkSlash[chOneChar]; + } + + // If anything left, this is gonna be our node name + if(szNodeBegin < szFileName + i) + { + // We need to reset the file node pointer, as the file node table might have changed + pFileNode = (PCASC_FILE_NODE)NodeTable.ItemAt(nFileNode); + + SetNodePlainName(pFileNode, szNodeBegin, szFileName + i); + pFileNode->Parent = Parent; + } + return true; +} + +size_t CASC_FILE_TREE::GetMaxFileIndex() +{ + if(FileDataIds.IsInitialized()) + { + return FileDataIds.ItemCount(); + } + else + { + return NodeTable.ItemCount(); + } +} + +size_t CASC_FILE_TREE::GetCount() +{ + return NodeTable.ItemCount(); +} + +size_t CASC_FILE_TREE::IndexOf(PCASC_FILE_NODE pFileNode) +{ + return NodeTable.IndexOf(pFileNode); +} + +void CASC_FILE_TREE::GetExtras(PCASC_FILE_NODE pFileNode, PDWORD PtrFileDataId, PDWORD PtrLocaleFlags, PDWORD PtrContentFlags) +{ + DWORD FileDataId = CASC_INVALID_ID; + DWORD LocaleFlags = CASC_INVALID_ID; + DWORD ContentFlags = CASC_INVALID_ID; + + // Retrieve the data ID, if supported + if(PtrFileDataId != NULL) + { + if(FileDataIdOffset != 0) + FileDataId = GET_NODE_INT32(pFileNode, FileDataIdOffset); + PtrFileDataId[0] = FileDataId; + } + + // Retrieve the locale ID, if supported + if(PtrLocaleFlags != NULL) + { + if(LocaleFlagsOffset != 0) + LocaleFlags = GET_NODE_INT32(pFileNode, LocaleFlagsOffset); + PtrLocaleFlags[0] = LocaleFlags; + } + + if(PtrContentFlags != NULL) + { + if(ContentFlagsOffset != 0) + ContentFlags = GET_NODE_INT32(pFileNode, ContentFlagsOffset); + PtrContentFlags[0] = ContentFlags; + } +} + +void CASC_FILE_TREE::SetExtras(PCASC_FILE_NODE pFileNode, DWORD FileDataId, DWORD LocaleFlags, DWORD ContentFlags) +{ + // Set the file data ID, if supported + if(FileDataIdOffset != 0) + { + SET_NODE_INT32(pFileNode, FileDataIdOffset, FileDataId); + } + + // Set the locale ID, if supported + if(LocaleFlagsOffset != 0) + { + SET_NODE_INT32(pFileNode, LocaleFlagsOffset, LocaleFlags); + } + + // Set the locale ID, if supported + if(ContentFlagsOffset != 0) + { + SET_NODE_INT32(pFileNode, ContentFlagsOffset, ContentFlags); + } +} diff --git a/dep/CascLib/src/common/FileTree.h b/dep/CascLib/src/common/FileTree.h new file mode 100644 index 00000000000..904da6c4c46 --- /dev/null +++ b/dep/CascLib/src/common/FileTree.h @@ -0,0 +1,116 @@ +/*****************************************************************************/ +/* FileTree.h Copyright (c) Ladislav Zezula 2018 */ +/*---------------------------------------------------------------------------*/ +/* Common implementation of a file tree object for various ROOt file formats */ +/*---------------------------------------------------------------------------*/ +/* Date Ver Who Comment */ +/* -------- ---- --- ------- */ +/* 29.05.18 1.00 Lad The first version of FileTree.h */ +/*****************************************************************************/ + +#ifndef __FILETREE_H__ +#define __FILETREE_H__ + +//----------------------------------------------------------------------------- +// Structures + +#define FTREE_FLAG_USE_DATA_ID 0x0001 // The FILE_NODE also contains file data ID +#define FTREE_FLAG_USE_LOCALE_FLAGS 0x0002 // The FILE_NODE also contains file locale flags +#define FTREE_FLAG_USE_CONTENT_FLAGS 0x0004 // The FILE_NODE also contains content flags + +#define CFN_FLAG_FOLDER 0x0001 // This item is a folder +#define CFN_FLAG_MOUNT_POINT 0x0002 // This item is a mount point. + +// Common structure for holding a single folder/file node +typedef struct _CASC_FILE_NODE +{ + ULONGLONG FileNameHash; // Jenkins hash of the normalized file name (uppercase, backslashes) + PCASC_CKEY_ENTRY pCKeyEntry; // Pointer to the CKey entry. + DWORD Parent; // The index of a parent directory. If CASC_INVALID_INDEX, then this is the root item + DWORD NameIndex; // Index of the node name. If CASC_INVALID_INDEX, then this node has no name + USHORT NameLength; // Length of the node name (without the zero terminator) + USHORT Flags; // See CFE_FLAG_XXX + + DWORD ExtraValues[4]; // FileDataId: Only if FTREE_FLAG_USE_DATA_ID specified at create + // LocaleFlags: Only if FTREE_FLAG_USE_LOCALE_FLAGS specified at create + // ContentFlags: Only if FTREE_FLAG_USE_CONTENT_FLAGS specified at create +} CASC_FILE_NODE, *PCASC_FILE_NODE; + +// Common structure for comparing a file node +typedef struct _CASC_COMPARE_CONTEXT +{ + ULONGLONG FileNameHash; + const char * szFileName; + void * pThis; +} CASC_COMPARE_CONTEXT, *PCASC_COMPARE_CONTEXT; + +// Main structure for the file tree +class CASC_FILE_TREE +{ + public: + + // Initializes/destroys the entire tree + int Create(DWORD Flags = 0); + void Free(); + + // Inserts a new node to the tree; either with name or nameless + PCASC_FILE_NODE InsertByName(PCASC_CKEY_ENTRY pCKeyEntry, const char * szFileName, DWORD FileDataId = CASC_INVALID_ID, DWORD LocaleFlags = CASC_INVALID_ID, DWORD ContentFlags = CASC_INVALID_ID); + PCASC_FILE_NODE InsertByHash(PCASC_CKEY_ENTRY pCKeyEntry, ULONGLONG FileNameHash, DWORD FileDataId, DWORD LocaleFlags = CASC_INVALID_ID, DWORD ContentFlags = CASC_INVALID_ID); + PCASC_FILE_NODE InsertById(PCASC_CKEY_ENTRY pCKeyEntry, DWORD FileDataId, DWORD LocaleFlags = CASC_INVALID_ID, DWORD ContentFlags = CASC_INVALID_ID); + + // Returns an item at the given index. The PathAt also builds the full path of the node + PCASC_FILE_NODE ItemAt(size_t nItemIndex); + PCASC_FILE_NODE PathAt(char * szBuffer, size_t cchBuffer, size_t nItemIndex); + size_t PathAt(char * szBuffer, size_t cchBuffer, PCASC_FILE_NODE pFileNode); + + // Finds a file using its full path, FileDataId or CKey/EKey + PCASC_FILE_NODE Find(const char * szFullPath, DWORD FileDataId, struct _CASC_FIND_DATA * pFindData); + PCASC_FILE_NODE Find(PCASC_CKEY_ENTRY pCKeyEntry); + PCASC_FILE_NODE Find(ULONGLONG FileNameHash); + PCASC_FILE_NODE FindById(DWORD FileDataId); + + // Assigns a file name to the node + bool SetNodeFileName(PCASC_FILE_NODE pFileNode, const char * szFileName); + + // Returns the number of items in the tree + size_t GetMaxFileIndex(); + size_t GetCount(); + + // Returns the index of an item in the tree + size_t IndexOf(PCASC_FILE_NODE pFileNode); + + // Retrieves the extra values from the node (if supported) + void GetExtras(PCASC_FILE_NODE pFileNode, PDWORD PtrFileDataId, PDWORD PtrLocaleFlags, PDWORD PtrContentFlags); + void SetExtras(PCASC_FILE_NODE pFileNode, DWORD FileDataId, DWORD LocaleFlags, DWORD ContentFlags); + + // Change the length of the key + bool SetKeyLength(DWORD KeyLength); + + // Retrieve the maximum FileDataId ever inserted + DWORD GetNextFileDataId(); + + protected: + + PCASC_FILE_NODE InsertNew(PCASC_CKEY_ENTRY pCKeyEntry); + PCASC_FILE_NODE InsertNew(); + bool InsertToHashTable(PCASC_FILE_NODE pFileNode); + bool InsertToIdTable(PCASC_FILE_NODE pFileNode); + + bool SetNodePlainName(PCASC_FILE_NODE pFileNode, const char * szPlainName, const char * szPlainNameEnd); + bool RebuildNameMaps(); + + CASC_ARRAY NodeTable; // Dynamic array that holds all CASC_FILE_NODEs + CASC_ARRAY NameTable; // Dynamic array that holds all node names + + CASC_ARRAY FileDataIds; // Dynamic array that maps FileDataId -> CASC_FILE_NODE + CASC_MAP NameMap; // Map of FileNameHash -> CASC_FILE_NODE + + size_t FileDataIdOffset; // If nonzero, this is the offset of the "FileDataId" field in the CASC_FILE_NODE + size_t LocaleFlagsOffset; // If nonzero, this is the offset of the "LocaleFlags" field in the CASC_FILE_NODE + size_t ContentFlagsOffset; // If nonzero, this is the offset of the "ContentFlags" field in the CASC_FILE_NODE + DWORD KeyLength; // Actual length of the key supported by the root handler +}; + +typedef CASC_FILE_TREE * PCASC_FILE_TREE; + +#endif // __FILETREE_H__ diff --git a/dep/CascLib/src/common/ListFile.cpp b/dep/CascLib/src/common/ListFile.cpp index dc9a88bf44c..351ea226188 100644 --- a/dep/CascLib/src/common/ListFile.cpp +++ b/dep/CascLib/src/common/ListFile.cpp @@ -15,11 +15,14 @@ //----------------------------------------------------------------------------- // Listfile cache structure +#define LISTFILE_FLAG_USES_FILEDATAID 0x0001 // A new CSV format, containing FileDataId; FullFileName + typedef struct _LISTFILE_CACHE { - char * pBegin; // The begin of the listfile cache - char * pPos; // Current position in the cache - char * pEnd; // The last character in the file cache + char * pBegin; // The begin of the listfile cache + char * pPos; // Current position in the cache + char * pEnd; // The last character in the file cache + DWORD Flags; // Followed by the cache (variable length) @@ -28,7 +31,7 @@ typedef struct _LISTFILE_CACHE //----------------------------------------------------------------------------- // Creating the listfile cache for the given amount of data -static PLISTFILE_CACHE CreateListFileCache(DWORD dwFileSize) +static PLISTFILE_CACHE ListFile_CreateCache(DWORD dwFileSize) { PLISTFILE_CACHE pCache; @@ -40,12 +43,81 @@ static PLISTFILE_CACHE CreateListFileCache(DWORD dwFileSize) pCache->pBegin = pCache->pPos = (char *)(pCache + 1); pCache->pEnd = pCache->pBegin + dwFileSize; + pCache->Flags = 0; } // Return the cache return pCache; } +static char * ListFile_SkipSpaces(PLISTFILE_CACHE pCache) +{ + // Skip newlines, spaces, tabs and another non-printable stuff + while(pCache->pPos < pCache->pEnd && pCache->pPos[0] <= 0x20) + pCache->pPos++; + + // Remember the begin of the line + return pCache->pPos; +} + +static void ListFile_CheckFormat(PLISTFILE_CACHE pCache) +{ + // Only if the listfile is greatger than 2 MB + if((pCache->pEnd - pCache->pBegin) > 0x100000) + { + char * szPtr = pCache->pBegin; + size_t nDigitCount = 0; + + // Calculate the amount of digits + while(nDigitCount <= 20 && '0' <= szPtr[nDigitCount] && szPtr[nDigitCount] <= '9') + nDigitCount++; + + // There must be a semicolon after + if(nDigitCount <= 10 && szPtr[nDigitCount] == ';') + { + pCache->Flags |= LISTFILE_FLAG_USES_FILEDATAID; + } + } +} + +static int ListFile_GetFileDataId(PLISTFILE_CACHE pCache, PDWORD PtrFileDataId) +{ + char * szLineBegin = ListFile_SkipSpaces(pCache); + char * szLineEnd; + DWORD dwNewInt32 = 0; + DWORD dwInt32 = 0; + + // Set the limit for loading the number + szLineEnd = CASCLIB_MIN((szLineBegin + 20), pCache->pEnd); + + // Extract decimal digits from the string + while(szLineBegin < szLineEnd && '0' <= szLineBegin[0] && szLineBegin[0] <= '9') + { + // Check integer overflow + dwNewInt32 = (dwInt32 * 10) + (szLineBegin[0] - '0'); + if(dwNewInt32 < dwInt32) + return ERROR_BAD_FORMAT; + + dwInt32 = dwNewInt32; + szLineBegin++; + } + + // There must still be some space + if(szLineBegin < szLineEnd) + { + // There must be a semicolon after the decimal integer + // The decimal integer must be smaller than 10 MB (files) + if(szLineBegin[0] != ';' || dwInt32 >= 0xA00000) + return ERROR_BAD_FORMAT; + + pCache->pPos = szLineBegin + 1; + PtrFileDataId[0] = dwInt32; + return ERROR_SUCCESS; + } + + return ERROR_NO_MORE_FILES; +} + //----------------------------------------------------------------------------- // Functions for parsing an external listfile @@ -65,13 +137,16 @@ void * ListFile_OpenExternal(const TCHAR * szListFile) { // Create the in-memory cache for the entire listfile // The listfile does not have any data loaded yet - pCache = CreateListFileCache((DWORD)FileSize); + pCache = ListFile_CreateCache((DWORD)FileSize); if(pCache != NULL) { - if(!FileStream_Read(pStream, NULL, pCache->pBegin, (DWORD)FileSize)) + if(FileStream_Read(pStream, NULL, pCache->pBegin, (DWORD)FileSize)) { - ListFile_Free(pCache); - pCache = NULL; + ListFile_CheckFormat(pCache); + } + else + { + CASC_FREE(pCache); } } } @@ -89,7 +164,7 @@ void * ListFile_FromBuffer(LPBYTE pbBuffer, DWORD cbBuffer) // Create the in-memory cache for the entire listfile // The listfile does not have any data loaded yet - pCache = CreateListFileCache(cbBuffer); + pCache = ListFile_CreateCache(cbBuffer); if(pCache != NULL) memcpy(pCache->pBegin, pbBuffer, cbBuffer); @@ -105,7 +180,7 @@ bool ListFile_VerifyMD5(void * pvListFile, LPBYTE pbHashMD5) assert(pCache->pPos == pCache->pBegin); // Verify the MD5 hash for the entire block - return VerifyDataBlockHash(pCache->pBegin, (DWORD)(pCache->pEnd - pCache->pBegin), pbHashMD5); + return CascVerifyDataBlockHash(pCache->pBegin, (DWORD)(pCache->pEnd - pCache->pBegin), pbHashMD5); } size_t ListFile_GetNextLine(void * pvListFile, const char ** pszLineBegin, const char ** pszLineEnd) @@ -116,17 +191,15 @@ size_t ListFile_GetNextLine(void * pvListFile, const char ** pszLineBegin, const char * szLineEnd; // Skip newlines, spaces, tabs and another non-printable stuff - while(pCache->pPos < pCache->pEnd && pCache->pPos[0] <= 0x20) - pCache->pPos++; - // Remember the begin of the line - szLineBegin = pCache->pPos; + szLineBegin = ListFile_SkipSpaces(pCache); // Copy the remaining characters while(pCache->pPos < pCache->pEnd) { // If we have found a newline, stop loading - if(pCache->pPos[0] == 0x0D || pCache->pPos[0] == 0x0A) + // Note: the 0x85 char came from Overwatch build 24919 + if(pCache->pPos[0] == 0x0A || pCache->pPos[0] == 0x0D || pCache->pPos[0] == 0x85) break; // Blizzard listfiles can also contain information about patch: @@ -169,14 +242,28 @@ size_t ListFile_GetNextLine(void * pvListFile, char * szBuffer, size_t nMaxChars return nLength; } -size_t ListFile_GetNext(void * pvListFile, const char * szMask, char * szBuffer, size_t nMaxChars) +size_t ListFile_GetNext(void * pvListFile, char * szBuffer, size_t nMaxChars, PDWORD PtrFileDataId) { + PLISTFILE_CACHE pCache = (PLISTFILE_CACHE)pvListFile; size_t nLength = 0; int nError = ERROR_SUCCESS; // Check for parameters for(;;) { + DWORD FileDataId = CASC_INVALID_ID; + + // If this is a CSV-format listfile, we need to extract the FileDataId + // Lines that contain bogus data, invalid numbers or too big values will be skipped + if(pCache->Flags & LISTFILE_FLAG_USES_FILEDATAID) + { + nError = ListFile_GetFileDataId(pCache, &FileDataId); + if(nError == ERROR_NO_MORE_FILES) + break; + if(nError != ERROR_SUCCESS || FileDataId == CASC_INVALID_ID) + continue; + } + // Read the (next) line nLength = ListFile_GetNextLine(pvListFile, szBuffer, nMaxChars); if(nLength == 0) @@ -185,12 +272,9 @@ size_t ListFile_GetNext(void * pvListFile, const char * szMask, char * szBuffer, break; } - // If some mask entered, check it - if(CheckWildCard(szBuffer, szMask)) - { - nError = ERROR_SUCCESS; - break; - } + // Give the file data id and return true + PtrFileDataId[0] = FileDataId; + return nLength; } if(nError != ERROR_SUCCESS) @@ -198,163 +282,22 @@ size_t ListFile_GetNext(void * pvListFile, const char * szMask, char * szBuffer, return nLength; } -void ListFile_Free(void * pvListFile) +LPBYTE ListFile_GetData(void * pvListFile, PDWORD PtrDataSize) { - if(pvListFile != NULL) - { - CASC_FREE(pvListFile); - } -} - -//----------------------------------------------------------------------------- -// Functions for creating a listfile map - -#define LISTMAP_INITIAL 0x100000 - -static PLISTFILE_MAP ListMap_Create() -{ - PLISTFILE_MAP pListMap; - size_t cbToAllocate; - - // Create buffer for the listfile - // Note that because the listfile is quite big and CASC_REALLOC - // is a costly operation, we want to have as few reallocs as possible. - cbToAllocate = sizeof(LISTFILE_MAP) + LISTMAP_INITIAL; - pListMap = (PLISTFILE_MAP)CASC_ALLOC(BYTE, cbToAllocate); - if(pListMap != NULL) - { - // Fill the listfile buffer - memset(pListMap, 0, sizeof(LISTFILE_MAP)); - pListMap->cbBufferMax = LISTMAP_INITIAL; - } - - return pListMap; -} - -static PLISTFILE_MAP ListMap_InsertName(PLISTFILE_MAP pListMap, const char * szFileName, size_t nLength) -{ - PLISTFILE_ENTRY pListEntry; - size_t cbToAllocate; - size_t cbEntrySize; - - // Make sure there is enough space in the list map - cbEntrySize = sizeof(LISTFILE_ENTRY) + nLength; - cbEntrySize = ALIGN_TO_SIZE(cbEntrySize, 8); - if((pListMap->cbBuffer + cbEntrySize) > pListMap->cbBufferMax) - { - cbToAllocate = sizeof(LISTFILE_MAP) + (pListMap->cbBufferMax * 3) / 2; - pListMap = (PLISTFILE_MAP)CASC_REALLOC(BYTE, pListMap, cbToAllocate); - if(pListMap == NULL) - return NULL; - - pListMap->cbBufferMax = (pListMap->cbBufferMax * 3) / 2; - } - - // Get the pointer to the first entry - pListEntry = (PLISTFILE_ENTRY)((LPBYTE)(pListMap + 1) + pListMap->cbBuffer); - pListEntry->FileNameHash = CalcFileNameHash(szFileName); - pListEntry->cbEntrySize = (DWORD)cbEntrySize; - - // Copy the file name to the entry - memcpy(pListEntry->szFileName, szFileName, nLength); - pListEntry->szFileName[nLength] = 0; - - // Move the next entry - pListMap->cbBuffer += cbEntrySize; - pListMap->nEntries++; - return pListMap; -} - -static PLISTFILE_MAP ListMap_Finish(PLISTFILE_MAP pListMap) -{ - PLISTFILE_ENTRY pListEntry; - PCASC_MAP pMap; - LPBYTE pbEntry; - - // Sanity check - assert(pListMap->pNameMap == NULL); - - // Create the map - pListMap->pNameMap = pMap = Map_Create((DWORD)pListMap->nEntries, sizeof(ULONGLONG), 0); - if(pListMap->pNameMap == NULL) - { - ListFile_FreeMap(pListMap); - return NULL; - } - - // Fill the map - pbEntry = (LPBYTE)(pListMap + 1); - for(size_t i = 0; i < pListMap->nEntries; i++) - { - // Get the listfile entry - pListEntry = (PLISTFILE_ENTRY)pbEntry; - pbEntry += pListEntry->cbEntrySize; - - // Insert the entry to the map - Map_InsertObject(pMap, pListEntry, &pListEntry->FileNameHash); - } - - return pListMap; -} - -PLISTFILE_MAP ListFile_CreateMap(const TCHAR * szListFile) -{ - PLISTFILE_MAP pListMap = NULL; - void * pvListFile; - char szFileName[MAX_PATH+1]; - size_t nLength; + PLISTFILE_CACHE pCache = (PLISTFILE_CACHE)pvListFile; + LPBYTE pbData = NULL; + DWORD cbData = 0; - // Only if the listfile name has been given - if(szListFile != NULL) + // Get data from the list file cache + if (pvListFile != NULL) { - // Create map for the listfile - pListMap = ListMap_Create(); - if(pListMap != NULL) - { - // Open the external listfile - pvListFile = ListFile_OpenExternal(szListFile); - if(pvListFile != NULL) - { - // Go through the entire listfile and insert each name to the map - while((nLength = ListFile_GetNext(pvListFile, "*", szFileName, MAX_PATH)) != 0) - { - // Insert the file name to the map - pListMap = ListMap_InsertName(pListMap, szFileName, nLength); - if(pListMap == NULL) - break; - } - - if(pListMap == NULL) - { - // Finish the listfile map - pListMap = ListMap_Finish(pListMap); - } - - // Free the listfile - ListFile_Free(pvListFile); - } - } + pbData = (LPBYTE)pCache->pBegin; + cbData = (DWORD)(pCache->pEnd - pCache->pBegin); } - // Return the created map - return pListMap; -} - -const char * ListFile_FindName(PLISTFILE_MAP pListMap, ULONGLONG FileNameHash) -{ - PLISTFILE_ENTRY pListEntry = NULL; - - if(pListMap != NULL) - pListEntry = (PLISTFILE_ENTRY)Map_FindObject(pListMap->pNameMap, &FileNameHash, NULL); - return (pListEntry != NULL) ? pListEntry->szFileName : ""; + // Give the data to the caller + if (PtrDataSize != NULL) + PtrDataSize[0] = cbData; + return pbData; } -void ListFile_FreeMap(PLISTFILE_MAP pListMap) -{ - if(pListMap != NULL) - { - if(pListMap->pNameMap != NULL) - Map_Free(pListMap->pNameMap); - CASC_FREE(pListMap); - } -} diff --git a/dep/CascLib/src/common/ListFile.h b/dep/CascLib/src/common/ListFile.h index 84bec3ed751..1333b52c2b5 100644 --- a/dep/CascLib/src/common/ListFile.h +++ b/dep/CascLib/src/common/ListFile.h @@ -12,28 +12,6 @@ #define __LISTFILE_H__ //----------------------------------------------------------------------------- -// Structures - -typedef struct _LISTFILE_ENTRY -{ - ULONGLONG FileNameHash; // Hash of the file name - DWORD cbEntrySize; // Length of this entry, in bytes - char szFileName[1]; // File name, aligned to 8-byte boundary - -} LISTFILE_ENTRY, *PLISTFILE_ENTRY; - -typedef struct _LISTFILE_MAP -{ - PCASC_MAP pNameMap; // Map of hash-to-name - size_t cbBufferMax; // Total size of the buffer, in bytes - size_t cbBuffer; // Current size of the buffer, in bytes - size_t nEntries; // Number of entries - - // First LISTFILE_ENTRY starts here - -} LISTFILE_MAP, *PLISTFILE_MAP; - -//----------------------------------------------------------------------------- // Functions for parsing an external listfile void * ListFile_OpenExternal(const TCHAR * szListFile); @@ -41,14 +19,7 @@ void * ListFile_FromBuffer(LPBYTE pbBuffer, DWORD cbBuffer); bool ListFile_VerifyMD5(void * pvListFile, LPBYTE pbHashMD5); size_t ListFile_GetNextLine(void * pvListFile, const char ** pszLineBegin, const char ** pszLineEnd); size_t ListFile_GetNextLine(void * pvListFile, char * szBuffer, size_t nMaxChars); -size_t ListFile_GetNext(void * pvListFile, const char * szMask, char * szBuffer, size_t nMaxChars); -void ListFile_Free(void * pvListFile); - -//----------------------------------------------------------------------------- -// Functions for creating a listfile map - -PLISTFILE_MAP ListFile_CreateMap(const TCHAR * szListFile); -const char * ListFile_FindName(PLISTFILE_MAP pListMap, ULONGLONG FileNameHash); -void ListFile_FreeMap(PLISTFILE_MAP pListMap); +size_t ListFile_GetNext(void * pvListFile, char * szBuffer, size_t nMaxChars, PDWORD PtrFileDataId); +LPBYTE ListFile_GetData(void * pvListFile, PDWORD PtrDataSize); #endif // __LISTFILE_H__ diff --git a/dep/CascLib/src/common/Map.cpp b/dep/CascLib/src/common/Map.cpp deleted file mode 100644 index aa1e2a2ada1..00000000000 --- a/dep/CascLib/src/common/Map.cpp +++ /dev/null @@ -1,287 +0,0 @@ -/*****************************************************************************/ -/* Map.cpp Copyright (c) Ladislav Zezula 2014 */ -/*---------------------------------------------------------------------------*/ -/* Implementation of map for CascLib */ -/*---------------------------------------------------------------------------*/ -/* Date Ver Who Comment */ -/* -------- ---- --- ------- */ -/* 10.06.14 1.00 Lad The first version of Map.cpp */ -/*****************************************************************************/ - -#define __CASCLIB_SELF__ -#include "../CascLib.h" -#include "../CascCommon.h" - -//----------------------------------------------------------------------------- -// Local functions - -// Returns the extension, right after "." -static const char * String_GetExtension(const char * szString) -{ - const char * szExtension = strrchr(szString, '.'); - return (szExtension != NULL) ? szExtension + 1 : NULL; -} - -static DWORD CalcHashIndex_Key(PCASC_MAP pMap, void * pvKey) -{ - LPBYTE pbKey = (LPBYTE)pvKey; - DWORD dwHash = 0x7EEE7EEE; - - // Construct the hash from the first 8 digits - dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ pbKey[0]; - dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ pbKey[1]; - dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ pbKey[2]; - dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ pbKey[3]; - dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ pbKey[4]; - dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ pbKey[5]; - dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ pbKey[6]; - dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ pbKey[7]; - - // Return the hash limited by the table size - return (dwHash % pMap->TableSize); -} - -static DWORD CalcHashIndex_String(PCASC_MAP pMap, const char * szString, const char * szStringEnd) -{ - LPBYTE pbKeyEnd = (LPBYTE)szStringEnd; - LPBYTE pbKey = (LPBYTE)szString; - DWORD dwHash = 0x7EEE7EEE; - - // Hash the string itself - while(pbKey < pbKeyEnd) - { - dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ AsciiToUpperTable_BkSlash[pbKey[0]]; - pbKey++; - } - - // Return the hash limited by the table size - return (dwHash % pMap->TableSize); -} - -static bool CompareObject_Key(PCASC_MAP pMap, void * pvObject, void * pvKey) -{ - LPBYTE pbObjectKey = (LPBYTE)pvObject + pMap->KeyOffset; - - return (memcmp(pbObjectKey, pvKey, pMap->KeyLength) == 0); -} - -static bool CompareObject_String( - PCASC_MAP pMap, - const char * szExistingString, - const char * szString, - const char * szStringEnd) -{ - // Keep compiler happy - CASCLIB_UNUSED(pMap); - - // Compare the whole part, case insensitive - while(szString < szStringEnd) - { - if(AsciiToUpperTable_BkSlash[*szExistingString] != AsciiToUpperTable_BkSlash[*szString]) - return false; - - szExistingString++; - szString++; - } - - return true; -} - -//----------------------------------------------------------------------------- -// Public functions - -PCASC_MAP Map_Create(DWORD dwMaxItems, DWORD dwKeyLength, DWORD dwKeyOffset) -{ - PCASC_MAP pMap; - size_t cbToAllocate; - size_t dwTableSize; - - // Calculate the size of the table - dwTableSize = (dwMaxItems * 3 / 2) | 0x01; - - // Allocate new map for the objects - cbToAllocate = sizeof(CASC_MAP) + (dwTableSize * sizeof(void *)); - pMap = (PCASC_MAP)CASC_ALLOC(LPBYTE, cbToAllocate); - if(pMap != NULL) - { - memset(pMap, 0, cbToAllocate); - pMap->KeyLength = dwKeyLength; - pMap->TableSize = dwTableSize; - pMap->KeyOffset = dwKeyOffset; - } - - // Return the allocated map - return pMap; -} - -size_t Map_EnumObjects(PCASC_MAP pMap, void **ppvArray) -{ - size_t nIndex = 0; - - // Verify pointer to the map - if(pMap != NULL && ppvArray != NULL) - { - // Enumerate all items in main table - for(size_t i = 0; i < pMap->TableSize; i++) - { - // Is that cell valid? - if(pMap->HashTable[i] != NULL) - { - ppvArray[nIndex++] = pMap->HashTable[i]; - } - } - - return pMap->ItemCount; - } - - return 0; -} - -void * Map_FindObject(PCASC_MAP pMap, void * pvKey, PDWORD PtrIndex) -{ - void * pvObject; - DWORD dwHashIndex; - - // Verify pointer to the map - if(pMap != NULL) - { - // Construct the main index - dwHashIndex = CalcHashIndex_Key(pMap, pvKey); - while(pMap->HashTable[dwHashIndex] != NULL) - { - // Get the pointer at that position - pvObject = pMap->HashTable[dwHashIndex]; - - // Compare the hash - if(CompareObject_Key(pMap, pvObject, pvKey)) - { - if(PtrIndex != NULL) - PtrIndex[0] = dwHashIndex; - return pvObject; - } - - // Move to the next entry - dwHashIndex = (dwHashIndex + 1) % pMap->TableSize; - } - } - - // Not found, sorry - return NULL; -} - -bool Map_InsertObject(PCASC_MAP pMap, void * pvNewObject, void * pvKey) -{ - void * pvExistingObject; - DWORD dwHashIndex; - - // Verify pointer to the map - if(pMap != NULL) - { - // Limit check - if((pMap->ItemCount + 1) >= pMap->TableSize) - return false; - - // Construct the hash index - dwHashIndex = CalcHashIndex_Key(pMap, pvKey); - while(pMap->HashTable[dwHashIndex] != NULL) - { - // Get the pointer at that position - pvExistingObject = pMap->HashTable[dwHashIndex]; - - // Check if hash being inserted conflicts with an existing hash - if(CompareObject_Key(pMap, pvExistingObject, pvKey)) - return false; - - // Move to the next entry - dwHashIndex = (dwHashIndex + 1) % pMap->TableSize; - } - - // Insert at that position - pMap->HashTable[dwHashIndex] = pvNewObject; - pMap->ItemCount++; - return true; - } - - // Failed - return false; -} - -bool Map_InsertString(PCASC_MAP pMap, const char * szString, bool bCutExtension) -{ - const char * szExistingString; - const char * szStringEnd = NULL; - DWORD dwHashIndex; - - // Verify pointer to the map - if(pMap != NULL) - { - // Limit check - if((pMap->ItemCount + 1) >= pMap->TableSize) - return false; - - // Retrieve the length of the string without extension - if(bCutExtension) - szStringEnd = String_GetExtension(szString); - if(szStringEnd == NULL) - szStringEnd = szString + strlen(szString); - - // Construct the hash index - dwHashIndex = CalcHashIndex_String(pMap, szString, szStringEnd); - while(pMap->HashTable[dwHashIndex] != NULL) - { - // Get the pointer at that position - szExistingString = (const char *)pMap->HashTable[dwHashIndex]; - - // Check if hash being inserted conflicts with an existing hash - if(CompareObject_String(pMap, szExistingString, szString, szStringEnd)) - return false; - - // Move to the next entry - dwHashIndex = (dwHashIndex + 1) % pMap->TableSize; - } - - // Insert at that position - pMap->HashTable[dwHashIndex] = (void *)szString; - pMap->ItemCount++; - return true; - } - - // Failed - return false; -} - -const char * Map_FindString(PCASC_MAP pMap, const char * szString, const char * szStringEnd) -{ - const char * szExistingString; - DWORD dwHashIndex; - - // Verify pointer to the map - if(pMap != NULL) - { - // Construct the main index - dwHashIndex = CalcHashIndex_String(pMap, szString, szStringEnd); - while(pMap->HashTable[dwHashIndex] != NULL) - { - // Get the pointer at that position - szExistingString = (const char *)pMap->HashTable[dwHashIndex]; - - // Compare the hash - if(CompareObject_String(pMap, szExistingString, szString, szStringEnd)) - return szExistingString; - - // Move to the next entry - dwHashIndex = (dwHashIndex + 1) % pMap->TableSize; - } - } - - // Not found, sorry - return NULL; -} - -void Map_Free(PCASC_MAP pMap) -{ - if(pMap != NULL) - { - CASC_FREE(pMap); - } -} diff --git a/dep/CascLib/src/common/Map.h b/dep/CascLib/src/common/Map.h index 2b590578105..13799eb0528 100644 --- a/dep/CascLib/src/common/Map.h +++ b/dep/CascLib/src/common/Map.h @@ -8,35 +8,355 @@ /* 10.06.14 1.00 Lad The first version of Map.h */ /*****************************************************************************/ -#ifndef __HASHTOPTR_H__ -#define __HASHTOPTR_H__ +#ifndef __CASC_MAP_H__ +#define __CASC_MAP_H__ //----------------------------------------------------------------------------- // Structures -#define KEY_LENGTH_STRING 0xFFFFFFFF // Pass this to Map_Create as dwKeyLength when you want map of string->object +#define MIN_HASH_TABLE_SIZE 0x00000100 // The smallest size of the hash table. +#define MAX_HASH_TABLE_SIZE 0x00800000 // The largest size of the hash table. Should be enough for any game. -typedef struct _CASC_MAP +typedef int (*PFNCOMPAREFUNC)(const void * pvObjectKey, const void * pvKey, size_t nKeyLength); +typedef DWORD (*PFNHASHFUNC)(void * pvKey, size_t nKeyLength); + +typedef enum _KEY_TYPE +{ + KeyIsHash, // Use when the key is already a hash. If specified, the map will not hash the key + KeyIsArbitrary, // The key is an arbitrary array of bytes. The map will hash it to get a map index + KeyIsString // Use when the key is a string +} KEY_TYPE, *PKEY_TYPE; + +#define KEY_LENGTH_STRING 0xFFFFFFFF + +//----------------------------------------------------------------------------- +// Hashing functions + +// Used when the key is a hash already - no need to hash it again +inline DWORD CalcHashValue_Hash(void * pvKey, size_t /* nKeyLength */) +{ + // Get the hash directly as value + return ConvertBytesToInteger_4((LPBYTE)pvKey); +} + +// Calculates hash value from a key +inline DWORD CalcHashValue_Key(void * pvKey, size_t nKeyLength) { - size_t TableSize; - size_t ItemCount; // Number of items in the map - size_t KeyOffset; // How far is the hash from the begin of the structure (in bytes) - size_t KeyLength; // Length of the hash key - void * HashTable[1]; // Pointer table + LPBYTE pbKey = (LPBYTE)pvKey; + DWORD dwHash = 0x7EEE7EEE; -} CASC_MAP, *PCASC_MAP; + // Construct the hash from the key + for(DWORD i = 0; i < nKeyLength; i++) + dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ pbKey[i]; -typedef bool (*MAP_COMPARE)(PCASC_MAP pMap, void * pvObject, void * pvKey); + // Return the hash limited by the table size + return dwHash; +} + +// Calculates hash value from a string +inline DWORD CalcHashValue_String(const char * szString, const char * szStringEnd) +{ + LPBYTE pbKeyEnd = (LPBYTE)szStringEnd; + LPBYTE pbKey = (LPBYTE)szString; + DWORD dwHash = 0x7EEE7EEE; + + // Hash the string itself + while(pbKey < pbKeyEnd) + { + dwHash = (dwHash >> 24) ^ (dwHash << 5) ^ dwHash ^ AsciiToUpperTable_BkSlash[pbKey[0]]; + pbKey++; + } + + // Return the hash limited by the table size + return dwHash; +} //----------------------------------------------------------------------------- -// Functions +// Map implementation + +class CASC_MAP +{ + public: + + CASC_MAP() + { + PfnCalcHashValue = NULL; + m_HashTable = NULL; + m_HashTableSize = 0; + m_ItemCount = 0; + m_KeyOffset = 0; + m_KeyLength = 0; + m_bKeyIsHash = false; + } + + ~CASC_MAP() + { + Free(); + } + + int Create(size_t MaxItems, size_t KeyLength, size_t KeyOffset, KEY_TYPE KeyType = KeyIsHash) + { + // Set the class variables + m_KeyLength = CASCLIB_MAX(KeyLength, 8); + m_KeyOffset = KeyOffset; + m_ItemCount = 0; + + // Setup the hashing function + switch(KeyType) + { + case KeyIsHash: + PfnCalcHashValue = CalcHashValue_Hash; + break; + + case KeyIsArbitrary: + PfnCalcHashValue = CalcHashValue_Key; + break; + + case KeyIsString: + PfnCalcHashValue = NULL; + break; + + default: + assert(false); + return ERROR_NOT_SUPPORTED; + } + + // Calculate the hash table size. Take 133% of the item count and round it up to the next power of two + // This will make the hash table indexes somewhat more resilient against count changes and will make + // e.g. file order in the file tree more stable. + m_HashTableSize = GetNearestPowerOfTwo(MaxItems * 4 / 3); + if(m_HashTableSize == 0) + return ERROR_NOT_ENOUGH_MEMORY; + + // Allocate new map for the objects + m_HashTable = (void **)CASC_ALLOC(void *, m_HashTableSize); + if(m_HashTable == NULL) + return ERROR_NOT_ENOUGH_MEMORY; + + // Initialize the map object + memset(m_HashTable, 0, m_HashTableSize * sizeof(void *)); + return ERROR_SUCCESS; + } + + void * FindObject(void * pvKey, PDWORD PtrIndex = NULL) + { + void * pvObject; + DWORD dwHashIndex; + + // Verify pointer to the map + if(m_HashTable != NULL) + { + // Construct the hash index + dwHashIndex = HashToIndex(PfnCalcHashValue(pvKey, m_KeyLength)); + + // Search the hash table + while((pvObject = m_HashTable[dwHashIndex]) != NULL) + { + // Compare the hash + if(CompareObject_Key(pvObject, pvKey)) + { + if(PtrIndex != NULL) + PtrIndex[0] = dwHashIndex; + return pvObject; + } + + // Move to the next entry + dwHashIndex = HashToIndex(dwHashIndex + 1); + } + } + + // Not found, sorry + return NULL; + } + + bool InsertObject(void * pvNewObject, void * pvKey) + { + void * pvExistingObject; + DWORD dwHashIndex; + + // Verify pointer to the map + if(m_HashTable != NULL) + { + // Limit check + if((m_ItemCount + 1) >= m_HashTableSize) + return false; + + // Construct the hash index + dwHashIndex = HashToIndex(PfnCalcHashValue(pvKey, m_KeyLength)); + + // Search the hash table + while((pvExistingObject = m_HashTable[dwHashIndex]) != NULL) + { + // Check if hash being inserted conflicts with an existing hash + if(CompareObject_Key(pvExistingObject, pvKey)) + return false; + + // Move to the next entry + dwHashIndex = HashToIndex(dwHashIndex + 1); + } + + // Insert at that position + m_HashTable[dwHashIndex] = pvNewObject; + m_ItemCount++; + return true; + } + + // Failed + return false; + } + + const char * FindString(const char * szString, const char * szStringEnd) + { + const char * szExistingString; + DWORD dwHashIndex; + + // Verify pointer to the map + if(m_HashTable != NULL) + { + // Construct the main index + dwHashIndex = HashToIndex(CalcHashValue_String(szString, szStringEnd)); + + // Search the hash table + while((szExistingString = (const char *)m_HashTable[dwHashIndex]) != NULL) + { + // Compare the hash + if(CompareObject_String(szExistingString, szString, szStringEnd)) + return szExistingString; + + // Move to the next entry + dwHashIndex = HashToIndex(dwHashIndex + 1); + } + } + + // Not found, sorry + return NULL; + } + + bool InsertString(const char * szString, bool bCutExtension) + { + const char * szExistingString; + const char * szStringEnd = NULL; + DWORD dwHashIndex; + + // Verify pointer to the map + if(m_HashTable != NULL) + { + // Limit check + if((m_ItemCount + 1) >= m_HashTableSize) + return false; + + // Retrieve the length of the string without extension + if(bCutExtension) + szStringEnd = GetFileExtension(szString); + else + szStringEnd = szString + strlen(szString); + + // Construct the hash index + dwHashIndex = HashToIndex(CalcHashValue_String(szString, szStringEnd)); + + // Search the hash table + while((szExistingString = (const char *)m_HashTable[dwHashIndex]) != NULL) + { + // Check if hash being inserted conflicts with an existing hash + if(CompareObject_String(szExistingString, szString, szStringEnd)) + return false; + + // Move to the next entry + dwHashIndex = HashToIndex(dwHashIndex + 1); + } + + // Insert at that position + m_HashTable[dwHashIndex] = (void *)szString; + m_ItemCount++; + return true; + } + + // Failed + return false; + } + + void * ItemAt(size_t nIndex) + { + assert(nIndex < m_HashTableSize); + return m_HashTable[nIndex]; + } + + size_t HashTableSize() + { + return m_HashTableSize; + } + + size_t ItemCount() + { + return m_ItemCount; + } + + bool IsInitialized() + { + return (m_HashTable && m_HashTableSize); + } + + void Free() + { + PfnCalcHashValue = NULL; + CASC_FREE(m_HashTable); + m_HashTableSize = 0; + } + + protected: + + DWORD HashToIndex(DWORD HashValue) + { + return HashValue & (m_HashTableSize - 1); + } + + bool CompareObject_Key(void * pvObject, void * pvKey) + { + LPBYTE pbObjectKey = (LPBYTE)pvObject + m_KeyOffset; + return (memcmp(pbObjectKey, pvKey, m_KeyLength) == 0); + } + + bool CompareObject_String(const char * szExistingString, const char * szString, const char * szStringEnd) + { + // Compare the whole part, case insensitive + while(szString < szStringEnd) + { + if(AsciiToUpperTable_BkSlash[*szExistingString] != AsciiToUpperTable_BkSlash[*szString]) + return false; + + szExistingString++; + szString++; + } + + return true; + } + + size_t GetNearestPowerOfTwo(size_t MaxItems) + { + size_t PowerOfTwo; + + // Round the hash table size up to the nearest power of two + for(PowerOfTwo = MIN_HASH_TABLE_SIZE; PowerOfTwo < MAX_HASH_TABLE_SIZE; PowerOfTwo <<= 1) + { + if(PowerOfTwo > MaxItems) + { + return PowerOfTwo; + } + } + + // If the hash table is too big, we cannot create the map + assert(false); + return 0; + } -PCASC_MAP Map_Create(DWORD dwMaxItems, DWORD dwKeyLength, DWORD dwKeyOffset); -size_t Map_EnumObjects(PCASC_MAP pMap, void **ppvArray); -void * Map_FindObject(PCASC_MAP pMap, void * pvKey, PDWORD PtrIndex); -bool Map_InsertObject(PCASC_MAP pMap, void * pvNewObject, void * pvKey); -const char * Map_FindString(PCASC_MAP pMap, const char * szString, const char * szStringEnd); -bool Map_InsertString(PCASC_MAP pMap, const char * szString, bool bCutExtension); -void Map_Free(PCASC_MAP pMap); + PFNHASHFUNC PfnCalcHashValue; + void ** m_HashTable; // Hash table + size_t m_HashTableSize; // Size of the hash table, in entries. Always a power of two. + size_t m_ItemCount; // Number of objects in the map + size_t m_KeyOffset; // How far is the hash from the begin of the objects (in bytes) + size_t m_KeyLength; // Length of the hash key, in bytes + bool m_bKeyIsHash; // If set, then it means that the key is a hash of some sort. + // Will improve performance, as we will not hash a hash :-) +}; -#endif // __HASHTOPTR_H__ +#endif // __CASC_MAP_H__ diff --git a/dep/CascLib/src/common/RootHandler.cpp b/dep/CascLib/src/common/RootHandler.cpp index 4baeb41a421..89b693f55cb 100644 --- a/dep/CascLib/src/common/RootHandler.cpp +++ b/dep/CascLib/src/common/RootHandler.cpp @@ -13,76 +13,105 @@ #include "../CascCommon.h" //----------------------------------------------------------------------------- -// Common support +// Constructor and destructor - TFileTreeRoot -int RootHandler_Insert(TRootHandler * pRootHandler, const char * szFileName, LPBYTE pbEncodingKey) +TFileTreeRoot::TFileTreeRoot(DWORD FileTreeFlags) : TRootHandler() { - if(pRootHandler == NULL || pRootHandler->Insert == NULL || pbEncodingKey == NULL) - return ERROR_NOT_SUPPORTED; + // Initialize the file tree + FileTree.Create(FileTreeFlags); +} - return pRootHandler->Insert(pRootHandler, szFileName, pbEncodingKey); +TFileTreeRoot::~TFileTreeRoot() +{ + // Free the file tree + FileTree.Free(); + dwFeatures = 0; } -LPBYTE RootHandler_Search(TRootHandler * pRootHandler, struct _TCascSearch * pSearch, PDWORD PtrFileSize, PDWORD PtrLocaleFlags, PDWORD PtrFileDataId) +//----------------------------------------------------------------------------- +// Virtual functions - TFileTreeRoot + +int TFileTreeRoot::Insert( + const char * szFileName, + PCASC_CKEY_ENTRY pCKeyEntry) { - // Check if the root structure is valid at all - if(pRootHandler == NULL) - return NULL; + PCASC_FILE_NODE pFileNode; - return pRootHandler->Search(pRootHandler, pSearch, PtrFileSize, PtrLocaleFlags, PtrFileDataId); + pFileNode = FileTree.InsertByName(pCKeyEntry, szFileName, FileTree.GetNextFileDataId()); + return (pFileNode != NULL) ? ERROR_SUCCESS : ERROR_CAN_NOT_COMPLETE; } -void RootHandler_EndSearch(TRootHandler * pRootHandler, struct _TCascSearch * pSearch) +PCASC_CKEY_ENTRY TFileTreeRoot::GetFile(TCascStorage * /* hs */, const char * szFileName) { - // Check if the root structure is valid at all - if(pRootHandler != NULL) - { - pRootHandler->EndSearch(pRootHandler, pSearch); - } + PCASC_FILE_NODE pFileNode; + ULONGLONG FileNameHash = CalcFileNameHash(szFileName); + + pFileNode = FileTree.Find(FileNameHash); + return (pFileNode != NULL) ? pFileNode->pCKeyEntry : NULL; } -LPBYTE RootHandler_GetKey(TRootHandler * pRootHandler, const char * szFileName) +PCASC_CKEY_ENTRY TFileTreeRoot::GetFile(TCascStorage * /* hs */, DWORD FileDataId) { - // Check if the root structure is valid at all - if(pRootHandler == NULL) - return NULL; + PCASC_FILE_NODE pFileNode; - return pRootHandler->GetKey(pRootHandler, szFileName); + pFileNode = FileTree.FindById(FileDataId); + return (pFileNode != NULL) ? pFileNode->pCKeyEntry : NULL; } -void RootHandler_Dump(TCascStorage * hs, LPBYTE pbRootHandler, DWORD cbRootHandler, const TCHAR * szNameFormat, const TCHAR * szListFile, int nDumpLevel) +PCASC_CKEY_ENTRY TFileTreeRoot::Search(TCascSearch * pSearch, PCASC_FIND_DATA pFindData) { - TDumpContext * dc; + PCASC_FILE_NODE pFileNode; + size_t nMaxFileIndex = FileTree.GetMaxFileIndex(); - // Only if the ROOT provider suports the dump option - if(hs->pRootHandler != NULL && hs->pRootHandler->Dump != NULL) + // Are we still inside the root directory range? + while(pSearch->nFileIndex < nMaxFileIndex) { - // Create the dump file - dc = CreateDumpContext(hs, szNameFormat); - if(dc != NULL) + //BREAKIF(pSearch->nFileIndex >= 2823765); + + // Retrieve the file item + pFileNode = FileTree.PathAt(pFindData->szFileName, MAX_PATH, pSearch->nFileIndex++); + if(pFileNode != NULL) { - // Dump the content and close the file - hs->pRootHandler->Dump(hs, dc, pbRootHandler, cbRootHandler, szListFile, nDumpLevel); - dump_close(dc); + // Ignore folders and mount points + if(!(pFileNode->Flags & CFN_FLAG_FOLDER)) + { + // Check the wildcard + if (CascCheckWildCard(pFindData->szFileName, pSearch->szMask)) + { + // Retrieve the extra values (FileDataId, file size and locale flags) + FileTree.GetExtras(pFileNode, &pFindData->dwFileDataId, &pFindData->dwLocaleFlags, &pFindData->dwContentFlags); + + // Supply the bCanOpenByDataId variable + pFindData->bCanOpenByName = (pFileNode->FileNameHash != 0); + pFindData->bCanOpenByDataId = (pFindData->dwFileDataId != CASC_INVALID_ID); + + // Return the found CKey entry + return pFileNode->pCKeyEntry; + } + } } } + + // No more entries + return NULL; } -void RootHandler_Close(TRootHandler * pRootHandler) +bool TFileTreeRoot::GetInfo(PCASC_CKEY_ENTRY pCKeyEntry, PCASC_FILE_FULL_INFO pFileInfo) { - // Check if the root structure is allocated at all - if(pRootHandler != NULL) + PCASC_FILE_NODE pFileNode; + + // Can't do much if the root key is NULL + if(pCKeyEntry != NULL) { - pRootHandler->Close(pRootHandler); + pFileNode = FileTree.Find(pCKeyEntry); + if(pFileNode != NULL) + { + FileTree.GetExtras(pFileNode, &pFileInfo->FileDataId, &pFileInfo->LocaleFlags, &pFileInfo->ContentFlags); + pFileInfo->FileNameHash = pFileNode->FileNameHash; + return true; + } } -} - -DWORD RootHandler_GetFileId(TRootHandler * pRootHandler, const char * szFileName) -{ - // Check if the root structure is valid at all - if(pRootHandler == NULL) - return 0; - return pRootHandler->GetFileId(pRootHandler, szFileName); + return false; } diff --git a/dep/CascLib/src/common/RootHandler.h b/dep/CascLib/src/common/RootHandler.h index d1b66e501d8..4e56650b034 100644 --- a/dep/CascLib/src/common/RootHandler.h +++ b/dep/CascLib/src/common/RootHandler.h @@ -15,82 +15,97 @@ // Defines #define CASC_MNDX_ROOT_SIGNATURE 0x58444E4D // 'MNDX' +#define CASC_TVFS_ROOT_SIGNATURE 0x53465654 // 'TVFS' #define CASC_DIABLO3_ROOT_SIGNATURE 0x8007D0C4 -#define CASC_OVERWATCH_ROOT_SIGNATURE 0x35444D23 // '#MD5' +#define CASC_WOW82_ROOT_SIGNATURE 0x4D465354 // 'TSFM', WoW since 8.2 -#define ROOT_FLAG_HAS_NAMES 0x00000001 // The root file contains file names - -#define DUMP_LEVEL_ROOT_FILE 1 // Dump root file -#define DUMP_LEVEL_ENCODING_FILE 2 // Dump root file + encoding file -#define DUMP_LEVEL_INDEX_ENTRIES 3 // Dump root file + encoding file + index entries +#define DUMP_LEVEL_ROOT_FILE 1 // Dump root file +#define DUMP_LEVEL_ENCODING_FILE 2 // Dump root file + encoding file +#define DUMP_LEVEL_INDEX_ENTRIES 3 // Dump root file + encoding file + index entries //----------------------------------------------------------------------------- -// Root file function prototypes - -typedef int (*ROOT_INSERT)( - struct TRootHandler * pRootHandler, // Pointer to an initialized root handler - const char * szFileName, // Pointer to the file name - LPBYTE pbEncodingKey // Pointer to the encoding key of the file name - ); - -typedef LPBYTE (*ROOT_SEARCH)( - struct TRootHandler * pRootHandler, // Pointer to an initialized root handler - struct _TCascSearch * pSearch, // Pointer to the initialized search structure - PDWORD PtrFileSize, // Pointer to receive file size (optional) - PDWORD PtrLocaleFlags, // Pointer to receive locale flags (optional) - PDWORD PtrFileDataId // Pointer to FileDataID (optional) - ); - -typedef void (*ROOT_ENDSEARCH)( - struct TRootHandler * pRootHandler, // Pointer to an initialized root handler - struct _TCascSearch * pSearch // Pointer to the initialized search structure - ); - -typedef LPBYTE (*ROOT_GETKEY)( - struct TRootHandler * pRootHandler, // Pointer to an initialized root handler - const char * szFileName // Pointer to the name of a file - ); - -typedef void (*ROOT_DUMP)( - struct _TCascStorage * hs, // Pointer to the open storage - TDumpContext * dc, // Opened dump context - LPBYTE pbRootHandler, // Pointer to the loaded ROOT file - DWORD cbRootHandler, // Length of the loaded ROOT file - const TCHAR * szListFile, - int nDumpLevel - ); - -typedef void (*ROOT_CLOSE)( - struct TRootHandler * pRootHandler // Pointer to an initialized root handler - ); - -typedef DWORD(*ROOT_GETFILEID)( -struct TRootHandler * pRootHandler, // Pointer to an initialized root handler - const char * szFileName // Pointer to the name of a file - ); +// Class for generic root handler struct TRootHandler { - ROOT_INSERT Insert; // Inserts an existing file name - ROOT_SEARCH Search; // Performs the root file search - ROOT_ENDSEARCH EndSearch; // Performs cleanup after searching - ROOT_GETKEY GetKey; // Retrieves encoding key for a file name - ROOT_DUMP Dump; - ROOT_CLOSE Close; // Closing the root file - ROOT_GETFILEID GetFileId; // Returns File Id for a given Filename - - DWORD dwRootFlags; // Root flags - see the ROOT_FLAG_XXX + public: + + TRootHandler() + { + dwFeatures = 0; + } + + virtual ~TRootHandler() + {} + + // Inserts new file name to the root handler + // szFileName - Pointer to the file name + // pCKeyEntry - Pointer to the CASC_CKEY_ENTRY for the file + virtual int Insert(const char * /* szFileName */, PCASC_CKEY_ENTRY /* pCKeyEntry */) + { + return ERROR_NOT_SUPPORTED; + } + + // Searches the file by file name + // hs - Pointer to the storage structure + // szFileName - Pointer to the file name + virtual PCASC_CKEY_ENTRY GetFile(struct TCascStorage * /* hs */, const char * /* szFileName */) + { + return NULL; + } + + // Searches the file by file data id + // hs - Pointer to the storage structure + // FileDataId - File data id + virtual PCASC_CKEY_ENTRY GetFile(struct TCascStorage * /* hs */, DWORD /* FileDataId */) + { + return NULL; + } + + // Performs find-next-file operation + // pSearch - Pointer to the initialized search structure + // pFindData - Pointer to output structure that will contain the information + virtual PCASC_CKEY_ENTRY Search(struct TCascSearch * /* pSearch */, struct _CASC_FIND_DATA * /* pFindData */) + { + return NULL; + } + + // Returns advanced info from the root file entry. + // pCKeyEntry - CKey/EKey, depending on which type the root handler provides + // pFileInfo - Pointer to CASC_FILE_FULL_INFO structure + virtual bool GetInfo(PCASC_CKEY_ENTRY /* pCKeyEntry */, struct _CASC_FILE_FULL_INFO * /* pFileInfo */) + { + return false; + } + + DWORD GetFeatures() + { + return dwFeatures; + } + + protected: + + DWORD dwFeatures; // CASC features. See CASC_FEATURE_XXX }; //----------------------------------------------------------------------------- -// Public functions - -int RootHandler_Insert(TRootHandler * pRootHandler, const char * szFileName, LPBYTE pbEncodingKey); -LPBYTE RootHandler_Search(TRootHandler * pRootHandler, struct _TCascSearch * pSearch, PDWORD PtrFileSize, PDWORD PtrLocaleFlags, PDWORD PtrFileDataId); -void RootHandler_EndSearch(TRootHandler * pRootHandler, struct _TCascSearch * pSearch); -LPBYTE RootHandler_GetKey(TRootHandler * pRootHandler, const char * szFileName); -void RootHandler_Dump(struct _TCascStorage * hs, LPBYTE pbRootHandler, DWORD cbRootHandler, const TCHAR * szNameFormat, const TCHAR * szListFile, int nDumpLevel); -void RootHandler_Close(TRootHandler * pRootHandler); -DWORD RootHandler_GetFileId(TRootHandler * pRootHandler, const char * szFileName); +// Class for root handler that has basic mapping of FileName -> CASC_FILE_NODE + +struct TFileTreeRoot : public TRootHandler +{ + TFileTreeRoot(DWORD FileTreeFlags); + virtual ~TFileTreeRoot(); + + int Insert(const char * szFileName, PCASC_CKEY_ENTRY pCKeyEntry); + + PCASC_CKEY_ENTRY GetFile(struct TCascStorage * hs, const char * szFileName); + PCASC_CKEY_ENTRY GetFile(struct TCascStorage * hs, DWORD FileDataId); + PCASC_CKEY_ENTRY Search(struct TCascSearch * pSearch, struct _CASC_FIND_DATA * pFindData); + bool GetInfo(PCASC_CKEY_ENTRY pCKeyEntry, struct _CASC_FILE_FULL_INFO * pFileInfo); + + protected: + + CASC_FILE_TREE FileTree; +}; #endif // __ROOT_HANDLER_H__ diff --git a/dep/CascLib/src/libtomcrypt/src/hashes/hash_memory.c b/dep/CascLib/src/libtomcrypt/src/hashes/hash_memory.c deleted file mode 100644 index 1daf0bffa1b..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/hashes/hash_memory.c +++ /dev/null @@ -1,69 +0,0 @@ -/* LibTomCrypt, modular cryptographic library -- Tom St Denis - * - * LibTomCrypt is a library that provides various cryptographic - * algorithms in a highly modular and flexible manner. - * - * The library is free for all purposes without any express - * guarantee it works. - * - * Tom St Denis, tomstdenis@gmail.com, http://libtom.org - */ -#include "../headers/tomcrypt.h" - -/** - @file hash_memory.c - Hash memory helper, Tom St Denis -*/ - -/** - Hash a block of memory and store the digest. - @param hash The index of the hash you wish to use - @param in The data you wish to hash - @param inlen The length of the data to hash (octets) - @param out [out] Where to store the digest - @param outlen [in/out] Max size and resulting size of the digest - @return CRYPT_OK if successful -*/ -int hash_memory(int hash, const unsigned char *in, unsigned long inlen, unsigned char *out, unsigned long *outlen) -{ - hash_state *md; - int err; - - LTC_ARGCHK(in != NULL); - LTC_ARGCHK(out != NULL); - LTC_ARGCHK(outlen != NULL); - - if ((err = hash_is_valid(hash)) != CRYPT_OK) { - return err; - } - - if (*outlen < hash_descriptor[hash].hashsize) { - *outlen = hash_descriptor[hash].hashsize; - return CRYPT_BUFFER_OVERFLOW; - } - - md = XMALLOC(sizeof(hash_state)); - if (md == NULL) { - return CRYPT_MEM; - } - - if ((err = hash_descriptor[hash].init(md)) != CRYPT_OK) { - goto LBL_ERR; - } - if ((err = hash_descriptor[hash].process(md, in, inlen)) != CRYPT_OK) { - goto LBL_ERR; - } - err = hash_descriptor[hash].done(md, out); - *outlen = hash_descriptor[hash].hashsize; -LBL_ERR: -#ifdef LTC_CLEAN_STACK - zeromem(md, sizeof(hash_state)); -#endif - XFREE(md); - - return err; -} - -/* $Source: /cvs/libtom/libtomcrypt/src/hashes/helper/hash_memory.c,v $ */ -/* $Revision: 1.6 $ */ -/* $Date: 2006/12/28 01:27:23 $ */ diff --git a/dep/CascLib/src/libtomcrypt/src/hashes/md5.c b/dep/CascLib/src/libtomcrypt/src/hashes/md5.c deleted file mode 100644 index e92da256d56..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/hashes/md5.c +++ /dev/null @@ -1,368 +0,0 @@ -/* LibTomCrypt, modular cryptographic library -- Tom St Denis - * - * LibTomCrypt is a library that provides various cryptographic - * algorithms in a highly modular and flexible manner. - * - * The library is free for all purposes without any express - * guarantee it works. - * - * Tom St Denis, tomstdenis@gmail.com, http://libtom.org - */ -#include "../headers/tomcrypt.h" - - -/** - @file md5.c - LTC_MD5 hash function by Tom St Denis -*/ - -#ifdef LTC_MD5 - -const struct ltc_hash_descriptor md5_desc = -{ - "md5", - 3, - 16, - 64, - - /* OID */ - { 1, 2, 840, 113549, 2, 5, }, - 6, - - &md5_init, - &md5_process, - &md5_done, - &md5_test, - NULL -}; - -#define F(x,y,z) (z ^ (x & (y ^ z))) -#define G(x,y,z) (y ^ (z & (y ^ x))) -#define H(x,y,z) (x^y^z) -#define I(x,y,z) (y^(x|(~z))) - -#ifdef LTC_SMALL_CODE - -#define FF(a,b,c,d,M,s,t) \ - a = (a + F(b,c,d) + M + t); a = ROL(a, s) + b; - -#define GG(a,b,c,d,M,s,t) \ - a = (a + G(b,c,d) + M + t); a = ROL(a, s) + b; - -#define HH(a,b,c,d,M,s,t) \ - a = (a + H(b,c,d) + M + t); a = ROL(a, s) + b; - -#define II(a,b,c,d,M,s,t) \ - a = (a + I(b,c,d) + M + t); a = ROL(a, s) + b; - -static const unsigned char Worder[64] = { - 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, - 1,6,11,0,5,10,15,4,9,14,3,8,13,2,7,12, - 5,8,11,14,1,4,7,10,13,0,3,6,9,12,15,2, - 0,7,14,5,12,3,10,1,8,15,6,13,4,11,2,9 -}; - -static const unsigned char Rorder[64] = { - 7,12,17,22,7,12,17,22,7,12,17,22,7,12,17,22, - 5,9,14,20,5,9,14,20,5,9,14,20,5,9,14,20, - 4,11,16,23,4,11,16,23,4,11,16,23,4,11,16,23, - 6,10,15,21,6,10,15,21,6,10,15,21,6,10,15,21 -}; - -static const ulong32 Korder[64] = { -0xd76aa478UL, 0xe8c7b756UL, 0x242070dbUL, 0xc1bdceeeUL, 0xf57c0fafUL, 0x4787c62aUL, 0xa8304613UL, 0xfd469501UL, -0x698098d8UL, 0x8b44f7afUL, 0xffff5bb1UL, 0x895cd7beUL, 0x6b901122UL, 0xfd987193UL, 0xa679438eUL, 0x49b40821UL, -0xf61e2562UL, 0xc040b340UL, 0x265e5a51UL, 0xe9b6c7aaUL, 0xd62f105dUL, 0x02441453UL, 0xd8a1e681UL, 0xe7d3fbc8UL, -0x21e1cde6UL, 0xc33707d6UL, 0xf4d50d87UL, 0x455a14edUL, 0xa9e3e905UL, 0xfcefa3f8UL, 0x676f02d9UL, 0x8d2a4c8aUL, -0xfffa3942UL, 0x8771f681UL, 0x6d9d6122UL, 0xfde5380cUL, 0xa4beea44UL, 0x4bdecfa9UL, 0xf6bb4b60UL, 0xbebfbc70UL, -0x289b7ec6UL, 0xeaa127faUL, 0xd4ef3085UL, 0x04881d05UL, 0xd9d4d039UL, 0xe6db99e5UL, 0x1fa27cf8UL, 0xc4ac5665UL, -0xf4292244UL, 0x432aff97UL, 0xab9423a7UL, 0xfc93a039UL, 0x655b59c3UL, 0x8f0ccc92UL, 0xffeff47dUL, 0x85845dd1UL, -0x6fa87e4fUL, 0xfe2ce6e0UL, 0xa3014314UL, 0x4e0811a1UL, 0xf7537e82UL, 0xbd3af235UL, 0x2ad7d2bbUL, 0xeb86d391UL -}; - -#else - -#define FF(a,b,c,d,M,s,t) \ - a = (a + F(b,c,d) + M + t); a = ROLc(a, s) + b; - -#define GG(a,b,c,d,M,s,t) \ - a = (a + G(b,c,d) + M + t); a = ROLc(a, s) + b; - -#define HH(a,b,c,d,M,s,t) \ - a = (a + H(b,c,d) + M + t); a = ROLc(a, s) + b; - -#define II(a,b,c,d,M,s,t) \ - a = (a + I(b,c,d) + M + t); a = ROLc(a, s) + b; - - -#endif - -#ifdef LTC_CLEAN_STACK -static int _md5_compress(hash_state *md, unsigned char *buf) -#else -static int md5_compress(hash_state *md, unsigned char *buf) -#endif -{ - ulong32 i, W[16], a, b, c, d; -#ifdef LTC_SMALL_CODE - ulong32 t; -#endif - - /* copy the state into 512-bits into W[0..15] */ - for (i = 0; i < 16; i++) { - LOAD32L(W[i], buf + (4*i)); - } - - /* copy state */ - a = md->md5.state[0]; - b = md->md5.state[1]; - c = md->md5.state[2]; - d = md->md5.state[3]; - -#ifdef LTC_SMALL_CODE - for (i = 0; i < 16; ++i) { - FF(a,b,c,d,W[Worder[i]],Rorder[i],Korder[i]); - t = d; d = c; c = b; b = a; a = t; - } - - for (; i < 32; ++i) { - GG(a,b,c,d,W[Worder[i]],Rorder[i],Korder[i]); - t = d; d = c; c = b; b = a; a = t; - } - - for (; i < 48; ++i) { - HH(a,b,c,d,W[Worder[i]],Rorder[i],Korder[i]); - t = d; d = c; c = b; b = a; a = t; - } - - for (; i < 64; ++i) { - II(a,b,c,d,W[Worder[i]],Rorder[i],Korder[i]); - t = d; d = c; c = b; b = a; a = t; - } - -#else - FF(a,b,c,d,W[0],7,0xd76aa478UL) - FF(d,a,b,c,W[1],12,0xe8c7b756UL) - FF(c,d,a,b,W[2],17,0x242070dbUL) - FF(b,c,d,a,W[3],22,0xc1bdceeeUL) - FF(a,b,c,d,W[4],7,0xf57c0fafUL) - FF(d,a,b,c,W[5],12,0x4787c62aUL) - FF(c,d,a,b,W[6],17,0xa8304613UL) - FF(b,c,d,a,W[7],22,0xfd469501UL) - FF(a,b,c,d,W[8],7,0x698098d8UL) - FF(d,a,b,c,W[9],12,0x8b44f7afUL) - FF(c,d,a,b,W[10],17,0xffff5bb1UL) - FF(b,c,d,a,W[11],22,0x895cd7beUL) - FF(a,b,c,d,W[12],7,0x6b901122UL) - FF(d,a,b,c,W[13],12,0xfd987193UL) - FF(c,d,a,b,W[14],17,0xa679438eUL) - FF(b,c,d,a,W[15],22,0x49b40821UL) - GG(a,b,c,d,W[1],5,0xf61e2562UL) - GG(d,a,b,c,W[6],9,0xc040b340UL) - GG(c,d,a,b,W[11],14,0x265e5a51UL) - GG(b,c,d,a,W[0],20,0xe9b6c7aaUL) - GG(a,b,c,d,W[5],5,0xd62f105dUL) - GG(d,a,b,c,W[10],9,0x02441453UL) - GG(c,d,a,b,W[15],14,0xd8a1e681UL) - GG(b,c,d,a,W[4],20,0xe7d3fbc8UL) - GG(a,b,c,d,W[9],5,0x21e1cde6UL) - GG(d,a,b,c,W[14],9,0xc33707d6UL) - GG(c,d,a,b,W[3],14,0xf4d50d87UL) - GG(b,c,d,a,W[8],20,0x455a14edUL) - GG(a,b,c,d,W[13],5,0xa9e3e905UL) - GG(d,a,b,c,W[2],9,0xfcefa3f8UL) - GG(c,d,a,b,W[7],14,0x676f02d9UL) - GG(b,c,d,a,W[12],20,0x8d2a4c8aUL) - HH(a,b,c,d,W[5],4,0xfffa3942UL) - HH(d,a,b,c,W[8],11,0x8771f681UL) - HH(c,d,a,b,W[11],16,0x6d9d6122UL) - HH(b,c,d,a,W[14],23,0xfde5380cUL) - HH(a,b,c,d,W[1],4,0xa4beea44UL) - HH(d,a,b,c,W[4],11,0x4bdecfa9UL) - HH(c,d,a,b,W[7],16,0xf6bb4b60UL) - HH(b,c,d,a,W[10],23,0xbebfbc70UL) - HH(a,b,c,d,W[13],4,0x289b7ec6UL) - HH(d,a,b,c,W[0],11,0xeaa127faUL) - HH(c,d,a,b,W[3],16,0xd4ef3085UL) - HH(b,c,d,a,W[6],23,0x04881d05UL) - HH(a,b,c,d,W[9],4,0xd9d4d039UL) - HH(d,a,b,c,W[12],11,0xe6db99e5UL) - HH(c,d,a,b,W[15],16,0x1fa27cf8UL) - HH(b,c,d,a,W[2],23,0xc4ac5665UL) - II(a,b,c,d,W[0],6,0xf4292244UL) - II(d,a,b,c,W[7],10,0x432aff97UL) - II(c,d,a,b,W[14],15,0xab9423a7UL) - II(b,c,d,a,W[5],21,0xfc93a039UL) - II(a,b,c,d,W[12],6,0x655b59c3UL) - II(d,a,b,c,W[3],10,0x8f0ccc92UL) - II(c,d,a,b,W[10],15,0xffeff47dUL) - II(b,c,d,a,W[1],21,0x85845dd1UL) - II(a,b,c,d,W[8],6,0x6fa87e4fUL) - II(d,a,b,c,W[15],10,0xfe2ce6e0UL) - II(c,d,a,b,W[6],15,0xa3014314UL) - II(b,c,d,a,W[13],21,0x4e0811a1UL) - II(a,b,c,d,W[4],6,0xf7537e82UL) - II(d,a,b,c,W[11],10,0xbd3af235UL) - II(c,d,a,b,W[2],15,0x2ad7d2bbUL) - II(b,c,d,a,W[9],21,0xeb86d391UL) -#endif - - md->md5.state[0] = md->md5.state[0] + a; - md->md5.state[1] = md->md5.state[1] + b; - md->md5.state[2] = md->md5.state[2] + c; - md->md5.state[3] = md->md5.state[3] + d; - - return CRYPT_OK; -} - -#ifdef LTC_CLEAN_STACK -static int md5_compress(hash_state *md, unsigned char *buf) -{ - int err; - err = _md5_compress(md, buf); - burn_stack(sizeof(ulong32) * 21); - return err; -} -#endif - -/** - Initialize the hash state - @param md The hash state you wish to initialize - @return CRYPT_OK if successful -*/ -int md5_init(hash_state * md) -{ - LTC_ARGCHK(md != NULL); - md->md5.state[0] = 0x67452301UL; - md->md5.state[1] = 0xefcdab89UL; - md->md5.state[2] = 0x98badcfeUL; - md->md5.state[3] = 0x10325476UL; - md->md5.curlen = 0; - md->md5.length = 0; - return CRYPT_OK; -} - -/** - Process a block of memory though the hash - @param md The hash state - @param in The data to hash - @param inlen The length of the data (octets) - @return CRYPT_OK if successful -*/ -HASH_PROCESS(md5_process, md5_compress, md5, 64) - -/** - Terminate the hash to get the digest - @param md The hash state - @param out [out] The destination of the hash (16 bytes) - @return CRYPT_OK if successful -*/ -int md5_done(hash_state * md, unsigned char *out) -{ - int i; - - LTC_ARGCHK(md != NULL); - LTC_ARGCHK(out != NULL); - - if (md->md5.curlen >= sizeof(md->md5.buf)) { - return CRYPT_INVALID_ARG; - } - - - /* increase the length of the message */ - md->md5.length += md->md5.curlen * 8; - - /* append the '1' bit */ - md->md5.buf[md->md5.curlen++] = (unsigned char)0x80; - - /* if the length is currently above 56 bytes we append zeros - * then compress. Then we can fall back to padding zeros and length - * encoding like normal. - */ - if (md->md5.curlen > 56) { - while (md->md5.curlen < 64) { - md->md5.buf[md->md5.curlen++] = (unsigned char)0; - } - md5_compress(md, md->md5.buf); - md->md5.curlen = 0; - } - - /* pad upto 56 bytes of zeroes */ - while (md->md5.curlen < 56) { - md->md5.buf[md->md5.curlen++] = (unsigned char)0; - } - - /* store length */ - STORE64L(md->md5.length, md->md5.buf+56); - md5_compress(md, md->md5.buf); - - /* copy output */ - for (i = 0; i < 4; i++) { - STORE32L(md->md5.state[i], out+(4*i)); - } -#ifdef LTC_CLEAN_STACK - zeromem(md, sizeof(hash_state)); -#endif - return CRYPT_OK; -} - -/** - Self-test the hash - @return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled -*/ -int md5_test(void) -{ - #ifndef LTC_TEST - return CRYPT_NOP; - #else - static const struct { - char *msg; - unsigned char hash[16]; - } tests[] = { - { "", - { 0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x00, 0xb2, 0x04, - 0xe9, 0x80, 0x09, 0x98, 0xec, 0xf8, 0x42, 0x7e } }, - { "a", - {0x0c, 0xc1, 0x75, 0xb9, 0xc0, 0xf1, 0xb6, 0xa8, - 0x31, 0xc3, 0x99, 0xe2, 0x69, 0x77, 0x26, 0x61 } }, - { "abc", - { 0x90, 0x01, 0x50, 0x98, 0x3c, 0xd2, 0x4f, 0xb0, - 0xd6, 0x96, 0x3f, 0x7d, 0x28, 0xe1, 0x7f, 0x72 } }, - { "message digest", - { 0xf9, 0x6b, 0x69, 0x7d, 0x7c, 0xb7, 0x93, 0x8d, - 0x52, 0x5a, 0x2f, 0x31, 0xaa, 0xf1, 0x61, 0xd0 } }, - { "abcdefghijklmnopqrstuvwxyz", - { 0xc3, 0xfc, 0xd3, 0xd7, 0x61, 0x92, 0xe4, 0x00, - 0x7d, 0xfb, 0x49, 0x6c, 0xca, 0x67, 0xe1, 0x3b } }, - { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", - { 0xd1, 0x74, 0xab, 0x98, 0xd2, 0x77, 0xd9, 0xf5, - 0xa5, 0x61, 0x1c, 0x2c, 0x9f, 0x41, 0x9d, 0x9f } }, - { "12345678901234567890123456789012345678901234567890123456789012345678901234567890", - { 0x57, 0xed, 0xf4, 0xa2, 0x2b, 0xe3, 0xc9, 0x55, - 0xac, 0x49, 0xda, 0x2e, 0x21, 0x07, 0xb6, 0x7a } }, - { NULL, { 0 } } - }; - - int i; - unsigned char tmp[16]; - hash_state md; - - for (i = 0; tests[i].msg != NULL; i++) { - md5_init(&md); - md5_process(&md, (unsigned char *)tests[i].msg, (unsigned long)strlen(tests[i].msg)); - md5_done(&md, tmp); - if (XMEMCMP(tmp, tests[i].hash, 16) != 0) { - return CRYPT_FAIL_TESTVECTOR; - } - } - return CRYPT_OK; - #endif -} - -#endif - - - -/* $Source: /cvs/libtom/libtomcrypt/src/hashes/md5.c,v $ */ -/* $Revision: 1.10 $ */ -/* $Date: 2007/05/12 14:25:28 $ */ diff --git a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt.h b/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt.h deleted file mode 100644 index 74cdff47549..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt.h +++ /dev/null @@ -1,87 +0,0 @@ -#ifndef TOMCRYPT_H_ -#define TOMCRYPT_H_ -#include <assert.h> -#include <stdio.h> -#include <string.h> -#include <stdlib.h> -#include <time.h> -#include <ctype.h> -#include <limits.h> - -/* use configuration data */ -#include "tomcrypt_custom.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* version */ -#define CRYPT 0x0117 -#define SCRYPT "1.17" - -/* max size of either a cipher/hash block or symmetric key [largest of the two] */ -#define MAXBLOCKSIZE 128 - -/* descriptor table size */ -#define TAB_SIZE 32 - -/* error codes [will be expanded in future releases] */ -enum { - CRYPT_OK=0, /* Result OK */ - CRYPT_ERROR, /* Generic Error */ - CRYPT_NOP, /* Not a failure but no operation was performed */ - - CRYPT_INVALID_KEYSIZE, /* Invalid key size given */ - CRYPT_INVALID_ROUNDS, /* Invalid number of rounds */ - CRYPT_FAIL_TESTVECTOR, /* Algorithm failed test vectors */ - - CRYPT_BUFFER_OVERFLOW, /* Not enough space for output */ - CRYPT_INVALID_PACKET, /* Invalid input packet given */ - - CRYPT_INVALID_PRNGSIZE, /* Invalid number of bits for a PRNG */ - CRYPT_ERROR_READPRNG, /* Could not read enough from PRNG */ - - CRYPT_INVALID_CIPHER, /* Invalid cipher specified */ - CRYPT_INVALID_HASH, /* Invalid hash specified */ - CRYPT_INVALID_PRNG, /* Invalid PRNG specified */ - - CRYPT_MEM, /* Out of memory */ - - CRYPT_PK_TYPE_MISMATCH, /* Not equivalent types of PK keys */ - CRYPT_PK_NOT_PRIVATE, /* Requires a private PK key */ - - CRYPT_INVALID_ARG, /* Generic invalid argument */ - CRYPT_FILE_NOTFOUND, /* File Not Found */ - - CRYPT_PK_INVALID_TYPE, /* Invalid type of PK key */ - CRYPT_PK_INVALID_SYSTEM,/* Invalid PK system specified */ - CRYPT_PK_DUP, /* Duplicate key already in key ring */ - CRYPT_PK_NOT_FOUND, /* Key not found in keyring */ - CRYPT_PK_INVALID_SIZE, /* Invalid size input for PK parameters */ - - CRYPT_INVALID_PRIME_SIZE,/* Invalid size of prime requested */ - CRYPT_PK_INVALID_PADDING /* Invalid padding on input */ -}; - -#include "tomcrypt_cfg.h" -#include "tomcrypt_macros.h" -#include "tomcrypt_cipher.h" -#include "tomcrypt_hash.h" -#include "tomcrypt_mac.h" -#include "tomcrypt_prng.h" -#include "tomcrypt_pk.h" -#include "tomcrypt_math.h" -#include "tomcrypt_misc.h" -#include "tomcrypt_argchk.h" -#include "tomcrypt_pkcs.h" - -#ifdef __cplusplus - } -#endif - -#endif /* TOMCRYPT_H_ */ - - -/* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt.h,v $ */ -/* $Revision: 1.21 $ */ -/* $Date: 2006/12/16 19:34:05 $ */ diff --git a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_argchk.h b/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_argchk.h deleted file mode 100644 index cfc93ad7ea6..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_argchk.h +++ /dev/null @@ -1,38 +0,0 @@ -/* Defines the LTC_ARGCHK macro used within the library */ -/* ARGTYPE is defined in mycrypt_cfg.h */ -#if ARGTYPE == 0 - -#include <signal.h> - -/* this is the default LibTomCrypt macro */ -void crypt_argchk(char *v, char *s, int d); -#define LTC_ARGCHK(x) if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); } -#define LTC_ARGCHKVD(x) LTC_ARGCHK(x) - -#elif ARGTYPE == 1 - -/* fatal type of error */ -#define LTC_ARGCHK(x) assert((x)) -#define LTC_ARGCHKVD(x) LTC_ARGCHK(x) - -#elif ARGTYPE == 2 - -#define LTC_ARGCHK(x) if (!(x)) { fprintf(stderr, "\nwarning: ARGCHK failed at %s:%d\n", __FILE__, __LINE__); } -#define LTC_ARGCHKVD(x) LTC_ARGCHK(x) - -#elif ARGTYPE == 3 - -#define LTC_ARGCHK(x) -#define LTC_ARGCHKVD(x) LTC_ARGCHK(x) - -#elif ARGTYPE == 4 - -#define LTC_ARGCHK(x) if (!(x)) return CRYPT_INVALID_ARG; -#define LTC_ARGCHKVD(x) if (!(x)) return; - -#endif - - -/* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt_argchk.h,v $ */ -/* $Revision: 1.5 $ */ -/* $Date: 2006/08/27 20:50:21 $ */ diff --git a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_cfg.h b/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_cfg.h deleted file mode 100644 index 7feae6e8bdc..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_cfg.h +++ /dev/null @@ -1,136 +0,0 @@ -/* This is the build config file. - * - * With this you can setup what to inlcude/exclude automatically during any build. Just comment - * out the line that #define's the word for the thing you want to remove. phew! - */ - -#ifndef TOMCRYPT_CFG_H -#define TOMCRYPT_CFG_H - -#if defined(_WIN32) || defined(_MSC_VER) -#define LTC_CALL __cdecl -#else -#ifndef LTC_CALL - #define LTC_CALL -#endif -#endif - -#ifndef LTC_EXPORT -#define LTC_EXPORT -#endif - -/* certain platforms use macros for these, making the prototypes broken */ -#ifndef LTC_NO_PROTOTYPES - -/* you can change how memory allocation works ... */ -LTC_EXPORT void * LTC_CALL XMALLOC(size_t n); -LTC_EXPORT void * LTC_CALL XREALLOC(void *p, size_t n); -LTC_EXPORT void * LTC_CALL XCALLOC(size_t n, size_t s); -LTC_EXPORT void LTC_CALL XFREE(void *p); - -LTC_EXPORT void LTC_CALL XQSORT(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *)); - - -/* change the clock function too */ -LTC_EXPORT clock_t LTC_CALL XCLOCK(void); - -/* various other functions */ -LTC_EXPORT void * LTC_CALL XMEMCPY(void *dest, const void *src, size_t n); -LTC_EXPORT int LTC_CALL XMEMCMP(const void *s1, const void *s2, size_t n); -LTC_EXPORT void * LTC_CALL XMEMSET(void *s, int c, size_t n); - -LTC_EXPORT int LTC_CALL XSTRCMP(const char *s1, const char *s2); - -#endif - -/* type of argument checking, 0=default, 1=fatal and 2=error+continue, 3=nothing */ -#ifndef ARGTYPE - #define ARGTYPE 0 -#endif - -/* Controls endianess and size of registers. Leave uncommented to get platform neutral [slower] code - * - * Note: in order to use the optimized macros your platform must support unaligned 32 and 64 bit read/writes. - * The x86 platforms allow this but some others [ARM for instance] do not. On those platforms you **MUST** - * use the portable [slower] macros. - */ - -/* detect x86-32 machines somewhat */ -#if !defined(__STRICT_ANSI__) && (defined(INTEL_CC) || (defined(_MSC_VER) && defined(WIN32)) || (defined(__GNUC__) && (defined(__DJGPP__) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__i386__)))) - #define ENDIAN_LITTLE - #define ENDIAN_32BITWORD - #define LTC_FAST - #define LTC_FAST_TYPE unsigned long -#endif - -/* detects MIPS R5900 processors (PS2) */ -#if (defined(__R5900) || defined(R5900) || defined(__R5900__)) && (defined(_mips) || defined(__mips__) || defined(mips)) - #define ENDIAN_LITTLE - #define ENDIAN_64BITWORD -#endif - -/* detect amd64 */ -#if !defined(__STRICT_ANSI__) && defined(__x86_64__) - #define ENDIAN_LITTLE - #define ENDIAN_64BITWORD - #define LTC_FAST - #define LTC_FAST_TYPE unsigned long -#endif - -/* detect PPC32 */ -#if !defined(__STRICT_ANSI__) && defined(LTC_PPC32) - #define ENDIAN_BIG - #define ENDIAN_32BITWORD - #define LTC_FAST - #define LTC_FAST_TYPE unsigned long -#endif - -/* detect sparc and sparc64 */ -#if defined(__sparc__) - #define ENDIAN_BIG - #if defined(__arch64__) - #define ENDIAN_64BITWORD - #else - #define ENDIAN_32BITWORD - #endif -#endif - - -#ifdef LTC_NO_FAST - #ifdef LTC_FAST - #undef LTC_FAST - #endif -#endif - -/* No asm is a quick way to disable anything "not portable" */ -#ifdef LTC_NO_ASM - #undef ENDIAN_LITTLE - #undef ENDIAN_BIG - #undef ENDIAN_32BITWORD - #undef ENDIAN_64BITWORD - #undef LTC_FAST - #undef LTC_FAST_TYPE - #define LTC_NO_ROLC - #define LTC_NO_BSWAP -#endif - -/* #define ENDIAN_LITTLE */ -/* #define ENDIAN_BIG */ - -/* #define ENDIAN_32BITWORD */ -/* #define ENDIAN_64BITWORD */ - -#if (defined(ENDIAN_BIG) || defined(ENDIAN_LITTLE)) && !(defined(ENDIAN_32BITWORD) || defined(ENDIAN_64BITWORD)) - #error You must specify a word size as well as endianess in tomcrypt_cfg.h -#endif - -#if !(defined(ENDIAN_BIG) || defined(ENDIAN_LITTLE)) - #define ENDIAN_NEUTRAL -#endif - -#endif - - -/* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt_cfg.h,v $ */ -/* $Revision: 1.19 $ */ -/* $Date: 2006/12/04 02:19:48 $ */ diff --git a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_cipher.h b/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_cipher.h deleted file mode 100644 index bd740bf4a0c..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_cipher.h +++ /dev/null @@ -1,891 +0,0 @@ -/* ---- SYMMETRIC KEY STUFF ----- - * - * We put each of the ciphers scheduled keys in their own structs then we put all of - * the key formats in one union. This makes the function prototypes easier to use. - */ -#ifdef LTC_BLOWFISH -struct blowfish_key { - ulong32 S[4][256]; - ulong32 K[18]; -}; -#endif - -#ifdef LTC_RC5 -struct rc5_key { - int rounds; - ulong32 K[50]; -}; -#endif - -#ifdef LTC_RC6 -struct rc6_key { - ulong32 K[44]; -}; -#endif - -#ifdef LTC_SAFERP -struct saferp_key { - unsigned char K[33][16]; - long rounds; -}; -#endif - -#ifdef LTC_RIJNDAEL -struct rijndael_key { - ulong32 eK[60], dK[60]; - int Nr; -}; -#endif - -#ifdef LTC_KSEED -struct kseed_key { - ulong32 K[32], dK[32]; -}; -#endif - -#ifdef LTC_KASUMI -struct kasumi_key { - ulong32 KLi1[8], KLi2[8], - KOi1[8], KOi2[8], KOi3[8], - KIi1[8], KIi2[8], KIi3[8]; -}; -#endif - -#ifdef LTC_XTEA -struct xtea_key { - unsigned long A[32], B[32]; -}; -#endif - -#ifdef LTC_TWOFISH -#ifndef LTC_TWOFISH_SMALL - struct twofish_key { - ulong32 S[4][256], K[40]; - }; -#else - struct twofish_key { - ulong32 K[40]; - unsigned char S[32], start; - }; -#endif -#endif - -#ifdef LTC_SAFER -#define LTC_SAFER_K64_DEFAULT_NOF_ROUNDS 6 -#define LTC_SAFER_K128_DEFAULT_NOF_ROUNDS 10 -#define LTC_SAFER_SK64_DEFAULT_NOF_ROUNDS 8 -#define LTC_SAFER_SK128_DEFAULT_NOF_ROUNDS 10 -#define LTC_SAFER_MAX_NOF_ROUNDS 13 -#define LTC_SAFER_BLOCK_LEN 8 -#define LTC_SAFER_KEY_LEN (1 + LTC_SAFER_BLOCK_LEN * (1 + 2 * LTC_SAFER_MAX_NOF_ROUNDS)) -typedef unsigned char safer_block_t[LTC_SAFER_BLOCK_LEN]; -typedef unsigned char safer_key_t[LTC_SAFER_KEY_LEN]; -struct safer_key { safer_key_t key; }; -#endif - -#ifdef LTC_RC2 -struct rc2_key { unsigned xkey[64]; }; -#endif - -#ifdef LTC_DES -struct des_key { - ulong32 ek[32], dk[32]; -}; - -struct des3_key { - ulong32 ek[3][32], dk[3][32]; -}; -#endif - -#ifdef LTC_CAST5 -struct cast5_key { - ulong32 K[32], keylen; -}; -#endif - -#ifdef LTC_NOEKEON -struct noekeon_key { - ulong32 K[4], dK[4]; -}; -#endif - -#ifdef LTC_SKIPJACK -struct skipjack_key { - unsigned char key[10]; -}; -#endif - -#ifdef LTC_KHAZAD -struct khazad_key { - ulong64 roundKeyEnc[8 + 1]; - ulong64 roundKeyDec[8 + 1]; -}; -#endif - -#ifdef LTC_ANUBIS -struct anubis_key { - int keyBits; - int R; - ulong32 roundKeyEnc[18 + 1][4]; - ulong32 roundKeyDec[18 + 1][4]; -}; -#endif - -#ifdef LTC_MULTI2 -struct multi2_key { - int N; - ulong32 uk[8]; -}; -#endif - -typedef union Symmetric_key { -#ifdef LTC_DES - struct des_key des; - struct des3_key des3; -#endif -#ifdef LTC_RC2 - struct rc2_key rc2; -#endif -#ifdef LTC_SAFER - struct safer_key safer; -#endif -#ifdef LTC_TWOFISH - struct twofish_key twofish; -#endif -#ifdef LTC_BLOWFISH - struct blowfish_key blowfish; -#endif -#ifdef LTC_RC5 - struct rc5_key rc5; -#endif -#ifdef LTC_RC6 - struct rc6_key rc6; -#endif -#ifdef LTC_SAFERP - struct saferp_key saferp; -#endif -#ifdef LTC_RIJNDAEL - struct rijndael_key rijndael; -#endif -#ifdef LTC_XTEA - struct xtea_key xtea; -#endif -#ifdef LTC_CAST5 - struct cast5_key cast5; -#endif -#ifdef LTC_NOEKEON - struct noekeon_key noekeon; -#endif -#ifdef LTC_SKIPJACK - struct skipjack_key skipjack; -#endif -#ifdef LTC_KHAZAD - struct khazad_key khazad; -#endif -#ifdef LTC_ANUBIS - struct anubis_key anubis; -#endif -#ifdef LTC_KSEED - struct kseed_key kseed; -#endif -#ifdef LTC_KASUMI - struct kasumi_key kasumi; -#endif -#ifdef LTC_MULTI2 - struct multi2_key multi2; -#endif - void *data; -} symmetric_key; - -#ifdef LTC_ECB_MODE -/** A block cipher ECB structure */ -typedef struct { - /** The index of the cipher chosen */ - int cipher, - /** The block size of the given cipher */ - blocklen; - /** The scheduled key */ - symmetric_key key; -} symmetric_ECB; -#endif - -#ifdef LTC_CFB_MODE -/** A block cipher CFB structure */ -typedef struct { - /** The index of the cipher chosen */ - int cipher, - /** The block size of the given cipher */ - blocklen, - /** The padding offset */ - padlen; - /** The current IV */ - unsigned char IV[MAXBLOCKSIZE], - /** The pad used to encrypt/decrypt */ - pad[MAXBLOCKSIZE]; - /** The scheduled key */ - symmetric_key key; -} symmetric_CFB; -#endif - -#ifdef LTC_OFB_MODE -/** A block cipher OFB structure */ -typedef struct { - /** The index of the cipher chosen */ - int cipher, - /** The block size of the given cipher */ - blocklen, - /** The padding offset */ - padlen; - /** The current IV */ - unsigned char IV[MAXBLOCKSIZE]; - /** The scheduled key */ - symmetric_key key; -} symmetric_OFB; -#endif - -#ifdef LTC_CBC_MODE -/** A block cipher CBC structure */ -typedef struct { - /** The index of the cipher chosen */ - int cipher, - /** The block size of the given cipher */ - blocklen; - /** The current IV */ - unsigned char IV[MAXBLOCKSIZE]; - /** The scheduled key */ - symmetric_key key; -} symmetric_CBC; -#endif - - -#ifdef LTC_CTR_MODE -/** A block cipher CTR structure */ -typedef struct { - /** The index of the cipher chosen */ - int cipher, - /** The block size of the given cipher */ - blocklen, - /** The padding offset */ - padlen, - /** The mode (endianess) of the CTR, 0==little, 1==big */ - mode, - /** counter width */ - ctrlen; - - /** The counter */ - unsigned char ctr[MAXBLOCKSIZE], - /** The pad used to encrypt/decrypt */ - pad[MAXBLOCKSIZE]; - /** The scheduled key */ - symmetric_key key; -} symmetric_CTR; -#endif - - -#ifdef LTC_LRW_MODE -/** A LRW structure */ -typedef struct { - /** The index of the cipher chosen (must be a 128-bit block cipher) */ - int cipher; - - /** The current IV */ - unsigned char IV[16], - - /** the tweak key */ - tweak[16], - - /** The current pad, it's the product of the first 15 bytes against the tweak key */ - pad[16]; - - /** The scheduled symmetric key */ - symmetric_key key; - -#ifdef LRW_TABLES - /** The pre-computed multiplication table */ - unsigned char PC[16][256][16]; -#endif -} symmetric_LRW; -#endif - -#ifdef LTC_F8_MODE -/** A block cipher F8 structure */ -typedef struct { - /** The index of the cipher chosen */ - int cipher, - /** The block size of the given cipher */ - blocklen, - /** The padding offset */ - padlen; - /** The current IV */ - unsigned char IV[MAXBLOCKSIZE], - MIV[MAXBLOCKSIZE]; - /** Current block count */ - ulong32 blockcnt; - /** The scheduled key */ - symmetric_key key; -} symmetric_F8; -#endif - - -/** cipher descriptor table, last entry has "name == NULL" to mark the end of table */ -extern struct ltc_cipher_descriptor { - /** name of cipher */ - char *name; - /** internal ID */ - unsigned char ID; - /** min keysize (octets) */ - int min_key_length, - /** max keysize (octets) */ - max_key_length, - /** block size (octets) */ - block_length, - /** default number of rounds */ - default_rounds; - /** Setup the cipher - @param key The input symmetric key - @param keylen The length of the input key (octets) - @param num_rounds The requested number of rounds (0==default) - @param skey [out] The destination of the scheduled key - @return CRYPT_OK if successful - */ - int (*setup)(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); - /** Encrypt a block - @param pt The plaintext - @param ct [out] The ciphertext - @param skey The scheduled key - @return CRYPT_OK if successful - */ - int (*ecb_encrypt)(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); - /** Decrypt a block - @param ct The ciphertext - @param pt [out] The plaintext - @param skey The scheduled key - @return CRYPT_OK if successful - */ - int (*ecb_decrypt)(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); - /** Test the block cipher - @return CRYPT_OK if successful, CRYPT_NOP if self-testing has been disabled - */ - int (*test)(void); - - /** Terminate the context - @param skey The scheduled key - */ - void (*done)(symmetric_key *skey); - - /** Determine a key size - @param keysize [in/out] The size of the key desired and the suggested size - @return CRYPT_OK if successful - */ - int (*keysize)(int *keysize); - -/** Accelerators **/ - /** Accelerated ECB encryption - @param pt Plaintext - @param ct Ciphertext - @param blocks The number of complete blocks to process - @param skey The scheduled key context - @return CRYPT_OK if successful - */ - int (*accel_ecb_encrypt)(const unsigned char *pt, unsigned char *ct, unsigned long blocks, symmetric_key *skey); - - /** Accelerated ECB decryption - @param pt Plaintext - @param ct Ciphertext - @param blocks The number of complete blocks to process - @param skey The scheduled key context - @return CRYPT_OK if successful - */ - int (*accel_ecb_decrypt)(const unsigned char *ct, unsigned char *pt, unsigned long blocks, symmetric_key *skey); - - /** Accelerated CBC encryption - @param pt Plaintext - @param ct Ciphertext - @param blocks The number of complete blocks to process - @param IV The initial value (input/output) - @param skey The scheduled key context - @return CRYPT_OK if successful - */ - int (*accel_cbc_encrypt)(const unsigned char *pt, unsigned char *ct, unsigned long blocks, unsigned char *IV, symmetric_key *skey); - - /** Accelerated CBC decryption - @param pt Plaintext - @param ct Ciphertext - @param blocks The number of complete blocks to process - @param IV The initial value (input/output) - @param skey The scheduled key context - @return CRYPT_OK if successful - */ - int (*accel_cbc_decrypt)(const unsigned char *ct, unsigned char *pt, unsigned long blocks, unsigned char *IV, symmetric_key *skey); - - /** Accelerated CTR encryption - @param pt Plaintext - @param ct Ciphertext - @param blocks The number of complete blocks to process - @param IV The initial value (input/output) - @param mode little or big endian counter (mode=0 or mode=1) - @param skey The scheduled key context - @return CRYPT_OK if successful - */ - int (*accel_ctr_encrypt)(const unsigned char *pt, unsigned char *ct, unsigned long blocks, unsigned char *IV, int mode, symmetric_key *skey); - - /** Accelerated LRW - @param pt Plaintext - @param ct Ciphertext - @param blocks The number of complete blocks to process - @param IV The initial value (input/output) - @param tweak The LRW tweak - @param skey The scheduled key context - @return CRYPT_OK if successful - */ - int (*accel_lrw_encrypt)(const unsigned char *pt, unsigned char *ct, unsigned long blocks, unsigned char *IV, const unsigned char *tweak, symmetric_key *skey); - - /** Accelerated LRW - @param ct Ciphertext - @param pt Plaintext - @param blocks The number of complete blocks to process - @param IV The initial value (input/output) - @param tweak The LRW tweak - @param skey The scheduled key context - @return CRYPT_OK if successful - */ - int (*accel_lrw_decrypt)(const unsigned char *ct, unsigned char *pt, unsigned long blocks, unsigned char *IV, const unsigned char *tweak, symmetric_key *skey); - - /** Accelerated CCM packet (one-shot) - @param key The secret key to use - @param keylen The length of the secret key (octets) - @param uskey A previously scheduled key [optional can be NULL] - @param nonce The session nonce [use once] - @param noncelen The length of the nonce - @param header The header for the session - @param headerlen The length of the header (octets) - @param pt [out] The plaintext - @param ptlen The length of the plaintext (octets) - @param ct [out] The ciphertext - @param tag [out] The destination tag - @param taglen [in/out] The max size and resulting size of the authentication tag - @param direction Encrypt or Decrypt direction (0 or 1) - @return CRYPT_OK if successful - */ - int (*accel_ccm_memory)( - const unsigned char *key, unsigned long keylen, - symmetric_key *uskey, - const unsigned char *nonce, unsigned long noncelen, - const unsigned char *header, unsigned long headerlen, - unsigned char *pt, unsigned long ptlen, - unsigned char *ct, - unsigned char *tag, unsigned long *taglen, - int direction); - - /** Accelerated GCM packet (one shot) - @param key The secret key - @param keylen The length of the secret key - @param IV The initial vector - @param IVlen The length of the initial vector - @param adata The additional authentication data (header) - @param adatalen The length of the adata - @param pt The plaintext - @param ptlen The length of the plaintext (ciphertext length is the same) - @param ct The ciphertext - @param tag [out] The MAC tag - @param taglen [in/out] The MAC tag length - @param direction Encrypt or Decrypt mode (GCM_ENCRYPT or GCM_DECRYPT) - @return CRYPT_OK on success - */ - int (*accel_gcm_memory)( - const unsigned char *key, unsigned long keylen, - const unsigned char *IV, unsigned long IVlen, - const unsigned char *adata, unsigned long adatalen, - unsigned char *pt, unsigned long ptlen, - unsigned char *ct, - unsigned char *tag, unsigned long *taglen, - int direction); - - /** Accelerated one shot LTC_OMAC - @param key The secret key - @param keylen The key length (octets) - @param in The message - @param inlen Length of message (octets) - @param out [out] Destination for tag - @param outlen [in/out] Initial and final size of out - @return CRYPT_OK on success - */ - int (*omac_memory)( - const unsigned char *key, unsigned long keylen, - const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen); - - /** Accelerated one shot XCBC - @param key The secret key - @param keylen The key length (octets) - @param in The message - @param inlen Length of message (octets) - @param out [out] Destination for tag - @param outlen [in/out] Initial and final size of out - @return CRYPT_OK on success - */ - int (*xcbc_memory)( - const unsigned char *key, unsigned long keylen, - const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen); - - /** Accelerated one shot F9 - @param key The secret key - @param keylen The key length (octets) - @param in The message - @param inlen Length of message (octets) - @param out [out] Destination for tag - @param outlen [in/out] Initial and final size of out - @return CRYPT_OK on success - @remark Requires manual padding - */ - int (*f9_memory)( - const unsigned char *key, unsigned long keylen, - const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen); -} cipher_descriptor[]; - -#ifdef LTC_BLOWFISH -int blowfish_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int blowfish_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -int blowfish_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); -int blowfish_test(void); -void blowfish_done(symmetric_key *skey); -int blowfish_keysize(int *keysize); -extern const struct ltc_cipher_descriptor blowfish_desc; -#endif - -#ifdef LTC_RC5 -int rc5_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int rc5_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -int rc5_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); -int rc5_test(void); -void rc5_done(symmetric_key *skey); -int rc5_keysize(int *keysize); -extern const struct ltc_cipher_descriptor rc5_desc; -#endif - -#ifdef LTC_RC6 -int rc6_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int rc6_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -int rc6_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); -int rc6_test(void); -void rc6_done(symmetric_key *skey); -int rc6_keysize(int *keysize); -extern const struct ltc_cipher_descriptor rc6_desc; -#endif - -#ifdef LTC_RC2 -int rc2_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int rc2_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -int rc2_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); -int rc2_test(void); -void rc2_done(symmetric_key *skey); -int rc2_keysize(int *keysize); -extern const struct ltc_cipher_descriptor rc2_desc; -#endif - -#ifdef LTC_SAFERP -int saferp_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int saferp_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -int saferp_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); -int saferp_test(void); -void saferp_done(symmetric_key *skey); -int saferp_keysize(int *keysize); -extern const struct ltc_cipher_descriptor saferp_desc; -#endif - -#ifdef LTC_SAFER -int safer_k64_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int safer_sk64_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int safer_k128_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int safer_sk128_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int safer_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *key); -int safer_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *key); -int safer_k64_test(void); -int safer_sk64_test(void); -int safer_sk128_test(void); -void safer_done(symmetric_key *skey); -int safer_64_keysize(int *keysize); -int safer_128_keysize(int *keysize); -extern const struct ltc_cipher_descriptor safer_k64_desc, safer_k128_desc, safer_sk64_desc, safer_sk128_desc; -#endif - -#ifdef LTC_RIJNDAEL - -/* make aes an alias */ -#define aes_setup rijndael_setup -#define aes_ecb_encrypt rijndael_ecb_encrypt -#define aes_ecb_decrypt rijndael_ecb_decrypt -#define aes_test rijndael_test -#define aes_done rijndael_done -#define aes_keysize rijndael_keysize - -#define aes_enc_setup rijndael_enc_setup -#define aes_enc_ecb_encrypt rijndael_enc_ecb_encrypt -#define aes_enc_keysize rijndael_enc_keysize - -int rijndael_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int rijndael_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -int rijndael_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); -int rijndael_test(void); -void rijndael_done(symmetric_key *skey); -int rijndael_keysize(int *keysize); -int rijndael_enc_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int rijndael_enc_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -void rijndael_enc_done(symmetric_key *skey); -int rijndael_enc_keysize(int *keysize); -extern const struct ltc_cipher_descriptor rijndael_desc, aes_desc; -extern const struct ltc_cipher_descriptor rijndael_enc_desc, aes_enc_desc; -#endif - -#ifdef LTC_XTEA -int xtea_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int xtea_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -int xtea_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); -int xtea_test(void); -void xtea_done(symmetric_key *skey); -int xtea_keysize(int *keysize); -extern const struct ltc_cipher_descriptor xtea_desc; -#endif - -#ifdef LTC_TWOFISH -int twofish_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int twofish_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -int twofish_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); -int twofish_test(void); -void twofish_done(symmetric_key *skey); -int twofish_keysize(int *keysize); -extern const struct ltc_cipher_descriptor twofish_desc; -#endif - -#ifdef LTC_DES -int des_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int des_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -int des_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); -int des_test(void); -void des_done(symmetric_key *skey); -int des_keysize(int *keysize); -int des3_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int des3_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -int des3_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); -int des3_test(void); -void des3_done(symmetric_key *skey); -int des3_keysize(int *keysize); -extern const struct ltc_cipher_descriptor des_desc, des3_desc; -#endif - -#ifdef LTC_CAST5 -int cast5_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int cast5_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -int cast5_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); -int cast5_test(void); -void cast5_done(symmetric_key *skey); -int cast5_keysize(int *keysize); -extern const struct ltc_cipher_descriptor cast5_desc; -#endif - -#ifdef LTC_NOEKEON -int noekeon_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int noekeon_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -int noekeon_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); -int noekeon_test(void); -void noekeon_done(symmetric_key *skey); -int noekeon_keysize(int *keysize); -extern const struct ltc_cipher_descriptor noekeon_desc; -#endif - -#ifdef LTC_SKIPJACK -int skipjack_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int skipjack_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -int skipjack_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); -int skipjack_test(void); -void skipjack_done(symmetric_key *skey); -int skipjack_keysize(int *keysize); -extern const struct ltc_cipher_descriptor skipjack_desc; -#endif - -#ifdef LTC_KHAZAD -int khazad_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int khazad_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -int khazad_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); -int khazad_test(void); -void khazad_done(symmetric_key *skey); -int khazad_keysize(int *keysize); -extern const struct ltc_cipher_descriptor khazad_desc; -#endif - -#ifdef LTC_ANUBIS -int anubis_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int anubis_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -int anubis_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); -int anubis_test(void); -void anubis_done(symmetric_key *skey); -int anubis_keysize(int *keysize); -extern const struct ltc_cipher_descriptor anubis_desc; -#endif - -#ifdef LTC_KSEED -int kseed_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int kseed_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -int kseed_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); -int kseed_test(void); -void kseed_done(symmetric_key *skey); -int kseed_keysize(int *keysize); -extern const struct ltc_cipher_descriptor kseed_desc; -#endif - -#ifdef LTC_KASUMI -int kasumi_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int kasumi_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -int kasumi_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); -int kasumi_test(void); -void kasumi_done(symmetric_key *skey); -int kasumi_keysize(int *keysize); -extern const struct ltc_cipher_descriptor kasumi_desc; -#endif - - -#ifdef LTC_MULTI2 -int multi2_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey); -int multi2_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey); -int multi2_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey); -int multi2_test(void); -void multi2_done(symmetric_key *skey); -int multi2_keysize(int *keysize); -extern const struct ltc_cipher_descriptor multi2_desc; -#endif - -#ifdef LTC_ECB_MODE -int ecb_start(int cipher, const unsigned char *key, - int keylen, int num_rounds, symmetric_ECB *ecb); -int ecb_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_ECB *ecb); -int ecb_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_ECB *ecb); -int ecb_done(symmetric_ECB *ecb); -#endif - -#ifdef LTC_CFB_MODE -int cfb_start(int cipher, const unsigned char *IV, const unsigned char *key, - int keylen, int num_rounds, symmetric_CFB *cfb); -int cfb_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_CFB *cfb); -int cfb_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_CFB *cfb); -int cfb_getiv(unsigned char *IV, unsigned long *len, symmetric_CFB *cfb); -int cfb_setiv(const unsigned char *IV, unsigned long len, symmetric_CFB *cfb); -int cfb_done(symmetric_CFB *cfb); -#endif - -#ifdef LTC_OFB_MODE -int ofb_start(int cipher, const unsigned char *IV, const unsigned char *key, - int keylen, int num_rounds, symmetric_OFB *ofb); -int ofb_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_OFB *ofb); -int ofb_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_OFB *ofb); -int ofb_getiv(unsigned char *IV, unsigned long *len, symmetric_OFB *ofb); -int ofb_setiv(const unsigned char *IV, unsigned long len, symmetric_OFB *ofb); -int ofb_done(symmetric_OFB *ofb); -#endif - -#ifdef LTC_CBC_MODE -int cbc_start(int cipher, const unsigned char *IV, const unsigned char *key, - int keylen, int num_rounds, symmetric_CBC *cbc); -int cbc_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_CBC *cbc); -int cbc_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_CBC *cbc); -int cbc_getiv(unsigned char *IV, unsigned long *len, symmetric_CBC *cbc); -int cbc_setiv(const unsigned char *IV, unsigned long len, symmetric_CBC *cbc); -int cbc_done(symmetric_CBC *cbc); -#endif - -#ifdef LTC_CTR_MODE - -#define CTR_COUNTER_LITTLE_ENDIAN 0x0000 -#define CTR_COUNTER_BIG_ENDIAN 0x1000 -#define LTC_CTR_RFC3686 0x2000 - -int ctr_start( int cipher, - const unsigned char *IV, - const unsigned char *key, int keylen, - int num_rounds, int ctr_mode, - symmetric_CTR *ctr); -int ctr_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_CTR *ctr); -int ctr_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_CTR *ctr); -int ctr_getiv(unsigned char *IV, unsigned long *len, symmetric_CTR *ctr); -int ctr_setiv(const unsigned char *IV, unsigned long len, symmetric_CTR *ctr); -int ctr_done(symmetric_CTR *ctr); -int ctr_test(void); -#endif - -#ifdef LTC_LRW_MODE - -#define LRW_ENCRYPT 0 -#define LRW_DECRYPT 1 - -int lrw_start( int cipher, - const unsigned char *IV, - const unsigned char *key, int keylen, - const unsigned char *tweak, - int num_rounds, - symmetric_LRW *lrw); -int lrw_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_LRW *lrw); -int lrw_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_LRW *lrw); -int lrw_getiv(unsigned char *IV, unsigned long *len, symmetric_LRW *lrw); -int lrw_setiv(const unsigned char *IV, unsigned long len, symmetric_LRW *lrw); -int lrw_done(symmetric_LRW *lrw); -int lrw_test(void); - -/* don't call */ -int lrw_process(const unsigned char *pt, unsigned char *ct, unsigned long len, int mode, symmetric_LRW *lrw); -#endif - -#ifdef LTC_F8_MODE -int f8_start( int cipher, const unsigned char *IV, - const unsigned char *key, int keylen, - const unsigned char *salt_key, int skeylen, - int num_rounds, symmetric_F8 *f8); -int f8_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_F8 *f8); -int f8_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_F8 *f8); -int f8_getiv(unsigned char *IV, unsigned long *len, symmetric_F8 *f8); -int f8_setiv(const unsigned char *IV, unsigned long len, symmetric_F8 *f8); -int f8_done(symmetric_F8 *f8); -int f8_test_mode(void); -#endif - -#ifdef LTC_XTS_MODE -typedef struct { - symmetric_key key1, key2; - int cipher; -} symmetric_xts; - -int xts_start( int cipher, - const unsigned char *key1, - const unsigned char *key2, - unsigned long keylen, - int num_rounds, - symmetric_xts *xts); - -int xts_encrypt( - const unsigned char *pt, unsigned long ptlen, - unsigned char *ct, - const unsigned char *tweak, - symmetric_xts *xts); -int xts_decrypt( - const unsigned char *ct, unsigned long ptlen, - unsigned char *pt, - const unsigned char *tweak, - symmetric_xts *xts); - -void xts_done(symmetric_xts *xts); -int xts_test(void); -void xts_mult_x(unsigned char *I); -#endif - -int find_cipher(const char *name); -int find_cipher_any(const char *name, int blocklen, int keylen); -int find_cipher_id(unsigned char ID); -int register_cipher(const struct ltc_cipher_descriptor *cipher); -int unregister_cipher(const struct ltc_cipher_descriptor *cipher); -int cipher_is_valid(int idx); - -LTC_MUTEX_PROTO(ltc_cipher_mutex) - -/* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt_cipher.h,v $ */ -/* $Revision: 1.54 $ */ -/* $Date: 2007/05/12 14:37:41 $ */ diff --git a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_custom.h b/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_custom.h deleted file mode 100644 index 88ec8f984ab..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_custom.h +++ /dev/null @@ -1,424 +0,0 @@ -#ifndef TOMCRYPT_CUSTOM_H_ -#define TOMCRYPT_CUSTOM_H_ - -#define LTC_NO_CIPHERS -#define LTC_NO_HASHES -#define LTC_NO_MACS -#define LTC_NO_PRNGS -#define LTC_NO_CURVES -#define LTC_NO_MODES -#define LTC_NO_PKCS -#define LTC_NO_ROLC - -#define LTC_SOURCE -#define LTC_SHA1 -#define LTC_MD5 -#define LTC_DER -#define LTC_RC4 - -#define USE_LTM -#define LTM_DESC - -/* macros for various libc functions you can change for embedded targets */ -#ifndef XMALLOC - #ifdef malloc - #define LTC_NO_PROTOTYPES - #endif -#define XMALLOC LibTomMalloc -#endif -#ifndef XREALLOC - #ifdef realloc - #define LTC_NO_PROTOTYPES - #endif -#define XREALLOC LibTomRealloc -#endif -#ifndef XCALLOC - #ifdef calloc - #define LTC_NO_PROTOTYPES - #endif -#define XCALLOC LibTomCalloc -#endif -#ifndef XFREE - #ifdef free - #define LTC_NO_PROTOTYPES - #endif -#define XFREE LibTomFree -#endif - -#ifndef XMEMSET - #ifdef memset - #define LTC_NO_PROTOTYPES - #endif -#define XMEMSET memset -#endif -#ifndef XMEMCPY - #ifdef memcpy - #define LTC_NO_PROTOTYPES - #endif -#define XMEMCPY memcpy -#endif -#ifndef XMEMCMP - #ifdef memcmp - #define LTC_NO_PROTOTYPES - #endif -#define XMEMCMP memcmp -#endif -#ifndef XSTRCMP - #ifdef strcmp - #define LTC_NO_PROTOTYPES - #endif -#define XSTRCMP strcmp -#endif - -#ifndef XCLOCK -#define XCLOCK LibTomClock -#endif -#ifndef XCLOCKS_PER_SEC -#define XCLOCKS_PER_SEC CLOCKS_PER_SEC -#endif - -#ifndef XQSORT - #ifdef qsort - #define LTC_NO_PROTOTYPES - #endif -#define XQSORT LibTomQsort -#endif - -/* Easy button? */ -#ifdef LTC_EASY - #define LTC_NO_CIPHERS - #define LTC_RIJNDAEL - #define LTC_BLOWFISH - #define LTC_DES - #define LTC_CAST5 - - #define LTC_NO_MODES - #define LTC_ECB_MODE - #define LTC_CBC_MODE - #define LTC_CTR_MODE - - #define LTC_NO_HASHES - #define LTC_SHA1 - #define LTC_SHA512 - #define LTC_SHA384 - #define LTC_SHA256 - #define LTC_SHA224 - - #define LTC_NO_MACS - #define LTC_HMAC - #define LTC_OMAC - #define LTC_CCM_MODE - - #define LTC_NO_PRNGS - #define LTC_SPRNG - #define LTC_YARROW - #define LTC_DEVRANDOM - #define TRY_URANDOM_FIRST - - #define LTC_NO_PK - #define LTC_MRSA - #define LTC_MECC -#endif - -/* Use small code where possible */ -/* #define LTC_SMALL_CODE */ - -/* Enable self-test test vector checking */ -#ifndef LTC_NO_TEST - #define LTC_TEST -#endif - -/* clean the stack of functions which put private information on stack */ -/* #define LTC_CLEAN_STACK */ - -/* disable all file related functions */ -/* #define LTC_NO_FILE */ - -/* disable all forms of ASM */ -/* #define LTC_NO_ASM */ - -/* disable FAST mode */ -/* #define LTC_NO_FAST */ - -/* disable BSWAP on x86 */ -/* #define LTC_NO_BSWAP */ - -/* ---> Symmetric Block Ciphers <--- */ -#ifndef LTC_NO_CIPHERS - -#define LTC_BLOWFISH -#define LTC_RC2 -#define LTC_RC5 -#define LTC_RC6 -#define LTC_SAFERP -#define LTC_RIJNDAEL -#define LTC_XTEA -/* _TABLES tells it to use tables during setup, _SMALL means to use the smaller scheduled key format - * (saves 4KB of ram), _ALL_TABLES enables all tables during setup */ -#define LTC_TWOFISH -#ifndef LTC_NO_TABLES - #define LTC_TWOFISH_TABLES - /* #define LTC_TWOFISH_ALL_TABLES */ -#else - #define LTC_TWOFISH_SMALL -#endif -/* #define LTC_TWOFISH_SMALL */ -/* LTC_DES includes EDE triple-LTC_DES */ -#define LTC_DES -#define LTC_CAST5 -#define LTC_NOEKEON -#define LTC_SKIPJACK -#define LTC_SAFER -#define LTC_KHAZAD -#define LTC_ANUBIS -#define LTC_ANUBIS_TWEAK -#define LTC_KSEED -#define LTC_KASUMI - -#endif /* LTC_NO_CIPHERS */ - - -/* ---> Block Cipher Modes of Operation <--- */ -#ifndef LTC_NO_MODES - -#define LTC_CFB_MODE -#define LTC_OFB_MODE -#define LTC_ECB_MODE -#define LTC_CBC_MODE -#define LTC_CTR_MODE - -/* F8 chaining mode */ -#define LTC_F8_MODE - -/* LRW mode */ -#define LTC_LRW_MODE -#ifndef LTC_NO_TABLES - /* like GCM mode this will enable 16 8x128 tables [64KB] that make - * seeking very fast. - */ - #define LRW_TABLES -#endif - -/* XTS mode */ -#define LTC_XTS_MODE - -#endif /* LTC_NO_MODES */ - -/* ---> One-Way Hash Functions <--- */ -#ifndef LTC_NO_HASHES - -#define LTC_CHC_HASH -#define LTC_WHIRLPOOL -#define LTC_SHA512 -#define LTC_SHA384 -#define LTC_SHA256 -#define LTC_SHA224 -#define LTC_TIGER -#define LTC_SHA1 -#define LTC_MD5 -#define LTC_MD4 -#define LTC_MD2 -#define LTC_RIPEMD128 -#define LTC_RIPEMD160 -#define LTC_RIPEMD256 -#define LTC_RIPEMD320 - -#endif /* LTC_NO_HASHES */ - -/* ---> MAC functions <--- */ -#ifndef LTC_NO_MACS - -#define LTC_HMAC -#define LTC_OMAC -#define LTC_PMAC -#define LTC_XCBC -#define LTC_F9_MODE -#define LTC_PELICAN - -#if defined(LTC_PELICAN) && !defined(LTC_RIJNDAEL) - #error Pelican-MAC requires LTC_RIJNDAEL -#endif - -/* ---> Encrypt + Authenticate Modes <--- */ - -#define LTC_EAX_MODE -#if defined(LTC_EAX_MODE) && !(defined(LTC_CTR_MODE) && defined(LTC_OMAC)) - #error LTC_EAX_MODE requires CTR and LTC_OMAC mode -#endif - -#define LTC_OCB_MODE -#define LTC_CCM_MODE -#define LTC_GCM_MODE - -/* Use 64KiB tables */ -#ifndef LTC_NO_TABLES - #define LTC_GCM_TABLES -#endif - -/* USE SSE2? requires GCC works on x86_32 and x86_64*/ -#ifdef LTC_GCM_TABLES -/* #define LTC_GCM_TABLES_SSE2 */ -#endif - -#endif /* LTC_NO_MACS */ - -/* Various tidbits of modern neatoness */ -#define LTC_BASE64 - -/* --> Pseudo Random Number Generators <--- */ -#ifndef LTC_NO_PRNGS - -/* Yarrow */ -#define LTC_YARROW -/* which descriptor of AES to use? */ -/* 0 = rijndael_enc 1 = aes_enc, 2 = rijndael [full], 3 = aes [full] */ -#define LTC_YARROW_AES 0 - -#if defined(LTC_YARROW) && !defined(LTC_CTR_MODE) - #error LTC_YARROW requires LTC_CTR_MODE chaining mode to be defined! -#endif - -/* a PRNG that simply reads from an available system source */ -#define LTC_SPRNG - -/* The LTC_RC4 stream cipher */ -#define LTC_RC4 - -/* Fortuna PRNG */ -#define LTC_FORTUNA -/* reseed every N calls to the read function */ -#define LTC_FORTUNA_WD 10 -/* number of pools (4..32) can save a bit of ram by lowering the count */ -#define LTC_FORTUNA_POOLS 32 - -/* Greg's LTC_SOBER128 PRNG ;-0 */ -#define LTC_SOBER128 - -/* the *nix style /dev/random device */ -#define LTC_DEVRANDOM -/* try /dev/urandom before trying /dev/random */ -#define TRY_URANDOM_FIRST - -#endif /* LTC_NO_PRNGS */ - -/* ---> math provider? <--- */ -#ifndef LTC_NO_MATH - -/* LibTomMath */ -#define LTM_LTC_DESC - -/* TomsFastMath */ -//#define TFM_LTC_DESC - -#endif /* LTC_NO_MATH */ - -/* ---> Public Key Crypto <--- */ -#ifndef LTC_NO_PK - -/* Include RSA support */ -#define LTC_MRSA - -/* Include Katja (a Rabin variant like RSA) */ -/* #define MKAT */ - -/* Digital Signature Algorithm */ -#define LTC_MDSA - -/* ECC */ -#define LTC_MECC - -/* use Shamir's trick for point mul (speeds up signature verification) */ -#define LTC_ECC_SHAMIR - -#if defined(TFM_LTC_DESC) && defined(LTC_MECC) - #define LTC_MECC_ACCEL -#endif - -/* do we want fixed point ECC */ -/* #define LTC_MECC_FP */ - -/* Timing Resistant? */ -/* #define LTC_ECC_TIMING_RESISTANT */ - -#endif /* LTC_NO_PK */ - -/* LTC_PKCS #1 (RSA) and #5 (Password Handling) stuff */ -#ifndef LTC_NO_PKCS - -#define LTC_PKCS_1 -#define LTC_PKCS_5 - -/* Include ASN.1 DER (required by DSA/RSA) */ -#define LTC_DER - -#endif /* LTC_NO_PKCS */ - -/* cleanup */ - -#ifdef LTC_MECC -/* Supported ECC Key Sizes */ -#ifndef LTC_NO_CURVES - #define ECC112 - #define ECC128 - #define ECC160 - #define ECC192 - #define ECC224 - #define ECC256 - #define ECC384 - #define ECC521 -#endif -#endif - -#if defined(LTC_MECC) || defined(LTC_MRSA) || defined(LTC_MDSA) || defined(MKATJA) - /* Include the MPI functionality? (required by the PK algorithms) */ - #define MPI -#endif - -#ifdef LTC_MRSA - #define LTC_PKCS_1 -#endif - -#if defined(LTC_DER) && !defined(MPI) - #error ASN.1 DER requires MPI functionality -#endif - -#if (defined(LTC_MDSA) || defined(LTC_MRSA) || defined(LTC_MECC) || defined(MKATJA)) && !defined(LTC_DER) - #error PK requires ASN.1 DER functionality, make sure LTC_DER is enabled -#endif - -/* THREAD management */ -#ifdef LTC_PTHREAD - -#include <pthread.h> - -#define LTC_MUTEX_GLOBAL(x) pthread_mutex_t x = PTHREAD_MUTEX_INITIALIZER; -#define LTC_MUTEX_PROTO(x) extern pthread_mutex_t x; -#define LTC_MUTEX_TYPE(x) pthread_mutex_t x; -#define LTC_MUTEX_INIT(x) pthread_mutex_init(x, NULL); -#define LTC_MUTEX_LOCK(x) pthread_mutex_lock(x); -#define LTC_MUTEX_UNLOCK(x) pthread_mutex_unlock(x); - -#else - -/* default no functions */ -#define LTC_MUTEX_GLOBAL(x) -#define LTC_MUTEX_PROTO(x) -#define LTC_MUTEX_TYPE(x) -#define LTC_MUTEX_INIT(x) -#define LTC_MUTEX_LOCK(x) -#define LTC_MUTEX_UNLOCK(x) - -#endif - -/* Debuggers */ - -/* define this if you use Valgrind, note: it CHANGES the way SOBER-128 and LTC_RC4 work (see the code) */ -/* #define LTC_VALGRIND */ - -#endif - - - -/* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt_custom.h,v $ */ -/* $Revision: 1.73 $ */ -/* $Date: 2007/05/12 14:37:41 $ */ diff --git a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_hash.h b/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_hash.h deleted file mode 100644 index 18553ebf9da..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_hash.h +++ /dev/null @@ -1,378 +0,0 @@ -/* ---- HASH FUNCTIONS ---- */ -#ifdef LTC_SHA512 -struct sha512_state { - ulong64 length, state[8]; - unsigned long curlen; - unsigned char buf[128]; -}; -#endif - -#ifdef LTC_SHA256 -struct sha256_state { - ulong64 length; - ulong32 state[8], curlen; - unsigned char buf[64]; -}; -#endif - -#ifdef LTC_SHA1 -struct sha1_state { - ulong64 length; - ulong32 state[5], curlen; - unsigned char buf[64]; -}; -#endif - -#ifdef LTC_MD5 -struct md5_state { - ulong64 length; - ulong32 state[4], curlen; - unsigned char buf[64]; -}; -#endif - -#ifdef LTC_MD4 -struct md4_state { - ulong64 length; - ulong32 state[4], curlen; - unsigned char buf[64]; -}; -#endif - -#ifdef LTC_TIGER -struct tiger_state { - ulong64 state[3], length; - unsigned long curlen; - unsigned char buf[64]; -}; -#endif - -#ifdef LTC_MD2 -struct md2_state { - unsigned char chksum[16], X[48], buf[16]; - unsigned long curlen; -}; -#endif - -#ifdef LTC_RIPEMD128 -struct rmd128_state { - ulong64 length; - unsigned char buf[64]; - ulong32 curlen, state[4]; -}; -#endif - -#ifdef LTC_RIPEMD160 -struct rmd160_state { - ulong64 length; - unsigned char buf[64]; - ulong32 curlen, state[5]; -}; -#endif - -#ifdef LTC_RIPEMD256 -struct rmd256_state { - ulong64 length; - unsigned char buf[64]; - ulong32 curlen, state[8]; -}; -#endif - -#ifdef LTC_RIPEMD320 -struct rmd320_state { - ulong64 length; - unsigned char buf[64]; - ulong32 curlen, state[10]; -}; -#endif - -#ifdef LTC_WHIRLPOOL -struct whirlpool_state { - ulong64 length, state[8]; - unsigned char buf[64]; - ulong32 curlen; -}; -#endif - -#ifdef LTC_CHC_HASH -struct chc_state { - ulong64 length; - unsigned char state[MAXBLOCKSIZE], buf[MAXBLOCKSIZE]; - ulong32 curlen; -}; -#endif - -typedef union Hash_state { -#ifdef LTC_CHC_HASH - struct chc_state chc; -#endif -#ifdef LTC_WHIRLPOOL - struct whirlpool_state whirlpool; -#endif -#ifdef LTC_SHA512 - struct sha512_state sha512; -#endif -#ifdef LTC_SHA256 - struct sha256_state sha256; -#endif -#ifdef LTC_SHA1 - struct sha1_state sha1; -#endif -#ifdef LTC_MD5 - struct md5_state md5; -#endif -#ifdef LTC_MD4 - struct md4_state md4; -#endif -#ifdef LTC_MD2 - struct md2_state md2; -#endif -#ifdef LTC_TIGER - struct tiger_state tiger; -#endif -#ifdef LTC_RIPEMD128 - struct rmd128_state rmd128; -#endif -#ifdef LTC_RIPEMD160 - struct rmd160_state rmd160; -#endif -#ifdef LTC_RIPEMD256 - struct rmd256_state rmd256; -#endif -#ifdef LTC_RIPEMD320 - struct rmd320_state rmd320; -#endif - void *data; -} hash_state; - -/** hash descriptor */ -extern struct ltc_hash_descriptor { - /** name of hash */ - char *name; - /** internal ID */ - unsigned char ID; - /** Size of digest in octets */ - unsigned long hashsize; - /** Input block size in octets */ - unsigned long blocksize; - /** ASN.1 OID */ - unsigned long OID[16]; - /** Length of DER encoding */ - unsigned long OIDlen; - - /** Init a hash state - @param hash The hash to initialize - @return CRYPT_OK if successful - */ - int (*init)(hash_state *hash); - /** Process a block of data - @param hash The hash state - @param in The data to hash - @param inlen The length of the data (octets) - @return CRYPT_OK if successful - */ - int (*process)(hash_state *hash, const unsigned char *in, unsigned long inlen); - /** Produce the digest and store it - @param hash The hash state - @param out [out] The destination of the digest - @return CRYPT_OK if successful - */ - int (*done)(hash_state *hash, unsigned char *out); - /** Self-test - @return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled - */ - int (*test)(void); - - /* accelerated hmac callback: if you need to-do multiple packets just use the generic hmac_memory and provide a hash callback */ - int (*hmac_block)(const unsigned char *key, unsigned long keylen, - const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen); - -} hash_descriptor[]; - -#ifdef LTC_CHC_HASH -int chc_register(int cipher); -int chc_init(hash_state * md); -int chc_process(hash_state * md, const unsigned char *in, unsigned long inlen); -int chc_done(hash_state * md, unsigned char *hash); -int chc_test(void); -extern const struct ltc_hash_descriptor chc_desc; -#endif - -#ifdef LTC_WHIRLPOOL -int whirlpool_init(hash_state * md); -int whirlpool_process(hash_state * md, const unsigned char *in, unsigned long inlen); -int whirlpool_done(hash_state * md, unsigned char *hash); -int whirlpool_test(void); -extern const struct ltc_hash_descriptor whirlpool_desc; -#endif - -#ifdef LTC_SHA512 -int sha512_init(hash_state * md); -int sha512_process(hash_state * md, const unsigned char *in, unsigned long inlen); -int sha512_done(hash_state * md, unsigned char *hash); -int sha512_test(void); -extern const struct ltc_hash_descriptor sha512_desc; -#endif - -#ifdef LTC_SHA384 -#ifndef LTC_SHA512 - #error LTC_SHA512 is required for LTC_SHA384 -#endif -int sha384_init(hash_state * md); -#define sha384_process sha512_process -int sha384_done(hash_state * md, unsigned char *hash); -int sha384_test(void); -extern const struct ltc_hash_descriptor sha384_desc; -#endif - -#ifdef LTC_SHA256 -int sha256_init(hash_state * md); -int sha256_process(hash_state * md, const unsigned char *in, unsigned long inlen); -int sha256_done(hash_state * md, unsigned char *hash); -int sha256_test(void); -extern const struct ltc_hash_descriptor sha256_desc; - -#ifdef LTC_SHA224 -#ifndef LTC_SHA256 - #error LTC_SHA256 is required for LTC_SHA224 -#endif -int sha224_init(hash_state * md); -#define sha224_process sha256_process -int sha224_done(hash_state * md, unsigned char *hash); -int sha224_test(void); -extern const struct ltc_hash_descriptor sha224_desc; -#endif -#endif - -#ifdef LTC_SHA1 -int sha1_init(hash_state * md); -int sha1_process(hash_state * md, const unsigned char *in, unsigned long inlen); -int sha1_done(hash_state * md, unsigned char *hash); -int sha1_test(void); -extern const struct ltc_hash_descriptor sha1_desc; -#endif - -#ifdef LTC_MD5 -int md5_init(hash_state * md); -int md5_process(hash_state * md, const unsigned char *in, unsigned long inlen); -int md5_done(hash_state * md, unsigned char *hash); -int md5_test(void); -extern const struct ltc_hash_descriptor md5_desc; -#endif - -#ifdef LTC_MD4 -int md4_init(hash_state * md); -int md4_process(hash_state * md, const unsigned char *in, unsigned long inlen); -int md4_done(hash_state * md, unsigned char *hash); -int md4_test(void); -extern const struct ltc_hash_descriptor md4_desc; -#endif - -#ifdef LTC_MD2 -int md2_init(hash_state * md); -int md2_process(hash_state * md, const unsigned char *in, unsigned long inlen); -int md2_done(hash_state * md, unsigned char *hash); -int md2_test(void); -extern const struct ltc_hash_descriptor md2_desc; -#endif - -#ifdef LTC_TIGER -int tiger_init(hash_state * md); -int tiger_process(hash_state * md, const unsigned char *in, unsigned long inlen); -int tiger_done(hash_state * md, unsigned char *hash); -int tiger_test(void); -extern const struct ltc_hash_descriptor tiger_desc; -#endif - -#ifdef LTC_RIPEMD128 -int rmd128_init(hash_state * md); -int rmd128_process(hash_state * md, const unsigned char *in, unsigned long inlen); -int rmd128_done(hash_state * md, unsigned char *hash); -int rmd128_test(void); -extern const struct ltc_hash_descriptor rmd128_desc; -#endif - -#ifdef LTC_RIPEMD160 -int rmd160_init(hash_state * md); -int rmd160_process(hash_state * md, const unsigned char *in, unsigned long inlen); -int rmd160_done(hash_state * md, unsigned char *hash); -int rmd160_test(void); -extern const struct ltc_hash_descriptor rmd160_desc; -#endif - -#ifdef LTC_RIPEMD256 -int rmd256_init(hash_state * md); -int rmd256_process(hash_state * md, const unsigned char *in, unsigned long inlen); -int rmd256_done(hash_state * md, unsigned char *hash); -int rmd256_test(void); -extern const struct ltc_hash_descriptor rmd256_desc; -#endif - -#ifdef LTC_RIPEMD320 -int rmd320_init(hash_state * md); -int rmd320_process(hash_state * md, const unsigned char *in, unsigned long inlen); -int rmd320_done(hash_state * md, unsigned char *hash); -int rmd320_test(void); -extern const struct ltc_hash_descriptor rmd320_desc; -#endif - - -int find_hash(const char *name); -int find_hash_id(unsigned char ID); -int find_hash_oid(const unsigned long *ID, unsigned long IDlen); -int find_hash_any(const char *name, int digestlen); -int register_hash(const struct ltc_hash_descriptor *hash); -int unregister_hash(const struct ltc_hash_descriptor *hash); -int hash_is_valid(int idx); - -LTC_MUTEX_PROTO(ltc_hash_mutex) - -int hash_memory(int hash, - const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen); -int hash_memory_multi(int hash, unsigned char *out, unsigned long *outlen, - const unsigned char *in, unsigned long inlen, ...); -int hash_filehandle(int hash, FILE *in, unsigned char *out, unsigned long *outlen); -int hash_file(int hash, const char *fname, unsigned char *out, unsigned long *outlen); - -/* a simple macro for making hash "process" functions */ -#define HASH_PROCESS(func_name, compress_name, state_var, block_size) \ -int func_name (hash_state * md, const unsigned char *in, unsigned long inlen) \ -{ \ - unsigned long n; \ - int err; \ - LTC_ARGCHK(md != NULL); \ - LTC_ARGCHK(in != NULL); \ - if (md-> state_var .curlen > sizeof(md-> state_var .buf)) { \ - return CRYPT_INVALID_ARG; \ - } \ - while (inlen > 0) { \ - if (md-> state_var .curlen == 0 && inlen >= block_size) { \ - if ((err = compress_name (md, (unsigned char *)in)) != CRYPT_OK) { \ - return err; \ - } \ - md-> state_var .length += block_size * 8; \ - in += block_size; \ - inlen -= block_size; \ - } else { \ - n = MIN(inlen, (block_size - md-> state_var .curlen)); \ - memcpy(md-> state_var .buf + md-> state_var.curlen, in, (size_t)n); \ - md-> state_var .curlen += n; \ - in += n; \ - inlen -= n; \ - if (md-> state_var .curlen == block_size) { \ - if ((err = compress_name (md, md-> state_var .buf)) != CRYPT_OK) { \ - return err; \ - } \ - md-> state_var .length += 8*block_size; \ - md-> state_var .curlen = 0; \ - } \ - } \ - } \ - return CRYPT_OK; \ -} - -/* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt_hash.h,v $ */ -/* $Revision: 1.22 $ */ -/* $Date: 2007/05/12 14:32:35 $ */ diff --git a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_mac.h b/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_mac.h deleted file mode 100644 index 7ad9516bd29..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_mac.h +++ /dev/null @@ -1,384 +0,0 @@ -#ifdef LTC_HMAC -typedef struct Hmac_state { - hash_state md; - int hash; - hash_state hashstate; - unsigned char *key; -} hmac_state; - -int hmac_init(hmac_state *hmac, int hash, const unsigned char *key, unsigned long keylen); -int hmac_process(hmac_state *hmac, const unsigned char *in, unsigned long inlen); -int hmac_done(hmac_state *hmac, unsigned char *out, unsigned long *outlen); -int hmac_test(void); -int hmac_memory(int hash, - const unsigned char *key, unsigned long keylen, - const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen); -int hmac_memory_multi(int hash, - const unsigned char *key, unsigned long keylen, - unsigned char *out, unsigned long *outlen, - const unsigned char *in, unsigned long inlen, ...); -int hmac_file(int hash, const char *fname, const unsigned char *key, - unsigned long keylen, - unsigned char *dst, unsigned long *dstlen); -#endif - -#ifdef LTC_OMAC - -typedef struct { - int cipher_idx, - buflen, - blklen; - unsigned char block[MAXBLOCKSIZE], - prev[MAXBLOCKSIZE], - Lu[2][MAXBLOCKSIZE]; - symmetric_key key; -} omac_state; - -int omac_init(omac_state *omac, int cipher, const unsigned char *key, unsigned long keylen); -int omac_process(omac_state *omac, const unsigned char *in, unsigned long inlen); -int omac_done(omac_state *omac, unsigned char *out, unsigned long *outlen); -int omac_memory(int cipher, - const unsigned char *key, unsigned long keylen, - const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen); -int omac_memory_multi(int cipher, - const unsigned char *key, unsigned long keylen, - unsigned char *out, unsigned long *outlen, - const unsigned char *in, unsigned long inlen, ...); -int omac_file(int cipher, - const unsigned char *key, unsigned long keylen, - const char *filename, - unsigned char *out, unsigned long *outlen); -int omac_test(void); -#endif /* LTC_OMAC */ - -#ifdef LTC_PMAC - -typedef struct { - unsigned char Ls[32][MAXBLOCKSIZE], /* L shifted by i bits to the left */ - Li[MAXBLOCKSIZE], /* value of Li [current value, we calc from previous recall] */ - Lr[MAXBLOCKSIZE], /* L * x^-1 */ - block[MAXBLOCKSIZE], /* currently accumulated block */ - checksum[MAXBLOCKSIZE]; /* current checksum */ - - symmetric_key key; /* scheduled key for cipher */ - unsigned long block_index; /* index # for current block */ - int cipher_idx, /* cipher idx */ - block_len, /* length of block */ - buflen; /* number of bytes in the buffer */ -} pmac_state; - -int pmac_init(pmac_state *pmac, int cipher, const unsigned char *key, unsigned long keylen); -int pmac_process(pmac_state *pmac, const unsigned char *in, unsigned long inlen); -int pmac_done(pmac_state *pmac, unsigned char *out, unsigned long *outlen); - -int pmac_memory(int cipher, - const unsigned char *key, unsigned long keylen, - const unsigned char *msg, unsigned long msglen, - unsigned char *out, unsigned long *outlen); - -int pmac_memory_multi(int cipher, - const unsigned char *key, unsigned long keylen, - unsigned char *out, unsigned long *outlen, - const unsigned char *in, unsigned long inlen, ...); - -int pmac_file(int cipher, - const unsigned char *key, unsigned long keylen, - const char *filename, - unsigned char *out, unsigned long *outlen); - -int pmac_test(void); - -/* internal functions */ -int pmac_ntz(unsigned long x); -void pmac_shift_xor(pmac_state *pmac); - -#endif /* PMAC */ - -#ifdef LTC_EAX_MODE - -#if !(defined(LTC_OMAC) && defined(LTC_CTR_MODE)) - #error LTC_EAX_MODE requires LTC_OMAC and CTR -#endif - -typedef struct { - unsigned char N[MAXBLOCKSIZE]; - symmetric_CTR ctr; - omac_state headeromac, ctomac; -} eax_state; - -int eax_init(eax_state *eax, int cipher, const unsigned char *key, unsigned long keylen, - const unsigned char *nonce, unsigned long noncelen, - const unsigned char *header, unsigned long headerlen); - -int eax_encrypt(eax_state *eax, const unsigned char *pt, unsigned char *ct, unsigned long length); -int eax_decrypt(eax_state *eax, const unsigned char *ct, unsigned char *pt, unsigned long length); -int eax_addheader(eax_state *eax, const unsigned char *header, unsigned long length); -int eax_done(eax_state *eax, unsigned char *tag, unsigned long *taglen); - -int eax_encrypt_authenticate_memory(int cipher, - const unsigned char *key, unsigned long keylen, - const unsigned char *nonce, unsigned long noncelen, - const unsigned char *header, unsigned long headerlen, - const unsigned char *pt, unsigned long ptlen, - unsigned char *ct, - unsigned char *tag, unsigned long *taglen); - -int eax_decrypt_verify_memory(int cipher, - const unsigned char *key, unsigned long keylen, - const unsigned char *nonce, unsigned long noncelen, - const unsigned char *header, unsigned long headerlen, - const unsigned char *ct, unsigned long ctlen, - unsigned char *pt, - unsigned char *tag, unsigned long taglen, - int *stat); - - int eax_test(void); -#endif /* EAX MODE */ - -#ifdef LTC_OCB_MODE -typedef struct { - unsigned char L[MAXBLOCKSIZE], /* L value */ - Ls[32][MAXBLOCKSIZE], /* L shifted by i bits to the left */ - Li[MAXBLOCKSIZE], /* value of Li [current value, we calc from previous recall] */ - Lr[MAXBLOCKSIZE], /* L * x^-1 */ - R[MAXBLOCKSIZE], /* R value */ - checksum[MAXBLOCKSIZE]; /* current checksum */ - - symmetric_key key; /* scheduled key for cipher */ - unsigned long block_index; /* index # for current block */ - int cipher, /* cipher idx */ - block_len; /* length of block */ -} ocb_state; - -int ocb_init(ocb_state *ocb, int cipher, - const unsigned char *key, unsigned long keylen, const unsigned char *nonce); - -int ocb_encrypt(ocb_state *ocb, const unsigned char *pt, unsigned char *ct); -int ocb_decrypt(ocb_state *ocb, const unsigned char *ct, unsigned char *pt); - -int ocb_done_encrypt(ocb_state *ocb, - const unsigned char *pt, unsigned long ptlen, - unsigned char *ct, - unsigned char *tag, unsigned long *taglen); - -int ocb_done_decrypt(ocb_state *ocb, - const unsigned char *ct, unsigned long ctlen, - unsigned char *pt, - const unsigned char *tag, unsigned long taglen, int *stat); - -int ocb_encrypt_authenticate_memory(int cipher, - const unsigned char *key, unsigned long keylen, - const unsigned char *nonce, - const unsigned char *pt, unsigned long ptlen, - unsigned char *ct, - unsigned char *tag, unsigned long *taglen); - -int ocb_decrypt_verify_memory(int cipher, - const unsigned char *key, unsigned long keylen, - const unsigned char *nonce, - const unsigned char *ct, unsigned long ctlen, - unsigned char *pt, - const unsigned char *tag, unsigned long taglen, - int *stat); - -int ocb_test(void); - -/* internal functions */ -void ocb_shift_xor(ocb_state *ocb, unsigned char *Z); -int ocb_ntz(unsigned long x); -int s_ocb_done(ocb_state *ocb, const unsigned char *pt, unsigned long ptlen, - unsigned char *ct, unsigned char *tag, unsigned long *taglen, int mode); - -#endif /* LTC_OCB_MODE */ - -#ifdef LTC_CCM_MODE - -#define CCM_ENCRYPT 0 -#define CCM_DECRYPT 1 - -int ccm_memory(int cipher, - const unsigned char *key, unsigned long keylen, - symmetric_key *uskey, - const unsigned char *nonce, unsigned long noncelen, - const unsigned char *header, unsigned long headerlen, - unsigned char *pt, unsigned long ptlen, - unsigned char *ct, - unsigned char *tag, unsigned long *taglen, - int direction); - -int ccm_test(void); - -#endif /* LTC_CCM_MODE */ - -#if defined(LRW_MODE) || defined(LTC_GCM_MODE) -void gcm_gf_mult(const unsigned char *a, const unsigned char *b, unsigned char *c); -#endif - - -/* table shared between GCM and LRW */ -#if defined(LTC_GCM_TABLES) || defined(LRW_TABLES) || ((defined(LTC_GCM_MODE) || defined(LTC_GCM_MODE)) && defined(LTC_FAST)) -extern const unsigned char gcm_shift_table[]; -#endif - -#ifdef LTC_GCM_MODE - -#define GCM_ENCRYPT 0 -#define GCM_DECRYPT 1 - -#define LTC_GCM_MODE_IV 0 -#define LTC_GCM_MODE_AAD 1 -#define LTC_GCM_MODE_TEXT 2 - -typedef struct { - symmetric_key K; - unsigned char H[16], /* multiplier */ - X[16], /* accumulator */ - Y[16], /* counter */ - Y_0[16], /* initial counter */ - buf[16]; /* buffer for stuff */ - - int cipher, /* which cipher */ - ivmode, /* Which mode is the IV in? */ - mode, /* mode the GCM code is in */ - buflen; /* length of data in buf */ - - ulong64 totlen, /* 64-bit counter used for IV and AAD */ - pttotlen; /* 64-bit counter for the PT */ - -#ifdef LTC_GCM_TABLES - unsigned char PC[16][256][16] /* 16 tables of 8x128 */ -#ifdef LTC_GCM_TABLES_SSE2 -__attribute__ ((aligned (16))) -#endif -; -#endif -} gcm_state; - -void gcm_mult_h(gcm_state *gcm, unsigned char *I); - -int gcm_init(gcm_state *gcm, int cipher, - const unsigned char *key, int keylen); - -int gcm_reset(gcm_state *gcm); - -int gcm_add_iv(gcm_state *gcm, - const unsigned char *IV, unsigned long IVlen); - -int gcm_add_aad(gcm_state *gcm, - const unsigned char *adata, unsigned long adatalen); - -int gcm_process(gcm_state *gcm, - unsigned char *pt, unsigned long ptlen, - unsigned char *ct, - int direction); - -int gcm_done(gcm_state *gcm, - unsigned char *tag, unsigned long *taglen); - -int gcm_memory( int cipher, - const unsigned char *key, unsigned long keylen, - const unsigned char *IV, unsigned long IVlen, - const unsigned char *adata, unsigned long adatalen, - unsigned char *pt, unsigned long ptlen, - unsigned char *ct, - unsigned char *tag, unsigned long *taglen, - int direction); -int gcm_test(void); - -#endif /* LTC_GCM_MODE */ - -#ifdef LTC_PELICAN - -typedef struct pelican_state -{ - symmetric_key K; - unsigned char state[16]; - int buflen; -} pelican_state; - -int pelican_init(pelican_state *pelmac, const unsigned char *key, unsigned long keylen); -int pelican_process(pelican_state *pelmac, const unsigned char *in, unsigned long inlen); -int pelican_done(pelican_state *pelmac, unsigned char *out); -int pelican_test(void); - -int pelican_memory(const unsigned char *key, unsigned long keylen, - const unsigned char *in, unsigned long inlen, - unsigned char *out); - -#endif - -#ifdef LTC_XCBC - -/* add this to "keylen" to xcbc_init to use a pure three-key XCBC MAC */ -#define LTC_XCBC_PURE 0x8000UL - -typedef struct { - unsigned char K[3][MAXBLOCKSIZE], - IV[MAXBLOCKSIZE]; - - symmetric_key key; - - int cipher, - buflen, - blocksize; -} xcbc_state; - -int xcbc_init(xcbc_state *xcbc, int cipher, const unsigned char *key, unsigned long keylen); -int xcbc_process(xcbc_state *xcbc, const unsigned char *in, unsigned long inlen); -int xcbc_done(xcbc_state *xcbc, unsigned char *out, unsigned long *outlen); -int xcbc_memory(int cipher, - const unsigned char *key, unsigned long keylen, - const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen); -int xcbc_memory_multi(int cipher, - const unsigned char *key, unsigned long keylen, - unsigned char *out, unsigned long *outlen, - const unsigned char *in, unsigned long inlen, ...); -int xcbc_file(int cipher, - const unsigned char *key, unsigned long keylen, - const char *filename, - unsigned char *out, unsigned long *outlen); -int xcbc_test(void); - -#endif - -#ifdef LTC_F9_MODE - -typedef struct { - unsigned char akey[MAXBLOCKSIZE], - ACC[MAXBLOCKSIZE], - IV[MAXBLOCKSIZE]; - - symmetric_key key; - - int cipher, - buflen, - keylen, - blocksize; -} f9_state; - -int f9_init(f9_state *f9, int cipher, const unsigned char *key, unsigned long keylen); -int f9_process(f9_state *f9, const unsigned char *in, unsigned long inlen); -int f9_done(f9_state *f9, unsigned char *out, unsigned long *outlen); -int f9_memory(int cipher, - const unsigned char *key, unsigned long keylen, - const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen); -int f9_memory_multi(int cipher, - const unsigned char *key, unsigned long keylen, - unsigned char *out, unsigned long *outlen, - const unsigned char *in, unsigned long inlen, ...); -int f9_file(int cipher, - const unsigned char *key, unsigned long keylen, - const char *filename, - unsigned char *out, unsigned long *outlen); -int f9_test(void); - -#endif - - -/* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt_mac.h,v $ */ -/* $Revision: 1.23 $ */ -/* $Date: 2007/05/12 14:37:41 $ */ diff --git a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_macros.h b/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_macros.h deleted file mode 100644 index 53bda9bb4ba..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_macros.h +++ /dev/null @@ -1,424 +0,0 @@ -/* fix for MSVC ...evil! */ -#ifdef _MSC_VER - #define CONST64(n) n ## ui64 - typedef unsigned __int64 ulong64; -#else - #define CONST64(n) n ## ULL - typedef unsigned long long ulong64; -#endif - -/* this is the "32-bit at least" data type - * Re-define it to suit your platform but it must be at least 32-bits - */ -#if defined(__x86_64__) || (defined(__sparc__) && defined(__arch64__)) - typedef unsigned ulong32; -#else - typedef unsigned long ulong32; -#endif - -/* ---- HELPER MACROS ---- */ -#ifdef ENDIAN_NEUTRAL - -#define STORE32L(x, y) \ - { (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \ - (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } - -#define LOAD32L(x, y) \ - { x = ((unsigned long)((y)[3] & 255)<<24) | \ - ((unsigned long)((y)[2] & 255)<<16) | \ - ((unsigned long)((y)[1] & 255)<<8) | \ - ((unsigned long)((y)[0] & 255)); } - -#define STORE64L(x, y) \ - { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255); \ - (y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255); \ - (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \ - (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } - -#define LOAD64L(x, y) \ - { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48)| \ - (((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32)| \ - (((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16)| \ - (((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); } - -#define STORE32H(x, y) \ - { (y)[0] = (unsigned char)(((x)>>24)&255); (y)[1] = (unsigned char)(((x)>>16)&255); \ - (y)[2] = (unsigned char)(((x)>>8)&255); (y)[3] = (unsigned char)((x)&255); } - -#define LOAD32H(x, y) \ - { x = ((unsigned long)((y)[0] & 255)<<24) | \ - ((unsigned long)((y)[1] & 255)<<16) | \ - ((unsigned long)((y)[2] & 255)<<8) | \ - ((unsigned long)((y)[3] & 255)); } - -#define STORE64H(x, y) \ - { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255); \ - (y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255); \ - (y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255); \ - (y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); } - -#define LOAD64H(x, y) \ - { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48) | \ - (((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32) | \ - (((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16) | \ - (((ulong64)((y)[6] & 255))<<8)|(((ulong64)((y)[7] & 255))); } - -#endif /* ENDIAN_NEUTRAL */ - -#ifdef ENDIAN_LITTLE - -#if !defined(LTC_NO_BSWAP) && (defined(INTEL_CC) || (defined(__GNUC__) && (defined(__DJGPP__) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__i386__) || defined(__x86_64__)))) - -#define STORE32H(x, y) \ -asm __volatile__ ( \ - "bswapl %0 \n\t" \ - "movl %0,(%1)\n\t" \ - "bswapl %0 \n\t" \ - ::"r"(x), "r"(y)); - -#define LOAD32H(x, y) \ -asm __volatile__ ( \ - "movl (%1),%0\n\t" \ - "bswapl %0\n\t" \ - :"=r"(x): "r"(y)); - -#else - -#define STORE32H(x, y) \ - { (y)[0] = (unsigned char)(((x)>>24)&255); (y)[1] = (unsigned char)(((x)>>16)&255); \ - (y)[2] = (unsigned char)(((x)>>8)&255); (y)[3] = (unsigned char)((x)&255); } - -#define LOAD32H(x, y) \ - { x = ((unsigned long)((y)[0] & 255)<<24) | \ - ((unsigned long)((y)[1] & 255)<<16) | \ - ((unsigned long)((y)[2] & 255)<<8) | \ - ((unsigned long)((y)[3] & 255)); } - -#endif - - -/* x86_64 processor */ -#if !defined(LTC_NO_BSWAP) && (defined(__GNUC__) && defined(__x86_64__)) - -#define STORE64H(x, y) \ -asm __volatile__ ( \ - "bswapq %0 \n\t" \ - "movq %0,(%1)\n\t" \ - "bswapq %0 \n\t" \ - ::"r"(x), "r"(y)); - -#define LOAD64H(x, y) \ -asm __volatile__ ( \ - "movq (%1),%0\n\t" \ - "bswapq %0\n\t" \ - :"=r"(x): "r"(y)); - -#else - -#define STORE64H(x, y) \ - { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255); \ - (y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255); \ - (y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255); \ - (y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); } - -#define LOAD64H(x, y) \ - { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48) | \ - (((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32) | \ - (((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16) | \ - (((ulong64)((y)[6] & 255))<<8)|(((ulong64)((y)[7] & 255))); } - -#endif - -#ifdef ENDIAN_32BITWORD - -#define STORE32L(x, y) \ - { ulong32 __t = (x); XMEMCPY(y, &__t, 4); } - -#define LOAD32L(x, y) \ - XMEMCPY(&(x), y, 4); - -#define STORE64L(x, y) \ - { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255); \ - (y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255); \ - (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \ - (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } - -#define LOAD64L(x, y) \ - { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48)| \ - (((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32)| \ - (((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16)| \ - (((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); } - -#else /* 64-bit words then */ - -#define STORE32L(x, y) \ - { ulong32 __t = (x); XMEMCPY(y, &__t, 4); } - -#define LOAD32L(x, y) \ - { XMEMCPY(&(x), y, 4); x &= 0xFFFFFFFF; } - -#define STORE64L(x, y) \ - { ulong64 __t = (x); XMEMCPY(y, &__t, 8); } - -#define LOAD64L(x, y) \ - { XMEMCPY(&(x), y, 8); } - -#endif /* ENDIAN_64BITWORD */ - -#endif /* ENDIAN_LITTLE */ - -#ifdef ENDIAN_BIG -#define STORE32L(x, y) \ - { (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \ - (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } - -#define LOAD32L(x, y) \ - { x = ((unsigned long)((y)[3] & 255)<<24) | \ - ((unsigned long)((y)[2] & 255)<<16) | \ - ((unsigned long)((y)[1] & 255)<<8) | \ - ((unsigned long)((y)[0] & 255)); } - -#define STORE64L(x, y) \ - { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255); \ - (y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255); \ - (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255); \ - (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } - -#define LOAD64L(x, y) \ - { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48) | \ - (((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32) | \ - (((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16) | \ - (((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); } - -#ifdef ENDIAN_32BITWORD - -#define STORE32H(x, y) \ - { ulong32 __t = (x); XMEMCPY(y, &__t, 4); } - -#define LOAD32H(x, y) \ - XMEMCPY(&(x), y, 4); - -#define STORE64H(x, y) \ - { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255); \ - (y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255); \ - (y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255); \ - (y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); } - -#define LOAD64H(x, y) \ - { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48)| \ - (((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32)| \ - (((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16)| \ - (((ulong64)((y)[6] & 255))<<8)| (((ulong64)((y)[7] & 255))); } - -#else /* 64-bit words then */ - -#define STORE32H(x, y) \ - { ulong32 __t = (x); XMEMCPY(y, &__t, 4); } - -#define LOAD32H(x, y) \ - { XMEMCPY(&(x), y, 4); x &= 0xFFFFFFFF; } - -#define STORE64H(x, y) \ - { ulong64 __t = (x); XMEMCPY(y, &__t, 8); } - -#define LOAD64H(x, y) \ - { XMEMCPY(&(x), y, 8); } - -#endif /* ENDIAN_64BITWORD */ -#endif /* ENDIAN_BIG */ - -#define BSWAP(x) ( ((x>>24)&0x000000FFUL) | ((x<<24)&0xFF000000UL) | \ - ((x>>8)&0x0000FF00UL) | ((x<<8)&0x00FF0000UL) ) - - -/* 32-bit Rotates */ -#if defined(_MSC_VER) - -/* instrinsic rotate */ -#include <stdlib.h> -#pragma intrinsic(_lrotr,_lrotl) -#define ROR(x,n) _lrotr(x,n) -#define ROL(x,n) _lrotl(x,n) -#define RORc(x,n) _lrotr(x,n) -#define ROLc(x,n) _lrotl(x,n) - -#elif !defined(__STRICT_ANSI__) && defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) && !defined(INTEL_CC) && !defined(LTC_NO_ASM) - -static inline unsigned ROL(unsigned word, int i) -{ - asm ("roll %%cl,%0" - :"=r" (word) - :"0" (word),"c" (i)); - return word; -} - -static inline unsigned ROR(unsigned word, int i) -{ - asm ("rorl %%cl,%0" - :"=r" (word) - :"0" (word),"c" (i)); - return word; -} - -#ifndef LTC_NO_ROLC - -static inline unsigned ROLc(unsigned word, const int i) -{ - asm ("roll %2,%0" - :"=r" (word) - :"0" (word),"I" (i)); - return word; -} - -static inline unsigned RORc(unsigned word, const int i) -{ - asm ("rorl %2,%0" - :"=r" (word) - :"0" (word),"I" (i)); - return word; -} - -#else - -#define ROLc ROL -#define RORc ROR - -#endif - -#elif !defined(__STRICT_ANSI__) && defined(LTC_PPC32) - -static inline unsigned ROL(unsigned word, int i) -{ - asm ("rotlw %0,%0,%2" - :"=r" (word) - :"0" (word),"r" (i)); - return word; -} - -static inline unsigned ROR(unsigned word, int i) -{ - asm ("rotlw %0,%0,%2" - :"=r" (word) - :"0" (word),"r" (32-i)); - return word; -} - -#ifndef LTC_NO_ROLC - -static inline unsigned ROLc(unsigned word, const int i) -{ - asm ("rotlwi %0,%0,%2" - :"=r" (word) - :"0" (word),"I" (i)); - return word; -} - -static inline unsigned RORc(unsigned word, const int i) -{ - asm ("rotrwi %0,%0,%2" - :"=r" (word) - :"0" (word),"I" (i)); - return word; -} - -#else - -#define ROLc ROL -#define RORc ROR - -#endif - - -#else - -/* rotates the hard way */ -#define ROL(x, y) ( (((unsigned long)(x)<<(unsigned long)((y)&31)) | (((unsigned long)(x)&0xFFFFFFFFUL)>>(unsigned long)(32-((y)&31)))) & 0xFFFFFFFFUL) -#define ROR(x, y) ( ((((unsigned long)(x)&0xFFFFFFFFUL)>>(unsigned long)((y)&31)) | ((unsigned long)(x)<<(unsigned long)(32-((y)&31)))) & 0xFFFFFFFFUL) -#define ROLc(x, y) ( (((unsigned long)(x)<<(unsigned long)((y)&31)) | (((unsigned long)(x)&0xFFFFFFFFUL)>>(unsigned long)(32-((y)&31)))) & 0xFFFFFFFFUL) -#define RORc(x, y) ( ((((unsigned long)(x)&0xFFFFFFFFUL)>>(unsigned long)((y)&31)) | ((unsigned long)(x)<<(unsigned long)(32-((y)&31)))) & 0xFFFFFFFFUL) - -#endif - - -/* 64-bit Rotates */ -#if !defined(__STRICT_ANSI__) && defined(__GNUC__) && defined(__x86_64__) && !defined(LTC_NO_ASM) - -static inline unsigned long ROL64(unsigned long word, int i) -{ - asm("rolq %%cl,%0" - :"=r" (word) - :"0" (word),"c" (i)); - return word; -} - -static inline unsigned long ROR64(unsigned long word, int i) -{ - asm("rorq %%cl,%0" - :"=r" (word) - :"0" (word),"c" (i)); - return word; -} - -#ifndef LTC_NO_ROLC - -static inline unsigned long ROL64c(unsigned long word, const int i) -{ - asm("rolq %2,%0" - :"=r" (word) - :"0" (word),"J" (i)); - return word; -} - -static inline unsigned long ROR64c(unsigned long word, const int i) -{ - asm("rorq %2,%0" - :"=r" (word) - :"0" (word),"J" (i)); - return word; -} - -#else /* LTC_NO_ROLC */ - -#define ROL64c ROL64 -#define ROR64c ROR64 - -#endif - -#else /* Not x86_64 */ - -#define ROL64(x, y) \ - ( (((x)<<((ulong64)(y)&63)) | \ - (((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)64-((y)&63)))) & CONST64(0xFFFFFFFFFFFFFFFF)) - -#define ROR64(x, y) \ - ( ((((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)(y)&CONST64(63))) | \ - ((x)<<((ulong64)(64-((y)&CONST64(63)))))) & CONST64(0xFFFFFFFFFFFFFFFF)) - -#define ROL64c(x, y) \ - ( (((x)<<((ulong64)(y)&63)) | \ - (((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)64-((y)&63)))) & CONST64(0xFFFFFFFFFFFFFFFF)) - -#define ROR64c(x, y) \ - ( ((((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)(y)&CONST64(63))) | \ - ((x)<<((ulong64)(64-((y)&CONST64(63)))))) & CONST64(0xFFFFFFFFFFFFFFFF)) - -#endif - -#ifndef MAX - #define MAX(x, y) ( ((x)>(y))?(x):(y) ) -#endif - -#ifndef MIN - #define MIN(x, y) ( ((x)<(y))?(x):(y) ) -#endif - -/* extract a byte portably */ -#ifdef _MSC_VER - #define byte(x, n) ((unsigned char)((x) >> (8 * (n)))) -#else - #define byte(x, n) (((x) >> (8 * (n))) & 255) -#endif - -/* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt_macros.h,v $ */ -/* $Revision: 1.15 $ */ -/* $Date: 2006/11/29 23:43:57 $ */ diff --git a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_math.h b/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_math.h deleted file mode 100644 index a05d7fff942..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_math.h +++ /dev/null @@ -1,500 +0,0 @@ -/** math functions **/ - -#define LTC_MP_LT -1 -#define LTC_MP_EQ 0 -#define LTC_MP_GT 1 - -#define LTC_MP_NO 0 -#define LTC_MP_YES 1 - -#ifndef LTC_MECC - typedef void ecc_point; -#endif - -#ifndef LTC_MRSA - typedef void rsa_key; -#endif - -/** math descriptor */ -typedef struct { - /** Name of the math provider */ - char *name; - - /** Bits per digit, amount of bits must fit in an unsigned long */ - int bits_per_digit; - -/* ---- init/deinit functions ---- */ - - /** initialize a bignum - @param a The number to initialize - @return CRYPT_OK on success - */ - int (*init)(void **a); - - /** init copy - @param dst The number to initialize and write to - @param src The number to copy from - @return CRYPT_OK on success - */ - int (*init_copy)(void **dst, void *src); - - /** deinit - @param a The number to free - @return CRYPT_OK on success - */ - void (*deinit)(void *a); - -/* ---- data movement ---- */ - - /** negate - @param src The number to negate - @param dst The destination - @return CRYPT_OK on success - */ - int (*neg)(void *src, void *dst); - - /** copy - @param src The number to copy from - @param dst The number to write to - @return CRYPT_OK on success - */ - int (*copy)(void *src, void *dst); - -/* ---- trivial low level functions ---- */ - - /** set small constant - @param a Number to write to - @param n Source upto bits_per_digit (actually meant for very small constants) - @return CRYPT_OK on succcess - */ - int (*set_int)(void *a, unsigned long n); - - /** get small constant - @param a Number to read, only fetches upto bits_per_digit from the number - @return The lower bits_per_digit of the integer (unsigned) - */ - unsigned long (*get_int)(void *a); - - /** get digit n - @param a The number to read from - @param n The number of the digit to fetch - @return The bits_per_digit sized n'th digit of a - */ - unsigned long (*get_digit)(void *a, int n); - - /** Get the number of digits that represent the number - @param a The number to count - @return The number of digits used to represent the number - */ - int (*get_digit_count)(void *a); - - /** compare two integers - @param a The left side integer - @param b The right side integer - @return LTC_MP_LT if a < b, LTC_MP_GT if a > b and LTC_MP_EQ otherwise. (signed comparison) - */ - int (*compare)(void *a, void *b); - - /** compare against int - @param a The left side integer - @param b The right side integer (upto bits_per_digit) - @return LTC_MP_LT if a < b, LTC_MP_GT if a > b and LTC_MP_EQ otherwise. (signed comparison) - */ - int (*compare_d)(void *a, unsigned long n); - - /** Count the number of bits used to represent the integer - @param a The integer to count - @return The number of bits required to represent the integer - */ - int (*count_bits)(void * a); - - /** Count the number of LSB bits which are zero - @param a The integer to count - @return The number of contiguous zero LSB bits - */ - int (*count_lsb_bits)(void *a); - - /** Compute a power of two - @param a The integer to store the power in - @param n The power of two you want to store (a = 2^n) - @return CRYPT_OK on success - */ - int (*twoexpt)(void *a , int n); - -/* ---- radix conversions ---- */ - - /** read ascii string - @param a The integer to store into - @param str The string to read - @param radix The radix the integer has been represented in (2-64) - @return CRYPT_OK on success - */ - int (*read_radix)(void *a, const char *str, int radix); - - /** write number to string - @param a The integer to store - @param str The destination for the string - @param radix The radix the integer is to be represented in (2-64) - @return CRYPT_OK on success - */ - int (*write_radix)(void *a, char *str, int radix); - - /** get size as unsigned char string - @param a The integer to get the size (when stored in array of octets) - @return The length of the integer - */ - unsigned long (*unsigned_size)(void *a); - - /** store an integer as an array of octets - @param src The integer to store - @param dst The buffer to store the integer in - @return CRYPT_OK on success - */ - int (*unsigned_write)(void *src, unsigned char *dst); - - /** read an array of octets and store as integer - @param dst The integer to load - @param src The array of octets - @param len The number of octets - @return CRYPT_OK on success - */ - int (*unsigned_read)(void *dst, unsigned char *src, unsigned long len); - -/* ---- basic math ---- */ - - /** add two integers - @param a The first source integer - @param b The second source integer - @param c The destination of "a + b" - @return CRYPT_OK on success - */ - int (*add)(void *a, void *b, void *c); - - - /** add two integers - @param a The first source integer - @param b The second source integer (single digit of upto bits_per_digit in length) - @param c The destination of "a + b" - @return CRYPT_OK on success - */ - int (*addi)(void *a, unsigned long b, void *c); - - /** subtract two integers - @param a The first source integer - @param b The second source integer - @param c The destination of "a - b" - @return CRYPT_OK on success - */ - int (*sub)(void *a, void *b, void *c); - - /** subtract two integers - @param a The first source integer - @param b The second source integer (single digit of upto bits_per_digit in length) - @param c The destination of "a - b" - @return CRYPT_OK on success - */ - int (*subi)(void *a, unsigned long b, void *c); - - /** multiply two integers - @param a The first source integer - @param b The second source integer (single digit of upto bits_per_digit in length) - @param c The destination of "a * b" - @return CRYPT_OK on success - */ - int (*mul)(void *a, void *b, void *c); - - /** multiply two integers - @param a The first source integer - @param b The second source integer (single digit of upto bits_per_digit in length) - @param c The destination of "a * b" - @return CRYPT_OK on success - */ - int (*muli)(void *a, unsigned long b, void *c); - - /** Square an integer - @param a The integer to square - @param b The destination - @return CRYPT_OK on success - */ - int (*sqr)(void *a, void *b); - - /** Divide an integer - @param a The dividend - @param b The divisor - @param c The quotient (can be NULL to signify don't care) - @param d The remainder (can be NULL to signify don't care) - @return CRYPT_OK on success - */ - int (*mpdiv)(void *a, void *b, void *c, void *d); - - /** divide by two - @param a The integer to divide (shift right) - @param b The destination - @return CRYPT_OK on success - */ - int (*div_2)(void *a, void *b); - - /** Get remainder (small value) - @param a The integer to reduce - @param b The modulus (upto bits_per_digit in length) - @param c The destination for the residue - @return CRYPT_OK on success - */ - int (*modi)(void *a, unsigned long b, unsigned long *c); - - /** gcd - @param a The first integer - @param b The second integer - @param c The destination for (a, b) - @return CRYPT_OK on success - */ - int (*gcd)(void *a, void *b, void *c); - - /** lcm - @param a The first integer - @param b The second integer - @param c The destination for [a, b] - @return CRYPT_OK on success - */ - int (*lcm)(void *a, void *b, void *c); - - /** Modular multiplication - @param a The first source - @param b The second source - @param c The modulus - @param d The destination (a*b mod c) - @return CRYPT_OK on success - */ - int (*mulmod)(void *a, void *b, void *c, void *d); - - /** Modular squaring - @param a The first source - @param b The modulus - @param c The destination (a*a mod b) - @return CRYPT_OK on success - */ - int (*sqrmod)(void *a, void *b, void *c); - - /** Modular inversion - @param a The value to invert - @param b The modulus - @param c The destination (1/a mod b) - @return CRYPT_OK on success - */ - int (*invmod)(void *, void *, void *); - -/* ---- reduction ---- */ - - /** setup montgomery - @param a The modulus - @param b The destination for the reduction digit - @return CRYPT_OK on success - */ - int (*montgomery_setup)(void *a, void **b); - - /** get normalization value - @param a The destination for the normalization value - @param b The modulus - @return CRYPT_OK on success - */ - int (*montgomery_normalization)(void *a, void *b); - - /** reduce a number - @param a The number [and dest] to reduce - @param b The modulus - @param c The value "b" from montgomery_setup() - @return CRYPT_OK on success - */ - int (*montgomery_reduce)(void *a, void *b, void *c); - - /** clean up (frees memory) - @param a The value "b" from montgomery_setup() - @return CRYPT_OK on success - */ - void (*montgomery_deinit)(void *a); - -/* ---- exponentiation ---- */ - - /** Modular exponentiation - @param a The base integer - @param b The power (can be negative) integer - @param c The modulus integer - @param d The destination - @return CRYPT_OK on success - */ - int (*exptmod)(void *a, void *b, void *c, void *d); - - /** Primality testing - @param a The integer to test - @param b The destination of the result (FP_YES if prime) - @return CRYPT_OK on success - */ - int (*isprime)(void *a, int *b); - -/* ---- (optional) ecc point math ---- */ - - /** ECC GF(p) point multiplication (from the NIST curves) - @param k The integer to multiply the point by - @param G The point to multiply - @param R The destination for kG - @param modulus The modulus for the field - @param map Boolean indicated whether to map back to affine or not (can be ignored if you work in affine only) - @return CRYPT_OK on success - */ - int (*ecc_ptmul)(void *k, ecc_point *G, ecc_point *R, void *modulus, int map); - - /** ECC GF(p) point addition - @param P The first point - @param Q The second point - @param R The destination of P + Q - @param modulus The modulus - @param mp The "b" value from montgomery_setup() - @return CRYPT_OK on success - */ - int (*ecc_ptadd)(ecc_point *P, ecc_point *Q, ecc_point *R, void *modulus, void *mp); - - /** ECC GF(p) point double - @param P The first point - @param R The destination of 2P - @param modulus The modulus - @param mp The "b" value from montgomery_setup() - @return CRYPT_OK on success - */ - int (*ecc_ptdbl)(ecc_point *P, ecc_point *R, void *modulus, void *mp); - - /** ECC mapping from projective to affine, currently uses (x,y,z) => (x/z^2, y/z^3, 1) - @param P The point to map - @param modulus The modulus - @param mp The "b" value from montgomery_setup() - @return CRYPT_OK on success - @remark The mapping can be different but keep in mind a ecc_point only has three - integers (x,y,z) so if you use a different mapping you have to make it fit. - */ - int (*ecc_map)(ecc_point *P, void *modulus, void *mp); - - /** Computes kA*A + kB*B = C using Shamir's Trick - @param A First point to multiply - @param kA What to multiple A by - @param B Second point to multiply - @param kB What to multiple B by - @param C [out] Destination point (can overlap with A or B - @param modulus Modulus for curve - @return CRYPT_OK on success - */ - int (*ecc_mul2add)(ecc_point *A, void *kA, - ecc_point *B, void *kB, - ecc_point *C, - void *modulus); - -/* ---- (optional) rsa optimized math (for internal CRT) ---- */ - - /** RSA Key Generation - @param prng An active PRNG state - @param wprng The index of the PRNG desired - @param size The size of the modulus (key size) desired (octets) - @param e The "e" value (public key). e==65537 is a good choice - @param key [out] Destination of a newly created private key pair - @return CRYPT_OK if successful, upon error all allocated ram is freed - */ - int (*rsa_keygen)(prng_state *prng, int wprng, int size, long e, rsa_key *key); - - - /** RSA exponentiation - @param in The octet array representing the base - @param inlen The length of the input - @param out The destination (to be stored in an octet array format) - @param outlen The length of the output buffer and the resulting size (zero padded to the size of the modulus) - @param which PK_PUBLIC for public RSA and PK_PRIVATE for private RSA - @param key The RSA key to use - @return CRYPT_OK on success - */ - int (*rsa_me)(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen, int which, - rsa_key *key); -} ltc_math_descriptor; - -extern ltc_math_descriptor ltc_mp; - -int ltc_init_multi(void **a, ...); -void ltc_deinit_multi(void *a, ...); - -#ifdef LTM_DESC -extern const ltc_math_descriptor ltm_desc; -#endif - -#ifdef TFM_DESC -extern const ltc_math_descriptor tfm_desc; -#endif - -#ifdef GMP_DESC -extern const ltc_math_descriptor gmp_desc; -#endif - -#if !defined(DESC_DEF_ONLY) && defined(LTC_SOURCE) - -#define MP_DIGIT_BIT ltc_mp.bits_per_digit - -/* some handy macros */ -#define mp_init(a) ltc_mp.init(a) -#define mp_init_multi ltc_init_multi -#define mp_clear(a) ltc_mp.deinit(a) -#define mp_clear_multi ltc_deinit_multi -#define mp_init_copy(a, b) ltc_mp.init_copy(a, b) - -#define mp_neg(a, b) ltc_mp.neg(a, b) -#define mp_copy(a, b) ltc_mp.copy(a, b) - -#define mp_set(a, b) ltc_mp.set_int(a, b) -#define mp_set_int(a, b) ltc_mp.set_int(a, b) -#define mp_get_int(a) ltc_mp.get_int(a) -#define mp_get_digit(a, n) ltc_mp.get_digit(a, n) -#define mp_get_digit_count(a) ltc_mp.get_digit_count(a) -#define mp_cmp(a, b) ltc_mp.compare(a, b) -#define mp_cmp_d(a, b) ltc_mp.compare_d(a, b) -#define mp_count_bits(a) ltc_mp.count_bits(a) -#define mp_cnt_lsb(a) ltc_mp.count_lsb_bits(a) -#define mp_2expt(a, b) ltc_mp.twoexpt(a, b) - -#define mp_read_radix(a, b, c) ltc_mp.read_radix(a, b, c) -#define mp_toradix(a, b, c) ltc_mp.write_radix(a, b, c) -#define mp_unsigned_bin_size(a) ltc_mp.unsigned_size(a) -#define mp_to_unsigned_bin(a, b) ltc_mp.unsigned_write(a, b) -#define mp_read_unsigned_bin(a, b, c) ltc_mp.unsigned_read(a, b, c) - -#define mp_add(a, b, c) ltc_mp.add(a, b, c) -#define mp_add_d(a, b, c) ltc_mp.addi(a, b, c) -#define mp_sub(a, b, c) ltc_mp.sub(a, b, c) -#define mp_sub_d(a, b, c) ltc_mp.subi(a, b, c) -#define mp_mul(a, b, c) ltc_mp.mul(a, b, c) -#define mp_mul_d(a, b, c) ltc_mp.muli(a, b, c) -#define mp_sqr(a, b) ltc_mp.sqr(a, b) -#define mp_div(a, b, c, d) ltc_mp.mpdiv(a, b, c, d) -#define mp_div_2(a, b) ltc_mp.div_2(a, b) -#define mp_mod(a, b, c) ltc_mp.mpdiv(a, b, NULL, c) -#define mp_mod_d(a, b, c) ltc_mp.modi(a, b, c) -#define mp_gcd(a, b, c) ltc_mp.gcd(a, b, c) -#define mp_lcm(a, b, c) ltc_mp.lcm(a, b, c) - -#define mp_mulmod(a, b, c, d) ltc_mp.mulmod(a, b, c, d) -#define mp_sqrmod(a, b, c) ltc_mp.sqrmod(a, b, c) -#define mp_invmod(a, b, c) ltc_mp.invmod(a, b, c) - -#define mp_montgomery_setup(a, b) ltc_mp.montgomery_setup(a, b) -#define mp_montgomery_normalization(a, b) ltc_mp.montgomery_normalization(a, b) -#define mp_montgomery_reduce(a, b, c) ltc_mp.montgomery_reduce(a, b, c) -#define mp_montgomery_free(a) ltc_mp.montgomery_deinit(a) - -#define mp_exptmod(a,b,c,d) ltc_mp.exptmod(a,b,c,d) -#define mp_prime_is_prime(a, b, c) ltc_mp.isprime(a, c) - -#define mp_iszero(a) (mp_cmp_d(a, 0) == LTC_MP_EQ ? LTC_MP_YES : LTC_MP_NO) -#define mp_isodd(a) (mp_get_digit_count(a) > 0 ? (mp_get_digit(a, 0) & 1 ? LTC_MP_YES : LTC_MP_NO) : LTC_MP_NO) -#define mp_exch(a, b) do { void *ABC__tmp = a; a = b; b = ABC__tmp; } while(0); - -#define mp_tohex(a, b) mp_toradix(a, b, 16) - -#endif - -/* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt_math.h,v $ */ -/* $Revision: 1.44 $ */ -/* $Date: 2007/05/12 14:32:35 $ */ diff --git a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_misc.h b/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_misc.h deleted file mode 100644 index f5384cacc51..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_misc.h +++ /dev/null @@ -1,23 +0,0 @@ -/* ---- LTC_BASE64 Routines ---- */ -#ifdef LTC_BASE64 -int base64_encode(const unsigned char *in, unsigned long len, - unsigned char *out, unsigned long *outlen); - -int base64_decode(const unsigned char *in, unsigned long len, - unsigned char *out, unsigned long *outlen); -#endif - -/* ---- MEM routines ---- */ -void zeromem(void *dst, size_t len); -void burn_stack(unsigned long len); - -const char *error_to_string(int err); - -extern const char *crypt_build_settings; - -/* ---- HMM ---- */ -int crypt_fsa(void *mp, ...); - -/* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt_misc.h,v $ */ -/* $Revision: 1.5 $ */ -/* $Date: 2007/05/12 14:32:35 $ */ diff --git a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_pk.h b/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_pk.h deleted file mode 100644 index b5f277a8848..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_pk.h +++ /dev/null @@ -1,558 +0,0 @@ -/* ---- NUMBER THEORY ---- */ - -enum { - PK_PUBLIC=0, - PK_PRIVATE=1 -}; - -int rand_prime(void *N, long len, prng_state *prng, int wprng); - -/* ---- RSA ---- */ -#ifdef LTC_MRSA - -/* Min and Max RSA key sizes (in bits) */ -#define MIN_RSA_SIZE 1024 -#define MAX_RSA_SIZE 4096 - -/** RSA LTC_PKCS style key */ -typedef struct Rsa_key { - /** Type of key, PK_PRIVATE or PK_PUBLIC */ - int type; - /** The public exponent */ - void *e; - /** The private exponent */ - void *d; - /** The modulus */ - void *N; - /** The p factor of N */ - void *p; - /** The q factor of N */ - void *q; - /** The 1/q mod p CRT param */ - void *qP; - /** The d mod (p - 1) CRT param */ - void *dP; - /** The d mod (q - 1) CRT param */ - void *dQ; -} rsa_key; - -int rsa_make_key(prng_state *prng, int wprng, int size, long e, rsa_key *key); - -int rsa_exptmod(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen, int which, - rsa_key *key); - -void rsa_free(rsa_key *key); - -/* These use LTC_PKCS #1 v2.0 padding */ -#define rsa_encrypt_key(_in, _inlen, _out, _outlen, _lparam, _lparamlen, _prng, _prng_idx, _hash_idx, _key) \ - rsa_encrypt_key_ex(_in, _inlen, _out, _outlen, _lparam, _lparamlen, _prng, _prng_idx, _hash_idx, LTC_LTC_PKCS_1_OAEP, _key) - -#define rsa_decrypt_key(_in, _inlen, _out, _outlen, _lparam, _lparamlen, _hash_idx, _stat, _key) \ - rsa_decrypt_key_ex(_in, _inlen, _out, _outlen, _lparam, _lparamlen, _hash_idx, LTC_LTC_PKCS_1_OAEP, _stat, _key) - -#define rsa_sign_hash(_in, _inlen, _out, _outlen, _prng, _prng_idx, _hash_idx, _saltlen, _key) \ - rsa_sign_hash_ex(_in, _inlen, _out, _outlen, LTC_LTC_PKCS_1_PSS, _prng, _prng_idx, _hash_idx, _saltlen, _key) - -#define rsa_verify_hash(_sig, _siglen, _hash, _hashlen, _hash_idx, _saltlen, _stat, _key) \ - rsa_verify_hash_ex(_sig, _siglen, _hash, _hashlen, LTC_LTC_PKCS_1_PSS, _hash_idx, _saltlen, _stat, _key) - -/* These can be switched between LTC_PKCS #1 v2.x and LTC_PKCS #1 v1.5 paddings */ -int rsa_encrypt_key_ex(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen, - const unsigned char *lparam, unsigned long lparamlen, - prng_state *prng, int prng_idx, int hash_idx, int padding, rsa_key *key); - -int rsa_decrypt_key_ex(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen, - const unsigned char *lparam, unsigned long lparamlen, - int hash_idx, int padding, - int *stat, rsa_key *key); - -int rsa_sign_hash_ex(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen, - int padding, - prng_state *prng, int prng_idx, - int hash_idx, unsigned long saltlen, - rsa_key *key); - -int rsa_verify_hash_ex(const unsigned char *sig, unsigned long siglen, - const unsigned char *hash, unsigned long hashlen, - int padding, - int hash_idx, unsigned long saltlen, - int *stat, rsa_key *key); - -/* LTC_PKCS #1 import/export */ -int rsa_export(unsigned char *out, unsigned long *outlen, int type, rsa_key *key); -int rsa_import(const unsigned char *in, unsigned long inlen, rsa_key *key); - -/* Ladik: Added for verifying Blizzard strong signature verification */ -int rsa_verify_simple(const unsigned char *sig, unsigned long siglen, - const unsigned char *hash, unsigned long hashlen, - int *stat, - rsa_key *key); - -#endif - -/* ---- Katja ---- */ -#ifdef MKAT - -/* Min and Max KAT key sizes (in bits) */ -#define MIN_KAT_SIZE 1024 -#define MAX_KAT_SIZE 4096 - -/** Katja LTC_PKCS style key */ -typedef struct KAT_key { - /** Type of key, PK_PRIVATE or PK_PUBLIC */ - int type; - /** The private exponent */ - void *d; - /** The modulus */ - void *N; - /** The p factor of N */ - void *p; - /** The q factor of N */ - void *q; - /** The 1/q mod p CRT param */ - void *qP; - /** The d mod (p - 1) CRT param */ - void *dP; - /** The d mod (q - 1) CRT param */ - void *dQ; - /** The pq param */ - void *pq; -} katja_key; - -int katja_make_key(prng_state *prng, int wprng, int size, katja_key *key); - -int katja_exptmod(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen, int which, - katja_key *key); - -void katja_free(katja_key *key); - -/* These use LTC_PKCS #1 v2.0 padding */ -int katja_encrypt_key(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen, - const unsigned char *lparam, unsigned long lparamlen, - prng_state *prng, int prng_idx, int hash_idx, katja_key *key); - -int katja_decrypt_key(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen, - const unsigned char *lparam, unsigned long lparamlen, - int hash_idx, int *stat, - katja_key *key); - -/* LTC_PKCS #1 import/export */ -int katja_export(unsigned char *out, unsigned long *outlen, int type, katja_key *key); -int katja_import(const unsigned char *in, unsigned long inlen, katja_key *key); - -#endif - -/* ---- ECC Routines ---- */ -#ifdef LTC_MECC - -/* size of our temp buffers for exported keys */ -#define ECC_BUF_SIZE 256 - -/* max private key size */ -#define ECC_MAXSIZE 66 - -/** Structure defines a NIST GF(p) curve */ -typedef struct { - /** The size of the curve in octets */ - int size; - - /** name of curve */ - char *name; - - /** The prime that defines the field the curve is in (encoded in hex) */ - char *prime; - - /** The fields B param (hex) */ - char *B; - - /** The order of the curve (hex) */ - char *order; - - /** The x co-ordinate of the base point on the curve (hex) */ - char *Gx; - - /** The y co-ordinate of the base point on the curve (hex) */ - char *Gy; -} ltc_ecc_set_type; - -/** A point on a ECC curve, stored in Jacbobian format such that (x,y,z) => (x/z^2, y/z^3, 1) when interpretted as affine */ -typedef struct { - /** The x co-ordinate */ - void *x; - - /** The y co-ordinate */ - void *y; - - /** The z co-ordinate */ - void *z; -} ecc_point; - -/** An ECC key */ -typedef struct { - /** Type of key, PK_PRIVATE or PK_PUBLIC */ - int type; - - /** Index into the ltc_ecc_sets[] for the parameters of this curve; if -1, then this key is using user supplied curve in dp */ - int idx; - - /** pointer to domain parameters; either points to NIST curves (identified by idx >= 0) or user supplied curve */ - const ltc_ecc_set_type *dp; - - /** The public key */ - ecc_point pubkey; - - /** The private key */ - void *k; -} ecc_key; - -/** the ECC params provided */ -extern const ltc_ecc_set_type ltc_ecc_sets[]; - -int ecc_test(void); -void ecc_sizes(int *low, int *high); -int ecc_get_size(ecc_key *key); - -int ecc_make_key(prng_state *prng, int wprng, int keysize, ecc_key *key); -int ecc_make_key_ex(prng_state *prng, int wprng, ecc_key *key, const ltc_ecc_set_type *dp); -void ecc_free(ecc_key *key); - -int ecc_export(unsigned char *out, unsigned long *outlen, int type, ecc_key *key); -int ecc_import(const unsigned char *in, unsigned long inlen, ecc_key *key); -int ecc_import_ex(const unsigned char *in, unsigned long inlen, ecc_key *key, const ltc_ecc_set_type *dp); - -int ecc_ansi_x963_export(ecc_key *key, unsigned char *out, unsigned long *outlen); -int ecc_ansi_x963_import(const unsigned char *in, unsigned long inlen, ecc_key *key); -int ecc_ansi_x963_import_ex(const unsigned char *in, unsigned long inlen, ecc_key *key, ltc_ecc_set_type *dp); - -int ecc_shared_secret(ecc_key *private_key, ecc_key *public_key, - unsigned char *out, unsigned long *outlen); - -int ecc_encrypt_key(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen, - prng_state *prng, int wprng, int hash, - ecc_key *key); - -int ecc_decrypt_key(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen, - ecc_key *key); - -int ecc_sign_hash(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen, - prng_state *prng, int wprng, ecc_key *key); - -int ecc_verify_hash(const unsigned char *sig, unsigned long siglen, - const unsigned char *hash, unsigned long hashlen, - int *stat, ecc_key *key); - -/* low level functions */ -ecc_point *ltc_ecc_new_point(void); -void ltc_ecc_del_point(ecc_point *p); -int ltc_ecc_is_valid_idx(int n); - -/* point ops (mp == montgomery digit) */ -#if !defined(LTC_MECC_ACCEL) || defined(LTM_LTC_DESC) || defined(GMP_LTC_DESC) -/* R = 2P */ -int ltc_ecc_projective_dbl_point(ecc_point *P, ecc_point *R, void *modulus, void *mp); - -/* R = P + Q */ -int ltc_ecc_projective_add_point(ecc_point *P, ecc_point *Q, ecc_point *R, void *modulus, void *mp); -#endif - -#if defined(LTC_MECC_FP) -/* optimized point multiplication using fixed point cache (HAC algorithm 14.117) */ -int ltc_ecc_fp_mulmod(void *k, ecc_point *G, ecc_point *R, void *modulus, int map); - -/* functions for saving/loading/freeing/adding to fixed point cache */ -int ltc_ecc_fp_save_state(unsigned char **out, unsigned long *outlen); -int ltc_ecc_fp_restore_state(unsigned char *in, unsigned long inlen); -void ltc_ecc_fp_free(void); -int ltc_ecc_fp_add_point(ecc_point *g, void *modulus, int lock); - -/* lock/unlock all points currently in fixed point cache */ -void ltc_ecc_fp_tablelock(int lock); -#endif - -/* R = kG */ -int ltc_ecc_mulmod(void *k, ecc_point *G, ecc_point *R, void *modulus, int map); - -#ifdef LTC_ECC_SHAMIR -/* kA*A + kB*B = C */ -int ltc_ecc_mul2add(ecc_point *A, void *kA, - ecc_point *B, void *kB, - ecc_point *C, - void *modulus); - -#ifdef LTC_MECC_FP -/* Shamir's trick with optimized point multiplication using fixed point cache */ -int ltc_ecc_fp_mul2add(ecc_point *A, void *kA, - ecc_point *B, void *kB, - ecc_point *C, void *modulus); -#endif - -#endif - - -/* map P to affine from projective */ -int ltc_ecc_map(ecc_point *P, void *modulus, void *mp); - -#endif - -#ifdef LTC_MDSA - -/* Max diff between group and modulus size in bytes */ -#define LTC_MDSA_DELTA 512 - -/* Max DSA group size in bytes (default allows 4k-bit groups) */ -#define LTC_MDSA_MAX_GROUP 512 - -/** DSA key structure */ -typedef struct { - /** The key type, PK_PRIVATE or PK_PUBLIC */ - int type; - - /** The order of the sub-group used in octets */ - int qord; - - /** The generator */ - void *g; - - /** The prime used to generate the sub-group */ - void *q; - - /** The large prime that generats the field the contains the sub-group */ - void *p; - - /** The private key */ - void *x; - - /** The public key */ - void *y; -} dsa_key; - -int dsa_make_key(prng_state *prng, int wprng, int group_size, int modulus_size, dsa_key *key); -void dsa_free(dsa_key *key); - -int dsa_sign_hash_raw(const unsigned char *in, unsigned long inlen, - void *r, void *s, - prng_state *prng, int wprng, dsa_key *key); - -int dsa_sign_hash(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen, - prng_state *prng, int wprng, dsa_key *key); - -int dsa_verify_hash_raw( void *r, void *s, - const unsigned char *hash, unsigned long hashlen, - int *stat, dsa_key *key); - -int dsa_verify_hash(const unsigned char *sig, unsigned long siglen, - const unsigned char *hash, unsigned long hashlen, - int *stat, dsa_key *key); - -int dsa_encrypt_key(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen, - prng_state *prng, int wprng, int hash, - dsa_key *key); - -int dsa_decrypt_key(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen, - dsa_key *key); - -int dsa_import(const unsigned char *in, unsigned long inlen, dsa_key *key); -int dsa_export(unsigned char *out, unsigned long *outlen, int type, dsa_key *key); -int dsa_verify_key(dsa_key *key, int *stat); - -int dsa_shared_secret(void *private_key, void *base, - dsa_key *public_key, - unsigned char *out, unsigned long *outlen); -#endif - -#ifdef LTC_DER -/* DER handling */ - -enum { - LTC_ASN1_EOL, - LTC_ASN1_BOOLEAN, - LTC_ASN1_INTEGER, - LTC_ASN1_SHORT_INTEGER, - LTC_ASN1_BIT_STRING, - LTC_ASN1_OCTET_STRING, - LTC_ASN1_NULL, - LTC_ASN1_OBJECT_IDENTIFIER, - LTC_ASN1_IA5_STRING, - LTC_ASN1_PRINTABLE_STRING, - LTC_ASN1_UTF8_STRING, - LTC_ASN1_UTCTIME, - LTC_ASN1_CHOICE, - LTC_ASN1_SEQUENCE, - LTC_ASN1_SET, - LTC_ASN1_SETOF -}; - -/** A LTC ASN.1 list type */ -typedef struct ltc_asn1_list_ { - /** The LTC ASN.1 enumerated type identifier */ - int type; - /** The data to encode or place for decoding */ - void *data; - /** The size of the input or resulting output */ - unsigned long size; - /** The used flag, this is used by the CHOICE ASN.1 type to indicate which choice was made */ - int used; - /** prev/next entry in the list */ - struct ltc_asn1_list_ *prev, *next, *child, *parent; -} ltc_asn1_list; - -#define LTC_SET_ASN1(list, index, Type, Data, Size) \ - do { \ - int LTC_MACRO_temp = (index); \ - ltc_asn1_list *LTC_MACRO_list = (list); \ - LTC_MACRO_list[LTC_MACRO_temp].type = (Type); \ - LTC_MACRO_list[LTC_MACRO_temp].data = (void*)(Data); \ - LTC_MACRO_list[LTC_MACRO_temp].size = (Size); \ - LTC_MACRO_list[LTC_MACRO_temp].used = 0; \ - } while (0); - -/* SEQUENCE */ -int der_encode_sequence_ex(ltc_asn1_list *list, unsigned long inlen, - unsigned char *out, unsigned long *outlen, int type_of); - -#define der_encode_sequence(list, inlen, out, outlen) der_encode_sequence_ex(list, inlen, out, outlen, LTC_ASN1_SEQUENCE) - -int der_decode_sequence_ex(const unsigned char *in, unsigned long inlen, - ltc_asn1_list *list, unsigned long outlen, int ordered); - -#define der_decode_sequence(in, inlen, list, outlen) der_decode_sequence_ex(in, inlen, list, outlen, 1) - -int der_length_sequence(ltc_asn1_list *list, unsigned long inlen, - unsigned long *outlen); - -/* SET */ -#define der_decode_set(in, inlen, list, outlen) der_decode_sequence_ex(in, inlen, list, outlen, 0) -#define der_length_set der_length_sequence -int der_encode_set(ltc_asn1_list *list, unsigned long inlen, - unsigned char *out, unsigned long *outlen); - -int der_encode_setof(ltc_asn1_list *list, unsigned long inlen, - unsigned char *out, unsigned long *outlen); - -/* VA list handy helpers with triplets of <type, size, data> */ -int der_encode_sequence_multi(unsigned char *out, unsigned long *outlen, ...); -int der_decode_sequence_multi(const unsigned char *in, unsigned long inlen, ...); - -/* FLEXI DECODER handle unknown list decoder */ -int der_decode_sequence_flexi(const unsigned char *in, unsigned long *inlen, ltc_asn1_list **out); -void der_free_sequence_flexi(ltc_asn1_list *list); -void der_sequence_free(ltc_asn1_list *in); - -/* BOOLEAN */ -int der_length_boolean(unsigned long *outlen); -int der_encode_boolean(int in, - unsigned char *out, unsigned long *outlen); -int der_decode_boolean(const unsigned char *in, unsigned long inlen, - int *out); -/* INTEGER */ -int der_encode_integer(void *num, unsigned char *out, unsigned long *outlen); -int der_decode_integer(const unsigned char *in, unsigned long inlen, void *num); -int der_length_integer(void *num, unsigned long *len); - -/* INTEGER -- handy for 0..2^32-1 values */ -int der_decode_short_integer(const unsigned char *in, unsigned long inlen, unsigned long *num); -int der_encode_short_integer(unsigned long num, unsigned char *out, unsigned long *outlen); -int der_length_short_integer(unsigned long num, unsigned long *outlen); - -/* BIT STRING */ -int der_encode_bit_string(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen); -int der_decode_bit_string(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen); -int der_length_bit_string(unsigned long nbits, unsigned long *outlen); - -/* OCTET STRING */ -int der_encode_octet_string(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen); -int der_decode_octet_string(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen); -int der_length_octet_string(unsigned long noctets, unsigned long *outlen); - -/* OBJECT IDENTIFIER */ -int der_encode_object_identifier(unsigned long *words, unsigned long nwords, - unsigned char *out, unsigned long *outlen); -int der_decode_object_identifier(const unsigned char *in, unsigned long inlen, - unsigned long *words, unsigned long *outlen); -int der_length_object_identifier(unsigned long *words, unsigned long nwords, unsigned long *outlen); -unsigned long der_object_identifier_bits(unsigned long x); - -/* IA5 STRING */ -int der_encode_ia5_string(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen); -int der_decode_ia5_string(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen); -int der_length_ia5_string(const unsigned char *octets, unsigned long noctets, unsigned long *outlen); - -int der_ia5_char_encode(int c); -int der_ia5_value_decode(int v); - -/* Printable STRING */ -int der_encode_printable_string(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen); -int der_decode_printable_string(const unsigned char *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen); -int der_length_printable_string(const unsigned char *octets, unsigned long noctets, unsigned long *outlen); - -int der_printable_char_encode(int c); -int der_printable_value_decode(int v); - -/* UTF-8 */ -#if (defined(SIZE_MAX) || __STDC_VERSION__ >= 199901L || defined(WCHAR_MAX) || defined(_WCHAR_T) || defined(_WCHAR_T_DEFINED) || defined (__WCHAR_TYPE__)) && !defined(LTC_NO_WCHAR) -#include <wchar.h> -#else -typedef ulong32 wchar_t; -#endif - -int der_encode_utf8_string(const wchar_t *in, unsigned long inlen, - unsigned char *out, unsigned long *outlen); - -int der_decode_utf8_string(const unsigned char *in, unsigned long inlen, - wchar_t *out, unsigned long *outlen); -unsigned long der_utf8_charsize(const wchar_t c); -int der_length_utf8_string(const wchar_t *in, unsigned long noctets, unsigned long *outlen); - - -/* CHOICE */ -int der_decode_choice(const unsigned char *in, unsigned long *inlen, - ltc_asn1_list *list, unsigned long outlen); - -/* UTCTime */ -typedef struct { - unsigned YY, /* year */ - MM, /* month */ - DD, /* day */ - hh, /* hour */ - mm, /* minute */ - ss, /* second */ - off_dir, /* timezone offset direction 0 == +, 1 == - */ - off_hh, /* timezone offset hours */ - off_mm; /* timezone offset minutes */ -} ltc_utctime; - -int der_encode_utctime(ltc_utctime *utctime, - unsigned char *out, unsigned long *outlen); - -int der_decode_utctime(const unsigned char *in, unsigned long *inlen, - ltc_utctime *out); - -int der_length_utctime(ltc_utctime *utctime, unsigned long *outlen); - - -#endif - -/* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt_pk.h,v $ */ -/* $Revision: 1.81 $ */ -/* $Date: 2007/05/12 14:32:35 $ */ diff --git a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_pkcs.h b/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_pkcs.h deleted file mode 100644 index 84fb82a6229..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_pkcs.h +++ /dev/null @@ -1,89 +0,0 @@ -/* LTC_PKCS Header Info */ - -/* ===> LTC_PKCS #1 -- RSA Cryptography <=== */ -#ifdef LTC_PKCS_1 - -enum ltc_pkcs_1_v1_5_blocks -{ - LTC_LTC_PKCS_1_EMSA = 1, /* Block type 1 (LTC_PKCS #1 v1.5 signature padding) */ - LTC_LTC_PKCS_1_EME = 2 /* Block type 2 (LTC_PKCS #1 v1.5 encryption padding) */ -}; - -enum ltc_pkcs_1_paddings -{ - LTC_LTC_PKCS_1_V1_5 = 1, /* LTC_PKCS #1 v1.5 padding (\sa ltc_pkcs_1_v1_5_blocks) */ - LTC_LTC_PKCS_1_OAEP = 2, /* LTC_PKCS #1 v2.0 encryption padding */ - LTC_LTC_PKCS_1_PSS = 3 /* LTC_PKCS #1 v2.1 signature padding */ -}; - -int pkcs_1_mgf1( int hash_idx, - const unsigned char *seed, unsigned long seedlen, - unsigned char *mask, unsigned long masklen); - -int pkcs_1_i2osp(void *n, unsigned long modulus_len, unsigned char *out); -int pkcs_1_os2ip(void *n, unsigned char *in, unsigned long inlen); - -/* *** v1.5 padding */ -int pkcs_1_v1_5_encode(const unsigned char *msg, - unsigned long msglen, - int block_type, - unsigned long modulus_bitlen, - prng_state *prng, - int prng_idx, - unsigned char *out, - unsigned long *outlen); - -int pkcs_1_v1_5_decode(const unsigned char *msg, - unsigned long msglen, - int block_type, - unsigned long modulus_bitlen, - unsigned char *out, - unsigned long *outlen, - int *is_valid); - -/* *** v2.1 padding */ -int pkcs_1_oaep_encode(const unsigned char *msg, unsigned long msglen, - const unsigned char *lparam, unsigned long lparamlen, - unsigned long modulus_bitlen, prng_state *prng, - int prng_idx, int hash_idx, - unsigned char *out, unsigned long *outlen); - -int pkcs_1_oaep_decode(const unsigned char *msg, unsigned long msglen, - const unsigned char *lparam, unsigned long lparamlen, - unsigned long modulus_bitlen, int hash_idx, - unsigned char *out, unsigned long *outlen, - int *res); - -int pkcs_1_pss_encode(const unsigned char *msghash, unsigned long msghashlen, - unsigned long saltlen, prng_state *prng, - int prng_idx, int hash_idx, - unsigned long modulus_bitlen, - unsigned char *out, unsigned long *outlen); - -int pkcs_1_pss_decode(const unsigned char *msghash, unsigned long msghashlen, - const unsigned char *sig, unsigned long siglen, - unsigned long saltlen, int hash_idx, - unsigned long modulus_bitlen, int *res); - -#endif /* LTC_PKCS_1 */ - -/* ===> LTC_PKCS #5 -- Password Based Cryptography <=== */ -#ifdef LTC_PKCS_5 - -/* Algorithm #1 (old) */ -int pkcs_5_alg1(const unsigned char *password, unsigned long password_len, - const unsigned char *salt, - int iteration_count, int hash_idx, - unsigned char *out, unsigned long *outlen); - -/* Algorithm #2 (new) */ -int pkcs_5_alg2(const unsigned char *password, unsigned long password_len, - const unsigned char *salt, unsigned long salt_len, - int iteration_count, int hash_idx, - unsigned char *out, unsigned long *outlen); - -#endif /* LTC_PKCS_5 */ - -/* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt_pkcs.h,v $ */ -/* $Revision: 1.8 $ */ -/* $Date: 2007/05/12 14:32:35 $ */ diff --git a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_prng.h b/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_prng.h deleted file mode 100644 index f3e3e550e88..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/headers/tomcrypt_prng.h +++ /dev/null @@ -1,199 +0,0 @@ -/* ---- PRNG Stuff ---- */ -#ifdef LTC_YARROW -struct yarrow_prng { - int cipher, hash; - unsigned char pool[MAXBLOCKSIZE]; - symmetric_CTR ctr; - LTC_MUTEX_TYPE(prng_lock) -}; -#endif - -#ifdef LTC_RC4 -struct rc4_prng { - int x, y; - unsigned char buf[256]; -}; -#endif - -#ifdef LTC_FORTUNA -struct fortuna_prng { - hash_state pool[LTC_FORTUNA_POOLS]; /* the pools */ - - symmetric_key skey; - - unsigned char K[32], /* the current key */ - IV[16]; /* IV for CTR mode */ - - unsigned long pool_idx, /* current pool we will add to */ - pool0_len, /* length of 0'th pool */ - wd; - - ulong64 reset_cnt; /* number of times we have reset */ - LTC_MUTEX_TYPE(prng_lock) -}; -#endif - -#ifdef LTC_SOBER128 -struct sober128_prng { - ulong32 R[17], /* Working storage for the shift register */ - initR[17], /* saved register contents */ - konst, /* key dependent constant */ - sbuf; /* partial word encryption buffer */ - - int nbuf, /* number of part-word stream bits buffered */ - flag, /* first add_entropy call or not? */ - set; /* did we call add_entropy to set key? */ - -}; -#endif - -typedef union Prng_state { - char dummy[1]; -#ifdef LTC_YARROW - struct yarrow_prng yarrow; -#endif -#ifdef LTC_RC4 - struct rc4_prng rc4; -#endif -#ifdef LTC_FORTUNA - struct fortuna_prng fortuna; -#endif -#ifdef LTC_SOBER128 - struct sober128_prng sober128; -#endif -} prng_state; - -/** PRNG descriptor */ -extern struct ltc_prng_descriptor { - /** Name of the PRNG */ - char *name; - /** size in bytes of exported state */ - int export_size; - /** Start a PRNG state - @param prng [out] The state to initialize - @return CRYPT_OK if successful - */ - int (*start)(prng_state *prng); - /** Add entropy to the PRNG - @param in The entropy - @param inlen Length of the entropy (octets)\ - @param prng The PRNG state - @return CRYPT_OK if successful - */ - int (*add_entropy)(const unsigned char *in, unsigned long inlen, prng_state *prng); - /** Ready a PRNG state to read from - @param prng The PRNG state to ready - @return CRYPT_OK if successful - */ - int (*ready)(prng_state *prng); - /** Read from the PRNG - @param out [out] Where to store the data - @param outlen Length of data desired (octets) - @param prng The PRNG state to read from - @return Number of octets read - */ - unsigned long (*read)(unsigned char *out, unsigned long outlen, prng_state *prng); - /** Terminate a PRNG state - @param prng The PRNG state to terminate - @return CRYPT_OK if successful - */ - int (*done)(prng_state *prng); - /** Export a PRNG state - @param out [out] The destination for the state - @param outlen [in/out] The max size and resulting size of the PRNG state - @param prng The PRNG to export - @return CRYPT_OK if successful - */ - int (*pexport)(unsigned char *out, unsigned long *outlen, prng_state *prng); - /** Import a PRNG state - @param in The data to import - @param inlen The length of the data to import (octets) - @param prng The PRNG to initialize/import - @return CRYPT_OK if successful - */ - int (*pimport)(const unsigned char *in, unsigned long inlen, prng_state *prng); - /** Self-test the PRNG - @return CRYPT_OK if successful, CRYPT_NOP if self-testing has been disabled - */ - int (*test)(void); -} prng_descriptor[]; - -#ifdef LTC_YARROW -int yarrow_start(prng_state *prng); -int yarrow_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng); -int yarrow_ready(prng_state *prng); -unsigned long yarrow_read(unsigned char *out, unsigned long outlen, prng_state *prng); -int yarrow_done(prng_state *prng); -int yarrow_export(unsigned char *out, unsigned long *outlen, prng_state *prng); -int yarrow_import(const unsigned char *in, unsigned long inlen, prng_state *prng); -int yarrow_test(void); -extern const struct ltc_prng_descriptor yarrow_desc; -#endif - -#ifdef LTC_FORTUNA -int fortuna_start(prng_state *prng); -int fortuna_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng); -int fortuna_ready(prng_state *prng); -unsigned long fortuna_read(unsigned char *out, unsigned long outlen, prng_state *prng); -int fortuna_done(prng_state *prng); -int fortuna_export(unsigned char *out, unsigned long *outlen, prng_state *prng); -int fortuna_import(const unsigned char *in, unsigned long inlen, prng_state *prng); -int fortuna_test(void); -extern const struct ltc_prng_descriptor fortuna_desc; -#endif - -#ifdef LTC_RC4 -int rc4_start(prng_state *prng); -int rc4_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng); -int rc4_ready(prng_state *prng); -unsigned long rc4_read(unsigned char *out, unsigned long outlen, prng_state *prng); -int rc4_done(prng_state *prng); -int rc4_export(unsigned char *out, unsigned long *outlen, prng_state *prng); -int rc4_import(const unsigned char *in, unsigned long inlen, prng_state *prng); -int rc4_test(void); -extern const struct ltc_prng_descriptor rc4_desc; -#endif - -#ifdef LTC_SPRNG -int sprng_start(prng_state *prng); -int sprng_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng); -int sprng_ready(prng_state *prng); -unsigned long sprng_read(unsigned char *out, unsigned long outlen, prng_state *prng); -int sprng_done(prng_state *prng); -int sprng_export(unsigned char *out, unsigned long *outlen, prng_state *prng); -int sprng_import(const unsigned char *in, unsigned long inlen, prng_state *prng); -int sprng_test(void); -extern const struct ltc_prng_descriptor sprng_desc; -#endif - -#ifdef LTC_SOBER128 -int sober128_start(prng_state *prng); -int sober128_add_entropy(const unsigned char *in, unsigned long inlen, prng_state *prng); -int sober128_ready(prng_state *prng); -unsigned long sober128_read(unsigned char *out, unsigned long outlen, prng_state *prng); -int sober128_done(prng_state *prng); -int sober128_export(unsigned char *out, unsigned long *outlen, prng_state *prng); -int sober128_import(const unsigned char *in, unsigned long inlen, prng_state *prng); -int sober128_test(void); -extern const struct ltc_prng_descriptor sober128_desc; -#endif - -int find_prng(const char *name); -int register_prng(const struct ltc_prng_descriptor *prng); -int unregister_prng(const struct ltc_prng_descriptor *prng); -int prng_is_valid(int idx); -LTC_MUTEX_PROTO(ltc_prng_mutex) - -/* Slow RNG you **might** be able to use to seed a PRNG with. Be careful as this - * might not work on all platforms as planned - */ -unsigned long rng_get_bytes(unsigned char *out, - unsigned long outlen, - void (*callback)(void)); - -int rng_make_prng(int bits, int wprng, prng_state *prng, void (*callback)(void)); - - -/* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt_prng.h,v $ */ -/* $Revision: 1.9 $ */ -/* $Date: 2007/05/12 14:32:35 $ */ diff --git a/dep/CascLib/src/libtomcrypt/src/misc/crypt_argchk.c b/dep/CascLib/src/libtomcrypt/src/misc/crypt_argchk.c deleted file mode 100644 index 39c686a5d46..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/misc/crypt_argchk.c +++ /dev/null @@ -1,30 +0,0 @@ -/* LibTomCrypt, modular cryptographic library -- Tom St Denis - * - * LibTomCrypt is a library that provides various cryptographic - * algorithms in a highly modular and flexible manner. - * - * The library is free for all purposes without any express - * guarantee it works. - * - * Tom St Denis, tomstdenis@gmail.com, http://libtom.org - */ -#include "../headers/tomcrypt.h" -#include <signal.h> - -/** - @file crypt_argchk.c - Perform argument checking, Tom St Denis -*/ - -#if (ARGTYPE == 0) -void crypt_argchk(char *v, char *s, int d) -{ - fprintf(stderr, "LTC_ARGCHK '%s' failure on line %d of file %s\n", - v, d, s); - (void)raise(SIGABRT); -} -#endif - -/* $Source: /cvs/libtom/libtomcrypt/src/misc/crypt/crypt_argchk.c,v $ */ -/* $Revision: 1.5 $ */ -/* $Date: 2006/12/28 01:27:24 $ */ diff --git a/dep/CascLib/src/libtomcrypt/src/misc/crypt_hash_descriptor.c b/dep/CascLib/src/libtomcrypt/src/misc/crypt_hash_descriptor.c deleted file mode 100644 index 9953551a8b7..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/misc/crypt_hash_descriptor.c +++ /dev/null @@ -1,27 +0,0 @@ -/* LibTomCrypt, modular cryptographic library -- Tom St Denis - * - * LibTomCrypt is a library that provides various cryptographic - * algorithms in a highly modular and flexible manner. - * - * The library is free for all purposes without any express - * guarantee it works. - * - * Tom St Denis, tomstdenis@gmail.com, http://libtom.org - */ -#include "../headers/tomcrypt.h" - -/** - @file crypt_hash_descriptor.c - Stores the hash descriptor table, Tom St Denis -*/ - -struct ltc_hash_descriptor hash_descriptor[TAB_SIZE] = { -{ NULL, 0, 0, 0, { 0 }, 0, NULL, NULL, NULL, NULL, NULL } -}; - -LTC_MUTEX_GLOBAL(ltc_hash_mutex) - - -/* $Source: /cvs/libtom/libtomcrypt/src/misc/crypt/crypt_hash_descriptor.c,v $ */ -/* $Revision: 1.10 $ */ -/* $Date: 2006/12/28 01:27:24 $ */ diff --git a/dep/CascLib/src/libtomcrypt/src/misc/crypt_hash_is_valid.c b/dep/CascLib/src/libtomcrypt/src/misc/crypt_hash_is_valid.c deleted file mode 100644 index 20cc30cb0e1..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/misc/crypt_hash_is_valid.c +++ /dev/null @@ -1,36 +0,0 @@ -/* LibTomCrypt, modular cryptographic library -- Tom St Denis - * - * LibTomCrypt is a library that provides various cryptographic - * algorithms in a highly modular and flexible manner. - * - * The library is free for all purposes without any express - * guarantee it works. - * - * Tom St Denis, tomstdenis@gmail.com, http://libtom.org - */ -#include "../headers/tomcrypt.h" - -/** - @file crypt_hash_is_valid.c - Determine if hash is valid, Tom St Denis -*/ - -/* - Test if a hash index is valid - @param idx The index of the hash to search for - @return CRYPT_OK if valid -*/ -int hash_is_valid(int idx) -{ - LTC_MUTEX_LOCK(<c_hash_mutex); - if (idx < 0 || idx >= TAB_SIZE || hash_descriptor[idx].name == NULL) { - LTC_MUTEX_UNLOCK(<c_hash_mutex); - return CRYPT_INVALID_HASH; - } - LTC_MUTEX_UNLOCK(<c_hash_mutex); - return CRYPT_OK; -} - -/* $Source: /cvs/libtom/libtomcrypt/src/misc/crypt/crypt_hash_is_valid.c,v $ */ -/* $Revision: 1.6 $ */ -/* $Date: 2006/12/28 01:27:24 $ */ diff --git a/dep/CascLib/src/libtomcrypt/src/misc/crypt_libc.c b/dep/CascLib/src/libtomcrypt/src/misc/crypt_libc.c deleted file mode 100644 index bcc89f4f94d..00000000000 --- a/dep/CascLib/src/libtomcrypt/src/misc/crypt_libc.c +++ /dev/null @@ -1,43 +0,0 @@ -/*****************************************************************************/ -/* crypt_libc.c Copyright (c) Ladislav Zezula 2010 */ -/*---------------------------------------------------------------------------*/ -/* Description: */ -/*---------------------------------------------------------------------------*/ -/* Date Ver Who Comment */ -/* -------- ---- --- ------- */ -/* 05.05.10 1.00 Lad The first version of crypt_libc.c */ -/*****************************************************************************/ - -// LibTomCrypt header -#include <stdlib.h> -#include "../headers/tomcrypt.h" - -void * LibTomMalloc(size_t n) -{ - return malloc(n); -} - -void * LibTomCalloc(size_t n, size_t s) -{ - return calloc(n, s); -} - -void * LibTomRealloc(void *p, size_t n) -{ - return realloc(p, n); -} - -void LibTomFree(void * p) -{ - free(p); -} - -clock_t LibTomClock(void) -{ - return clock(); -} - -void LibTomQsort(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *)) -{ - qsort(base, nmemb, size, compar); -} diff --git a/dep/CascLib/src/md5/md5.cpp b/dep/CascLib/src/md5/md5.cpp new file mode 100644 index 00000000000..b6cc49db42b --- /dev/null +++ b/dep/CascLib/src/md5/md5.cpp @@ -0,0 +1,291 @@ +/* + * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc. + * MD5 Message-Digest Algorithm (RFC 1321). + * + * Homepage: + * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5 + * + * Author: + * Alexander Peslyak, better known as Solar Designer <solar at openwall.com> + * + * This software was written by Alexander Peslyak in 2001. No copyright is + * claimed, and the software is hereby placed in the public domain. + * In case this attempt to disclaim copyright and place the software in the + * public domain is deemed null and void, then the software is + * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the + * general public under the following terms: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted. + * + * There's ABSOLUTELY NO WARRANTY, express or implied. + * + * (This is a heavily cut-down "BSD license".) + * + * This differs from Colin Plumb's older public domain implementation in that + * no exactly 32-bit integer data type is required (any 32-bit or wider + * unsigned integer data type will do), there's no compile-time endianness + * configuration, and the function prototypes match OpenSSL's. No code from + * Colin Plumb's implementation has been reused; this comment merely compares + * the properties of the two independent implementations. + * + * The primary goals of this implementation are portability and ease of use. + * It is meant to be fast, but not as fast as possible. Some known + * optimizations are not included to reduce source code size and avoid + * compile-time configuration. + */ + +#ifndef HAVE_OPENSSL + +#include <string.h> + +#include "md5.h" + +/* + * The basic MD5 functions. + * + * F and G are optimized compared to their RFC 1321 definitions for + * architectures that lack an AND-NOT instruction, just like in Colin Plumb's + * implementation. + */ +#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z)))) +#define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y)))) +#define H(x, y, z) (((x) ^ (y)) ^ (z)) +#define H2(x, y, z) ((x) ^ ((y) ^ (z))) +#define I(x, y, z) ((y) ^ ((x) | ~(z))) + +/* + * The MD5 transformation for all four rounds. + */ +#define STEP(f, a, b, c, d, x, t, s) \ + (a) += f((b), (c), (d)) + (x) + (t); \ + (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \ + (a) += (b); + +/* + * SET reads 4 input bytes in little-endian byte order and stores them in a + * properly aligned word in host byte order. + * + * The check for little-endian architectures that tolerate unaligned memory + * accesses is just an optimization. Nothing will break if it fails to detect + * a suitable architecture. + * + * Unfortunately, this optimization may be a C strict aliasing rules violation + * if the caller's data buffer has effective type that cannot be aliased by + * MD5_u32plus. In practice, this problem may occur if these MD5 routines are + * inlined into a calling function, or with future and dangerously advanced + * link-time optimizations. For the time being, keeping these MD5 routines in + * their own translation unit avoids the problem. + */ +#if defined(__i386__) || defined(__x86_64__) || defined(__vax__) +#define SET(n) \ + (*(MD5_u32plus *)&ptr[(n) * 4]) +#define GET(n) \ + SET(n) +#else +#define SET(n) \ + (ctx->block[(n)] = \ + (MD5_u32plus)ptr[(n) * 4] | \ + ((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \ + ((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \ + ((MD5_u32plus)ptr[(n) * 4 + 3] << 24)) +#define GET(n) \ + (ctx->block[(n)]) +#endif + +/* + * This processes one or more 64-byte data blocks, but does NOT update the bit + * counters. There are no alignment requirements. + */ +static const void *body(MD5_CTX *ctx, const void *data, unsigned long size) +{ + const unsigned char *ptr; + MD5_u32plus a, b, c, d; + MD5_u32plus saved_a, saved_b, saved_c, saved_d; + + ptr = (const unsigned char *)data; + + a = ctx->a; + b = ctx->b; + c = ctx->c; + d = ctx->d; + + do { + saved_a = a; + saved_b = b; + saved_c = c; + saved_d = d; + +/* Round 1 */ + STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7) + STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12) + STEP(F, c, d, a, b, SET(2), 0x242070db, 17) + STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22) + STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7) + STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12) + STEP(F, c, d, a, b, SET(6), 0xa8304613, 17) + STEP(F, b, c, d, a, SET(7), 0xfd469501, 22) + STEP(F, a, b, c, d, SET(8), 0x698098d8, 7) + STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12) + STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17) + STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22) + STEP(F, a, b, c, d, SET(12), 0x6b901122, 7) + STEP(F, d, a, b, c, SET(13), 0xfd987193, 12) + STEP(F, c, d, a, b, SET(14), 0xa679438e, 17) + STEP(F, b, c, d, a, SET(15), 0x49b40821, 22) + +/* Round 2 */ + STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5) + STEP(G, d, a, b, c, GET(6), 0xc040b340, 9) + STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14) + STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20) + STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5) + STEP(G, d, a, b, c, GET(10), 0x02441453, 9) + STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14) + STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20) + STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5) + STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9) + STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14) + STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20) + STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5) + STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9) + STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14) + STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20) + +/* Round 3 */ + STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4) + STEP(H2, d, a, b, c, GET(8), 0x8771f681, 11) + STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16) + STEP(H2, b, c, d, a, GET(14), 0xfde5380c, 23) + STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4) + STEP(H2, d, a, b, c, GET(4), 0x4bdecfa9, 11) + STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16) + STEP(H2, b, c, d, a, GET(10), 0xbebfbc70, 23) + STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4) + STEP(H2, d, a, b, c, GET(0), 0xeaa127fa, 11) + STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16) + STEP(H2, b, c, d, a, GET(6), 0x04881d05, 23) + STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4) + STEP(H2, d, a, b, c, GET(12), 0xe6db99e5, 11) + STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16) + STEP(H2, b, c, d, a, GET(2), 0xc4ac5665, 23) + +/* Round 4 */ + STEP(I, a, b, c, d, GET(0), 0xf4292244, 6) + STEP(I, d, a, b, c, GET(7), 0x432aff97, 10) + STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15) + STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21) + STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6) + STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10) + STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15) + STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21) + STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6) + STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10) + STEP(I, c, d, a, b, GET(6), 0xa3014314, 15) + STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21) + STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6) + STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10) + STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15) + STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21) + + a += saved_a; + b += saved_b; + c += saved_c; + d += saved_d; + + ptr += 64; + } while (size -= 64); + + ctx->a = a; + ctx->b = b; + ctx->c = c; + ctx->d = d; + + return ptr; +} + +void MD5_Init(MD5_CTX *ctx) +{ + ctx->a = 0x67452301; + ctx->b = 0xefcdab89; + ctx->c = 0x98badcfe; + ctx->d = 0x10325476; + + ctx->lo = 0; + ctx->hi = 0; +} + +void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size) +{ + MD5_u32plus saved_lo; + unsigned long used, available; + + saved_lo = ctx->lo; + if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo) + ctx->hi++; + ctx->hi += size >> 29; + + used = saved_lo & 0x3f; + + if (used) { + available = 64 - used; + + if (size < available) { + memcpy(&ctx->buffer[used], data, size); + return; + } + + memcpy(&ctx->buffer[used], data, available); + data = (const unsigned char *)data + available; + size -= available; + body(ctx, ctx->buffer, 64); + } + + if (size >= 64) { + data = body(ctx, data, size & ~(unsigned long)0x3f); + size &= 0x3f; + } + + memcpy(ctx->buffer, data, size); +} + +#define OUT(dst, src) \ + (dst)[0] = (unsigned char)(src); \ + (dst)[1] = (unsigned char)((src) >> 8); \ + (dst)[2] = (unsigned char)((src) >> 16); \ + (dst)[3] = (unsigned char)((src) >> 24); + +void MD5_Final(unsigned char *result, MD5_CTX *ctx) +{ + unsigned long used, available; + + used = ctx->lo & 0x3f; + + ctx->buffer[used++] = 0x80; + + available = 64 - used; + + if (available < 8) { + memset(&ctx->buffer[used], 0, available); + body(ctx, ctx->buffer, 64); + used = 0; + available = 64; + } + + memset(&ctx->buffer[used], 0, available - 8); + + ctx->lo <<= 3; + OUT(&ctx->buffer[56], ctx->lo) + OUT(&ctx->buffer[60], ctx->hi) + + body(ctx, ctx->buffer, 64); + + OUT(&result[0], ctx->a) + OUT(&result[4], ctx->b) + OUT(&result[8], ctx->c) + OUT(&result[12], ctx->d) + + memset(ctx, 0, sizeof(*ctx)); +} + +#endif diff --git a/dep/CascLib/src/md5/md5.h b/dep/CascLib/src/md5/md5.h new file mode 100644 index 00000000000..4216c0204c8 --- /dev/null +++ b/dep/CascLib/src/md5/md5.h @@ -0,0 +1,45 @@ +/* + * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc. + * MD5 Message-Digest Algorithm (RFC 1321). + * + * Homepage: + * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5 + * + * Author: + * Alexander Peslyak, better known as Solar Designer <solar at openwall.com> + * + * This software was written by Alexander Peslyak in 2001. No copyright is + * claimed, and the software is hereby placed in the public domain. + * In case this attempt to disclaim copyright and place the software in the + * public domain is deemed null and void, then the software is + * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the + * general public under the following terms: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted. + * + * There's ABSOLUTELY NO WARRANTY, express or implied. + * + * See md5.c for more information. + */ + +#ifdef HAVE_OPENSSL +#include <openssl/md5.h> +#elif !defined(_MD5_H) +#define _MD5_H + +/* Any 32-bit or wider unsigned integer data type will do */ +typedef unsigned int MD5_u32plus; + +typedef struct { + MD5_u32plus lo, hi; + MD5_u32plus a, b, c, d; + unsigned char buffer[64]; + MD5_u32plus block[16]; +} MD5_CTX; + +void MD5_Init(MD5_CTX *ctx); +void MD5_Update(MD5_CTX *ctx, const void *data, unsigned long size); +void MD5_Final(unsigned char *result, MD5_CTX *ctx); + +#endif diff --git a/dep/PackageList.txt b/dep/PackageList.txt index e928f137448..e539385e789 100644 --- a/dep/PackageList.txt +++ b/dep/PackageList.txt @@ -62,7 +62,7 @@ recastnavigation (Recast is state of the art navigation mesh construction toolse CascLib (An open-source implementation of library for reading CASC storage from Blizzard games since 2014) https://github.com/ladislav-zezula/CascLib - Version: c63818ecf8d998fae811a2d6db23045f4f6e36a1 + Version: a1197edf0b3bd4d52c3f39be7fa7b44bb0b98012 rapidjson (A fast JSON parser/generator for C++ with both SAX/DOM style API http://rapidjson.org/) https://github.com/miloyip/rapidjson diff --git a/src/tools/extractor_common/CascHandles.cpp b/src/tools/extractor_common/CascHandles.cpp index 44805fdccd1..9487b3de093 100644 --- a/src/tools/extractor_common/CascHandles.cpp +++ b/src/tools/extractor_common/CascHandles.cpp @@ -72,32 +72,30 @@ CASC::StorageHandle CASC::OpenStorage(boost::filesystem::path const& path, DWORD namespace CASC { - static DWORD GetStorageInfo(StorageHandle const& storage, CASC_STORAGE_INFO_CLASS storageInfoClass) + template<typename T> + static bool GetStorageInfo(StorageHandle const& storage, CASC_STORAGE_INFO_CLASS storageInfoClass, T* value) { - DWORD value = 0; size_t infoDataSizeNeeded = 0; - if (!::CascGetStorageInfo(storage.get(), storageInfoClass, &value, sizeof(value), &infoDataSizeNeeded)) - { - if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) - { - std::unique_ptr<char> buf(new char[infoDataSizeNeeded]); - ::CascGetStorageInfo(storage.get(), storageInfoClass, buf.get(), infoDataSizeNeeded, &infoDataSizeNeeded); - return *reinterpret_cast<DWORD*>(buf.get()); - } - } - - return value; + return ::CascGetStorageInfo(storage.get(), storageInfoClass, value, sizeof(T), &infoDataSizeNeeded); } } DWORD CASC::GetBuildNumber(StorageHandle const& storage) { - return GetStorageInfo(storage, CascStorageGameBuild); + CASC_STORAGE_PRODUCT product; + if (GetStorageInfo(storage, CascStorageProduct, &product)) + return product.dwBuildNumber; + + return 0; } DWORD CASC::GetInstalledLocalesMask(StorageHandle const& storage) { - return GetStorageInfo(storage, CascStorageInstalledLocales); + DWORD locales; + if (GetStorageInfo(storage, CascStorageInstalledLocales, &locales)) + return locales; + + return 0; } CASC::FileHandle CASC::OpenFile(StorageHandle const& storage, char const* fileName, DWORD localeMask, bool printErrors /*= false*/) |