Common.h File Reference

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

Go to the source code of this file.

Macros
#define	MAKE_OFFSET64(hi, lo)   (((ULONGLONG)hi << 32) | (ULONGLONG)lo)
#define	ALIGN_TO_SIZE(x, a)   (((x) + (a)-1) & ~((a)-1))

Typedefs
typedef bool(*	INDEX_FILE_FOUND )(const TCHAR *szFileName, PDWORD IndexArray, PDWORD OldIndexArray, void *pvContext)

Functions
void	CopyString (char *szTarget, const char *szSource, size_t cchLength)
void	CopyString (wchar_t *szTarget, const char *szSource, size_t cchLength)
void	CopyString (char *szTarget, const wchar_t *szSource, size_t cchLength)
char *	CascNewStr (const char *szString, size_t nCharsToReserve)
wchar_t *	CascNewStr (const wchar_t *szString, size_t nCharsToReserve)
TCHAR *	CascNewStrFromAnsi (const char *szBegin, const char *szEnd)
TCHAR *	CombinePath (const TCHAR *szPath, const TCHAR *szSubDir)
TCHAR *	CombinePathAndString (const TCHAR *szPath, const char *szString, size_t nLength)
size_t	NormalizeFileName_UpperBkSlash (char *szNormName, const char *szFileName, size_t cchMaxChars)
size_t	NormalizeFileName_LowerSlash (char *szNormName, const char *szFileName, size_t cchMaxChars)
ULONGLONG	CalcFileNameHash (const char *szFileName)
int	ConvertDigitToInt32 (const TCHAR *szString, PDWORD PtrValue)
int	ConvertStringToInt08 (const char *szString, PDWORD PtrValue)
int	ConvertStringToInt32 (const TCHAR *szString, size_t nMaxDigits, PDWORD PtrValue)
int	ConvertStringToBinary (const char *szString, size_t nMaxDigits, LPBYTE pbBinary)
char *	StringFromBinary (LPBYTE pbBinary, size_t cbBinary, char *szBuffer)
char *	StringFromMD5 (LPBYTE md5, char *szBuffer)
bool	CheckWildCard (const char *szString, const char *szWildCard)
const wchar_t *	GetPlainFileName (const wchar_t *szFileName)
const char *	GetPlainFileName (const char *szFileName)
ULONGLONG	HashStringJenkins (const char *szFileName)
bool	IsValidMD5 (LPBYTE pbMd5)
void	CalculateDataBlockHash (void *pvDataBlock, DWORD cbDataBlock, LPBYTE md5_hash)
bool	VerifyDataBlockHash (void *pvDataBlock, DWORD cbDataBlock, LPBYTE expected_md5)
bool	DirectoryExists (const TCHAR *szDirectory)
int	ScanIndexDirectory (const TCHAR *szIndexPath, INDEX_FILE_FOUND pfnOnFileFound, PDWORD IndexArray, PDWORD OldIndexArray, void *pvContext)

Variables
unsigned char	AsciiToLowerTable_Slash [256]
unsigned char	AsciiToUpperTable_BkSlash [256]
unsigned char	IntToHexChar []

Macro Definition Documentation

#define ALIGN_TO_SIZE	(		x,
			a
	)		(((x) + (a)-1) & ~((a)-1))

#define MAKE_OFFSET64	(		hi,
			lo
	)		(((ULONGLONG)hi << 32) | (ULONGLONG)lo)

Typedef Documentation

typedef bool(* INDEX_FILE_FOUND)(const TCHAR *szFileName, PDWORD IndexArray, PDWORD OldIndexArray, void *pvContext)

Function Documentation

ULONGLONG CalcFileNameHash

(

const char *

szFileName

)

{
 char szNormName[MAX_PATH+1];
 uint32_t dwHashHigh = 0;
 uint32_t dwHashLow = 0;
 size_t nLength;

 // Normalize the file name - convert to uppercase, slashes to backslashes
 nLength = NormalizeFileName_UpperBkSlash(szNormName, szFileName, MAX_PATH);

 // Calculate the HASH value of the normalized file name
 hashlittle2(szNormName, nLength, &dwHashHigh, &dwHashLow);
 return ((ULONGLONG)dwHashHigh << 0x20) | dwHashLow;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CalculateDataBlockHash	(	void *	pvDataBlock,
		DWORD	cbDataBlock,
		LPBYTE	md5_hash
	)

{
 hash_state md5_state;

 md5_init(&md5_state);
 md5_process(&md5_state, (unsigned char *)pvDataBlock, cbDataBlock);
 md5_done(&md5_state, md5_hash);
}

Here is the call graph for this function:

char* CascNewStr	(	const char *	szString,
		size_t	nCharsToReserve
	)

{
 char * szNewString = NULL;
 size_t nLength;

 if(szString != NULL)
 {
 nLength = strlen(szString);
 szNewString = CASC_ALLOC(char, nLength + nCharsToReserve + 1);
 if(szNewString != NULL)
 {
 memcpy(szNewString, szString, nLength);
 szNewString[nLength] = 0;
 }
 }

 return szNewString;
}

Here is the caller graph for this function:

wchar_t* CascNewStr	(	const wchar_t *	szString,
		size_t	nCharsToReserve
	)

{
 wchar_t * szNewString = NULL;
 size_t nLength;

 if(szString != NULL)
 {
 nLength = wcslen(szString);
 szNewString = CASC_ALLOC(wchar_t, nLength + nCharsToReserve + 1);
 if(szNewString != NULL)
 {
 memcpy(szNewString, szString, nLength * sizeof(wchar_t));
 szNewString[nLength] = 0;
 }
 }

 return szNewString;
}

TCHAR* CascNewStrFromAnsi	(	const char *	szBegin,
		const char *	szEnd
	)

{
 TCHAR * szNewString = NULL;

 // Only if the entry is valid
 if(szBegin != NULL && szEnd > szBegin)
 {
 // Allocate and copy the string
 szNewString = CASC_ALLOC(TCHAR, (szEnd - szBegin + 1));
 if(szNewString != NULL)
 CopyString(szNewString, szBegin, (szEnd - szBegin));
 }

 // Return the string
 return szNewString;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool CheckWildCard	(	const char *	szString,
		const char *	szWildCard
	)

{
 const char * szWildCardPtr;

 for(;;)
 {
 // If there is '?' in the wildcard, we skip one char
 while(szWildCard[0] == '?')
 {
 if(szString[0] == 0)
 return false;

 szWildCard++;
 szString++;
 }

 // Handle '*'
 szWildCardPtr = szWildCard;
 if(szWildCardPtr[0] != 0)
 {
 if(szWildCardPtr[0] == '*')
 {
 szWildCardPtr++;

 if(szWildCardPtr[0] == '*')
 continue;

 if(szWildCardPtr[0] == 0)
 return true;

 if(AsciiToUpperTable_BkSlash[szWildCardPtr[0]] == AsciiToUpperTable_BkSlash[szString[0]])
 {
 if(CheckWildCard(szString, szWildCardPtr))
 return true;
 }
 }
 else
 {
 if(AsciiToUpperTable_BkSlash[szWildCardPtr[0]] != AsciiToUpperTable_BkSlash[szString[0]])
 return false;

 szWildCard = szWildCardPtr + 1;
 }

 if(szString[0] == 0)
 return false;
 szString++;
 }
 else
 {
 return (szString[0] == 0) ? true : false;
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

TCHAR* CombinePath	(	const TCHAR *	szPath,
		const TCHAR *	szSubDir
	)

{
 TCHAR * szFullPath = NULL;
 TCHAR * szPathPtr;
 size_t nLength1 = 0;
 size_t nLength2 = 0;

 // Calculate lengths of each part
 if(szDirectory != NULL)
 {
 // Get the length of the directory
 nLength1 = _tcslen(szDirectory);

 // Cut all ending backslashes
 while(nLength1 > 0 && szDirectory[nLength1 - 1] == _T(PATH_SEPARATOR))
 nLength1--;
 }

 if(szSubDir != NULL)
 {
 // Cut all leading backslashes
 while(szSubDir[0] == _T(PATH_SEPARATOR))
 szSubDir++;

 // Get the length of the subdir
 nLength2 = _tcslen(szSubDir);

 // Cut all ending backslashes
 while(nLength2 > 0 && szSubDir[nLength2 - 1] == _T(PATH_SEPARATOR))
 nLength2--;
 }

 // Allocate space for the full path
 szFullPath = szPathPtr = CASC_ALLOC(TCHAR, nLength1 + nLength2 + 2);
 if(szFullPath != NULL)
 {
 // Copy the directory
 if(szDirectory != NULL && nLength1 != 0)
 {
 memcpy(szPathPtr, szDirectory, (nLength1 * sizeof(TCHAR)));
 szPathPtr += nLength1;
 }

 // Copy the sub-directory
 if(szSubDir != NULL && nLength2 != 0)
 {
 // Append backslash to the previous one
 if(szPathPtr > szFullPath)
 *szPathPtr++ = _T(PATH_SEPARATOR);

 // Copy the string
 memcpy(szPathPtr, szSubDir, (nLength2 * sizeof(TCHAR)));
 szPathPtr += nLength2;
 }

 // Terminate the string
 szPathPtr[0] = 0;
 }

 return szFullPath;
}

Here is the caller graph for this function:

TCHAR* CombinePathAndString	(	const TCHAR *	szPath,
		const char *	szString,
		size_t	nLength
	)

{
 TCHAR * szFullPath = NULL;
 TCHAR * szSubDir;

 // Create the subdir string
 szSubDir = CASC_ALLOC(TCHAR, nLength + 1);
 if(szSubDir != NULL)
 {
 CopyString(szSubDir, szString, nLength);
 szFullPath = CombinePath(szPath, szSubDir);
 CASC_FREE(szSubDir);
 }

 return szFullPath;
}

Here is the call graph for this function:

int ConvertDigitToInt32	(	const TCHAR *	szString,
		PDWORD	PtrValue
	)

{
 BYTE Digit;

 Digit = (BYTE)(AsciiToUpperTable_BkSlash[szString[0]] - _T('0'));
 if(Digit > 9)
 Digit -= 'A' - '9' - 1;

 PtrValue[0] = Digit;
 return (Digit > 0x0F) ? ERROR_BAD_FORMAT : ERROR_SUCCESS;
}

Here is the caller graph for this function:

int ConvertStringToBinary	(	const char *	szString,
		size_t	nMaxDigits,
		LPBYTE	pbBinary
	)

{
 const char * szStringEnd = szString + nMaxDigits;
 DWORD dwCounter = 0;
 BYTE DigitValue;
 BYTE ByteValue = 0;

 // Convert the string
 while(szString < szStringEnd)
 {
 // Retrieve the digit converted to hexa
 DigitValue = (BYTE)(AsciiToUpperTable_BkSlash[szString[0]] - '0');
 if(DigitValue > 9)
 DigitValue -= 'A' - '9' - 1;
 if(DigitValue > 0x0F)
 return ERROR_BAD_FORMAT;

 // Insert the digit to the binary buffer
 ByteValue = (ByteValue << 0x04) | DigitValue;
 dwCounter++;

 // If we reached the second digit, it means that we need
 // to flush the byte value and move on
 if((dwCounter & 0x01) == 0)
 *pbBinary++ = ByteValue;
 szString++;
 }

 return ERROR_SUCCESS;
}

Here is the caller graph for this function:

int ConvertStringToInt08	(	const char *	szString,
		PDWORD	PtrValue
	)

{
 BYTE DigitOne = AsciiToUpperTable_BkSlash[szString[0]] - '0';
 BYTE DigitTwo = AsciiToUpperTable_BkSlash[szString[1]] - '0';

 // Fix the digits
 if(DigitOne > 9)
 DigitOne -= 'A' - '9' - 1;
 if(DigitTwo > 9)
 DigitTwo -= 'A' - '9' - 1;

 // Combine them into a value
 PtrValue[0] = (DigitOne << 0x04) | DigitTwo;
 return (DigitOne <= 0x0F && DigitTwo <= 0x0F) ? ERROR_SUCCESS : ERROR_BAD_FORMAT;
}

Here is the caller graph for this function:

int ConvertStringToInt32	(	const TCHAR *	szString,
		size_t	nMaxDigits,
		PDWORD	PtrValue
	)

{
 // The number of digits must be even
 assert((nMaxDigits & 0x01) == 0);
 assert(nMaxDigits <= 8);

 // Prepare the variables
 PtrValue[0] = 0;
 nMaxDigits >>= 1;

 // Convert the string up to the number of digits
 for(size_t i = 0; i < nMaxDigits; i++)
 {
 BYTE DigitOne;
 BYTE DigitTwo;

 DigitOne = (BYTE)(AsciiToUpperTable_BkSlash[szString[0]] - _T('0'));
 if(DigitOne > 9)
 DigitOne -= 'A' - '9' - 1;

 DigitTwo = (BYTE)(AsciiToUpperTable_BkSlash[szString[1]] - _T('0'));
 if(DigitTwo > 9)
 DigitTwo -= 'A' - '9' - 1;

 if(DigitOne > 0x0F || DigitTwo > 0x0F)
 return ERROR_BAD_FORMAT;

 PtrValue[0] = (PtrValue[0] << 0x08) | (DigitOne << 0x04) | DigitTwo;
 szString += 2;
 }

 return ERROR_SUCCESS;
}

Here is the caller graph for this function:

void CopyString	(	char *	szTarget,
		const char *	szSource,
		size_t	cchLength
	)

{
 memcpy(szTarget, szSource, cchLength);
 szTarget[cchLength] = 0;
}

Here is the caller graph for this function:

void CopyString	(	wchar_t *	szTarget,
		const char *	szSource,
		size_t	cchLength
	)

{
 mbstowcs(szTarget, szSource, cchLength);
 szTarget[cchLength] = 0;
}

void CopyString	(	char *	szTarget,
		const wchar_t *	szSource,
		size_t	cchLength
	)

{
 wcstombs(szTarget, szSource, cchLength);
 szTarget[cchLength] = 0;
}

bool DirectoryExists

(

const TCHAR *

szDirectory

)

{
#ifdef PLATFORM_WINDOWS

 DWORD dwAttributes = GetFileAttributes(szDirectory);
 if((dwAttributes != INVALID_FILE_ATTRIBUTES) && (dwAttributes & FILE_ATTRIBUTE_DIRECTORY))
 return true;

#else // PLATFORM_WINDOWS

 DIR * dir = opendir(szDirectory);

 if(dir != NULL)
 {
 closedir(dir);
 return true;
 }

#endif

 return false;
}

Here is the caller graph for this function:

const wchar_t* GetPlainFileName

(

const wchar_t *

szFileName

)

{
 const wchar_t * szPlainName = szFileName;

 while(*szFileName != 0)
 {
 if(*szFileName == '\\' || *szFileName == '/')
 szPlainName = szFileName + 1;
 szFileName++;
 }

 return szPlainName;
}

Here is the caller graph for this function:

const char* GetPlainFileName

(

const char *

szFileName

)

{
 const char * szPlainName = szFileName;

 while(*szFileName != 0)
 {
 if(*szFileName == '\\' || *szFileName == '/')
 szPlainName = szFileName + 1;
 szFileName++;
 }

 return szPlainName;
}

ULONGLONG HashStringJenkins

(

const char *

szFileName

)

bool IsValidMD5

(

LPBYTE

pbMd5

)

{
 BYTE BitSummary = 0;

 // The MD5 is considered invalid of it is zeroed
 BitSummary |= pbMd5[0x00] | pbMd5[0x01] | pbMd5[0x02] | pbMd5[0x03] | pbMd5[0x04] | pbMd5[0x05] | pbMd5[0x06] | pbMd5[0x07];
 BitSummary |= pbMd5[0x08] | pbMd5[0x09] | pbMd5[0x0A] | pbMd5[0x0B] | pbMd5[0x0C] | pbMd5[0x0D] | pbMd5[0x0E] | pbMd5[0x0F];
 return (BitSummary != 0);
}

Here is the caller graph for this function:

size_t NormalizeFileName_LowerSlash	(	char *	szNormName,
		const char *	szFileName,
		size_t	cchMaxChars
	)

{
 return NormalizeFileName(AsciiToLowerTable_Slash, szNormName, szFileName, cchMaxChars);
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t NormalizeFileName_UpperBkSlash	(	char *	szNormName,
		const char *	szFileName,
		size_t	cchMaxChars
	)

{
 return NormalizeFileName(AsciiToUpperTable_BkSlash, szNormName, szFileName, cchMaxChars);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ScanIndexDirectory	(	const TCHAR *	szIndexPath,
		INDEX_FILE_FOUND	pfnOnFileFound,
		PDWORD	IndexArray,
		PDWORD	OldIndexArray,
		void *	pvContext
	)

{
#ifdef PLATFORM_WINDOWS

 WIN32_FIND_DATA wf;
 TCHAR * szSearchMask;
 HANDLE hFind;

 // Prepare the search mask
 szSearchMask = CombinePath(szIndexPath, _T("*"));
 if(szSearchMask == NULL)
 return ERROR_NOT_ENOUGH_MEMORY;

 // Prepare directory search
 hFind = FindFirstFile(szSearchMask, &wf);
 if(hFind != INVALID_HANDLE_VALUE)
 {
 // Skip the first file as it's always just "." or ".."
 while(FindNextFile(hFind, &wf))
 {
 // If the found object is a file, pass it to the handler
 if(!(wf.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
 {
 // Let the callback scan the file name
 pfnOnFileFound(wf.cFileName, MainIndexes, OldIndexArray, pvContext);
 }
 }

 // Close the search handle
 FindClose(hFind);
 }

 CASC_FREE(szSearchMask);

#else // PLATFORM_WINDOWS

 struct dirent * dir_entry;
 DIR * dir;

 dir = opendir(szIndexPath);
 if(dir != NULL)
 {
 while((dir_entry = readdir(dir)) != NULL)
 {
 if(dir_entry->d_type != DT_DIR)
 {
 pfnOnFileFound(dir_entry->d_name, MainIndexes, OldIndexArray, pvContext);
 }
 }

 closedir(dir);
 }

#endif

 return ERROR_SUCCESS;
}

Here is the caller graph for this function:

char* StringFromBinary	(	LPBYTE	pbBinary,
		size_t	cbBinary,
		char *	szBuffer
	)

{
 char * szSaveBuffer = szBuffer;

 // Convert the string to the array of MD5
 // Copy the blob data as text
 for(size_t i = 0; i < cbBinary; i++)
 {
 *szBuffer++ = IntToHexChar[pbBinary[0] >> 0x04];
 *szBuffer++ = IntToHexChar[pbBinary[0] & 0x0F];
 pbBinary++;
 }

 // Terminate the string
 *szBuffer = 0;
 return szSaveBuffer;
}

Here is the caller graph for this function:

char* StringFromMD5	(	LPBYTE	md5,
		char *	szBuffer
	)

{
 return StringFromBinary(md5, MD5_HASH_SIZE, szBuffer);
}

Here is the call graph for this function:

bool VerifyDataBlockHash	(	void *	pvDataBlock,
		DWORD	cbDataBlock,
		LPBYTE	expected_md5
	)

{
 hash_state md5_state;
 BYTE md5_digest[MD5_HASH_SIZE];

 // Don't verify the block if the MD5 is not valid.
 if(!IsValidMD5(expected_md5))
 return true;

 // Calculate the MD5 of the data block
 md5_init(&md5_state);
 md5_process(&md5_state, (unsigned char *)pvDataBlock, cbDataBlock);
 md5_done(&md5_state, md5_digest);

 // Does the MD5's match?
 return (memcmp(md5_digest, expected_md5, MD5_HASH_SIZE) == 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

unsigned char AsciiToLowerTable_Slash[256]

unsigned char AsciiToUpperTable_BkSlash[256]

unsigned char IntToHexChar[]