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

Include dependency graph for CascRootFile_Diablo3.cpp:

Classes
struct	_DIABLO3_FILEID1_ENTRY

struct	_DIABLO3_FILEID2_ENTRY

struct	_DIABLO3_NAMED_ENTRY

struct	_DIABLO3_CORE_TOC_HEADER

struct	_DIABLO3_CORE_TOC_ENTRY

struct	_DIABLO3_DIR_HEADER

struct	_DIABLO3_CORE_TOC

struct	_DIABLO3_PACKAGES_DAT_HEADER

struct	_DIABLO3_ASSET_INFO

struct	_CASC_FILE_ENTRY

struct	TRootHandler_Diablo3

Macros
#define	__CASCLIB_SELF__

#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

#define	DIABLO3_MAX_LEVEL0_LENGTH 0x10

#define	INVALID_FILE_INDEX 0xFFFFFFFF

#define	INVALID_ASSET_INDEX 0xFF

#define	ENTRY_FLAG_DIRECTORY_ENTRY 0x80

#define	ENTRY_FLAG_PLAIN_NAME 0x01

#define	ENTRY_FLAG_FULL_NAME 0x02

#define	ENTRY_FLAG_FLAGS_MASK 0xF0

#define	ENTRY_FLAG_NAME_MASK 0x0F

#define	CASC_ENTRY_SHORT_NAME 0x000000001

#define	CASC_ENTRY_HAS_SUBINDEX 0x000000002

#define	SEARCH_PHASE_NAMES 0

#define	SEARCH_PHASE_FILE_IDS 1

#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_ASSET_COUNT (sizeof(Assets) / sizeof(Assets[0]))

Typedefs
typedef struct _DIABLO3_FILEID1_ENTRY	DIABLO3_FILEID1_ENTRY

typedef struct _DIABLO3_FILEID1_ENTRY *	PDIABLO3_FILEID1_ENTRY

typedef struct _DIABLO3_FILEID2_ENTRY	DIABLO3_FILEID2_ENTRY

typedef struct _DIABLO3_FILEID2_ENTRY *	PDIABLO3_FILEID2_ENTRY

typedef struct _DIABLO3_NAMED_ENTRY	DIABLO3_NAMED_ENTRY

typedef struct _DIABLO3_NAMED_ENTRY *	PDIABLO3_NAMED_ENTRY

typedef struct _DIABLO3_CORE_TOC_HEADER	DIABLO3_CORE_TOC_HEADER

typedef struct _DIABLO3_CORE_TOC_HEADER *	PDIABLO3_CORE_TOC_HEADER

typedef struct _DIABLO3_CORE_TOC_ENTRY	DIABLO3_CORE_TOC_ENTRY

typedef struct _DIABLO3_CORE_TOC_ENTRY *	PDIABLO3_CORE_TOC_ENTRY

typedef struct _DIABLO3_DIR_HEADER	DIABLO3_DIR_HEADER

typedef struct _DIABLO3_DIR_HEADER *	PDIABLO3_DIR_HEADER

typedef struct _DIABLO3_CORE_TOC	DIABLO3_CORE_TOC

typedef struct _DIABLO3_CORE_TOC *	PDIABLO3_CORE_TOC

typedef struct _DIABLO3_PACKAGES_DAT_HEADER	DIABLO3_PACKAGES_DAT_HEADER

typedef struct _DIABLO3_PACKAGES_DAT_HEADER *	PDIABLO3_PACKAGES_DAT_HEADER

typedef struct _DIABLO3_ASSET_INFO	DIABLO3_ASSET_INFO

typedef const DIABLO3_ASSET_INFO *	PDIABLO3_ASSET_INFO

typedef struct _CASC_FILE_ENTRY	CASC_FILE_ENTRY

typedef struct _CASC_FILE_ENTRY *	PCASC_FILE_ENTRY

Functions
static PDIABLO3_ASSET_INFO	GetAssetInfo (DWORD dwAssetIndex)

static DWORD	VerifyNamedFileEntry (LPBYTE pbNamedEntry, LPBYTE pbFileEnd)

static char *	FindPackageName (PCASC_MAP pPackageMap, const char szAssetName, const char szPlainName)

static size_t	CreateShortName (PCASC_MAP pPackageMap, DWORD dwRootIndex, DWORD dwAssetIndex, const char szPlainName, DWORD dwSubIndex, char szBuffer)

static size_t	CreateFileName (TRootHandler_Diablo3 pRootHandler, const char szShortName, char *szBuffer)

static PCASC_MAP	CreatePackageMap (LPBYTE pbPackagesDat, LPBYTE pbPackagesEnd)

static int	InsertFileEntry (TRootHandler_Diablo3 pRootHandler, ENCODING_KEY &EncodingKey, const char szFileName, size_t cchFileName)

static int	ParseDirEntries_FileId1 (TRootHandler_Diablo3 *pRootHandler, LPBYTE pbFileEntries, DWORD dwFileEntries, DWORD dwRootDirIndex)

static int	ParseDirEntries_FileId2 (TRootHandler_Diablo3 *pRootHandler, LPBYTE pbFileEntries, DWORD dwFileEntries, DWORD dwRootDirIndex)

static int	ParseDirEntries_Named (TRootHandler_Diablo3 *pRootHandler, LPBYTE pbFileEntries, LPBYTE pbFileEnd, DWORD dwFileEntries, DWORD dwRootDirIndex)

static void	ResolveFullFileNames (TRootHandler_Diablo3 *pRootHandler, PDIABLO3_CORE_TOC_ENTRY pCoreTocEntries, PCASC_MAP pPackageMap, LPBYTE pbCoreTocFile, DWORD dwFileIndexes)

static LPBYTE	LoadFileToMemory (TCascStorage hs, LPBYTE pbEncodingKey, DWORD pcbFileData)

static LPBYTE	LoadFileToMemory (TCascStorage hs, const char szFileName, DWORD *pcbFileData)

static int	ParseDirectoryHeader (PDIABLO3_DIR_HEADER pDirHeader, LPBYTE pbDirFile, LPBYTE pbFileEnd)

static DWORD	ScanDirectoryFile (TCascStorage *hs, LPBYTE pbRootFile, LPBYTE pbFileEnd)

static int	ParseDirectoryFile (TRootHandler_Diablo3 *pRootHandler, LPBYTE pbDirFile, LPBYTE pbFileEnd, DWORD dwRootDirIndex)

static int	ParseCoreTOC (TRootHandler_Diablo3 *pRootHandler, PCASC_MAP pPackageMap, LPBYTE pbCoreTocFile, LPBYTE pbCoreTocEnd)

static int	D3Handler_Insert (TRootHandler_Diablo3 pRootHandler, const char szFileName, LPBYTE pbEncodingKey)

static LPBYTE	D3Handler_Search (TRootHandler_Diablo3 pRootHandler, TCascSearch pSearch, PDWORD, PDWORD)

static void	D3Handler_EndSearch (TRootHandler_Diablo3 , TCascSearch )

static LPBYTE	D3Handler_GetKey (TRootHandler_Diablo3 pRootHandler, const char szFileName)

static void	D3Handler_Close (TRootHandler_Diablo3 *pRootHandler)

int	RootHandler_CreateDiablo3 (TCascStorage *hs, LPBYTE pbRootFile, DWORD cbRootFile)

Variables
static const DIABLO3_ASSET_INFO	Assets []

static const DIABLO3_ASSET_INFO	UnknownAsset = {"Unknown", "xxx"}

Macro Definition Documentation

#define __CASCLIB_SELF__

#define CASC_ENTRY_HAS_SUBINDEX 0x000000002

#define CASC_ENTRY_SHORT_NAME 0x000000001

#define DIABLO3_ASSET_COUNT (sizeof(Assets) / sizeof(Assets[0]))

#define DIABLO3_INVALID_FILE 0xFFFFFFFF

#define DIABLO3_INVALID_INDEX 0xFFFFFFFF

#define DIABLO3_MAX_ASSETS 70

#define DIABLO3_MAX_LEVEL0_LENGTH 0x10

#define DIABLO3_MAX_SUBDIRS 0x20

#define DIABLO3_PACKAGES_SIGNATURE 0xAABB0002

#define DIABLO3_SUBDIR_SIGNATURE 0xEAF1FE87

#define ENTRY_FLAG_DIRECTORY_ENTRY 0x80

#define ENTRY_FLAG_FLAGS_MASK 0xF0

#define ENTRY_FLAG_FULL_NAME 0x02

#define ENTRY_FLAG_NAME_MASK 0x0F

#define ENTRY_FLAG_PLAIN_NAME 0x01

#define INDEX64_FILE_INDEX ( hash ) (DWORD)((hash >> 0x18) & 0xFFFFFFFF)

#define INDEX64_ROOT_INDEX ( hash ) (DWORD)((hash >> 0x38) & 0x000000FF)

#define INDEX64_SUB_INDEX ( hash ) (DWORD)((hash >> 0x00) & 0x00FFFFFF)

#define INVALID_ASSET_INDEX 0xFF

#define INVALID_FILE_INDEX 0xFFFFFFFF

#define MAKE_INDEX64	(	ri,
		fi,
		si
	)	(((ULONGLONG)ri << 0x38) \| ((ULONGLONG)fi << 0x18) \| ((ULONGLONG)si))

#define SEARCH_PHASE_FILE_IDS 1

#define SEARCH_PHASE_NAMES 0

Typedef Documentation

typedef struct _CASC_FILE_ENTRY CASC_FILE_ENTRY

typedef struct _DIABLO3_ASSET_INFO DIABLO3_ASSET_INFO

typedef struct _DIABLO3_CORE_TOC DIABLO3_CORE_TOC

typedef struct _DIABLO3_CORE_TOC_ENTRY DIABLO3_CORE_TOC_ENTRY

typedef struct _DIABLO3_CORE_TOC_HEADER DIABLO3_CORE_TOC_HEADER

typedef struct _DIABLO3_DIR_HEADER DIABLO3_DIR_HEADER

typedef struct _DIABLO3_FILEID1_ENTRY DIABLO3_FILEID1_ENTRY

typedef struct _DIABLO3_FILEID2_ENTRY DIABLO3_FILEID2_ENTRY

typedef struct _DIABLO3_NAMED_ENTRY DIABLO3_NAMED_ENTRY

typedef struct _DIABLO3_PACKAGES_DAT_HEADER DIABLO3_PACKAGES_DAT_HEADER

typedef struct _CASC_FILE_ENTRY * PCASC_FILE_ENTRY

typedef const DIABLO3_ASSET_INFO* PDIABLO3_ASSET_INFO

typedef struct _DIABLO3_CORE_TOC * PDIABLO3_CORE_TOC

typedef struct _DIABLO3_CORE_TOC_ENTRY * PDIABLO3_CORE_TOC_ENTRY

typedef struct _DIABLO3_CORE_TOC_HEADER * PDIABLO3_CORE_TOC_HEADER

typedef struct _DIABLO3_DIR_HEADER * PDIABLO3_DIR_HEADER

typedef struct _DIABLO3_FILEID1_ENTRY * PDIABLO3_FILEID1_ENTRY

typedef struct _DIABLO3_FILEID2_ENTRY * PDIABLO3_FILEID2_ENTRY

typedef struct _DIABLO3_NAMED_ENTRY * PDIABLO3_NAMED_ENTRY

typedef struct _DIABLO3_PACKAGES_DAT_HEADER * PDIABLO3_PACKAGES_DAT_HEADER

Function Documentation

static size_t CreateFileName	(	TRootHandler_Diablo3 *	pRootHandler,
		const char *	szShortName,
		char *	szBuffer
	)

static

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

Here is the call graph for this function:

Here is the caller graph for this function:

static PCASC_MAP CreatePackageMap	(	LPBYTE	pbPackagesDat,
		LPBYTE	pbPackagesEnd
	)

static

 {
  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)
  {
  char * szFileName = (char *)pbPackagesDat;
 
  // Go as long as there is something
  for(DWORD i = 0; i < pDatHeader->NumberOfNames; i++)
  {
  // 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;
  }
  }
 
  return pPackageMap;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static size_t CreateShortName	(	PCASC_MAP	pPackageMap,
		DWORD	dwRootIndex,
		DWORD	dwAssetIndex,
		const char *	szPlainName,
		DWORD	dwSubIndex,
		char *	szBuffer
	)

static

 {
  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)
  {
  // Retrieve the asset name
  szPackageName = FindPackageName(pPackageMap, pAssetInfo->szDirectoryName, szBuffer);
  if(szPackageName != NULL)
  {
  strcpy(szBuffer, szPackageName + strlen(pAssetInfo->szDirectoryName) + 1);
  nLength = strlen(szBuffer);
  }
  }
 
  // If we havent't found the package, we either use the default asset extension or "xxx"
  if(szPackageName == NULL)
  {
  if(dwSubIndex == DIABLO3_INVALID_INDEX)
  {
  strcpy(szBuffer + nLength, pAssetInfo->szExtension);
  nLength += strlen(pAssetInfo->szExtension);
  }
  else
  {
  strcpy(szBuffer + nLength, "xxx");
  nLength += 3;
  }
  }
 
  // Return the length of the short file name
  return nLength + 4;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void D3Handler_Close ( TRootHandler_Diablo3 * pRootHandler )

static

 {
  if(pRootHandler != NULL)
  {
  // Free the file map
  Map_Free(pRootHandler->pRootMap);
 
  // Free the array of the file entries and file names
  Array_Free(&pRootHandler->FileTable);
  Array_Free(&pRootHandler->FileNames);
 
  // Free the root file itself
  CASC_FREE(pRootHandler);
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void D3Handler_EndSearch	(	TRootHandler_Diablo3 *	,
		TCascSearch *
	)

static

 {
  // Do nothing
 }

Here is the caller graph for this function:

static LPBYTE D3Handler_GetKey	(	TRootHandler_Diablo3 *	pRootHandler,
		const char *	szFileName
	)

static

 {
  PCASC_FILE_ENTRY pFileEntry;
  ULONGLONG FileNameHash = CalcFileNameHash(szFileName);
 
  // Find the file in the name table
  pFileEntry = (PCASC_FILE_ENTRY)Map_FindObject(pRootHandler->pRootMap, &FileNameHash, 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 D3Handler_Insert	(	TRootHandler_Diablo3 *	pRootHandler,
		const char *	szFileName,
		LPBYTE	pbEncodingKey
	)

static

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

Here is the call graph for this function:

Here is the caller graph for this function:

static LPBYTE D3Handler_Search	(	TRootHandler_Diablo3 *	pRootHandler,
		TCascSearch *	pSearch,
		PDWORD	,
		PDWORD
	)

static

 {
  PCASC_FILE_ENTRY pFileEntry;
  const char * szSrcName = NULL;
 
  // Are we still inside the root directory range?
  while(pSearch->IndexLevel1 < pRootHandler->FileTable.ItemCount)
  {
  // 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);
 
  // This is either a full file name or an abbreviated name
  if(pFileEntry->dwFlags & CASC_ENTRY_SHORT_NAME)
  {
  CreateFileName(pRootHandler, szSrcName, pSearch->szFileName);
  }
  else
  {
  strcpy(pSearch->szFileName, szSrcName);
  }
 
  // Prepare for the next search
  pSearch->IndexLevel1++;
  return pFileEntry->EncodingKey.Value;
  }
 
  // No more entries
  return NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static char* FindPackageName	(	PCASC_MAP	pPackageMap,
		const char *	szAssetName,
		const char *	szPlainName
	)

static

 {
  char szFileName[MAX_PATH+1];
  size_t nLength;
 
  // 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);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static PDIABLO3_ASSET_INFO GetAssetInfo ( DWORD dwAssetIndex )

static

 {
  if(dwAssetIndex < DIABLO3_ASSET_COUNT && Assets[dwAssetIndex].szDirectoryName != NULL)
  return &Assets[dwAssetIndex];
  return &UnknownAsset;
 }

Here is the caller graph for this function:

static int InsertFileEntry	(	TRootHandler_Diablo3 *	pRootHandler,
		ENCODING_KEY &	EncodingKey,
		const char *	szFileName,
		size_t	cchFileName
	)

static

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

Here is the call graph for this function:

Here is the caller graph for this function:

static LPBYTE LoadFileToMemory	(	TCascStorage *	hs,
		LPBYTE	pbEncodingKey,
		DWORD *	pcbFileData
	)

static

 {
  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)
  {
  pbFileData = CASC_ALLOC(BYTE, cbFileData);
  if(pbFileData != NULL)
  {
  CascReadFile(hFile, pbFileData, cbFileData, &cbBytesRead);
  }
  }
 
  // Close the file
  CascCloseFile(hFile);
  }
 
  // Give the file to the caller
  if(pcbFileData != NULL)
  pcbFileData[0] = cbBytesRead;
  return pbFileData;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static LPBYTE LoadFileToMemory	(	TCascStorage *	hs,
		const char *	szFileName,
		DWORD *	pcbFileData
	)

static

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

Here is the call graph for this function:

static int ParseCoreTOC	(	TRootHandler_Diablo3 *	pRootHandler,
		PCASC_MAP	pPackageMap,
		LPBYTE	pbCoreTocFile,
		LPBYTE	pbCoreTocEnd
	)

static

 {
  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++)
  {
  // Get the first entry
  pTocEntry = (PDIABLO3_CORE_TOC_ENTRY)(pbCoreTocFile + pTocHeader->EntryOffsets[i]);
 
  // Find out the entry with the maximum index
  for(DWORD n = 0; n < pTocHeader->EntryCounts[i]; n++)
  {
  if(pTocEntry->FileIndex > dwFileIndexes)
  dwFileIndexes = pTocEntry->FileIndex + 1;
  pTocEntry++;
  }
  }
 
  // Allocate and populate the array of DIABLO3_CORE_TOC_ENTRYs
  pSortedEntries = CASC_ALLOC(DIABLO3_CORE_TOC_ENTRY, dwFileIndexes);
  if(pSortedEntries != NULL)
  {
  // Initialize all entries to invalid
  memset(pSortedEntries, 0xFF, dwFileIndexes * sizeof(DIABLO3_CORE_TOC_ENTRY));
 
  // Populate the linear array with the entries
  for(i = 0; i < DIABLO3_MAX_ASSETS; i++)
  {
  // 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++)
  {
  pSortedEntries[pTocEntry->FileIndex].AssetIndex = pTocEntry->AssetIndex;
  pSortedEntries[pTocEntry->FileIndex].FileIndex = pTocEntry->FileIndex;
  pSortedEntries[pTocEntry->FileIndex].NameOffset = (DWORD)(pbCoreTocNames - pbCoreTocFile) + pTocEntry->NameOffset;
  pTocEntry++;
  }
  }
 
  // Now use the linear array to resolve the asset indexes and plain names
  ResolveFullFileNames(pRootHandler, pSortedEntries, pPackageMap, pbCoreTocFile, dwFileIndexes);
  CASC_FREE(pSortedEntries);
  }
 
  return ERROR_SUCCESS;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int ParseDirectoryFile	(	TRootHandler_Diablo3 *	pRootHandler,
		LPBYTE	pbDirFile,
		LPBYTE	pbFileEnd,
		DWORD	dwRootDirIndex
	)

static

 {
  DIABLO3_DIR_HEADER DirHeader;
  int nError;
 
  // Sanity checks
  assert(pRootHandler->FileTable.ItemArray != NULL);
  assert(pRootHandler->FileTable.ItemCount < pRootHandler->FileTable.ItemCountMax);
 
  // Parse the directory header in order to retrieve the items
  nError = ParseDirectoryHeader(&DirHeader, pbDirFile, pbFileEnd);
  if(nError != ERROR_SUCCESS)
  return nError;
 
  // 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;
  }
 
  // 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)
  {
  assert(dwRootDirIndex != DIABLO3_INVALID_INDEX);
  nError = ParseDirEntries_FileId2(pRootHandler, DirHeader.pbEntries2, DirHeader.dwEntries2, dwRootDirIndex);
  if(nError != ERROR_SUCCESS)
  return nError;
  }
 
 
  // 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;
  }
 
  // Give the directory to the caller
  return nError;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int ParseDirectoryHeader	(	PDIABLO3_DIR_HEADER	pDirHeader,
		LPBYTE	pbDirFile,
		LPBYTE	pbFileEnd
	)

static

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

Here is the caller graph for this function:

static int ParseDirEntries_FileId1	(	TRootHandler_Diablo3 *	pRootHandler,
		LPBYTE	pbFileEntries,
		DWORD	dwFileEntries,
		DWORD	dwRootDirIndex
	)

static

 {
  PDIABLO3_FILEID1_ENTRY pEntry = (PDIABLO3_FILEID1_ENTRY)pbFileEntries;
  PCASC_FILE_ENTRY pFileEntry;
 
  // Overflow test
  if((pRootHandler->FileTable.ItemCount + dwFileEntries) >= pRootHandler->FileTable.ItemCountMax)
  {
  assert(false);
  return ERROR_NOT_ENOUGH_MEMORY;
  }
 
  // Parse the all ID1 entries in the file
  for(DWORD i = 0; i < dwFileEntries; i++, pEntry++)
  {
  // 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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int ParseDirEntries_FileId2	(	TRootHandler_Diablo3 *	pRootHandler,
		LPBYTE	pbFileEntries,
		DWORD	dwFileEntries,
		DWORD	dwRootDirIndex
	)

static

 {
  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;
  }
 
  // Parse the all ID1 entries in the file
  for(DWORD i = 0; i < dwFileEntries; i++, pEntry++)
  {
  // 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;
  }
 
  return ERROR_SUCCESS;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int ParseDirEntries_Named	(	TRootHandler_Diablo3 *	pRootHandler,
		LPBYTE	pbFileEntries,
		LPBYTE	pbFileEnd,
		DWORD	dwFileEntries,
		DWORD	dwRootDirIndex
	)

static

 {
  char szFileName[MAX_PATH+1];
  char * szNamePtr = szFileName;
  DWORD cbFileEntry;
  int nError = ERROR_SUCCESS;
 
  // Overflow test
  if((pRootHandler->FileTable.ItemCount + dwFileEntries) >= pRootHandler->FileTable.ItemCountMax)
  {
  assert(false);
  return ERROR_NOT_ENOUGH_MEMORY;
  }
 
  // If we the file is not in the root directory itself,
  // prepare the prefix for the root directory.
  if(dwRootDirIndex != DIABLO3_INVALID_INDEX)
  {
  PCASC_FILE_ENTRY pRootEntry = (PCASC_FILE_ENTRY)Array_ItemAt(&pRootHandler->FileTable, dwRootDirIndex);
  const char * szRootName = (const char *)Array_ItemAt(&pRootHandler->FileNames, pRootEntry->dwFileName);
 
  // Copy the root directory name
  while(szRootName[0] != 0)
  *szNamePtr++ = *szRootName++;
 
  // Append the backslash
  *szNamePtr++ = '\\';
  }
 
  // 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;
     }
 
     return ERROR_SUCCESS;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void ResolveFullFileNames	(	TRootHandler_Diablo3 *	pRootHandler,
		PDIABLO3_CORE_TOC_ENTRY	pCoreTocEntries,
		PCASC_MAP	pPackageMap,
		LPBYTE	pbCoreTocFile,
		DWORD	dwFileIndexes
	)

static

 {
     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];
 
     // Parse the entire file table
     for(size_t i = 0; i < pRootHandler->FileTable.ItemCount; i++)
     {
         // Retrieve the file entry at n-th position
         pFileEntry = (PCASC_FILE_ENTRY)Array_ItemAt(&pRootHandler->FileTable, i);
 
         // 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);
         }
     }
 }

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:

static DWORD ScanDirectoryFile	(	TCascStorage *	hs,
		LPBYTE	pbRootFile,
		LPBYTE	pbFileEnd
	)

static

 {
     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++)
     {
         // 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)
         {
             // Count the files in the subdirectory
             if(ParseDirectoryHeader(&DirHeader, pbSubDir, pbSubDir + cbSubDir) == ERROR_SUCCESS)
             {
                 dwTotalFileCount += DirHeader.dwEntries1 + DirHeader.dwEntries2 + DirHeader.dwEntries3;
             }
 
             // Free the subdirectory
             CASC_FREE(pbSubDir);
         }
     }
 
     // Return the total number of entries
     return dwTotalFileCount;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static DWORD VerifyNamedFileEntry	(	LPBYTE	pbNamedEntry,
		LPBYTE	pbFileEnd
	)

static

 {
     LPBYTE pbFileName = ((PDIABLO3_NAMED_ENTRY)pbNamedEntry)->szFileName;
 
     // Find the end of the name
     while(pbFileName < pbFileEnd && pbFileName[0] != 0)
         pbFileName++;
 
     // 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);
 }

Here is the caller graph for this function:

Variable Documentation

const DIABLO3_ASSET_INFO Assets[]

static

const DIABLO3_ASSET_INFO UnknownAsset = {"Unknown", "xxx"}

static

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation