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

Include dependency graph for CascRootFile_Mndx.cpp:

Classes
struct	_FILE_MNDX_HEADER

struct	_FILE_MAR_INFO

struct	_CASC_MNDX_INFO

struct	_CASC_MNDX_PACKAGE

struct	_CASC_MNDX_PACKAGES

struct	_CASC_ROOT_ENTRY_MNDX

struct	TRootHandler_MNDX

Macros
#define	__CASCLIB_SELF__

#define	CASC_MAR_SIGNATURE 0x0052414d

#define	GetNumbrOfSetBits32(x) (GetNumberOfSetBits(x) >> 0x18)

#define	CASC_PACKAGES_INIT 0x10

#define	CASC_PACKAGES_DELTA 0x10

Typedefs
typedef struct _FILE_MNDX_HEADER	FILE_MNDX_HEADER

typedef struct _FILE_MNDX_HEADER *	PFILE_MNDX_HEADER

typedef struct _FILE_MAR_INFO	FILE_MAR_INFO

typedef struct _FILE_MAR_INFO *	PFILE_MAR_INFO

typedef struct _CASC_MNDX_INFO	CASC_MNDX_INFO

typedef struct _CASC_MNDX_INFO *	PCASC_MNDX_INFO

typedef struct _CASC_MNDX_PACKAGE	CASC_MNDX_PACKAGE

typedef struct _CASC_MNDX_PACKAGE *	PCASC_MNDX_PACKAGE

typedef struct _CASC_MNDX_PACKAGES	CASC_MNDX_PACKAGES

typedef struct _CASC_MNDX_PACKAGES *	PCASC_MNDX_PACKAGES

typedef struct _CASC_ROOT_ENTRY_MNDX	CASC_ROOT_ENTRY_MNDX

typedef struct _CASC_ROOT_ENTRY_MNDX *	PCASC_ROOT_ENTRY_MNDX

Functions
DWORD	GetNumberOfSetBits (DWORD Value32)

static bool	RootFileRead (LPBYTE pbFilePointer, LPBYTE pbFileEnd, void *pvBuffer, size_t dwBytesToRead)

static void	MAR_FILE_CreateDatabase (PMAR_FILE pMarFile)

static int	MAR_FILE_SearchFile (PMAR_FILE pMarFile, TMndxFindResult *pStruct1C)

static void	MAR_FILE_Destructor (PMAR_FILE pMarFile)

static PCASC_MNDX_PACKAGES	AllocatePackages (size_t nNameEntries, size_t nNameBufferMax)

static PCASC_MNDX_PACKAGES	InsertToPackageList (PCASC_MNDX_PACKAGES pPackages, const char *szFileName, size_t cchFileName, size_t nPackageIndex)

static int	LoadPackageNames (PCASC_MNDX_INFO pMndxInfo, PCASC_MNDX_PACKAGES *ppPackages)

PCASC_MNDX_PACKAGE	FindMndxPackage (TRootHandler_MNDX pRootHandler, const char szFileName)

int	SearchMndxInfo (TRootHandler_MNDX pRootHandler, const char szFileName, DWORD dwPackage, PCASC_ROOT_ENTRY_MNDX *ppRootEntry)

static LPBYTE	FillFindData (TRootHandler_MNDX pRootHandler, TCascSearch pSearch, TMndxFindResult *pStruct1C, PDWORD PtrFileSize)

static int	MndxHandler_Insert (TRootHandler_MNDX , const char , LPBYTE)

static LPBYTE	MndxHandler_Search (TRootHandler_MNDX pRootHandler, TCascSearch pSearch, PDWORD PtrFileSize, PDWORD)

static void	MndxHandler_EndSearch (TRootHandler_MNDX , TCascSearch pSearch)

static LPBYTE	MndxHandler_GetKey (TRootHandler_MNDX pRootHandler, const char szFileName)

static void	MndxHandler_Close (TRootHandler_MNDX *pRootHandler)

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

Variables
unsigned char	table_1BA1818 [0x800]

Macro Definition Documentation

#define __CASCLIB_SELF__

#define CASC_MAR_SIGNATURE 0x0052414d

#define CASC_PACKAGES_DELTA 0x10

#define CASC_PACKAGES_INIT 0x10

#define GetNumbrOfSetBits32 ( x ) (GetNumberOfSetBits(x) >> 0x18)

Typedef Documentation

typedef struct _CASC_MNDX_INFO CASC_MNDX_INFO

typedef struct _CASC_MNDX_PACKAGE CASC_MNDX_PACKAGE

typedef struct _CASC_MNDX_PACKAGES CASC_MNDX_PACKAGES

typedef struct _CASC_ROOT_ENTRY_MNDX CASC_ROOT_ENTRY_MNDX

typedef struct _FILE_MAR_INFO FILE_MAR_INFO

typedef struct _FILE_MNDX_HEADER FILE_MNDX_HEADER

typedef struct _CASC_MNDX_INFO * PCASC_MNDX_INFO

typedef struct _CASC_MNDX_PACKAGE * PCASC_MNDX_PACKAGE

typedef struct _CASC_MNDX_PACKAGES * PCASC_MNDX_PACKAGES

typedef struct _CASC_ROOT_ENTRY_MNDX * PCASC_ROOT_ENTRY_MNDX

typedef struct _FILE_MAR_INFO * PFILE_MAR_INFO

typedef struct _FILE_MNDX_HEADER * PFILE_MNDX_HEADER

Function Documentation

static PCASC_MNDX_PACKAGES AllocatePackages	(	size_t	nNameEntries,
		size_t	nNameBufferMax
	)

static

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

Here is the caller graph for this function:

static LPBYTE FillFindData	(	TRootHandler_MNDX *	pRootHandler,
		TCascSearch *	pSearch,
		TMndxFindResult *	pStruct1C,
		PDWORD	PtrFileSize
	)

static

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

Here is the call graph for this function:

Here is the caller graph for this function:

PCASC_MNDX_PACKAGE FindMndxPackage	(	TRootHandler_MNDX *	pRootHandler,
		const char *	szFileName
	)

 {
  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;
  }
  }
  }
 
  // Give the package pointer or NULL if not found
  return pMatching;
 }

Here is the caller graph for this function:

DWORD GetNumberOfSetBits ( DWORD Value32 )

 {
  Value32 = ((Value32 >> 1) & 0x55555555) + (Value32 & 0x55555555);
  Value32 = ((Value32 >> 2) & 0x33333333) + (Value32 & 0x33333333);
  Value32 = ((Value32 >> 4) & 0x0F0F0F0F) + (Value32 & 0x0F0F0F0F);
 
  return (Value32 * 0x01010101);
 }

Here is the caller graph for this function:

static PCASC_MNDX_PACKAGES InsertToPackageList	(	PCASC_MNDX_PACKAGES	pPackages,
		const char *	szFileName,
		size_t	cchFileName,
		size_t	nPackageIndex
	)

static

 {
  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);
 
  // 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;
  }
  }
 
  // Fill the limits
  pPackages->NameEntries = nNewNameEntries;
  pPackages->NameBufferUsed = pOldPackages->NameBufferUsed;
  pPackages->NameBufferMax = nNewNameBufferMax;
 
  // Switch the name lists
  CASC_FREE(pOldPackages);
  }
 
  // The slot is expected to be empty at the moment
  assert(pPackages->Packages[nPackageIndex].szFileName == NULL);
  assert(pPackages->Packages[nPackageIndex].nLength == 0);
 
  // 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;
 }

Here is the caller graph for this function:

static int LoadPackageNames	(	PCASC_MNDX_INFO	pMndxInfo,
		PCASC_MNDX_PACKAGES *	ppPackages
	)

static

 {
  TMndxFindResult Struct1C;
  PCASC_MNDX_PACKAGES pPackages = NULL;
  PMAR_FILE pMarFile;
 
  // Sanity checks
  assert(pMndxInfo != NULL);
 
  // Prepare the file name search in the top level directory
  pMarFile = pMndxInfo->pMarFile1;
  Struct1C.SetSearchPath("", 0);
 
  // Allocate initial name list structure
  pPackages = AllocatePackages(CASC_PACKAGES_INIT, 0x1000);
  if(pPackages == NULL)
  return ERROR_NOT_ENOUGH_MEMORY;
 
  // Keep searching as long as we find something
  for(;;)
  {
  bool bFindResult = false;
 
  // Search the next file name
  pMarFile->pDatabasePtr->sub_1956CE0(&Struct1C, &bFindResult);
  if(bFindResult == false)
  break;
 
  // 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;
  }
 
  // Give the packages to the caller
  if(ppPackages != NULL)
  ppPackages[0] = pPackages;
  return ERROR_SUCCESS;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void MAR_FILE_CreateDatabase ( PMAR_FILE pMarFile )

static

 {
  pMarFile->pDatabasePtr = new TFileNameDatabasePtr;
  if(pMarFile->pDatabasePtr != NULL)
  pMarFile->pDatabasePtr->CreateDatabase(pMarFile->pbMarData, pMarFile->cbMarData);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void MAR_FILE_Destructor ( PMAR_FILE pMarFile )

static

 {
  if(pMarFile != NULL)
  {
  if(pMarFile->pDatabasePtr != NULL)
  delete pMarFile->pDatabasePtr;
  if(pMarFile->pbMarData != NULL)
  CASC_FREE(pMarFile->pbMarData);
 
  CASC_FREE(pMarFile);
  }
 }

Here is the caller graph for this function:

static int MAR_FILE_SearchFile	(	PMAR_FILE	pMarFile,
		TMndxFindResult *	pStruct1C
	)

static

 {
  return pMarFile->pDatabasePtr->FindFileInDatabase(pStruct1C);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void MndxHandler_Close ( TRootHandler_MNDX * pRootHandler )

static

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

Here is the call graph for this function:

Here is the caller graph for this function:

static void MndxHandler_EndSearch	(	TRootHandler_MNDX *	,
		TCascSearch *	pSearch
	)

static

 {
  if(pSearch != NULL)
  delete (TMndxFindResult *)pSearch->pRootContext;
  pSearch->pRootContext = NULL;
 }

Here is the caller graph for this function:

static LPBYTE MndxHandler_GetKey	(	TRootHandler_MNDX *	pRootHandler,
		const char *	szFileName
	)

static

 {
  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++;
 
  // Find the root entry
  nError = SearchMndxInfo(pRootHandler, szStrippedName, (DWORD)(pPackage - pRootHandler->pPackages->Packages), &pRootEntry);
  if(nError != ERROR_SUCCESS || pRootEntry == NULL)
  return NULL;
 
  // Return the encoding key
  return pRootEntry->EncodingKey;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int MndxHandler_Insert	(	TRootHandler_MNDX *	,
		const char *	,
		LPBYTE
	)

static

 {
  return ERROR_NOT_SUPPORTED;
 }

Here is the caller graph for this function:

static LPBYTE MndxHandler_Search	(	TRootHandler_MNDX *	pRootHandler,
		TCascSearch *	pSearch,
		PDWORD	PtrFileSize,
		PDWORD
	)

static

 {
  TMndxFindResult * pStruct1C = NULL;
  PCASC_MNDX_INFO pMndxInfo = &pRootHandler->MndxInfo;
  PMAR_FILE pMarFile = pMndxInfo->pMarFile3;
  bool bFindResult = false;
 
  // If the first time, allocate the structure for the search result
  if(pSearch->pRootContext == NULL)
  {
  // Create the new search structure
  pStruct1C = new TMndxFindResult;
  if(pStruct1C == 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;
 
  // Search the next file name (our code)
  pMarFile->pDatabasePtr->sub_1956CE0(pStruct1C, &bFindResult);
  if(bFindResult == false)
  return NULL;
 
  // Give the file size and encoding key
  return FillFindData(pRootHandler, pSearch, pStruct1C, PtrFileSize);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool RootFileRead	(	LPBYTE	pbFilePointer,
		LPBYTE	pbFileEnd,
		void *	pvBuffer,
		size_t	dwBytesToRead
	)

static

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

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 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;
 
  // Search the database for the file name
  if(pMndxInfo->bRootFileLoaded)
  {
  Struct1C.SetSearchPath(szFileName, strlen(szFileName));
 
  // 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;
 
  // The found MNDX index must fall into range of valid MNDX entries
  if(Struct1C.FileNameIndex < pMndxInfo->MndxEntriesValid)
  {
  // 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;
  }
  }
 
  return ERROR_FILE_NOT_FOUND;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

unsigned char table_1BA1818[0x800]

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation