#include "CascLib.h"
#include "CascCommon.h"

Include dependency graph for CascRootFile_WoW6.cpp:

Classes
struct	_FILE_LOCALE_BLOCK

struct	_FILE_ROOT_ENTRY

struct	_CASC_ROOT_BLOCK

struct	_CASC_FILE_ENTRY

struct	TRootHandler_WoW6

Macros
#define	__CASCLIB_SELF__

#define	ROOT_SEARCH_PHASE_INITIALIZING 0

#define	ROOT_SEARCH_PHASE_LISTFILE 1

#define	ROOT_SEARCH_PHASE_NAMELESS 2

#define	ROOT_SEARCH_PHASE_FINISHED 2

Typedefs
typedef struct _FILE_LOCALE_BLOCK	FILE_LOCALE_BLOCK

typedef struct _FILE_LOCALE_BLOCK *	PFILE_LOCALE_BLOCK

typedef struct _FILE_ROOT_ENTRY	FILE_ROOT_ENTRY

typedef struct _FILE_ROOT_ENTRY *	PFILE_ROOT_ENTRY

typedef struct _CASC_ROOT_BLOCK	CASC_ROOT_BLOCK

typedef struct _CASC_ROOT_BLOCK *	PCASC_ROOT_BLOCK

typedef struct _CASC_FILE_ENTRY	CASC_FILE_ENTRY

typedef struct _CASC_FILE_ENTRY *	PCASC_FILE_ENTRY

typedef int(*	PARSE_ROOT )(TRootHandler_WoW6 *pRootHandler, PCASC_ROOT_BLOCK pBlockInfo)

Functions
static bool	IsFileDataIdName (const char *szFileName)

PCASC_FILE_ENTRY	FindRootEntry (DYNAMIC_ARRAY &FileTable, DWORD FileDataId)

PCASC_FILE_ENTRY	FindRootEntry (PCASC_MAP pRootMap, const char szFileName, DWORD PtrTableIndex)

LPBYTE	VerifyLocaleBlock (PCASC_ROOT_BLOCK pBlockInfo, LPBYTE pbFilePointer, LPBYTE pbFileEnd)

static int	ParseRoot_CountFiles (TRootHandler_WoW6 *pRootHandler, PCASC_ROOT_BLOCK pRootBlock)

static int	ParseRoot_AddRootEntries (TRootHandler_WoW6 *pRootHandler, PCASC_ROOT_BLOCK pRootBlock)

static int	ParseWowRootFileInternal (TRootHandler_WoW6 *pRootHandler, PARSE_ROOT pfnParseRoot, LPBYTE pbRootFile, LPBYTE pbRootFileEnd, DWORD dwLocaleMask, bool bLoadBlocksWithFlags80, BYTE HighestBitValue)

static int	ParseWowRootFile2 (TRootHandler_WoW6 *pRootHandler, PARSE_ROOT pfnParseRoot, LPBYTE pbRootFile, LPBYTE pbRootFileEnd, DWORD dwLocaleMask, BYTE HighestBitValue)

static int	ParseWowRootFile (TRootHandler_WoW6 *pRootHandler, PARSE_ROOT pfnParseRoot, LPBYTE pbRootFile, LPBYTE pbRootFileEnd, DWORD dwLocaleMask)

static int	WowHandler_Insert (TRootHandler_WoW6 pRootHandler, const char szFileName, LPBYTE pbEncodingKey)

static LPBYTE	WowHandler_Search (TRootHandler_WoW6 pRootHandler, TCascSearch pSearch, PDWORD, PDWORD PtrLocaleFlags)

static LPBYTE	WowHandler_GetKey (TRootHandler_WoW6 pRootHandler, const char szFileName)

static void	WowHandler_EndSearch (TRootHandler_WoW6 , TCascSearch pSearch)

static void	WowHandler_Close (TRootHandler_WoW6 *pRootHandler)

int	RootHandler_CreateWoW6 (TCascStorage *hs, LPBYTE pbRootFile, DWORD cbRootFile, DWORD dwLocaleMask)

Macro Definition Documentation

#define __CASCLIB_SELF__

#define ROOT_SEARCH_PHASE_FINISHED 2

#define ROOT_SEARCH_PHASE_INITIALIZING 0

#define ROOT_SEARCH_PHASE_LISTFILE 1

#define ROOT_SEARCH_PHASE_NAMELESS 2

Typedef Documentation

typedef struct _CASC_FILE_ENTRY CASC_FILE_ENTRY

typedef struct _CASC_ROOT_BLOCK CASC_ROOT_BLOCK

typedef struct _FILE_LOCALE_BLOCK FILE_LOCALE_BLOCK

typedef struct _FILE_ROOT_ENTRY FILE_ROOT_ENTRY

typedef int(* PARSE_ROOT)(TRootHandler_WoW6 *pRootHandler, PCASC_ROOT_BLOCK pBlockInfo)

typedef struct _CASC_FILE_ENTRY * PCASC_FILE_ENTRY

typedef struct _CASC_ROOT_BLOCK * PCASC_ROOT_BLOCK

typedef struct _FILE_LOCALE_BLOCK * PFILE_LOCALE_BLOCK

typedef struct _FILE_ROOT_ENTRY * PFILE_ROOT_ENTRY

Function Documentation

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

Here is the caller graph for this function:

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

Here is the call graph for this function:

static bool IsFileDataIdName ( const char * szFileName )

static

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

Here is the call graph for this function:

Here is the caller graph for this function:

static int ParseRoot_AddRootEntries	(	TRootHandler_WoW6 *	pRootHandler,
		PCASC_ROOT_BLOCK	pRootBlock
	)

static

 {
  PCASC_FILE_ENTRY pFileEntry;
 
  // Sanity checks
  assert(pRootHandler->FileTable.ItemArray != NULL);
  assert(pRootHandler->FileTable.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);
 
  // (004147A3) Prepare the CASC_FILE_ENTRY structure
  pFileEntry->FileNameHash = pRootBlock->pRootEntries[i].FileNameHash;
  pFileEntry->FileDataId = pRootHandler->FileDataId + 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);
  pRootHandler->FileDataId = pFileEntry->FileDataId + 1;
 
  // Move to the next root entry
  pFileEntry++;
  }
 
  return ERROR_SUCCESS;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int ParseRoot_CountFiles	(	TRootHandler_WoW6 *	pRootHandler,
		PCASC_ROOT_BLOCK	pRootBlock
	)

static

 {
  // Add the file count to the total file count
  pRootHandler->dwTotalFileCount += pRootBlock->pLocaleBlockHdr->NumberOfFiles;
  return ERROR_SUCCESS;
 }

Here is the caller graph for this function:

static int ParseWowRootFile	(	TRootHandler_WoW6 *	pRootHandler,
		PARSE_ROOT	pfnParseRoot,
		LPBYTE	pbRootFile,
		LPBYTE	pbRootFileEnd,
		DWORD	dwLocaleMask
	)

static

 {
  ParseWowRootFile2(pRootHandler, pfnParseRoot, pbRootFile, pbRootFileEnd, dwLocaleMask, 0);
  ParseWowRootFile2(pRootHandler, pfnParseRoot, pbRootFile, pbRootFileEnd, dwLocaleMask, 1);
  return ERROR_SUCCESS;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int ParseWowRootFile2	(	TRootHandler_WoW6 *	pRootHandler,
		PARSE_ROOT	pfnParseRoot,
		LPBYTE	pbRootFile,
		LPBYTE	pbRootFileEnd,
		DWORD	dwLocaleMask,
		BYTE	HighestBitValue
	)

static

 {
  // Load the locale as-is
  ParseWowRootFileInternal(pRootHandler, pfnParseRoot, pbRootFile, pbRootFileEnd, dwLocaleMask, false, HighestBitValue);
 
  // 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, HighestBitValue);
 
  if(dwLocaleMask == CASC_LOCALE_PTPT)
  ParseWowRootFileInternal(pRootHandler, pfnParseRoot, pbRootFile, pbRootFileEnd, CASC_LOCALE_PTBR, false, HighestBitValue);
 
  return ERROR_SUCCESS;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int ParseWowRootFileInternal	(	TRootHandler_WoW6 *	pRootHandler,
		PARSE_ROOT	pfnParseRoot,
		LPBYTE	pbRootFile,
		LPBYTE	pbRootFileEnd,
		DWORD	dwLocaleMask,
		bool	bLoadBlocksWithFlags80,
		BYTE	HighestBitValue
	)

static

 {
  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 arg_4 is set to FALSE (which is by default)
  if((RootBlock.pLocaleBlockHdr->Flags & 0x80) && bLoadBlocksWithFlags80 == 0)
  continue;
 
  // WoW.exe (build 19116): Entries with (flags >> 0x1F) not equal to arg_8 are skipped
  if((RootBlock.pLocaleBlockHdr->Flags >> 0x1F) != HighestBitValue)
  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;
 }

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:

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

Here is the caller graph for this function:

static void WowHandler_Close ( TRootHandler_WoW6 * pRootHandler )

static

 {
  if(pRootHandler != NULL)
  {
  Array_Free(&pRootHandler->FileTable);
  Map_Free(pRootHandler->pRootMap);
  CASC_FREE(pRootHandler);
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void WowHandler_EndSearch	(	TRootHandler_WoW6 *	,
		TCascSearch *	pSearch
	)

static

 {
  if(pSearch->pRootContext != NULL)
  CASC_FREE(pSearch->pRootContext);
  pSearch->pRootContext = NULL;
 }

Here is the caller graph for this function:

static LPBYTE WowHandler_GetKey	(	TRootHandler_WoW6 *	pRootHandler,
		const char *	szFileName
	)

static

 {
  PCASC_FILE_ENTRY pFileEntry;
  DWORD FileDataId;
  BYTE FileDataIdLE[4];
 
  // Open by FileDataId. The file name must be as following:
  // File########.xxx, 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->FileTable, FileDataId);
  }
  else
  {
  // Find by the file name hash
  pFileEntry = FindRootEntry(pRootHandler->pRootMap, szFileName, NULL);
  }
 
  return (pFileEntry != NULL) ? pFileEntry->EncodingKey.Value : NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int WowHandler_Insert	(	TRootHandler_WoW6 *	pRootHandler,
		const char *	szFileName,
		LPBYTE	pbEncodingKey
	)

static

 {
  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;
 
  // Insert the item to the linear file list
  pFileEntry = (PCASC_FILE_ENTRY)Array_Insert(&pRootHandler->FileTable, NULL, 1);
  if(pFileEntry != NULL)
  {
  // 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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static LPBYTE WowHandler_Search	(	TRootHandler_WoW6 *	pRootHandler,
		TCascSearch *	pSearch,
		PDWORD	,
		PDWORD	PtrLocaleFlags
	)

static

 {
  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;
  return pFileEntry->EncodingKey.Value;
  }
  }
  }
 
  // No more files
  return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

Typedef Documentation

Function Documentation