CascLib.h File Reference

#include "CascPort.h"

Include dependency graph for CascLib.h:

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

Go to the source code of this file.

Classes
struct	_QUERY_KEY
struct	_CASC_FIND_DATA

Macros
#define	CASCLIB_VERSION   0x0100
#define	CASCLIB_VERSION_STRING   "1.00"
#define	ERROR_UNKNOWN_FILE_KEY   10001
#define	ERROR_FILE_INCOMPLETE   10006
#define	CASC_STOR_XXXXX   0x00000001
#define	CASC_OPEN_BY_ENCODING_KEY   0x00000001
#define	BASE_PROVIDER_FILE   0x00000000
#define	BASE_PROVIDER_MAP   0x00000001
#define	BASE_PROVIDER_HTTP   0x00000002
#define	BASE_PROVIDER_MASK   0x0000000F
#define	STREAM_PROVIDER_FLAT   0x00000000
#define	STREAM_PROVIDER_PARTIAL   0x00000010
#define	STREAM_PROVIDER_ENCRYPTED   0x00000020
#define	STREAM_PROVIDER_BLOCK4   0x00000030
#define	STREAM_PROVIDER_MASK   0x000000F0
#define	STREAM_FLAG_READ_ONLY   0x00000100
#define	STREAM_FLAG_WRITE_SHARE   0x00000200
#define	STREAM_FLAG_USE_BITMAP   0x00000400
#define	STREAM_OPTIONS_MASK   0x0000FF00
#define	STREAM_PROVIDERS_MASK   0x000000FF
#define	STREAM_FLAGS_MASK   0x0000FFFF
#define	CASC_LOCALE_ALL   0xFFFFFFFF
#define	CASC_LOCALE_NONE   0x00000000
#define	CASC_LOCALE_UNKNOWN1   0x00000001
#define	CASC_LOCALE_ENUS   0x00000002
#define	CASC_LOCALE_KOKR   0x00000004
#define	CASC_LOCALE_RESERVED   0x00000008
#define	CASC_LOCALE_FRFR   0x00000010
#define	CASC_LOCALE_DEDE   0x00000020
#define	CASC_LOCALE_ZHCN   0x00000040
#define	CASC_LOCALE_ESES   0x00000080
#define	CASC_LOCALE_ZHTW   0x00000100
#define	CASC_LOCALE_ENGB   0x00000200
#define	CASC_LOCALE_ENCN   0x00000400
#define	CASC_LOCALE_ENTW   0x00000800
#define	CASC_LOCALE_ESMX   0x00001000
#define	CASC_LOCALE_RURU   0x00002000
#define	CASC_LOCALE_PTBR   0x00004000
#define	CASC_LOCALE_ITIT   0x00008000
#define	CASC_LOCALE_PTPT   0x00010000
#define	CASC_LOCALE_BIT_ENUS   0x01
#define	CASC_LOCALE_BIT_KOKR   0x02
#define	CASC_LOCALE_DUAL_LANG   0x03
#define	CASC_LOCALE_BIT_FRFR   0x04
#define	CASC_LOCALE_BIT_DEDE   0x05
#define	CASC_LOCALE_BIT_ZHCN   0x06
#define	CASC_LOCALE_BIT_ESES   0x07
#define	CASC_LOCALE_BIT_ZHTW   0x08
#define	CASC_LOCALE_BIT_ENGB   0x09
#define	CASC_LOCALE_BIT_ENCN   0x0A
#define	CASC_LOCALE_BIT_ENTW   0x0B
#define	CASC_LOCALE_BIT_ESMX   0x0C
#define	CASC_LOCALE_BIT_RURU   0x0D
#define	CASC_LOCALE_BIT_PTBR   0x0E
#define	CASC_LOCALE_BIT_ITIT   0x0F
#define	CASC_LOCALE_BIT_PTPT   0x10
#define	MAX_CASC_KEY_LENGTH   0x10
#define	MD5_HASH_SIZE   0x10
#define	MD5_STRING_SIZE   0x20
#define	SHA1_DIGEST_SIZE   0x14
#define	LANG_NEUTRAL   0x00
#define	CASC_INVALID_SIZE   0xFFFFFFFF
#define	CASC_INVALID_POS   0xFFFFFFFF
#define	CASC_FEATURE_LISTFILE   0x00000001

Typedefs
typedef enum _CASC_STORAGE_INFO_CLASS	CASC_STORAGE_INFO_CLASS
typedef enum _CASC_STORAGE_INFO_CLASS *	PCASC_STORAGE_INFO_CLASS
typedef struct _QUERY_KEY	QUERY_KEY
typedef struct _QUERY_KEY *	PQUERY_KEY
typedef struct _CASC_FIND_DATA	CASC_FIND_DATA
typedef struct _CASC_FIND_DATA *	PCASC_FIND_DATA
typedef struct TFileStream	TFileStream
typedef void(WINAPI *	STREAM_DOWNLOAD_CALLBACK )(void *pvUserData, ULONGLONG ByteOffset, DWORD dwTotalBytes)

Enumerations
enum	_CASC_STORAGE_INFO_CLASS {   CascStorageFileCount, CascStorageFeatures, CascStorageGameInfo, CascStorageGameBuild,   CascStorageInfoClassMax }

Functions
void	qsort_pointer_array (void **base, size_t num, int(*compare)(const void *, const void *, const void *), const void *context)
bool WINAPI	CascOpenStorage (const TCHAR *szDataPath, DWORD dwLocaleMask, HANDLE *phStorage)
bool WINAPI	CascGetStorageInfo (HANDLE hStorage, CASC_STORAGE_INFO_CLASS InfoClass, void *pvStorageInfo, size_t cbStorageInfo, size_t *pcbLengthNeeded)
bool WINAPI	CascCloseStorage (HANDLE hStorage)
bool WINAPI	CascOpenFileByIndexKey (HANDLE hStorage, PQUERY_KEY pIndexKey, DWORD dwFlags, HANDLE *phFile)
bool WINAPI	CascOpenFileByEncodingKey (HANDLE hStorage, PQUERY_KEY pEncodingKey, DWORD dwFlags, HANDLE *phFile)
bool WINAPI	CascOpenFile (HANDLE hStorage, const char *szFileName, DWORD dwLocale, DWORD dwFlags, HANDLE *phFile)
DWORD WINAPI	CascGetFileSize (HANDLE hFile, PDWORD pdwFileSizeHigh)
DWORD WINAPI	CascSetFilePointer (HANDLE hFile, LONG lFilePos, LONG *plFilePosHigh, DWORD dwMoveMethod)
bool WINAPI	CascReadFile (HANDLE hFile, void *lpBuffer, DWORD dwToRead, PDWORD pdwRead)
bool WINAPI	CascCloseFile (HANDLE hFile)
HANDLE WINAPI	CascFindFirstFile (HANDLE hStorage, const char *szMask, PCASC_FIND_DATA pFindData, const TCHAR *szListFile)
bool WINAPI	CascFindNextFile (HANDLE hFind, PCASC_FIND_DATA pFindData)
bool WINAPI	CascFindClose (HANDLE hFind)
int	GetLastError ()
void	SetLastError (int nError)

Macro Definition Documentation

#define BASE_PROVIDER_FILE   0x00000000

#define BASE_PROVIDER_HTTP   0x00000002

#define BASE_PROVIDER_MAP   0x00000001

#define BASE_PROVIDER_MASK   0x0000000F

#define CASC_FEATURE_LISTFILE   0x00000001

#define CASC_INVALID_POS   0xFFFFFFFF

#define CASC_INVALID_SIZE   0xFFFFFFFF

#define CASC_LOCALE_ALL   0xFFFFFFFF

#define CASC_LOCALE_BIT_DEDE   0x05

#define CASC_LOCALE_BIT_ENCN   0x0A

#define CASC_LOCALE_BIT_ENGB   0x09

#define CASC_LOCALE_BIT_ENTW   0x0B

#define CASC_LOCALE_BIT_ENUS   0x01

#define CASC_LOCALE_BIT_ESES   0x07

#define CASC_LOCALE_BIT_ESMX   0x0C

#define CASC_LOCALE_BIT_FRFR   0x04

#define CASC_LOCALE_BIT_ITIT   0x0F

#define CASC_LOCALE_BIT_KOKR   0x02

#define CASC_LOCALE_BIT_PTBR   0x0E

#define CASC_LOCALE_BIT_PTPT   0x10

#define CASC_LOCALE_BIT_RURU   0x0D

#define CASC_LOCALE_BIT_ZHCN   0x06

#define CASC_LOCALE_BIT_ZHTW   0x08

#define CASC_LOCALE_DEDE   0x00000020

#define CASC_LOCALE_DUAL_LANG   0x03

#define CASC_LOCALE_ENCN   0x00000400

#define CASC_LOCALE_ENGB   0x00000200

#define CASC_LOCALE_ENTW   0x00000800

#define CASC_LOCALE_ENUS   0x00000002

#define CASC_LOCALE_ESES   0x00000080

#define CASC_LOCALE_ESMX   0x00001000

#define CASC_LOCALE_FRFR   0x00000010

#define CASC_LOCALE_ITIT   0x00008000

#define CASC_LOCALE_KOKR   0x00000004

#define CASC_LOCALE_NONE   0x00000000

#define CASC_LOCALE_PTBR   0x00004000

#define CASC_LOCALE_PTPT   0x00010000

#define CASC_LOCALE_RESERVED   0x00000008

#define CASC_LOCALE_RURU   0x00002000

#define CASC_LOCALE_UNKNOWN1   0x00000001

#define CASC_LOCALE_ZHCN   0x00000040

#define CASC_LOCALE_ZHTW   0x00000100

#define CASC_OPEN_BY_ENCODING_KEY   0x00000001

#define CASC_STOR_XXXXX   0x00000001

#define CASCLIB_VERSION   0x0100

#define CASCLIB_VERSION_STRING   "1.00"

#define ERROR_FILE_INCOMPLETE   10006

#define ERROR_UNKNOWN_FILE_KEY   10001

#define LANG_NEUTRAL   0x00

#define MAX_CASC_KEY_LENGTH   0x10

#define MD5_HASH_SIZE   0x10

#define MD5_STRING_SIZE   0x20

#define SHA1_DIGEST_SIZE   0x14

#define STREAM_FLAG_READ_ONLY   0x00000100

#define STREAM_FLAG_USE_BITMAP   0x00000400

#define STREAM_FLAG_WRITE_SHARE   0x00000200

#define STREAM_FLAGS_MASK   0x0000FFFF

#define STREAM_OPTIONS_MASK   0x0000FF00

#define STREAM_PROVIDER_BLOCK4   0x00000030

#define STREAM_PROVIDER_ENCRYPTED   0x00000020

#define STREAM_PROVIDER_FLAT   0x00000000

#define STREAM_PROVIDER_MASK   0x000000F0

#define STREAM_PROVIDER_PARTIAL   0x00000010

#define STREAM_PROVIDERS_MASK   0x000000FF

Typedef Documentation

typedef struct _CASC_FIND_DATA CASC_FIND_DATA

typedef enum _CASC_STORAGE_INFO_CLASS CASC_STORAGE_INFO_CLASS

typedef struct _CASC_FIND_DATA * PCASC_FIND_DATA

typedef enum _CASC_STORAGE_INFO_CLASS * PCASC_STORAGE_INFO_CLASS

typedef struct _QUERY_KEY * PQUERY_KEY

typedef struct _QUERY_KEY QUERY_KEY

typedef void(WINAPI * STREAM_DOWNLOAD_CALLBACK)(void *pvUserData, ULONGLONG ByteOffset, DWORD dwTotalBytes)

typedef struct TFileStream TFileStream

Enumeration Type Documentation

enum _CASC_STORAGE_INFO_CLASS

Enumerator
CascStorageFileCount
CascStorageFeatures
CascStorageGameInfo
CascStorageGameBuild
CascStorageInfoClassMax

{
 CascStorageFileCount,
 CascStorageFeatures,
 CascStorageGameInfo,
 CascStorageGameBuild,
 CascStorageInfoClassMax

} CASC_STORAGE_INFO_CLASS, *PCASC_STORAGE_INFO_CLASS;

Function Documentation

bool WINAPI CascCloseFile

(

HANDLE

hFile

)

{
 TCascFile * hf;

 hf = IsValidFileHandle(hFile);
 if(hf != NULL)
 {
 // Close (dereference) the archive handle
 if(hf->hs != NULL)
 CascCloseStorage((HANDLE)hf->hs);
 hf->hs = NULL;

 // Free the file cache and frame array
 if(hf->pbFileCache != NULL)
 CASC_FREE(hf->pbFileCache);
 if(hf->pFrames != NULL)
 CASC_FREE(hf->pFrames);

 // Free the structure itself
 hf->szClassName = NULL;
 CASC_FREE(hf);
 return true;
 }

 SetLastError(ERROR_INVALID_HANDLE);
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool WINAPI CascCloseStorage

(

HANDLE

hStorage

)

{
 TCascStorage * hs;

 // Verify the storage handle
 hs = IsValidStorageHandle(hStorage);
 if(hs == NULL)
 {
 SetLastError(ERROR_INVALID_PARAMETER);
 return false;
 }

 // Only free the storage if the reference count reaches 0
 if(hs->dwRefCount == 1)
 {
 FreeCascStorage(hs);
 return true;
 }

 // Just decrement number of references
 hs->dwRefCount--;
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool WINAPI CascFindClose

(

HANDLE

hFind

)

{
 TCascSearch * pSearch;

 pSearch = IsValidSearchHandle(hFind);
 if(pSearch == NULL)
 {
 SetLastError(ERROR_INVALID_PARAMETER);
 return false;
 }

 FreeSearchHandle(pSearch);
 return true;
}

Here is the call graph for this function:

HANDLE WINAPI CascFindFirstFile	(	HANDLE	hStorage,
		const char *	szMask,
		PCASC_FIND_DATA	pFindData,
		const TCHAR *	szListFile
	)

{
 TCascStorage * hs;
 TCascSearch * pSearch = NULL;
 int nError = ERROR_SUCCESS;

 // Check parameters
 if((hs = IsValidStorageHandle(hStorage)) == NULL)
 nError = ERROR_INVALID_HANDLE;
 if(szMask == NULL || pFindData == NULL)
 nError = ERROR_INVALID_PARAMETER;

 // Init the search structure and search handle
 if(nError == ERROR_SUCCESS)
 {
 // Clear the entire search structure
 memset(pFindData, 0, sizeof(CASC_FIND_DATA));

 // Allocate the search handle
 pSearch = AllocateSearchHandle(hs, szListFile, szMask);
 if(pSearch == NULL)
 nError = ERROR_NOT_ENOUGH_MEMORY;
 }

 // Perform search
 if(nError == ERROR_SUCCESS)
 {
 if(!DoStorageSearch(pSearch, pFindData))
 nError = ERROR_NO_MORE_FILES;
 }

 if(nError != ERROR_SUCCESS)
 {
 if(pSearch != NULL)
 FreeSearchHandle(pSearch);
 pSearch = NULL;
 }

 return (HANDLE)pSearch;
}

Here is the call graph for this function:

bool WINAPI CascFindNextFile	(	HANDLE	hFind,
		PCASC_FIND_DATA	pFindData
	)

{
 TCascSearch * pSearch;

 pSearch = IsValidSearchHandle(hFind);
 if(pSearch == NULL || pFindData == NULL)
 {
 SetLastError(ERROR_INVALID_PARAMETER);
 return false;
 }

 // Perform search
 return DoStorageSearch(pSearch, pFindData);
}

Here is the call graph for this function:

DWORD WINAPI CascGetFileSize	(	HANDLE	hFile,
		PDWORD	pdwFileSizeHigh
	)

{
 TCascFile * hf;
 int nError;

 CASCLIB_UNUSED(pdwFileSizeHigh);

 // Validate the file handle
 if((hf = IsValidFileHandle(hFile)) == NULL)
 {
 SetLastError(ERROR_INVALID_HANDLE);
 return CASC_INVALID_SIZE;
 }

 // Make sure that the file header area is loaded
 nError = EnsureFrameHeadersLoaded(hf);
 if(nError != ERROR_SUCCESS)
 {
 SetLastError(nError);
 return CASC_INVALID_SIZE;
 }

 // Give the file size to the caller
 if(pdwFileSizeHigh != NULL)
 *pdwFileSizeHigh = 0;
 return hf->FileSize;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool WINAPI CascGetStorageInfo	(	HANDLE	hStorage,
		CASC_STORAGE_INFO_CLASS	InfoClass,
		void *	pvStorageInfo,
		size_t	cbStorageInfo,
		size_t *	pcbLengthNeeded
	)

{
 TCascStorage * hs;
 DWORD dwInfoValue = 0;

 // Verify the storage handle
 hs = IsValidStorageHandle(hStorage);
 if(hs == NULL)
 {
 SetLastError(ERROR_INVALID_HANDLE);
 return false;
 }

 // Differentiate between info classes
 switch(InfoClass)
 {
 case CascStorageFileCount:
 dwInfoValue = (DWORD)hs->pIndexEntryMap->ItemCount;
 break;

 case CascStorageFeatures:
 dwInfoValue |= (hs->pRootHandler->dwRootFlags & ROOT_FLAG_HAS_NAMES) ? CASC_FEATURE_LISTFILE : 0;
 break;

 case CascStorageGameInfo:
 dwInfoValue = hs->dwGameInfo;
 break;

 case CascStorageGameBuild:
 dwInfoValue = hs->dwBuildNumber;
 break;

 default:
 SetLastError(ERROR_INVALID_PARAMETER);
 return false;
 }

 //
 // Return the required DWORD value
 //

 if(cbStorageInfo < sizeof(DWORD))
 {
 *pcbLengthNeeded = sizeof(DWORD);
 SetLastError(ERROR_INSUFFICIENT_BUFFER);
 return false;
 }

 // Give the number of files
 *(PDWORD)pvStorageInfo = dwInfoValue;
 return true;
}

Here is the call graph for this function:

bool WINAPI CascOpenFile	(	HANDLE	hStorage,
		const char *	szFileName,
		DWORD	dwLocale,
		DWORD	dwFlags,
		HANDLE *	phFile
	)

{
 TCascStorage * hs;
 QUERY_KEY EncodingKey;
 LPBYTE pbEncodingKey;
 BYTE KeyBuffer[MD5_HASH_SIZE];
 int nError = ERROR_SUCCESS;

 CASCLIB_UNUSED(dwLocale);

 // Validate the storage handle
 hs = IsValidStorageHandle(hStorage);
 if(hs == NULL)
 {
 SetLastError(ERROR_INVALID_HANDLE);
 return false;
 }

 // Validate the other parameters
 if(szFileName == NULL || szFileName[0] == 0 || phFile == NULL)
 {
 SetLastError(ERROR_INVALID_PARAMETER);
 return false;
 }

 // If the user is opening the file via encoding key, skip the ROOT file processing
 if((dwFlags & CASC_OPEN_BY_ENCODING_KEY) == 0)
 {
 // Let the root directory provider get us the encoding key
 pbEncodingKey = RootHandler_GetKey(hs->pRootHandler, szFileName);
 if(pbEncodingKey == NULL)
 {
 SetLastError(ERROR_FILE_NOT_FOUND);
 return false;
 }

 // Setup the encoding key
 EncodingKey.pbData = pbEncodingKey;
 EncodingKey.cbData = MD5_HASH_SIZE;
 }
 else
 {
 // Check the length of the file name
 if(strlen(szFileName) < MD5_STRING_SIZE)
 {
 SetLastError(ERROR_INVALID_PARAMETER);
 return false;
 }

 // Convert the file name to binary blob
 EncodingKey.pbData = KeyBuffer;
 EncodingKey.cbData = MD5_HASH_SIZE;
 nError = ConvertStringToBinary(szFileName, MD5_STRING_SIZE, KeyBuffer);
 }

 // Use the encoding key to find the file in the encoding table entry
 if(nError == ERROR_SUCCESS)
 {
 if(!OpenFileByEncodingKey(hs, &EncodingKey, dwFlags, (TCascFile **)phFile))
 {
 assert(GetLastError() != ERROR_SUCCESS);
 nError = GetLastError();
 }
 }

#ifdef CASCLIB_TEST
// if(phFile[0] != NULL && pRootEntryMndx != NULL)
// {
// ((TCascFile *)(phFile[0]))->FileSize_RootEntry = pRootEntryMndx->FileSize;
// }
#endif

 if(nError != ERROR_SUCCESS)
 SetLastError(nError);
 return (nError == ERROR_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool WINAPI CascOpenFileByEncodingKey	(	HANDLE	hStorage,
		PQUERY_KEY	pEncodingKey,
		DWORD	dwFlags,
		HANDLE *	phFile
	)

{
 TCascStorage * hs;

 // Validate the storage handle
 hs = IsValidStorageHandle(hStorage);
 if(hs == NULL)
 {
 SetLastError(ERROR_INVALID_HANDLE);
 return false;
 }

 // Validate the other parameters
 if(pEncodingKey == NULL || pEncodingKey->pbData == NULL || pEncodingKey->cbData == 0 || phFile == NULL)
 {
 SetLastError(ERROR_INVALID_PARAMETER);
 return false;
 }

 // Use the internal function fo open the file
 return OpenFileByEncodingKey(hs, pEncodingKey, dwFlags, (TCascFile **)phFile);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool WINAPI CascOpenFileByIndexKey	(	HANDLE	hStorage,
		PQUERY_KEY	pIndexKey,
		DWORD	dwFlags,
		HANDLE *	phFile
	)

{
 TCascStorage * hs;

 // Validate the storage handle
 hs = IsValidStorageHandle(hStorage);
 if(hs == NULL)
 {
 SetLastError(ERROR_INVALID_HANDLE);
 return false;
 }

 // Validate the other parameters
 if(pIndexKey == NULL || pIndexKey->pbData == NULL || pIndexKey->cbData == 0 || phFile == NULL)
 {
 SetLastError(ERROR_INVALID_PARAMETER);
 return false;
 }

 // Use the internal function to open the file
 return OpenFileByIndexKey(hs, pIndexKey, dwFlags, (TCascFile **)phFile);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool WINAPI CascOpenStorage	(	const TCHAR *	szDataPath,
		DWORD	dwLocaleMask,
		HANDLE *	phStorage
	)

{
 TCascStorage * hs;
 int nError = ERROR_SUCCESS;

 // Allocate the storage structure
 hs = (TCascStorage *)CASC_ALLOC(TCascStorage, 1);
 if(hs == NULL)
 nError = ERROR_NOT_ENOUGH_MEMORY;

 // Load the storage configuration
 if(nError == ERROR_SUCCESS)
 {
 // Prepare the base storage parameters
 memset(hs, 0, sizeof(TCascStorage));
 hs->szClassName = "TCascStorage";
 hs->dwFileBeginDelta = 0xFFFFFFFF;
 hs->dwDefaultLocale = CASC_LOCALE_ENUS | CASC_LOCALE_ENGB;
 hs->dwRefCount = 1;
 nError = InitializeCascDirectories(hs, szDataPath);
 }

 // Now we need to load the root file so we know the config files
 if(nError == ERROR_SUCCESS)
 {
 nError = LoadBuildInfo(hs);
 }

 // Load the index files
 if(nError == ERROR_SUCCESS)
 {
 nError = LoadIndexFiles(hs);
 }

 // Load the index files
 if(nError == ERROR_SUCCESS)
 {
 nError = LoadEncodingFile(hs);
 }

 // Initialize the dynamic array for extra files
 // Reserve space for 0x20 encoding entries
 if(nError == ERROR_SUCCESS)
 {
 nError = Array_Create(&hs->ExtraEntries, CASC_ENCODING_ENTRY_1, CASC_EXTRA_FILES);
 }

 // Load the index files
 if(nError == ERROR_SUCCESS)
 {
 nError = LoadRootFile(hs, dwLocaleMask);
 }

 // If something failed, free the storage and return
 if(nError != ERROR_SUCCESS)
 {
 hs = FreeCascStorage(hs);
 SetLastError(nError);
 }

 *phStorage = (HANDLE)hs;
 return (nError == ERROR_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool WINAPI CascReadFile	(	HANDLE	hFile,
		void *	lpBuffer,
		DWORD	dwToRead,
		PDWORD	pdwRead
	)

{
 PCASC_FILE_FRAME pFrame = NULL;
 ULONGLONG StreamSize;
 ULONGLONG FileOffset;
 TCascFile * hf;
 LPBYTE pbBuffer = (LPBYTE)pvBuffer;
 DWORD dwStartPointer = 0;
 DWORD dwFilePointer = 0;
 DWORD dwEndPointer = 0;
 DWORD dwFrameSize;
 bool bReadResult;
 int nError = ERROR_SUCCESS;

 // The buffer must be valid
 if(pvBuffer == NULL)
 {
 SetLastError(ERROR_INVALID_PARAMETER);
 return false;
 }

 // Validate the file handle
 if((hf = IsValidFileHandle(hFile)) == NULL)
 {
 SetLastError(ERROR_INVALID_HANDLE);
 return false;
 }

 // If the file frames are not loaded yet, do it now
 if(nError == ERROR_SUCCESS)
 {
 nError = EnsureFrameHeadersLoaded(hf);
 }

 // If the file position is at or beyond end of file, do nothing
 if(nError == ERROR_SUCCESS && hf->FilePointer >= hf->FileSize)
 {
 *pdwBytesRead = 0;
 return ERROR_SUCCESS;
 }

 // Find the file frame where to read from
 if(nError == ERROR_SUCCESS)
 {
 // Get the frame
 pFrame = FindFileFrame(hf, hf->FilePointer);
 if(pFrame == NULL || pFrame->CompressedSize < 1)
 nError = ERROR_FILE_CORRUPT;
 }

 // Perform the read
 if(nError == ERROR_SUCCESS)
 {
 // If not enough bytes in the file remaining, cut them
 dwStartPointer = dwFilePointer = hf->FilePointer;
 dwEndPointer = dwStartPointer + dwBytesToRead;
 if(dwEndPointer > hf->FileSize)
 dwEndPointer = hf->FileSize;

 // Perform block read from each file frame
 while(dwFilePointer < dwEndPointer)
 {
 LPBYTE pbFrameData = NULL;
 DWORD dwFrameStart = pFrame->FrameFileOffset;
 DWORD dwFrameEnd = pFrame->FrameFileOffset + pFrame->FrameSize;

 // Shall we populate the cache with a new data?
 if(dwFrameStart != hf->CacheStart || hf->CacheEnd != dwFrameEnd)
 {
 // Shall we reallocate the cache buffer?
 if(pFrame->FrameSize > hf->cbFileCache)
 {
 if(hf->pbFileCache != NULL)
 CASC_FREE(hf->pbFileCache);

 hf->pbFileCache = CASC_ALLOC(BYTE, pFrame->FrameSize);
 hf->cbFileCache = pFrame->FrameSize;
 }

 // We also need to allocate buffer for the raw data
 pbFrameData = CASC_ALLOC(BYTE, pFrame->CompressedSize);
 if(pbFrameData == NULL)
 {
 nError = ERROR_NOT_ENOUGH_MEMORY;
 break;
 }

 // Load the raw file data to memory
 FileOffset = pFrame->FrameArchiveOffset;
 bReadResult = FileStream_Read(hf->pStream, &FileOffset, pbFrameData, pFrame->CompressedSize);

 // Note: The raw file data size could be less than expected
 // Happened in WoW build 19342 with the ROOT file. MD5 in the frame header
 // is zeroed, which means it should not be checked
 // Frame File: data.029
 // Frame Offs: 0x013ED9F0 size 0x01325B32
 // Frame End: 0x02713522
 // File Size: 0x027134FC
 if(bReadResult == false && GetLastError() == ERROR_HANDLE_EOF && !IsValidMD5(pFrame->md5))
 {
 // Get the size of the remaining file
 FileStream_GetSize(hf->pStream, &StreamSize);
 dwFrameSize = (DWORD)(StreamSize - FileOffset);

 // If the frame offset is before EOF and frame end is beyond EOF, correct it
 if(FileOffset < StreamSize && dwFrameSize < pFrame->CompressedSize)
 {
 memset(pbFrameData + dwFrameSize, 0, (pFrame->CompressedSize - dwFrameSize));
 bReadResult = true;
 }
 }

 // If the read result failed, we cannot finish reading it
 if(bReadResult && VerifyDataBlockHash(pbFrameData, pFrame->CompressedSize, pFrame->md5))
 {
 // Convert the source frame to the file cache
 nError = ProcessFileFrame(hf->pbFileCache,
 pFrame->FrameSize,
 pbFrameData,
 pFrame->CompressedSize,
 (DWORD)(pFrame - hf->pFrames));
 if(nError == ERROR_SUCCESS)
 {
 // Set the start and end of the cache
 hf->CacheStart = dwFrameStart;
 hf->CacheEnd = dwFrameEnd;
 }
 }
 else
 {
 nError = ERROR_FILE_CORRUPT;
 }

 // Free the raw frame data
 CASC_FREE(pbFrameData);
 }

 // Copy the decompressed data
 if(dwFrameEnd > dwEndPointer)
 dwFrameEnd = dwEndPointer;
 memcpy(pbBuffer, hf->pbFileCache + (dwFilePointer - dwFrameStart), (dwFrameEnd - dwFilePointer));
 pbBuffer += (dwFrameEnd - dwFilePointer);

 // Move pointers
 dwFilePointer = dwFrameEnd;
 pFrame++;
 }
 }

 // Update the file position
 if(nError == ERROR_SUCCESS)
 {
 if(pdwBytesRead != NULL)
 *pdwBytesRead = (dwFilePointer - dwStartPointer);
 hf->FilePointer = dwFilePointer;
 }

 if(nError != ERROR_SUCCESS)
 SetLastError(nError);
 return (nError == ERROR_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

DWORD WINAPI CascSetFilePointer	(	HANDLE	hFile,
		LONG	lFilePos,
		LONG *	plFilePosHigh,
		DWORD	dwMoveMethod
	)

{
 TCascFile * hf;
 ULONGLONG FilePosition;
 ULONGLONG MoveOffset;
 DWORD dwFilePosHi;

 // If the hFile is not a valid file handle, return an error.
 hf = IsValidFileHandle(hFile);
 if(hf == NULL)
 {
 SetLastError(ERROR_INVALID_HANDLE);
 return CASC_INVALID_POS;
 }

 // Get the relative point where to move from
 switch(dwMoveMethod)
 {
 case FILE_BEGIN:
 FilePosition = 0;
 break;

 case FILE_CURRENT:
 FilePosition = hf->FilePointer;
 break;

 case FILE_END:
 FilePosition = hf->FileSize;
 break;

 default:
 SetLastError(ERROR_INVALID_PARAMETER);
 return CASC_INVALID_POS;
 }

 // Now get the move offset. Note that both values form
 // a signed 64-bit value (a file pointer can be moved backwards)
 if(plFilePosHigh != NULL)
 dwFilePosHi = *plFilePosHigh;
 else
        dwFilePosHi = (lFilePos & 0x80000000) ? 0xFFFFFFFF : 0;
    MoveOffset = MAKE_OFFSET64(dwFilePosHi, lFilePos);

    // Now calculate the new file pointer
    // Do not allow the file pointer to overflow
    FilePosition = ((FilePosition + MoveOffset) >= FilePosition) ? (FilePosition + MoveOffset) : 0;

    // CASC files can't be bigger than 4 GB.
    // We don't allow to go past 4 GB
    if(FilePosition >> 32)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return CASC_INVALID_POS;
    }

    // Change the file position
    hf->FilePointer = (DWORD)FilePosition;

    // Return the new file position
    if(plFilePosHigh != NULL)
        *plFilePosHigh = 0;
    return hf->FilePointer;
}

Here is the call graph for this function:

int GetLastError

(

)

{
    return nLastError;
}

Here is the caller graph for this function:

void qsort_pointer_array	(	void **	base,
		size_t	num,
		int(*)(const void *, const void *, const void *)	compare,
		const void *	context
	)

{
    size_t lo, hi;                  /* ends of sub-array currently sorting */
    size_t mid;                     /* points to middle of subarray */
    size_t loguy, higuy;            /* traveling pointers for partition step */
    size_t size;                    /* size of the sub-array */
    size_t lostk[STKSIZ], histk[STKSIZ];
    void * temp;
    int stkptr;                     /* stack for saving sub-array to be processed */

    /* validation section */
    assert(base != NULL);
    assert(compare != NULL);

    if (num < 2)
        return;                 /* nothing to do */

    stkptr = 0;                 /* initialize stack */

    lo = 0;
    hi = (num-1);               /* initialize limits */

    /* this entry point is for pseudo-recursion calling: setting
       lo and hi and jumping to here is like recursion, but stkptr is
       preserved, locals aren't, so we preserve stuff on the stack */
recurse:

    size = (hi - lo) + 1;       /* number of el's to sort */

    /* First we pick a partitioning element.  The efficiency of the
       algorithm demands that we find one that is approximately the median
       of the values, but also that we select one fast.  We choose the
       median of the first, middle, and last elements, to avoid bad
       performance in the face of already sorted data, or data that is made
       up of multiple sorted runs appended together.  Testing shows that a
       median-of-three algorithm provides better performance than simply
       picking the middle element for the latter case. */

    mid = lo + (size / 2);      /* find middle element */

    /* Sort the first, middle, last elements into order */
    if (compare(context, base[lo], base[mid]) > 0) {
        SWAP_ENTRIES(lo, mid);
    }
    if (compare(context, base[lo], base[hi]) > 0) {
        SWAP_ENTRIES(lo, hi);
    }
    if (compare(context, base[mid], base[hi]) > 0) {
        SWAP_ENTRIES(mid, hi);
    }

    /* We now wish to partition the array into three pieces, one consisting
       of elements <= partition element, one of elements equal to the
       partition element, and one of elements > than it.  This is done
       below; comments indicate conditions established at every step. */

    loguy = lo;
    higuy = hi;

    /* Note that higuy decreases and loguy increases on every iteration,
       so loop must terminate. */
    for (;;) {
        /* lo <= loguy < hi, lo < higuy <= hi,
           A[i] <= A[mid] for lo <= i <= loguy,
           A[i] > A[mid] for higuy <= i < hi,
           A[hi] >= A[mid] */

        /* The doubled loop is to avoid calling comp(mid,mid), since some
           existing comparison funcs don't work when passed the same
           value for both pointers. */

        if (mid > loguy) {
            do  {
                loguy ++;
            } while (loguy < mid && compare(context, base[loguy], base[mid]) <= 0);
        }
        if (mid <= loguy) {
            do  {
                loguy ++;
            } while (loguy <= hi && compare(context, base[loguy], base[mid]) <= 0);
        }

        /* lo < loguy <= hi+1, A[i] <= A[mid] for lo <= i < loguy,
           either loguy > hi or A[loguy] > A[mid] */

        do  {
            higuy --;
        } while (higuy > mid && compare(context, base[higuy], base[mid]) > 0);

        /* lo <= higuy < hi, A[i] > A[mid] for higuy < i < hi,
           either higuy == lo or A[higuy] <= A[mid] */

        if (higuy < loguy)
            break;

        /* if loguy > hi or higuy == lo, then we would have exited, so
           A[loguy] > A[mid], A[higuy] <= A[mid],
           loguy <= hi, higuy > lo */

        SWAP_ENTRIES(loguy, higuy);

        /* If the partition element was moved, follow it.  Only need
           to check for mid == higuy, since before the swap,
           A[loguy] > A[mid] implies loguy != mid. */

        if (mid == higuy)
            mid = loguy;

        /* A[loguy] <= A[mid], A[higuy] > A[mid]; so condition at top
           of loop is re-established */
    }

    /*     A[i] <= A[mid] for lo <= i < loguy,
           A[i] > A[mid] for higuy < i < hi,
           A[hi] >= A[mid]
           higuy < loguy
       implying:
           higuy == loguy-1
           or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid] */

    /* Find adjacent elements equal to the partition element.  The
       doubled loop is to avoid calling comp(mid,mid), since some
       existing comparison funcs don't work when passed the same value
       for both pointers. */

    higuy ++;
    if (mid < higuy) {
        do  {
            higuy --;
        } while (higuy > mid && compare(context, base[higuy], base[mid]) == 0);
    }
    if (mid >= higuy) {
        do  {
            higuy --;
        } while (higuy > lo && compare(context, base[higuy], base[mid]) == 0);
    }

    /* OK, now we have the following:
          higuy < loguy
          lo <= higuy <= hi
          A[i]  <= A[mid] for lo <= i <= higuy
          A[i]  == A[mid] for higuy < i < loguy
          A[i]  >  A[mid] for loguy <= i < hi
          A[hi] >= A[mid] */

    /* We've finished the partition, now we want to sort the subarrays
       [lo, higuy] and [loguy, hi].
       We do the smaller one first to minimize stack usage.
       We only sort arrays of length 2 or more.*/

    if ( higuy - lo >= hi - loguy ) {
        if (lo < higuy) {
            lostk[stkptr] = lo;
            histk[stkptr] = higuy;
            ++stkptr;
        }                           /* save big recursion for later */

        if (loguy < hi) {
            lo = loguy;
            goto recurse;           /* do small recursion */
        }
    }
    else {
        if (loguy < hi) {
            lostk[stkptr] = loguy;
            histk[stkptr] = hi;
            ++stkptr;               /* save big recursion for later */
        }

        if (lo < higuy) {
            hi = higuy;
            goto recurse;           /* do small recursion */
        }
    }

    /* We have sorted the array, except for any pending sorts on the stack.
       Check if there are any, and do them. */

    --stkptr;
    if (stkptr >= 0) {
        lo = lostk[stkptr];
        hi = histk[stkptr];
        goto recurse;           /* pop subarray from stack */
    }
    else
        return;                 /* all subarrays done */
}

void SetLastError

(

int

nError

)

{
    nLastError = nError;
}

Here is the caller graph for this function: