You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
879 lines
18 KiB
879 lines
18 KiB
/*++
|
|
|
|
Copyright (c) 1997 Microsoft Corporation
|
|
All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
Util.c
|
|
|
|
Abstract:
|
|
|
|
Uitility routines for printer migration from Win9x to NT
|
|
|
|
Author:
|
|
|
|
Muhunthan Sivapragasam (MuhuntS) 02-Jan-1996
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
|
|
#include "precomp.h"
|
|
|
|
|
|
|
|
|
|
|
|
PVOID
|
|
AllocMem(
|
|
IN UINT cbSize
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Allocate memory from the heap
|
|
|
|
Arguments:
|
|
cbSize : Byte count
|
|
|
|
Return Value:
|
|
Pointer to the allocated memory
|
|
|
|
--*/
|
|
{
|
|
return LocalAlloc(LPTR, cbSize);
|
|
}
|
|
|
|
|
|
VOID
|
|
FreeMem(
|
|
IN PVOID p
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Free memory allocated on the heap
|
|
|
|
Arguments:
|
|
p : Pointer to the memory to be freed
|
|
|
|
Return Value:
|
|
None
|
|
|
|
--*/
|
|
{
|
|
LocalFree(p);
|
|
}
|
|
|
|
|
|
LPSTR
|
|
AllocStrA(
|
|
LPCSTR pszStr
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Allocate memory and make a copy of an ansi string field
|
|
|
|
Arguments:
|
|
pszStr : String to copy
|
|
|
|
Return Value:
|
|
Pointer to the copied string. Memory is allocated.
|
|
|
|
--*/
|
|
{
|
|
LPSTR pszRet = NULL;
|
|
|
|
if ( pszStr && *pszStr ) {
|
|
|
|
pszRet = AllocMem((strlen(pszStr) + 1) * sizeof(CHAR));
|
|
if ( pszRet )
|
|
strcpy(pszRet, pszStr);
|
|
}
|
|
|
|
return pszRet;
|
|
}
|
|
|
|
|
|
|
|
LPSTR
|
|
AllocStrAFromStrW(
|
|
LPCWSTR pszStr
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Returns the ansi string for a give unicode string. Memory is allocated.
|
|
|
|
Arguments:
|
|
pszStr : Gives the ansi string to copy
|
|
|
|
Return Value:
|
|
Pointer to the copied ansi string. Memory is allocated.
|
|
|
|
--*/
|
|
{
|
|
DWORD dwLen;
|
|
LPSTR pszRet = NULL;
|
|
|
|
if ( pszStr &&
|
|
*pszStr &&
|
|
(dwLen = wcslen(pszStr)) &&
|
|
(pszRet = AllocMem((dwLen + 1 ) * sizeof(CHAR))) ) {
|
|
|
|
WideCharToMultiByte(CP_ACP,
|
|
0,
|
|
pszStr,
|
|
dwLen,
|
|
pszRet,
|
|
dwLen,
|
|
NULL,
|
|
NULL );
|
|
}
|
|
|
|
return pszRet;
|
|
}
|
|
|
|
|
|
BOOL
|
|
WriteToFile(
|
|
HANDLE hFile,
|
|
LPCSTR pszFormat,
|
|
...
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Format and write a string to the text file. This is used to write the
|
|
printing configuration on Win9x
|
|
|
|
Arguments:
|
|
hFile : File handle
|
|
pszFormat : Format string for the message
|
|
|
|
Return Value:
|
|
None
|
|
|
|
--*/
|
|
{
|
|
CHAR szMsg[MAX_LINELENGTH];
|
|
int iResult;
|
|
va_list vargs;
|
|
DWORD dwSize, dwWritten;
|
|
BOOL bRet;
|
|
|
|
bRet = TRUE;
|
|
|
|
va_start(vargs, pszFormat);
|
|
// vsprintf(szMsg, pszFormat, vargs);
|
|
iResult = StringCbVPrintfA(szMsg, sizeof(szMsg), pszFormat, vargs);
|
|
va_end(vargs);
|
|
|
|
dwSize = strlen(szMsg) * sizeof(CHAR);
|
|
|
|
if ( !WriteFile(hFile, (LPCVOID)szMsg, dwSize, &dwWritten, NULL) ||
|
|
dwSize != dwWritten ) {
|
|
|
|
bRet = FALSE;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
LPSTR
|
|
GetStringFromRcFileA(
|
|
UINT uId
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Load a string from the .rc file and make a copy of it by doing AllocStr
|
|
|
|
Arguments:
|
|
uId : Identifier for the string to be loaded
|
|
|
|
Return Value:
|
|
String value loaded, NULL on error. Caller should free the memory
|
|
|
|
--*/
|
|
{
|
|
CHAR buf[MAX_LINELENGTH+1];
|
|
|
|
if(0 != LoadStringA(g_hInst, uId, buf, sizeof(buf))){
|
|
buf[sizeof(buf)-1] = '\0';
|
|
return AllocStrA(buf);
|
|
} else {
|
|
return NULL;
|
|
} // if(0 != LoadStringA(g_hInst, uId, buf, sizeof(buf)))
|
|
} // GetStringFromRcFileA()
|
|
|
|
|
|
|
|
VOID
|
|
ReadString(
|
|
IN HANDLE hFile,
|
|
OUT LPSTR *ppszParam1,
|
|
OUT LPSTR *ppszParam2
|
|
)
|
|
{
|
|
CHAR c;
|
|
LPSTR pszParameter1;
|
|
LPSTR pszParameter2;
|
|
DWORD dwLen;
|
|
CHAR LineBuffer[MAX_LINELENGTH+1];
|
|
DWORD Idx;
|
|
PCHAR pCurrent;
|
|
|
|
//
|
|
// Initialize local.
|
|
//
|
|
|
|
c = 0;
|
|
pszParameter1 = NULL;
|
|
pszParameter2 = NULL;
|
|
dwLen = 0;
|
|
Idx = 0;
|
|
pCurrent = NULL;
|
|
|
|
memset(LineBuffer, 0, sizeof(LineBuffer));
|
|
|
|
//
|
|
// Initialize caller buffer
|
|
//
|
|
|
|
*ppszParam1 = NULL;
|
|
*ppszParam2 = NULL;
|
|
|
|
//
|
|
// First skip space/\r/\n.
|
|
//
|
|
|
|
c = (CHAR) My_fgetc(hFile);
|
|
while( (' ' == c)
|
|
|| ('\n' == c)
|
|
|| ('\r' == c) )
|
|
{
|
|
c = (CHAR) My_fgetc(hFile);
|
|
}
|
|
|
|
//
|
|
// See if it's EOF.
|
|
//
|
|
|
|
if(EOF == c){
|
|
|
|
//
|
|
// End of file.
|
|
//
|
|
|
|
goto ReadString_return;
|
|
}
|
|
|
|
//
|
|
// Get a line.
|
|
//
|
|
|
|
Idx = 0;
|
|
while( ('\n' != c) && (EOF != c) && (Idx < sizeof(LineBuffer)-2) ){
|
|
LineBuffer[Idx++] = c;
|
|
c = (CHAR) My_fgetc(hFile);
|
|
} // while( ('\n' != c) && (EOF != c) )
|
|
dwLen = Idx;
|
|
|
|
//
|
|
// See if it's EOF.
|
|
//
|
|
|
|
if(EOF == c){
|
|
|
|
//
|
|
// Illegal migration file.
|
|
//
|
|
|
|
SetupLogError("WIA Migration: ReadString: ERROR!! Illegal migration file.\r\n", LogSevError);
|
|
goto ReadString_return;
|
|
} else if ('\n' != c) {
|
|
|
|
//
|
|
// A line too long.
|
|
//
|
|
|
|
SetupLogError("WIA Migration: ReadString: ERROR!! Reading line is too long.\r\n", LogSevError);
|
|
goto ReadString_return;
|
|
}
|
|
|
|
//
|
|
// See if it's double quated.
|
|
//
|
|
|
|
if('\"' != LineBuffer[0]){
|
|
//
|
|
// There's no '"'. Invalid migration file.
|
|
//
|
|
SetupLogError("WIA Migration: ReadString: ERROR!! Illegal migration file with no Quote.\r\n", LogSevError);
|
|
goto ReadString_return;
|
|
} // if('\"' != LineBuffer[0])
|
|
|
|
|
|
pszParameter1 = &LineBuffer[1];
|
|
pCurrent = &LineBuffer[1];
|
|
|
|
//
|
|
// Find next '"' and replace with '\0'.
|
|
//
|
|
|
|
pCurrent = strchr(pCurrent, '\"');
|
|
if(NULL == pCurrent){
|
|
SetupLogError("WIA Migration: ReadString: ERROR!! Illegal migration file.\r\n", LogSevError);
|
|
goto ReadString_return;
|
|
} // if(NULL == pCurrent)
|
|
|
|
*pCurrent++ = '\0';
|
|
|
|
//
|
|
// Find next (3rd) '"', it's beginning of 2nd parameter.
|
|
//
|
|
|
|
pCurrent = strchr(pCurrent, '\"');
|
|
if(NULL == pCurrent){
|
|
SetupLogError("WIA Migration: ReadString: ERROR!! Illegal migration file.\r\n", LogSevError);
|
|
goto ReadString_return;
|
|
} // if(NULL == pCurrent)
|
|
|
|
pCurrent++;
|
|
pszParameter2 = pCurrent;
|
|
|
|
//
|
|
// Find last '"' and replace with '\0'.
|
|
//
|
|
|
|
pCurrent = strchr(pCurrent, '\"');
|
|
if(NULL == pCurrent){
|
|
SetupLogError("WIA Migration: ReadString: ERROR!! Illegal migration file.\r\n", LogSevError);
|
|
goto ReadString_return;
|
|
} // if(NULL == pCurrent)
|
|
|
|
*pCurrent = '\0';
|
|
|
|
//
|
|
// Allocate buffer for returning string.
|
|
//
|
|
|
|
*ppszParam1 = AllocStrA(pszParameter1);
|
|
*ppszParam2 = AllocStrA(pszParameter2);
|
|
|
|
ReadString_return:
|
|
return;
|
|
} // ReadString()
|
|
|
|
|
|
|
|
LONG
|
|
WriteRegistryToFile(
|
|
IN HANDLE hFile,
|
|
IN HKEY hKey,
|
|
IN LPCSTR pszPath
|
|
)
|
|
{
|
|
LONG lError;
|
|
HKEY hSubKey;
|
|
DWORD dwValueSize;
|
|
DWORD dwDataSize;
|
|
DWORD dwSubKeySize;
|
|
DWORD dwTypeBuffer;
|
|
|
|
PCHAR pSubKeyBuffer;
|
|
PCHAR pValueBuffer;
|
|
PCHAR pDataBuffer;
|
|
|
|
DWORD Idx;
|
|
|
|
//
|
|
// Initialize local.
|
|
//
|
|
|
|
lError = ERROR_SUCCESS;
|
|
hSubKey = (HKEY)INVALID_HANDLE_VALUE;
|
|
dwValueSize = 0;
|
|
dwDataSize = 0;
|
|
dwSubKeySize = 0;
|
|
dwTypeBuffer = 0;
|
|
Idx = 0;
|
|
|
|
pSubKeyBuffer = NULL;
|
|
pValueBuffer = NULL;
|
|
pDataBuffer = NULL;
|
|
|
|
//
|
|
// Query necessary buffer size.
|
|
//
|
|
|
|
lError = RegQueryInfoKeyA(hKey,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&dwSubKeySize,
|
|
NULL,
|
|
NULL,
|
|
&dwValueSize,
|
|
&dwDataSize,
|
|
NULL,
|
|
NULL);
|
|
if(ERROR_SUCCESS != lError){
|
|
|
|
//
|
|
// Unable to retrieve key info.
|
|
//
|
|
|
|
goto WriteRegistryToFile_return;
|
|
|
|
} // if(ERROR_SUCCESS != lError)
|
|
|
|
//
|
|
// Allocate buffers.
|
|
//
|
|
|
|
dwValueSize = (dwValueSize+1+1) * sizeof(CHAR);
|
|
dwSubKeySize = (dwSubKeySize+1) * sizeof(CHAR);
|
|
|
|
pValueBuffer = AllocMem(dwValueSize);
|
|
pDataBuffer = AllocMem(dwDataSize);
|
|
pSubKeyBuffer = AllocMem(dwSubKeySize);
|
|
|
|
if( (NULL == pValueBuffer)
|
|
|| (NULL == pDataBuffer)
|
|
|| (NULL == pSubKeyBuffer) )
|
|
{
|
|
|
|
//
|
|
// Insufficient memory.
|
|
//
|
|
|
|
SetupLogError("WIA Migration: WriteRegistryToFile: ERROR!! Unable to allocate buffer.\r\n", LogSevError);
|
|
lError = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto WriteRegistryToFile_return;
|
|
} // if(NULL == pDataBuffer)
|
|
|
|
//
|
|
// Indicate beginning of this subkey to the file.
|
|
//
|
|
|
|
WriteToFile(hFile, "\"%s\" = \"BEGIN\"\r\n", pszPath);
|
|
|
|
//
|
|
// Enumerate all values.
|
|
//
|
|
|
|
while(ERROR_SUCCESS == lError){
|
|
|
|
DWORD dwLocalValueSize;
|
|
DWORD dwLocalDataSize;
|
|
|
|
//
|
|
// Reset buffer and size.
|
|
//
|
|
|
|
dwLocalValueSize = dwValueSize;
|
|
dwLocalDataSize = dwDataSize;
|
|
memset(pValueBuffer, 0, dwValueSize);
|
|
memset(pDataBuffer, 0, dwDataSize);
|
|
|
|
//
|
|
// Acquire registry value/data..
|
|
//
|
|
|
|
lError = RegEnumValueA(hKey,
|
|
Idx,
|
|
pValueBuffer,
|
|
&dwLocalValueSize,
|
|
NULL,
|
|
&dwTypeBuffer,
|
|
pDataBuffer,
|
|
&dwLocalDataSize);
|
|
if(ERROR_NO_MORE_ITEMS == lError){
|
|
|
|
//
|
|
// End of data.
|
|
//
|
|
|
|
continue;
|
|
} // if(ERROR_NO_MORE_ITEMS == lError)
|
|
|
|
if(ERROR_SUCCESS != lError){
|
|
|
|
//
|
|
// Unable to read registry value.
|
|
//
|
|
|
|
SetupLogError("WIA Migration: WriteRegistryToFile: ERROR!! Unable to acqure registry value/data.\r\n", LogSevError);
|
|
goto WriteRegistryToFile_return;
|
|
} // if(ERROR_NO_MORE_ITEMS == lError)
|
|
|
|
//
|
|
// Write this value to a file.
|
|
//
|
|
|
|
lError = WriteRegistryValueToFile(hFile,
|
|
pValueBuffer,
|
|
dwTypeBuffer,
|
|
pDataBuffer,
|
|
dwLocalDataSize);
|
|
if(ERROR_SUCCESS != lError){
|
|
|
|
//
|
|
// Unable to write to a file.
|
|
//
|
|
|
|
SetupLogError("WIA Migration: WriteRegistryToFile: ERROR!! Unable to write to a file.\r\n", LogSevError);
|
|
goto WriteRegistryToFile_return;
|
|
} // if(ERROR_SUCCESS != lError)
|
|
|
|
//
|
|
// Goto next value.
|
|
//
|
|
|
|
Idx++;
|
|
|
|
} // while(ERROR_SUCCESS == lError)
|
|
|
|
//
|
|
// Enumerate all sub keys.
|
|
//
|
|
|
|
lError = ERROR_SUCCESS;
|
|
Idx = 0;
|
|
|
|
while(ERROR_SUCCESS == lError){
|
|
|
|
memset(pSubKeyBuffer, 0, dwSubKeySize);
|
|
lError = RegEnumKeyA(hKey, Idx++, pSubKeyBuffer, dwSubKeySize);
|
|
if(ERROR_SUCCESS == lError){
|
|
|
|
//
|
|
// There's sub key exists. Spew it to the file and store all the
|
|
// values recursively.
|
|
//
|
|
|
|
lError = RegOpenKey(hKey, pSubKeyBuffer, &hSubKey);
|
|
if(ERROR_SUCCESS != lError){
|
|
SetupLogError("WIA Migration: WriteRegistryToFile: ERROR!! Unable to open subkey.\r\n", LogSevError);
|
|
continue;
|
|
} // if(ERROR_SUCCESS != lError)
|
|
|
|
//
|
|
// Call subkey recursively.
|
|
//
|
|
|
|
lError = WriteRegistryToFile(hFile, hSubKey, pSubKeyBuffer);
|
|
|
|
} // if(ERROR_SUCCESS == lError)
|
|
} // while(ERROR_SUCCESS == lError)
|
|
|
|
if(ERROR_NO_MORE_ITEMS == lError){
|
|
|
|
//
|
|
// Operation completed as expected.
|
|
//
|
|
|
|
lError = ERROR_SUCCESS;
|
|
|
|
} // if(ERROR_NO_MORE_ITEMS == lError)
|
|
|
|
//
|
|
// Indicate end of this subkey to the file.
|
|
//
|
|
|
|
WriteToFile(hFile, "\"%s\" = \"END\"\r\n", pszPath);
|
|
|
|
WriteRegistryToFile_return:
|
|
|
|
//
|
|
// Clean up.
|
|
//
|
|
|
|
if(NULL != pValueBuffer){
|
|
FreeMem(pValueBuffer);
|
|
} // if(NULL != pValueBuffer)
|
|
|
|
if(NULL != pDataBuffer){
|
|
FreeMem(pDataBuffer);
|
|
} // if(NULL != pDataBuffer)
|
|
|
|
if(NULL != pSubKeyBuffer){
|
|
FreeMem(pSubKeyBuffer);
|
|
} // if(NULL != pSubKeyBuffer)
|
|
|
|
return lError;
|
|
} // WriteRegistryToFile()
|
|
|
|
|
|
LONG
|
|
WriteRegistryValueToFile(
|
|
HANDLE hFile,
|
|
LPSTR pszValue,
|
|
DWORD dwType,
|
|
PCHAR pDataBuffer,
|
|
DWORD dwSize
|
|
)
|
|
{
|
|
|
|
LONG lError;
|
|
PCHAR pSpewBuffer;
|
|
DWORD Idx;
|
|
|
|
//
|
|
// Initialize locals.
|
|
//
|
|
|
|
lError = ERROR_SUCCESS;
|
|
pSpewBuffer = NULL;
|
|
|
|
//
|
|
// Allocate buffer for actual spew.
|
|
//
|
|
|
|
pSpewBuffer = AllocMem(dwSize*3);
|
|
if(NULL == pSpewBuffer){
|
|
|
|
//
|
|
// Unable to allocate buffer.
|
|
//
|
|
|
|
lError = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto WriteRegistryValueToFile_return;
|
|
} // if(NULL == pSpewBuffer)
|
|
|
|
for(Idx = 0; Idx < dwSize; Idx++){
|
|
|
|
wsprintf(pSpewBuffer+Idx*3, "%02x", pDataBuffer[Idx]);
|
|
*(pSpewBuffer+Idx*3+2) = ',';
|
|
|
|
} // for(Idx = 0; Idx < dwSize; Idx++)
|
|
|
|
*(pSpewBuffer+dwSize*3-1) = '\0';
|
|
|
|
WriteToFile(hFile, "\"%s\" = \"%08x:%s\"\r\n", pszValue, dwType, pSpewBuffer);
|
|
|
|
//
|
|
// Operation succeeded.
|
|
//
|
|
|
|
lError = ERROR_SUCCESS;
|
|
|
|
WriteRegistryValueToFile_return:
|
|
|
|
//
|
|
// Clean up.
|
|
//
|
|
|
|
if(NULL != pSpewBuffer){
|
|
FreeMem(pSpewBuffer);
|
|
} // if(NULL != pSpewBuffer)
|
|
|
|
return lError;
|
|
|
|
} // WriteRegistryValueToFile()
|
|
|
|
|
|
LONG
|
|
GetRegData(
|
|
HKEY hKey,
|
|
LPSTR pszValue,
|
|
PCHAR *ppDataBuffer,
|
|
PDWORD pdwType,
|
|
PDWORD pdwSize
|
|
)
|
|
{
|
|
|
|
LONG lError;
|
|
PCHAR pTempBuffer;
|
|
DWORD dwRequiredSize;
|
|
DWORD dwType;
|
|
|
|
//
|
|
// Initialize local.
|
|
//
|
|
|
|
lError = ERROR_SUCCESS;
|
|
pTempBuffer = NULL;
|
|
dwRequiredSize = 0;
|
|
dwType = 0;
|
|
|
|
//
|
|
// Get required size.
|
|
//
|
|
|
|
lError = RegQueryValueEx(hKey,
|
|
pszValue,
|
|
NULL,
|
|
&dwType,
|
|
NULL,
|
|
&dwRequiredSize);
|
|
if( (ERROR_SUCCESS != lError)
|
|
|| (0 == dwRequiredSize) )
|
|
{
|
|
|
|
pTempBuffer = NULL;
|
|
goto GetRegData_return;
|
|
|
|
} // if(ERROR_MORE_DATA != lError)
|
|
|
|
//
|
|
// If it doesn't need actual data, just bail out.
|
|
//
|
|
|
|
if(NULL == ppDataBuffer){
|
|
lError = ERROR_SUCCESS;
|
|
goto GetRegData_return;
|
|
} // if(NULL == ppDataBuffer)
|
|
|
|
//
|
|
// Allocate buffer to receive data.
|
|
//
|
|
|
|
pTempBuffer = AllocMem(dwRequiredSize);
|
|
if(NULL == pTempBuffer){
|
|
|
|
//
|
|
// Allocation failed.
|
|
//
|
|
|
|
SetupLogError("WIA Migration: GetRegData: ERROR!! Unable to allocate buffer.\r\n", LogSevError);
|
|
lError = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto GetRegData_return;
|
|
} // if(NULL == pTempBuffer)
|
|
|
|
//
|
|
// Query the data.
|
|
//
|
|
|
|
lError = RegQueryValueEx(hKey,
|
|
pszValue,
|
|
NULL,
|
|
&dwType,
|
|
pTempBuffer,
|
|
&dwRequiredSize);
|
|
if(ERROR_SUCCESS != lError){
|
|
|
|
//
|
|
// Data acquisition somehow failed. Free buffer.
|
|
//
|
|
|
|
goto GetRegData_return;
|
|
} // if(ERROR_SUCCESS != lError)
|
|
|
|
GetRegData_return:
|
|
|
|
if(ERROR_SUCCESS != lError){
|
|
|
|
//
|
|
// Operation unsuccessful. Free the buffer if allocated.
|
|
//
|
|
|
|
if(NULL != pTempBuffer){
|
|
FreeMem(pTempBuffer);
|
|
pTempBuffer = NULL;
|
|
} // if(NULL != pTempBuffer)
|
|
} // if(ERROR_SUCCESS != lError)
|
|
|
|
//
|
|
// Copy the result.
|
|
//
|
|
|
|
if(NULL != pdwSize){
|
|
*pdwSize = dwRequiredSize;
|
|
} // if(NULL != pdwSize)
|
|
|
|
if(NULL != ppDataBuffer){
|
|
*ppDataBuffer = pTempBuffer;
|
|
} // if(NULL != ppDataBuffer)
|
|
|
|
if(NULL != pdwType){
|
|
*pdwType = dwType;
|
|
} // if(NULL != pdwType)
|
|
|
|
return lError;
|
|
} // GetRegData()
|
|
|
|
VOID
|
|
MyLogError(
|
|
LPCSTR pszFormat,
|
|
...
|
|
)
|
|
{
|
|
LPSTR psz;
|
|
CHAR szMsg[1024];
|
|
va_list vargs;
|
|
|
|
if(NULL != pszFormat){
|
|
va_start(vargs, pszFormat);
|
|
vsprintf(szMsg, pszFormat, vargs);
|
|
va_end(vargs);
|
|
|
|
SetupLogError(szMsg, LogSevError);
|
|
} // if(NULL != pszFormat)
|
|
|
|
} // MyLogError()
|
|
|
|
CHAR
|
|
My_fgetc(
|
|
HANDLE hFile
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Gets a character from the file
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
CHAR c;
|
|
DWORD cbRead;
|
|
|
|
if ( ReadFile(hFile, (LPBYTE)&c, sizeof(c), &cbRead, NULL) &&
|
|
cbRead == sizeof(c) )
|
|
return c;
|
|
else
|
|
return (CHAR) EOF;
|
|
} // My_fgetc()
|
|
|
|
int
|
|
MyStrCmpiA(
|
|
LPCSTR str1,
|
|
LPCSTR str2
|
|
)
|
|
{
|
|
int iRet;
|
|
|
|
//
|
|
// Initialize local.
|
|
//
|
|
|
|
iRet = 0;
|
|
|
|
//
|
|
// Compare string.
|
|
//
|
|
|
|
if(CSTR_EQUAL == CompareStringA(LOCALE_INVARIANT,
|
|
NORM_IGNORECASE,
|
|
str1,
|
|
-1,
|
|
str2,
|
|
-1) )
|
|
{
|
|
iRet = 0;
|
|
} else {
|
|
iRet = -1;
|
|
}
|
|
|
|
return iRet;
|
|
}
|