|
|
//--------------------------------------------------------------
//
// File: bothchar
//
// Contents: Functions that need to be compiled as ascii for
// scanstate and unicode for loadstate.
//
//---------------------------------------------------------------
#include "bothchar.hxx"
//---------------------------------------------------------------
// Constants
UCHAR EMPTY_STRING[] = "";
const UCHAR NEWLINE_SET[256] ={ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
const DWORD VERBOSE_BIT = 0x01; // used with -v flag
const DWORD DEBUGOUTPUT_BIT = 0x02; // used with -v flag
const DWORD VERBOSEREG_BIT = 0x04; // used with -v flag
#define LOADSTATE_KEY TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Loadstate")
//---------------------------------------------------------------
// Globals.
TCHAR *DomainName = NULL;TCHAR *UserName = NULL;TCHAR *UserPath = NULL;
//---------------------------------------------------------------
void CStringList::Add( CStringList *pslMore ){ CStringList *b; CStringList *c; CStringList *d;
// Do nothing if there is no list.
if (pslMore == NULL) return;
// Determine some nodes to work with.
b = pslMore->_pslNext; c = pslMore; d = _pslNext;
// Relink the list so head points to b is a list to c points to d is
// a list back to head.
_pslNext = b; c->_pslNext = d;}
//---------------------------------------------------------------
CStringList::CStringList( DWORD dwLen ){ _pslNext = this; if (dwLen == 0) { _ptsString = NULL; _fHead = TRUE; } else { _fHead = FALSE; _ptsString = (TCHAR *) malloc( dwLen*sizeof(TCHAR) ); }}
//---------------------------------------------------------------
CStringList::~CStringList(){ CStringList *pslCurrent = _pslNext; CStringList *pslEnd;
// Non header nodes just free their string.
if (_ptsString != NULL) free( _ptsString ); // Header nodes free the list.
if (_fHead) { while (pslCurrent != this) { pslEnd = pslCurrent->_pslNext; delete pslCurrent; pslCurrent = pslEnd; } }}
//---------------------------------------------------------------
DWORD ParseSectionList( INFCONTEXT *pic, TCHAR **pptsLabel, CStringList **pslList ){ DWORD len; BOOL fSuccess; DWORD dwFields; DWORD i; DWORD dwResult = ERROR_SUCCESS; CStringList *pslCurrent;
// Initialize output
*pslList = NULL;
// Query the length of the label name
fSuccess = SetupGetStringField( pic, 0, NULL, 0, &len ); LOG_ASSERT_GLE( fSuccess, dwResult );
// Allocate space
*pptsLabel = (TCHAR *) malloc( len * sizeof(TCHAR) ); LOG_ASSERT_EXPR( *pptsLabel != NULL, IDS_NOT_ENOUGH_MEMORY, dwResult, ERROR_NOT_ENOUGH_MEMORY );
// Read the label name
fSuccess = SetupGetStringField( pic, 0, *pptsLabel, len, NULL ); LOG_ASSERT_GLE( fSuccess, dwResult );
// Find out how many fields are on the line.
dwFields = SetupGetFieldCount( pic ); LOG_ASSERT_GLE( dwFields != 0, dwResult );
// Read each field.
for (i = 1; i <= dwFields; i++) { // Query the length of the field
fSuccess = SetupGetStringField( pic, i, NULL, 0, &len ); LOG_ASSERT_GLE( fSuccess, dwResult );
// Allocate a new node.
pslCurrent = new CStringList( len ); LOG_ASSERT_EXPR( pslCurrent != NULL, IDS_NOT_ENOUGH_MEMORY, dwResult, ERROR_NOT_ENOUGH_MEMORY); LOG_ASSERT_EXPR( pslCurrent->String() != NULL, IDS_NOT_ENOUGH_MEMORY, dwResult, ERROR_NOT_ENOUGH_MEMORY );
// Copy the field into the node.
fSuccess = SetupGetStringField( pic, i, pslCurrent->String(), len, NULL ); LOG_ASSERT_GLE( fSuccess, dwResult );
// Link the node in the list.
if (*pslList == NULL) *pslList = pslCurrent; else (*pslList)->Add( pslCurrent ); }
cleanup: return dwResult;}
/***************************************************************************
ParseRegPath
Read a string field from a line in the rules inf file and parse itinto a root, key, and value. All components of the reg path are optional.
root\key [value]
***************************************************************************/
DWORD ParseRegPath( INFCONTEXT *pic, DWORD dwField, TCHAR **pptsRoot, TCHAR **pptsKey, TCHAR **pptsValue ){ TCHAR *ptsBuffer = NULL; TCHAR *ptsStop; TCHAR *ptsStart; TCHAR *bracket; BOOL fSuccess; DWORD dwLen = 0; DWORD dwResult = ERROR_SUCCESS;
//Null out return values in case of later error.
*pptsRoot = NULL; *pptsKey = NULL; *pptsValue = NULL; // Compute the length of the reg path field.
SetupGetStringField( pic, dwField, NULL, 0, &dwLen );
// Allocate a buffer.
ptsBuffer = (TCHAR *) malloc( dwLen*sizeof(TCHAR) ); LOG_ASSERT_EXPR( ptsBuffer != NULL, IDS_NOT_ENOUGH_MEMORY, dwResult, ERROR_NOT_ENOUGH_MEMORY );
// Get the whole reg path. The function fails if the field is empty.
fSuccess = SetupGetStringField( pic, dwField, ptsBuffer, dwLen, &dwLen ); if (!fSuccess) { free( ptsBuffer ); return ERROR_SUCCESS; }
// Look for a backslash.
ptsStop = _tcschr( ptsBuffer, TEXT('\\') );
// If there wasn't one, there is no root.
if (ptsStop == NULL) { *pptsRoot = NULL; ptsStart = ptsBuffer; }
// If there was one, copy the root name.
else { *pptsRoot = (TCHAR *) malloc( ((ptsStop - ptsBuffer) + 1) * sizeof(TCHAR) ); LOG_ASSERT_EXPR( *pptsRoot != NULL, IDS_NOT_ENOUGH_MEMORY, dwResult, ERROR_NOT_ENOUGH_MEMORY ); _tcsncpy( *pptsRoot, ptsBuffer, ptsStop - ptsBuffer ); (*pptsRoot)[ptsStop - ptsBuffer] = 0; ptsStart = ptsStop + 1; }
// Look for an opening square bracket.
ptsStop = _tcschr( ptsStart, TEXT('[') );
// If there wasn't one, copy the rest of the string to the key name.
if (ptsStop == NULL) { if (ptsStart[0] == 0) *pptsKey = NULL; else { *pptsKey = (TCHAR *) malloc( (dwLen - (ptsStart - ptsBuffer)) * sizeof(TCHAR) ); *pptsValue = NULL; LOG_ASSERT_EXPR( *pptsKey != NULL, IDS_NOT_ENOUGH_MEMORY, dwResult, ERROR_NOT_ENOUGH_MEMORY ); _tcscpy( *pptsKey, ptsStart ); } }
// Handle an optional key and a value.
else { // Back up past any intervening white space.
bracket = ptsStop + 1; while (ptsStop != ptsStart && (ptsStop[0] == TEXT(' ') || ptsStop[0] == TEXT('['))) ptsStop -= 1;
// If there are any characters left, copy them to the key.
if (ptsStop != ptsStart) { ptsStop += 1; *pptsKey = (TCHAR *) malloc( ((ptsStop - ptsStart) + 1) * sizeof(TCHAR) ); LOG_ASSERT_EXPR( *pptsKey != NULL, IDS_NOT_ENOUGH_MEMORY, dwResult, ERROR_NOT_ENOUGH_MEMORY ); _tcsncpy( *pptsKey, ptsStart, ptsStop - ptsStart ); (*pptsKey)[ptsStop - ptsStart] = 0; } else *pptsKey = NULL;
// Find the closing square bracket.
ptsStart = bracket; bracket = _tcschr( ptsStart, TEXT(']') ); LOG_ASSERT_EXPR( bracket != NULL, IDS_INF_ERROR, dwResult, SPAPI_E_GENERAL_SYNTAX );
// Copy the value name.
*pptsValue = (TCHAR *) malloc( ((bracket - ptsStart) + 1) * sizeof(TCHAR) ); LOG_ASSERT_EXPR( *pptsValue != NULL, IDS_NOT_ENOUGH_MEMORY, dwResult, ERROR_NOT_ENOUGH_MEMORY ); _tcsncpy( *pptsValue, ptsStart, bracket - ptsStart ); (*pptsValue)[bracket - ptsStart] = 0; }
cleanup: if (ptsBuffer != NULL) free( ptsBuffer ); return dwResult;}
/***************************************************************************
ParseRule
Read a line from the rules inf file in one of the following formats.When partial paths are specified, compute the full path. Create a rulerecord from the line.
reg_path2 is optional and reg_path is parsed by the functionParseRegPath into a root, key, and value. reg-path1 = reg_path2
If reg_path2 contains just a leaf name, generate a full path usingthe path from reg_path1 and replacing its leaf with the leaf from reg_path2.
***************************************************************************/
DWORD ParseRule( INFCONTEXT *pic, HASH_NODE **pphnRule ){ TCHAR *ptsBuffer; DWORD dwReqLen; DWORD dwResult = ERROR_SUCCESS; BOOL fSuccess; TCHAR *ptsLast; TCHAR *ptsTemp;
// Allocate a new rule.
*pphnRule = (HASH_NODE *) malloc( sizeof(HASH_NODE) ); LOG_ASSERT_EXPR( *pphnRule != NULL, IDS_NOT_ENOUGH_MEMORY, dwResult, ERROR_NOT_ENOUGH_MEMORY ); (*pphnRule)->dwAction = 0; (*pphnRule)->phnNext = 0; (*pphnRule)->ptsNewValue = NULL; (*pphnRule)->ptsNewKey = NULL; (*pphnRule)->ptsFunction = NULL; (*pphnRule)->ptsFileDest = NULL;
// Get the first reg path.
dwResult = ParseRegPath( pic, 0, &(*pphnRule)->ptsRoot, &(*pphnRule)->ptsKey, &(*pphnRule)->ptsValue ); FAIL_ON_ERROR( dwResult );
// Get the second reg path.
dwResult = ParseRegPath( pic, 1, &ptsBuffer, &(*pphnRule)->ptsNewKey, &(*pphnRule)->ptsNewValue ); FAIL_ON_ERROR( dwResult );
// Get the optional regfile destination
fSuccess = SetupGetStringField( pic, 2, NULL, 0, &dwReqLen ); if ((TRUE == fSuccess) && (dwReqLen > 0)) { (*pphnRule)->ptsFileDest = (TCHAR *)malloc(dwReqLen * sizeof(TCHAR)); LOG_ASSERT_EXPR( (*pphnRule)->ptsFileDest != NULL, IDS_NOT_ENOUGH_MEMORY, dwResult, ERROR_NOT_ENOUGH_MEMORY );
fSuccess = SetupGetStringField(pic, 2, (*pphnRule)->ptsFileDest, dwReqLen, NULL); LOG_ASSERT_GLE(fSuccess, dwResult); }
// If the original key ends with a star, remove it and set the recursive
// flag.
if ((*pphnRule)->ptsKey != NULL) { dwReqLen = _tcslen( (*pphnRule)->ptsKey ); if (dwReqLen > 2 && (*pphnRule)->ptsKey[dwReqLen-1] == TEXT('*') && (*pphnRule)->ptsKey[dwReqLen-2] == TEXT('\\')) { (*pphnRule)->dwAction |= recursive_fa; (*pphnRule)->ptsKey[dwReqLen-2] = 0; } // If there is a new key, set the rename_leaf or rename_path flag.
if ((*pphnRule)->ptsNewKey != NULL) if ((*pphnRule)->dwAction & recursive_fa) (*pphnRule)->dwAction |= rename_path_fa; else (*pphnRule)->dwAction |= rename_leaf_fa; }
// If there is a new value, set the rename_value flag.
if ((*pphnRule)->ptsNewValue != NULL) (*pphnRule)->dwAction |= rename_value_fa;
// If the new key did not contain a root, compute a full path for it.
if (ptsBuffer == NULL && (*pphnRule)->ptsKey != NULL && (*pphnRule)->ptsNewKey != NULL) { // Find the last backslash in the key.
ptsLast = (*pphnRule)->ptsKey; do { ptsTemp = _tcschr( ptsLast, TEXT('\\') ); if (ptsTemp != NULL) ptsLast = ptsTemp+1; } while (ptsTemp != NULL);
// Don't do anything if the original key contains just a leaf.
if (ptsLast != (*pphnRule)->ptsKey) {
// Allocate a ptsBuffer to hold the old path and the new leaf.
free( ptsBuffer ); dwReqLen = _tcslen( (*pphnRule)->ptsNewKey ) + (ptsLast - (*pphnRule)->ptsKey) + 2; ptsBuffer = (TCHAR *) malloc( dwReqLen*sizeof(TCHAR) ); LOG_ASSERT_EXPR( ptsBuffer != NULL, IDS_NOT_ENOUGH_MEMORY, dwResult, ERROR_NOT_ENOUGH_MEMORY );
// Copy in the old path and the new leaf.
_tcsncpy( ptsBuffer, (*pphnRule)->ptsKey, (ptsLast - (*pphnRule)->ptsKey) ); _tcscpy( &ptsBuffer[ptsLast-(*pphnRule)->ptsKey], (*pphnRule)->ptsNewKey ); free( (*pphnRule)->ptsNewKey ); (*pphnRule)->ptsNewKey = ptsBuffer; } } else free(ptsBuffer);
// Consider freeing strings on error.
cleanup: if (dwResult != ERROR_SUCCESS) { if (*pphnRule != NULL) { free((*pphnRule)->ptsRoot); free((*pphnRule)->ptsKey); free((*pphnRule)->ptsValue); free((*pphnRule)->ptsNewKey); free((*pphnRule)->ptsNewValue); free((*pphnRule)->ptsFunction); free((*pphnRule)->ptsFileDest); free(*pphnRule); *pphnRule = NULL; } } return dwResult;}
//---------------------------------------------------------------
// This function prints from an ascii format string to a unicode
// win32 file handle. It is not thread safe.
DWORD Win32Printf( HANDLE file, char *format, ... ){ va_list va; DWORD dwWritten; DWORD dwLen; DWORD dwWideLength; WCHAR *pwsBuffer = NULL; const ULONG LINEBUFSIZE = 4096;#ifdef UNICODE
char *pszBuffer; int iCharLen; char szOutputBuffer[LINEBUFSIZE];#endif
BOOL fSuccess; TCHAR tcsPrintBuffer[LINEBUFSIZE]; TCHAR *ptsFormat;
#ifdef UNICODE
WCHAR wcsFormat[LINEBUFSIZE];
dwWideLength = MultiByteToWideChar(CP_ACP, 0, format, -1, NULL, 0); if (dwWideLength >= LINEBUFSIZE) { pwsBuffer = (WCHAR *)_alloca( dwWideLength * sizeof(WCHAR)); if (pwsBuffer == NULL) return ERROR_NOT_ENOUGH_MEMORY; ptsFormat = pwsBuffer; if (!MultiByteToWideChar( CP_ACP, 0, format, -1, pwsBuffer, dwWideLength )) return GetLastError(); } else { if (!MultiByteToWideChar(CP_ACP, 0, format, -1, wcsFormat, LINEBUFSIZE)) { return GetLastError(); } ptsFormat = wcsFormat; }#else
ptsFormat = format;#endif
va_start( va, format );
// The doc says if wvsprintf fails, return value is less than
// the length of the expected output. Since its hard to know the
// correct output length, always clear the last error and always
// check it.
SetLastError(ERROR_SUCCESS); wvsprintf( tcsPrintBuffer, ptsFormat, va ); va_end(va); if (GetLastError() != ERROR_SUCCESS) return GetLastError();
// When printing to the console or logfile use ascii.
// When printing to the migration file use Unicode.
dwLen = _tcslen(tcsPrintBuffer); if ((file != OutputFile) || OutputAnsi) {#ifdef UNICODE
//Convert to ANSI for output
iCharLen = WideCharToMultiByte(CP_ACP, 0, tcsPrintBuffer, -1, NULL, 0, NULL, NULL); if (iCharLen >= LINEBUFSIZE) { pszBuffer = (char *)_alloca( iCharLen * sizeof(char)); if (pszBuffer == NULL) return ERROR_OUTOFMEMORY; if (!WideCharToMultiByte(CP_ACP, 0, tcsPrintBuffer, -1, pszBuffer, iCharLen, NULL, NULL)) return GetLastError(); pwsBuffer = (WCHAR *)pszBuffer; } else { if (!WideCharToMultiByte(CP_ACP, 0, tcsPrintBuffer, -1, szOutputBuffer, LINEBUFSIZE, NULL, NULL)) return GetLastError(); pwsBuffer = (WCHAR *)szOutputBuffer; } dwWideLength = dwLen;#else
pwsBuffer = (WCHAR *) tcsPrintBuffer; dwWideLength = dwLen;#endif
} else {#ifdef UNICODE
pwsBuffer = tcsPrintBuffer; dwWideLength = dwLen * sizeof(WCHAR);#else
// Allocate a buffer to hold the unicode string.
DEBUG_ASSERT( dwLen < LINEBUFSIZE ); dwWideLength = MultiByteToWideChar( CP_ACP, 0, tcsPrintBuffer, dwLen, NULL, 0 ); pwsBuffer = (WCHAR *) _alloca( dwWideLength*sizeof(WCHAR) ); if (pwsBuffer == NULL) return ERROR_NOT_ENOUGH_MEMORY;
// Convert the buffer to unicode.
dwWideLength = MultiByteToWideChar( CP_ACP, 0, tcsPrintBuffer, dwLen, pwsBuffer, dwWideLength ); if (dwWideLength == 0) return GetLastError(); dwWideLength *= sizeof(WCHAR);#endif
}
// Write the unicode string.
fSuccess = WriteFile( file, pwsBuffer, dwWideLength, &dwWritten, NULL ); if (!fSuccess || dwWideLength != dwWritten) return GetLastError();
if (file == STDERR) { //Also write to the log file for these
fSuccess = WriteFile( LogFile, pwsBuffer, dwWideLength, &dwWritten, NULL ); if (!fSuccess || dwWideLength != dwWritten) { return GetLastError(); } }
return ERROR_SUCCESS;}
//*****************************************************************
//
// Synopsis: Recursive function to make the command line. We have to do
// this because CStringList stores the parameter in reverse
// order.
//
// Parameters: h
// We need to know when we reach the end of the
// CStringList, which is denoted by pointing back to the
// head of the chain. But in a recursive function we lose
// the head of the chain so it is passed in.
//
// History: 11/8/1999 Created by WeiruC.
//
// Return Value: Win32 error code.
//
//*****************************************************************
void MakeCommandLine(CStringList* h, CStringList* command, TCHAR* commandLine){ if (h==NULL || command == NULL || commandLine == NULL) { if (DebugOutput) { Win32Printf(LogFile, "Error: NULL pointer passed to MakeCommandLine\r\n"); } _tcscpy(commandLine, TEXT("")); return; } if(command->Next() != h) { MakeCommandLine(h, command->Next(), commandLine); }
// No sizes of these buffers are passed in, so we must assume that there is enough space
_tcscat(commandLine, TEXT("\"")); _tcscat(commandLine, command->String()); _tcscat(commandLine, TEXT("\"")); _tcscat(commandLine, TEXT(" "));}
//---------------------------------------------------------------
// This is a variation of strpbrk. It searchs a string that may
// contain nulls for any character in the set. It returns a pointer
// to the first character in the set or null if the string does
// not contain any characters in the set. Since the function
// searchs past nulls in the str parameter, the len parameter
// indicates the actual length of str. The set is an array of
// booleans.
UCHAR *mempbrk( UCHAR *str, DWORD len, const UCHAR set[256] ){ DWORD i;
for (i = 0; i < len; i++) if (set[str[i]] != 0) return &str[i]; return NULL;}
//---------------------------------------------------------------
DWORD WriteKey( HANDLE outfile, DWORD type, TCHAR *rootname, TCHAR *key, TCHAR *value_name, UCHAR *data, DWORD data_len ){ DWORD result = ERROR_SUCCESS; DWORD j; UCHAR *curr; DWORD orig = 0;
// If a string contains an embedded carriage return or linefeed, save
// it as binary and convert it back to a string on read.
if (type == REG_SZ || type == REG_MULTI_SZ || type == REG_EXPAND_SZ) { curr = mempbrk( data, data_len, NEWLINE_SET ); if (curr != NULL) { if (type == REG_SZ) orig = 0x400000; else if (type == REG_MULTI_SZ) orig = 0x100000; else orig = 0x200000; type = REG_BINARY; } }
if (NULL == rootname) rootname = TEXT(""); if (NULL == key) key = TEXT(""); if (NULL == value_name) value_name = TEXT("");
switch (type) { case REG_DWORD: if (data == NULL) *data = 0; result = Win32Printf( outfile, "%s, \"%s\", \"%s\", 0x10001, 0x%x\r\n", rootname, key, value_name, *((DWORD *) data) ); FAIL_ON_ERROR( result ); break;
case REG_EXPAND_SZ: case REG_SZ: if (data == NULL) data = EMPTY_STRING; result = Win32Printf( outfile, "%s, \"%s\", \"%s\", 0x%x, \"%s\"\r\n", rootname, key, value_name, type == REG_SZ ? FLG_ADDREG_TYPE_SZ : FLG_ADDREG_TYPE_EXPAND_SZ, data ); FAIL_ON_ERROR( result ); break;
case REG_MULTI_SZ:
// Print the start of the line and the first string.
if (data == NULL) data = EMPTY_STRING; result = Win32Printf( outfile, "%s, \"%s\", \"%s\", 0x10000, \"%s\"", rootname, key, value_name, data ); FAIL_ON_ERROR( result );
// Print each remaining string.
curr = data+strlen((char *) data)+1; do { // Print a comma and the current string.
Win32Printf( outfile, ", \"%s\"", curr );
// Skip passed the current string and its null.
curr += strlen((char *) curr)+1; } while ((DWORD) (curr - data) < data_len);
// Print the trailing newline.
result = Win32Printf( outfile, "\r\n" ); FAIL_ON_ERROR( result ); break;
case REG_BINARY: case REG_NONE: default: // Unknown types, just copy the type and treat the data as binary
// Print the start of the line.
result = Win32Printf( outfile, "%s, \"%s\", \"%s\", 0x%x", rootname, key, value_name, ((type == REG_NONE ? 0x800000 : type ) | orig) ); FAIL_ON_ERROR( result );
// Print each byte in hex without the 0x prefix.
for (j = 0; j < data_len; j++) { result = Win32Printf( outfile, ",%x", data[j] ); FAIL_ON_ERROR( result ); if ( (j+1) % 20 == 0) { result = Win32Printf( outfile, "\\\r\n" ); FAIL_ON_ERROR( result ); } }
result = Win32Printf( outfile, "\r\n" ); FAIL_ON_ERROR( result ); break; }
cleanup: return result;}
//---------------------------------------------------------------
//
DWORD LogReadRule( HASH_NODE *phnNode ){ DWORD dwRetval = ERROR_SUCCESS; BOOL fRuleFound = FALSE;
dwRetval = Win32Printf(LogFile, "Read rule: "); FAIL_ON_ERROR( dwRetval );
if (phnNode->dwAction & function_fa ) { dwRetval = Win32Printf(LogFile, "function"); FAIL_ON_ERROR( dwRetval ); fRuleFound = TRUE; } if (phnNode->dwAction & (rename_leaf_fa | rename_path_fa | rename_value_fa)) { dwRetval = Win32Printf(LogFile, "rename" ); FAIL_ON_ERROR( dwRetval ); fRuleFound = TRUE; } if (phnNode->dwAction & file_fa) { dwRetval = Win32Printf(LogFile, "copy file"); FAIL_ON_ERROR( dwRetval ); fRuleFound = TRUE; } if (phnNode->dwAction & delete_fa || phnNode->dwAction & suppress_fa) { dwRetval = Win32Printf(LogFile, "delete" ); FAIL_ON_ERROR( dwRetval ); fRuleFound = TRUE; } // If none of the above, then it must be an addreg
if ( fRuleFound == FALSE ) { dwRetval = Win32Printf(LogFile, "addreg" ); FAIL_ON_ERROR( dwRetval ); }
dwRetval = Win32Printf(LogFile, " %s\\%s ", phnNode->ptsRoot, phnNode->ptsKey); FAIL_ON_ERROR( dwRetval );
if ( phnNode->ptsValue != NULL ) { dwRetval = Win32Printf(LogFile, "[%s] ", phnNode->ptsValue ); FAIL_ON_ERROR( dwRetval ); }
if ( phnNode->ptsNewKey != NULL || phnNode->ptsNewValue != NULL ) { dwRetval = Win32Printf(LogFile, "to "); FAIL_ON_ERROR( dwRetval ); if (phnNode->ptsNewKey != NULL) { dwRetval = Win32Printf(LogFile, "%s ", phnNode->ptsNewKey); FAIL_ON_ERROR( dwRetval ); } if (phnNode->ptsNewValue != NULL) { dwRetval = Win32Printf(LogFile, "[%s]", phnNode->ptsNewValue); FAIL_ON_ERROR( dwRetval ); } }
dwRetval = Win32Printf(LogFile, "\r\n"); FAIL_ON_ERROR( dwRetval );
cleanup: return (dwRetval);}//---------------------------------------------------------------
char *GetValueFromRegistry(const char *lpValue){ HKEY hKey; char *buffer = NULL; DWORD dwDataSize = 0; DWORD result;
result = RegOpenKeyEx( HKEY_CURRENT_USER, LOADSTATE_KEY, 0, KEY_READ, &hKey ); FAIL_ON_ERROR( result );
// Determine size needed
dwDataSize = 0; result = RegQueryValueExA( hKey, lpValue, NULL, NULL, NULL, &dwDataSize); FAIL_ON_ERROR( result ); buffer = (char *)malloc((dwDataSize + 1) * sizeof(char)); if (NULL == buffer) { Win32PrintfResource(Console, IDS_NOT_ENOUGH_MEMORY); goto cleanup; } result = RegQueryValueExA( hKey, lpValue, NULL, NULL, (LPBYTE)buffer, &dwDataSize);
cleanup: if ((ERROR_SUCCESS != result) && (NULL != buffer)) { free(buffer); buffer = NULL; } RegCloseKey(hKey);
return buffer;}
#define MAX_VALUE_LENGTH 255
//---------------------------------------------------------------
DWORD OpenInfsFromRegistry(){ HKEY hKey; DWORD dwIndex = 0; char szData[MAX_PATH + 1]; char szValueName[MAX_VALUE_LENGTH]; DWORD dwValueSize; DWORD dwDataSize; DWORD result = ERROR_SUCCESS;
result = RegOpenKeyEx( HKEY_CURRENT_USER, LOADSTATE_KEY, 0, KEY_READ, &hKey ); FAIL_ON_ERROR( result );
do { dwDataSize = MAX_PATH; dwValueSize = MAX_VALUE_LENGTH; result = RegEnumValueA(hKey, dwIndex, szValueName, &dwValueSize, NULL, NULL, (UCHAR *)szData, &dwDataSize);
if (ERROR_NO_MORE_ITEMS != result) { FAIL_ON_ERROR( result );
// If this is an Inf* key, then open the Inf file
if (0 == strncmp(szValueName, "Inf", 3)) { result = OpenInf( szData ); FAIL_ON_ERROR( result ); }
dwIndex++; } } while (ERROR_SUCCESS == result);
cleanup: RegCloseKey(hKey); return result;}
//---------------------------------------------------------------
DWORD ParseParams( int argc, char *argv[], BOOL scan, TCHAR *pszFullLogFilename ){ int i; BOOL cleared_flags = FALSE; DWORD result; char *error; int iarg; BOOL fAppendLog = FALSE; BOOL fLogFile = FALSE; TCHAR *logfile = NULL; TCHAR szArgv[MAX_PATH + 1]; char *lpData;
// Save the OS version.
Win9x = (GetVersion() & 0x80000000);
// Check all the parameters.
for (i = 1; i < argc; i++) { if (argv[i][0] == '/' || argv[i][0] == '-') { switch (tolower(argv[i][1])) { case 'a': OutputAnsi = TRUE; break; case 'f': CopyFiles = TRUE; if (!cleared_flags) { CopyUser = FALSE; CopySystem = FALSE; SchedSystem = FALSE; cleared_flags = TRUE; } break; case 'i': // Verify that there is a file name.
if (i == argc-1) { Win32PrintfResourceA( Console, IDS_INF_REQUIRED ); PrintHelp( scan ); return ERROR_INVALID_PARAMETER; }
// Open the inf file.
i += 1; result = OpenInf( argv[i] ); if (result != ERROR_SUCCESS) return result; break; case 'l': // Verify that there is a file name.
if (i == argc-1) { Win32PrintfResourceA( Console, IDS_LOG_REQUIRED ); PrintHelp( scan ); return ERROR_INVALID_PARAMETER; }
// Fail if the log file was already specified.
if (fLogFile == TRUE) { Win32PrintfResourceA( Console, IDS_LOG_ONCE ); PrintHelp( scan ); return ERROR_INVALID_PARAMETER; }
i += 1;#ifdef _UNICODE
if (0 == MultiByteToWideChar (GetACP(), 0, argv[i], -1, szArgv, MAX_PATH)) { result = GetLastError(); Win32PrintfResourceA( Console, IDS_INVALID_PARAMETER, argv[i] ); return result; } logfile = szArgv;#else
logfile = argv[i];#endif
fLogFile = TRUE; break; case 'm': ReallyCopyFiles = FALSE; break; case 'p': UserPortion = TRUE; fAppendLog = TRUE;
if (!scan) { if (fLogFile == TRUE) { Win32PrintfResourceA( Console, IDS_LOG_ONCE ); PrintHelp( scan ); return ERROR_INVALID_PARAMETER; } lpData = GetValueFromRegistry("Logfile");#ifdef _UNICODE
if (0 == MultiByteToWideChar (GetACP(), 0, lpData, -1, szArgv, MAX_PATH)) { result = GetLastError(); Win32PrintfResourceA( Console, IDS_INVALID_PARAMETER, lpData); return result; } logfile = szArgv;#else
logfile = lpData;#endif
fLogFile = TRUE;
MigrationPath = GetValueFromRegistry("Store"); if (MigrationPath != NULL) { MultiByteToWideChar(CP_ACP, 0, MigrationPath, -1, wcsMigrationPath, MAX_PATH + 1); }
OpenInfsFromRegistry(); } break; case 'q': // TestMode will:
// - skip version checking the OS
// - not create a user hive with /f (still will with /u)
TestMode = TRUE; break; case 'r': // run once
SchedSystem = TRUE; if (!cleared_flags) { CopyFiles = FALSE; CopySystem = FALSE; CopyUser = FALSE; cleared_flags = TRUE; } break; case 's': CopySystem = TRUE; if (!cleared_flags) { CopyFiles = FALSE; CopyUser = FALSE; SchedSystem = FALSE; cleared_flags = TRUE; } break; case 'u': CopyUser = TRUE; if (!cleared_flags) { CopyFiles = FALSE; CopySystem = FALSE; SchedSystem = FALSE; cleared_flags = TRUE; } break; case 'v': // Verify that there is a verbosity argument
i += 1; if ((i == argc) || (1 != sscanf(argv[i], "%d", &iarg))) { Win32PrintfResourceA( Console, IDS_VERBOSE_FLAG_REQUIRED ); PrintHelp( scan ); return ERROR_INVALID_PARAMETER; }
if ( ( iarg & VERBOSE_BIT ) == VERBOSE_BIT ) { Verbose = TRUE; } if ( ( iarg & DEBUGOUTPUT_BIT ) == DEBUGOUTPUT_BIT ) { DebugOutput = TRUE; } if ( ( iarg & VERBOSEREG_BIT ) == VERBOSEREG_BIT ) { VerboseReg = TRUE; } break; case 'x': if (!cleared_flags) { CopyFiles = FALSE; CopySystem = FALSE; CopyUser = FALSE; SchedSystem = FALSE; cleared_flags = TRUE; } break; case '9': Win9x = TRUE; break;
default:
// There should be no other switches defined.
Win32PrintfResourceA( Console, IDS_INVALID_PARAMETER, argv[i] ); PrintHelp( scan ); return ERROR_INVALID_PARAMETER; } } else if (MigrationPath != NULL) { // The path to the server should be specified exactly once.
Win32PrintfResourceA( Console, IDS_INVALID_PARAMETER, argv[i] ); PrintHelp( scan ); return ERROR_INVALID_PARAMETER; } else { // Save the migration path.
MigrationPath = argv[i]; DWORD ccMigPath; if (!(ccMigPath = MultiByteToWideChar(CP_ACP, 0, MigrationPath, -1, wcsMigrationPath, MAX_PATH + 1))) { Win32PrintfResourceA( Console, IDS_INVALID_PARAMETER, MigrationPath ); PrintHelp( scan ); return ERROR_INVALID_PARAMETER; } } }
// Verify that a path was specified.
if (MigrationPath == NULL) { Win32PrintfResourceA( Console, IDS_MISSING_MIGRATION ); PrintHelp( scan ); return ERROR_INVALID_PARAMETER; }
// Open LogFile
if ( fLogFile == FALSE ) { if (scan) logfile = TEXT("scanstate.log"); else logfile = TEXT("loadstate.log"); } if (fAppendLog == FALSE) { // Delete any previous log
DeleteFile( logfile ); } LogFile = CreateFile( logfile, GENERIC_WRITE, 0, NULL, fAppendLog ? OPEN_ALWAYS : CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL ); if (LogFile == INVALID_HANDLE_VALUE) { result = GetLastError(); Win32PrintfResourceA( Console, IDS_OPEN_LOG_ERROR, logfile ); error = NULL; FormatMessageA( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, 0, result, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (char *) &error, 0, NULL ); if (error != NULL) { Win32Printf( Console, error ); LocalFree( error ); } return result; } else if (fAppendLog == TRUE) { // Move file pointer to the end of the file,
// so we won't overwrite previous entries
result = SetFilePointer( LogFile, 0, NULL, FILE_END); if ( result == INVALID_SET_FILE_POINTER ) { result = GetLastError(); Win32PrintfResourceA( Console, IDS_OPEN_LOG_ERROR, logfile ); error = NULL; FormatMessageA( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, 0, result, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (char *) &error, 0, NULL ); if (error != NULL) { Win32Printf( Console, error ); LocalFree( error ); } return result; } }
TCHAR *ptsFileNamePart; result = GetFullPathName( logfile, MAX_PATH, pszFullLogFilename, &ptsFileNamePart); if (0 == result) { return GetLastError(); }
return ERROR_SUCCESS; }
|
