CascCommon.h File Reference

#include "zlib/zlib.h"
#include "CascPort.h"
#include "common/Common.h"
#include "common/DynamicArray.h"
#include "common/Map.h"
#include "common/FileStream.h"
#include "common/Directory.h"
#include "common/ListFile.h"
#include "common/DumpContext.h"
#include "common/RootHandler.h"
#include "libtomcrypt/src/headers/tomcrypt.h"
#include "jenkins/lookup.h"

Include dependency graph for CascCommon.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_ENCODING_KEY
struct	_CASC_INDEX_ENTRY
struct	_CASC_MAPPING_TABLE
struct	_CASC_FILE_FRAME
struct	_CASC_ENCODING_HEADER
struct	_CASC_ENCODING_ENTRY
struct	_CASC_ENCODING_ENTRY_1
struct	_TCascStorage
struct	_TCascFile
struct	_TCascSearch

Macros
#define	CASC_GAME_HOTS   0x00010000
#define	CASC_GAME_WOW6   0x00020000
#define	CASC_GAME_DIABLO3   0x00030000
#define	CASC_GAME_OVERWATCH   0x00040000
#define	CASC_GAME_STARCRAFT2   0x00050000
#define	CASC_GAME_MASK   0xFFFF0000
#define	CASC_INDEX_COUNT   0x10
#define	CASC_FILE_KEY_SIZE   0x09
#define	CASC_MAX_DATA_FILES   0x100
#define	CASC_EXTRA_FILES   0x20
#define	CASC_SEARCH_HAVE_NAME   0x0001
#define	BLTE_HEADER_SIGNATURE   0x45544C42
#define	BLTE_HEADER_DELTA   0x1E
#define	MAX_HEADER_AREA_SIZE   0x2A
#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
#define	_maxchars(buff)   ((sizeof(buff) / sizeof(buff[0])) - 1)
#define	GET_INDEX_KEY(pEncodingEntry)   (pEncodingEntry->EncodingKey + MD5_HASH_SIZE)
#define	FAKE_ENCODING_ENTRY_SIZE   (sizeof(CASC_ENCODING_ENTRY) + MD5_HASH_SIZE)
#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)

Typedefs
typedef enum _CBLD_TYPE	CBLD_TYPE
typedef enum _CBLD_TYPE *	PCBLD_TYPE
typedef struct _ENCODING_KEY	ENCODING_KEY
typedef struct _ENCODING_KEY *	PENCODING_KEY
typedef struct _CASC_INDEX_ENTRY	CASC_INDEX_ENTRY
typedef struct _CASC_INDEX_ENTRY *	PCASC_INDEX_ENTRY
typedef struct _CASC_MAPPING_TABLE	CASC_MAPPING_TABLE
typedef struct _CASC_MAPPING_TABLE *	PCASC_MAPPING_TABLE
typedef struct _CASC_FILE_FRAME	CASC_FILE_FRAME
typedef struct _CASC_FILE_FRAME *	PCASC_FILE_FRAME
typedef struct _CASC_ENCODING_HEADER	CASC_ENCODING_HEADER
typedef struct _CASC_ENCODING_HEADER *	PCASC_ENCODING_HEADER
typedef struct _CASC_ENCODING_ENTRY	CASC_ENCODING_ENTRY
typedef struct _CASC_ENCODING_ENTRY *	PCASC_ENCODING_ENTRY
typedef struct _CASC_ENCODING_ENTRY_1	CASC_ENCODING_ENTRY_1
typedef struct _CASC_ENCODING_ENTRY_1 *	PCASC_ENCODING_ENTRY_1
typedef struct _TCascStorage	TCascStorage
typedef struct _TCascFile	TCascFile
typedef struct _TCascSearch	TCascSearch

Enumerations
enum	_CBLD_TYPE { CascBuildNone = 0, CascBuildInfo, CascBuildDb }

Functions
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)
void	FreeCascBlob (PQUERY_KEY pQueryKey)
int	LoadBuildInfo (TCascStorage *hs)
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)
TCascStorage *	IsValidStorageHandle (HANDLE hStorage)
TCascFile *	IsValidFileHandle (HANDLE hFile)
PCASC_ENCODING_ENTRY	FindEncodingEntry (TCascStorage *hs, PQUERY_KEY pEncodingKey, PDWORD PtrIndex)
PCASC_INDEX_ENTRY	FindIndexEntry (TCascStorage *hs, PQUERY_KEY pIndexKey)
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	RootHandler_CreateMNDX (TCascStorage *hs, LPBYTE pbRootFile, DWORD cbRootFile)
int	RootHandler_CreateDiablo3 (TCascStorage *hs, LPBYTE pbRootFile, DWORD cbRootFile)
int	RootHandler_CreateOverwatch (TCascStorage *hs, LPBYTE pbRootFile, DWORD cbRootFile)
int	RootHandler_CreateWoW6 (TCascStorage *hs, LPBYTE pbRootFile, DWORD cbRootFile, DWORD dwLocaleMask)

Macro Definition Documentation

#define _maxchars

(

buff

)

((sizeof(buff) / sizeof(buff[0])) - 1)

#define BLTE_HEADER_DELTA   0x1E

#define BLTE_HEADER_SIGNATURE   0x45544C42

#define CASC_ALLOC	(		type,
			count
	)		(type *)malloc((count) * sizeof(type))

#define CASC_EXTRA_FILES   0x20

#define CASC_FILE_KEY_SIZE   0x09

#define CASC_FREE

(

ptr

)

free(ptr)

#define CASC_GAME_DIABLO3   0x00030000

#define CASC_GAME_HOTS   0x00010000

#define CASC_GAME_MASK   0xFFFF0000

#define CASC_GAME_OVERWATCH   0x00040000

#define CASC_GAME_STARCRAFT2   0x00050000

#define CASC_GAME_WOW6   0x00020000

#define CASC_INDEX_COUNT   0x10

#define CASC_MAX_DATA_FILES   0x100

#define CASC_PACKAGE_BUFFER   0x1000

#define CASC_REALLOC	(		type,
			ptr,
			count
	)		(type *)realloc(ptr, (count) * sizeof(type))

#define CASC_SEARCH_HAVE_NAME   0x0001

#define CASCLIB_MAX	(		a,
			b
	)		((a > b) ? a : b)

#define CASCLIB_MIN	(		a,
			b
	)		((a < b) ? a : b)

#define CASCLIB_UNUSED

(

p

)

((void)(p))

#define FAKE_ENCODING_ENTRY_SIZE   (sizeof(CASC_ENCODING_ENTRY) + MD5_HASH_SIZE)

#define GET_INDEX_KEY

(

pEncodingEntry

)

(pEncodingEntry->EncodingKey + MD5_HASH_SIZE)

#define MAX_HEADER_AREA_SIZE   0x2A

Typedef Documentation

typedef struct _CASC_ENCODING_ENTRY CASC_ENCODING_ENTRY

typedef struct _CASC_ENCODING_ENTRY_1 CASC_ENCODING_ENTRY_1

typedef struct _CASC_ENCODING_HEADER CASC_ENCODING_HEADER

typedef struct _CASC_FILE_FRAME CASC_FILE_FRAME

typedef struct _CASC_INDEX_ENTRY CASC_INDEX_ENTRY

typedef struct _CASC_MAPPING_TABLE CASC_MAPPING_TABLE

typedef enum _CBLD_TYPE CBLD_TYPE

typedef struct _ENCODING_KEY ENCODING_KEY

typedef struct _CASC_ENCODING_ENTRY * PCASC_ENCODING_ENTRY

typedef struct _CASC_ENCODING_ENTRY_1 * PCASC_ENCODING_ENTRY_1

typedef struct _CASC_ENCODING_HEADER * PCASC_ENCODING_HEADER

typedef struct _CASC_FILE_FRAME * PCASC_FILE_FRAME

typedef struct _CASC_INDEX_ENTRY * PCASC_INDEX_ENTRY

typedef struct _CASC_MAPPING_TABLE * PCASC_MAPPING_TABLE

typedef enum _CBLD_TYPE * PCBLD_TYPE

typedef struct _ENCODING_KEY * PENCODING_KEY

typedef struct _TCascFile TCascFile

typedef struct _TCascSearch TCascSearch

typedef struct _TCascStorage TCascStorage

Enumeration Type Documentation

enum _CBLD_TYPE

Enumerator
CascBuildNone
CascBuildInfo
CascBuildDb

{
 CascBuildNone = 0, // No build type found
 CascBuildInfo, // .build.info
 CascBuildDb, // .build.db (older storages)
} CBLD_TYPE, *PCBLD_TYPE;

Function Documentation

int CascDecompress	(	LPBYTE	pvOutBuffer,
		PDWORD	pcbOutBuffer,
		LPBYTE	pvInBuffer,
		DWORD	cbInBuffer
	)

{
 z_stream z; // Stream information for zlib
 int nResult;

 // 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.total_out = 0;
 z.zalloc = NULL;
 z.zfree = NULL;

 // Initialize the decompression structure
 if((nResult = inflateInit(&z)) == Z_OK)
 {
 // Call zlib to decompress the data
 nResult = inflate(&z, Z_NO_FLUSH);
 inflateEnd(&z);

 // Give the size of the uncompressed data
 *pcbOutBuffer = z.total_out;
 }

 // Return an error code
 return (nResult == Z_OK || nResult == Z_STREAM_END) ? ERROR_SUCCESS : ERROR_FILE_CORRUPT;
}

Here is the caller graph for this function:

int CascDecrypt	(	LPBYTE	pbOutBuffer,
		PDWORD	pcbOutBuffer,
		LPBYTE	pbInBuffer,
		DWORD	cbInBuffer,
		DWORD	dwFrameIndex
	)

{
 ULONGLONG KeyName = 0;
 LPBYTE pbBufferEnd = pbInBuffer + cbInBuffer;
 LPBYTE pbKey;
 DWORD KeyNameSize;
 DWORD dwShift = 0;
 DWORD IVSize;
 BYTE Vector[0x08];
 BYTE EncryptionType;
 int nError;

 // Verify and retrieve the key name size
 if(pbInBuffer >= pbBufferEnd)
 return ERROR_FILE_CORRUPT;
 if(pbInBuffer[0] != 0 && pbInBuffer[0] != 8)
 return ERROR_NOT_SUPPORTED;
 KeyNameSize = *pbInBuffer++;

 // Copy the key name
 if((pbInBuffer + KeyNameSize) >= pbBufferEnd)
 return ERROR_FILE_CORRUPT;
 memcpy(&KeyName, pbInBuffer, KeyNameSize);
 pbInBuffer += KeyNameSize;

 // Verify and retrieve the Vector size
 if(pbInBuffer >= pbBufferEnd)
 return ERROR_FILE_CORRUPT;
 if(pbInBuffer[0] != 4 && pbInBuffer[0] != 8)
 return ERROR_NOT_SUPPORTED;
 IVSize = *pbInBuffer++;

 // Copy the initialization vector
 if((pbInBuffer + IVSize) >= pbBufferEnd)
 return ERROR_FILE_CORRUPT;
 memset(Vector, 0, sizeof(Vector));
 memcpy(Vector, pbInBuffer, IVSize);
 pbInBuffer += IVSize;

 // Verify and retrieve the encryption type
 if(pbInBuffer >= pbBufferEnd)
 return ERROR_FILE_CORRUPT;
 if(pbInBuffer[0] != 'S' && pbInBuffer[0] != 'A')
 return ERROR_NOT_SUPPORTED;
 EncryptionType = *pbInBuffer++;

 // Do we have enough space in the output buffer?
 if((DWORD)(pbBufferEnd - pbInBuffer) > pcbOutBuffer[0])
 return ERROR_INSUFFICIENT_BUFFER;

 // Check if we know the key
 pbKey = FindCascKey(KeyName);
 if(pbKey == NULL)
 return ERROR_UNKNOWN_FILE_KEY;

 // 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++)
 {
 Vector[i] = Vector[i] ^ (BYTE)((dwFrameIndex >> dwShift) & 0xFF);
 dwShift += 8;
 }

 // Perform the decryption-specific action
 switch(EncryptionType)
 {
 case 'S': // Salsa20
 nError = Decrypt_Salsa20(pbOutBuffer, pbInBuffer, (pbBufferEnd - pbInBuffer), pbKey, 0x10, Vector);
 if(nError != ERROR_SUCCESS)
 return nError;

 // Supply the size of the output buffer
 pcbOutBuffer[0] = (DWORD)(pbBufferEnd - pbInBuffer);
 return ERROR_SUCCESS;

// case 'A': 
// return ERROR_NOT_SUPPORTED;
 }

 assert(false);
 return ERROR_NOT_SUPPORTED;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CascDirectCopy	(	LPBYTE	pbOutBuffer,
		PDWORD	pcbOutBuffer,
		LPBYTE	pbInBuffer,
		DWORD	cbInBuffer
	)

{
 // Check the buffer size
 if((cbInBuffer - 1) > pcbOutBuffer[0])
 return ERROR_INSUFFICIENT_BUFFER;

 // Copy the data
 memcpy(pbOutBuffer, pbInBuffer, cbInBuffer);
 pcbOutBuffer[0] = cbInBuffer;
 return ERROR_SUCCESS;
}

Here is the caller graph for this function:

int CheckGameDirectory	(	TCascStorage *	hs,
		TCHAR *	szDirectory
	)

{
 TFileStream * pStream;
 TCHAR * szBuildFile;
 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++)
 {
 // Create the full name of the .agent.db file
 szBuildFile = CombinePath(szDirectory, BuildTypes[i].szFileName);
 if(szBuildFile != NULL)
 {
 // Attempt to open the file
 pStream = FileStream_OpenFile(szBuildFile, 0);
 if(pStream != NULL)
 {
 // Free the stream
 FileStream_Close(pStream);

 // Check for the data directory
 nError = CheckDataDirectory(hs, szDirectory);
 if(nError == ERROR_SUCCESS)
 {
 hs->szBuildFile = szBuildFile;
 hs->BuildFileType = BuildTypes[i].BuildFileType;
 return ERROR_SUCCESS;
 }
 }

 CASC_FREE(szBuildFile);
 }
 }

 return nError;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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;
}

Here is the caller graph for this function:

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;
}

Here is the caller graph for this function:

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;
}

Here is the caller graph for this function:

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;
}

Here is the caller graph for this function:

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;
}

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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PCASC_INDEX_ENTRY FindIndexEntry	(	TCascStorage *	hs,
		PQUERY_KEY	pIndexKey
	)

{
 PCASC_INDEX_ENTRY pIndexEntry = NULL;

 if(hs->pIndexEntryMap != NULL)
 pIndexEntry = (PCASC_INDEX_ENTRY)Map_FindObject(hs->pIndexEntryMap, pIndexKey->pbData, NULL);

 return pIndexEntry;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void FreeCascBlob

(

PQUERY_KEY

pQueryKey

)

{
 if(pBlob != NULL)
 {
 if(pBlob->pbData != NULL)
 CASC_FREE(pBlob->pbData);

 pBlob->pbData = NULL;
 pBlob->cbData = 0;
 }
}

Here is the caller graph for this function:

int GetRootVariableIndex	(	const char *	szLinePtr,
		const char *	szLineEnd,
		const char *	szVariableName,
		int *	PtrIndex
	)

{
 size_t nLength = strlen(szVariableName);
 int nIndex = 0;
 
 while(szLinePtr < szLineEnd)
 {
 // Check the variable there
 if(!_strnicmp(szLinePtr, szVariableName, nLength))
 {
 // Does the length match?
 if(szLinePtr[nLength] == '|' || szLinePtr[nLength] == '0')
 {
 PtrIndex[0] = nIndex;
 return ERROR_SUCCESS;
 }
 }

 // Get the next variable
 szLinePtr = SkipInfoVariable(szLinePtr, szLineEnd);
 if(szLinePtr == NULL)
 break;
 nIndex++;
 }

 return ERROR_BAD_FORMAT;
}

Here is the call graph for this function:

Here is the caller graph for this function:

TCascFile* IsValidFileHandle

(

HANDLE

hFile

)

{
 TCascFile * hf = (TCascFile *)hFile;

 return (hf != NULL && hf->hs != NULL && hf->szClassName != NULL && !strcmp(hf->szClassName, "TCascFile")) ? hf : NULL;
}

TCascStorage* IsValidStorageHandle

(

HANDLE

hStorage

)

{
 TCascStorage * hs = (TCascStorage *)hStorage;

 return (hs != NULL && hs->szClassName != NULL && !strcmp(hs->szClassName, "TCascStorage")) ? hs : NULL;
}

Here is the caller graph for this function:

int LoadBuildInfo

(

TCascStorage *

hs

)

{
 PARSEINFOFILE PfnParseProc = NULL;
 void * pvListFile;
 int nError = ERROR_SUCCESS;

 switch(hs->BuildFileType)
 {
 case CascBuildInfo:
 PfnParseProc = ParseFile_BuildInfo;
 break;

 case CascBuildDb:
 PfnParseProc = ParseFile_BuildDb;
 break;

 default:
 nError = ERROR_NOT_SUPPORTED;
 break;
 }

 // Parse the appropriate build file
 if(nError == ERROR_SUCCESS)
 {
 pvListFile = ListFile_OpenExternal(hs->szBuildFile);
 if(pvListFile != NULL)
 {
 // Parse the info file
 nError = PfnParseProc(hs, pvListFile);
 ListFile_Free(pvListFile);
 }
 else
 nError = ERROR_FILE_NOT_FOUND;
 }

 // If the .build.info OR .build.db file has been loaded,
 // proceed with loading the CDN config file and CDN build file
 if(nError == ERROR_SUCCESS)
 {
 // Load the configuration file
 pvListFile = FetchAndVerifyConfigFile(hs, &hs->CdnConfigKey);
 if(pvListFile != NULL)
 {
 nError = LoadCdnConfigFile(hs, pvListFile);
 ListFile_Free(pvListFile);
 }
 else
 nError = ERROR_FILE_NOT_FOUND;
 }

 // Load the build file
 if(nError == ERROR_SUCCESS)
 {
 pvListFile = FetchAndVerifyConfigFile(hs, &hs->CdnBuildKey);
 if(pvListFile != NULL)
 {
 nError = LoadCdnBuildFile(hs, pvListFile);
 ListFile_Free(pvListFile);
 }
 else
 nError = ERROR_FILE_NOT_FOUND;
 }

 // Fill the index directory
 if(nError == ERROR_SUCCESS)
 {
 // First, check for more common "data" subdirectory
 if((hs->szIndexPath = CheckForIndexDirectory(hs, _T("data"))) != NULL)
 return ERROR_SUCCESS;

 // Second, try the "darch" subdirectory (older builds of HOTS - Alpha)
 if((hs->szIndexPath = CheckForIndexDirectory(hs, _T("darch"))) != NULL)
 return ERROR_SUCCESS;

 nError = ERROR_FILE_NOT_FOUND;
 }

 return nError;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ParseRootFileLine	(	const char *	szLinePtr,
		const char *	szLineEnd,
		int	nFileNameIndex,
		PQUERY_KEY	pEncodingKey,
		char *	szFileName,
		size_t	nMaxChars
	)

{
 int nIndex = 0;
 int nError;

 // Extract the MD5 (aka encoding key)
 if(szLinePtr[MD5_STRING_SIZE] != '|')
 return ERROR_BAD_FORMAT;

 // 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;

 // Skip the variable
 szLinePtr += MD5_STRING_SIZE + 1;
 nIndex = 1;

 // Skip the variables until we find the file name
 while(szLinePtr < szLineEnd && nIndex < nFileNameIndex)
 {
 if(szLinePtr[0] == '|')
 nIndex++;
 szLinePtr++;
 }

 // Extract the file name
 while(szLinePtr < szLineEnd && szLinePtr[0] != '|' && nMaxChars > 1)
 {
 *szFileName++ = *szLinePtr++;
 nMaxChars--;
 }

 *szFileName = 0;
 return ERROR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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;

 // 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;

 // 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)
 {
 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(size_t i = 0; i < dwRootEntries; i++)
 {
 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)
 {
 nError = ParseDirectoryFile(pRootHandler, pbRootFile, pbRootFile + cbRootFile, i);
 CASC_FREE(pbRootFile);
 }
 }
 }

 // 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);
 return nError;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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;
 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);
 }

 // 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++)
 {
 // 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;

 // Allocate MAR_FILE structure
 pMarFile = CASC_ALLOC(MAR_FILE, 1);
 if(pMarFile == NULL)
 {
 nError = ERROR_NOT_ENOUGH_MEMORY;
 break;
 }

 // Allocate space for the MAR data
 pMarFile->pDatabasePtr = NULL;
 pMarFile->pbMarData = CASC_ALLOC(BYTE, MarInfo.MarDataSize);
 pMarFile->cbMarData = MarInfo.MarDataSize;
 if(pMarFile->pbMarData == NULL)
 {
 nError = ERROR_NOT_ENOUGH_MEMORY;
 break;
 }

 // Read the MAR data
 if(!RootFileRead(pbRootFile + MarInfo.MarDataOffset, pbRootFileEnd, pMarFile->pbMarData, pMarFile->cbMarData))
 {
 nError = ERROR_FILE_CORRUPT;
 break;
 }

 // HOTS: 00E94FF1
 MAR_FILE_CreateDatabase(pMarFile);
 if(i == 0)
 pMndxInfo->pMarFile1 = pMarFile;
 if(i == 1)
 pMndxInfo->pMarFile2 = pMarFile;
 if(i == 2)
 pMndxInfo->pMarFile3 = pMarFile;
 }

 // 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;
 }

 // Load the complete array of MNDX entries
 if(nError == ERROR_SUCCESS)
 {
 TFileNameDatabasePtr * pDbPtr = pMndxInfo->pMarFile2->pDatabasePtr;
 DWORD FileNameCount;

 nError = pDbPtr->GetFileNameCount(&FileNameCount);
 if(nError == ERROR_SUCCESS && FileNameCount == pMndxInfo->MndxEntriesValid)
        {
            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;
        }
        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)
        {
            PCASC_ROOT_ENTRY_MNDX pRootEntry = pRootHandler->pMndxEntries;
            DWORD ValidEntryCount = 1; // edx
            DWORD nIndex1 = 0;

            // The first entry is always valid
            pRootHandler->ppValidEntries[nIndex1++] = pRootHandler->pMndxEntries;

            // Put the remaining entries
            for(i = 0; i < pMndxInfo->MndxEntriesTotal; i++, pRootEntry++)
            {
                if(ValidEntryCount > pMndxInfo->MndxEntriesValid)
                    break;

                if(pRootEntry->Flags & 0x80000000)
                {
                    pRootHandler->ppValidEntries[nIndex1++] = pRootEntry + 1;
                    ValidEntryCount++;
                }
            }

            // 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

    // Return the result
    return nError;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 = 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;

    // 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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;

#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 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);
    return ERROR_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function: