|
|
#include "precomp.h"
#pragma hdrstop
//
// Uncomment the next #define line to get debug trace info about
// Registry keys opened, created or closed.
//
// #define DBG_REG_HANDLES
//
extern HWND hwndFrame;
//
// Updated by DavidHov on 6/1/92:
//
// Centralized error handling;
// Eliminated "title" parameter from APIs; it's
// reserved now, so using it gives "invalid parameter"
//
//
// Updated by DavidHov on 1/6/93
//
// Chnaged FCreateRegKey and FOpenRegKey to always update
// the desired value; a null (empty) string is used if the
// operation has failed.
//
//
// Local Prototypes
//
BOOL FDeleteTree( HKEY KeyHandle );BOOL FSetRegValueSz( HKEY hKey, SZ szValueName, UINT TitleIndex, SZ szValueData );BOOL FSetRegValueExpandSz( HKEY hKey, SZ szValueName, UINT TitleIndex, SZ szValueData );BOOL FSetRegValueMultiSz( HKEY hKey, SZ szValueName, UINT TitleIndex, UINT ValueType, SZ szValueData );BOOL FSetRegValueDword( HKEY hKey, SZ szValueName, UINT TitleIndex, SZ szValueData );BOOL FSetRegValueBin( HKEY hKey, SZ szValueName, UINT TitleIndex, UINT ValueType, SZ szValueData );
PVOID SzToMultiSz( SZ sz, PDWORD cbData );SZ MultiSzToSz( PVOID Data, DWORD cbData );PVOID SzToBin( SZ sz, PDWORD cbData );SZ BinToSz( PVOID Data, DWORD cbData );SZ ValueDataToSz( DWORD ValueType, PVOID ValueData, DWORD cbData );
//
// Central error handling for all Registry processing errors.
//
void FUpdateRegLastError ( LONG Status, SZ szOp, SZ szName ){ char RegLastError[25];
_ltoa( Status, RegLastError, 10 );
FAddSymbolValueToSymTab( REGLASTERROR, RegLastError );
/* Uncomment to display all registry errors and their origin */
#if defined(DBG_REG_HANDLES)
OutputDebugString( "SETUP: Reg Error in " ); OutputDebugString( szOp ); OutputDebugString( " = " ); OutputDebugString( RegLastError ) ; if ( szName ) { OutputDebugString( "; " ); OutputDebugString( szName ) ; } OutputDebugString( "\n" );
#endif
}
// Debugging helper routing for finding lost Registry handles.
void FDebugRegKey ( SZ szHandle, SZ szAction, SZ szName ){
OutputDebugString( "SETUP: REGKEYTRACE: " ); OutputDebugString( szHandle ); OutputDebugString( " : " ); OutputDebugString( szAction ); OutputDebugString( " : " ); if ( szName ) { OutputDebugString( szName ) ; } OutputDebugString( "\n" );}
#if defined(DBG_REG_HANDLES)
#define DEBUGREGKEY(a,b,c) FDebugRegKey(a,b,c)
#else
#define DEBUGREGKEY(a,b,c)
#endif
/*
* FCreateRegKey * * Crates a key in the registry * * Arguments: * */BOOL FCreateRegKey( SZ szHandle, SZ szKeyName, UINT TitleIndex, SZ szClass, SZ Security, UINT Access, UINT Options, SZ szNewHandle, CMO cmo )
{ BOOL fOkay; HKEY hKey; HKEY hSubKey; DWORD Disposition; LONG Status; char LibraryHandleSTR[25]; LPSECURITY_ATTRIBUTES SecurityAttributes;
hKey = (HKEY)LongToHandle(atol( szHandle + 1 ));
//
// If the Security parameter is specified, it must contain the
// string "&<Address>" where <Address> is the decimal numeric
// representation of the memory address of a SECURITY_ATTRIBUTES
// structure.
//
if ( !Security || Security[0] != '\0' ) {
if ( Security[0] != '&' ) { return fFalse; }
SecurityAttributes = (LPSECURITY_ATTRIBUTES)LongToHandle(atol( Security + 1 ));
if ( !SecurityAttributes || !IsValidSecurityDescriptor( SecurityAttributes->lpSecurityDescriptor ) ) { return fFalse; }
} else {
SecurityAttributes = NULL; }
//
// Create the key
//
fOkay = !( Status = RegCreateKeyEx( hKey, szKeyName, 0, szClass, Options, Access, SecurityAttributes, &hSubKey, &Disposition ));
// Prepare an initial null result
LibraryHandleSTR[0] = '\0' ;
if ( !fOkay ) {
FUpdateRegLastError( Status, "CreateRegKey", szKeyName );
} else {
//
// If the key already existed, we error out.
//
if ( Disposition == REG_OPENED_EXISTING_KEY ) {
RegCloseKey( hSubKey ); FUpdateRegLastError( ERROR_CANTOPEN, "CreateRegKey", szKeyName ); fOkay = fFalse;
} else {
//
// Put the handle in the specified variable
//
LibraryHandleSTR[0] = '|';
#if defined(_WIN64)
_ui64toa( (DWORD_PTR)hSubKey, LibraryHandleSTR+1, 20 );#else
_ultoa( (DWORD)hSubKey, LibraryHandleSTR+1, 10 );#endif
DEBUGREGKEY( LibraryHandleSTR+1, "created", szKeyName ) ; } }
// Always add the value to the symbol table, even if null (empty).
while ( !FAddSymbolValueToSymTab( szNewHandle, LibraryHandleSTR ) ) { if ( !FHandleOOM( hwndFrame ) ) { if ( fOkay ) { RegCloseKey( hSubKey ); RegDeleteKey( hKey, szKeyName ); fOkay = fFalse; } break; } }
return (cmo & cmoVital) ? fOkay : fTrue;}
/*
* FOpenRegKey * * Opens a key in the registry * * Arguments: * */BOOL FOpenRegKey( SZ szHandle, SZ szMachineName, SZ szKeyName, UINT Access, SZ szNewHandle, CMO cmo ){ BOOL fOkay = fTrue; HKEY hKey; HKEY hSubKey; LONG Status; char LibraryHandleSTR[25];
hKey = (HKEY)LongToHandle(atol( szHandle + 1 ));
//
// If a remote machine is specified, we connect to the remote
// machine and use the new handle.
//
if ( szMachineName[0] != '\0' ) {
// BUGBUG ramonsa - Until RegConnectRegistry is operational
//
Status = ERROR_INVALID_PARAMETER; fOkay = fFalse;
//
//fOkay = !(Status = RegConnectRegistry( szMachineName,
// hKey,
// &hKey
// );
} else if ( szKeyName[0] == '\0' ) {
//
// If no machine name was given then a subkey name must
// be given!
//
Status = ERROR_INVALID_PARAMETER; fOkay = fFalse; }
// Prepare an initial null result
LibraryHandleSTR[0] = '\0' ;
if ( fOkay ) {
//
// If no subkey is given, we just want a root handle of the
// remote machine. Otherwise we must open the subkey (and
// close the handle if remote).
//
if ( szKeyName[0] == '\0' ) {
//
// The remote handle is what we want.
//
hSubKey = hKey;
} else {
//
// We want a subkey.
//
fOkay = !( Status = RegOpenKeyEx( hKey, szKeyName, 0, Access, &hSubKey ));
//
// If a remote machine is specified, then hkey has
// a remote handle and we must close it.
//
if ( szMachineName[0] != '\0' ) { RegCloseKey( hKey ); } }
if ( fOkay ) {
//
// Put the handle in the specified variable
//
LibraryHandleSTR[0] = '|';
#if defined(_WIN64)
_ui64toa( (DWORD_PTR)hSubKey, LibraryHandleSTR+1, 20 );#else
_ultoa( (DWORD)hSubKey, LibraryHandleSTR+1, 10 );#endif
DEBUGREGKEY( LibraryHandleSTR+1, "opened ", szKeyName ) ; } }
if ( !fOkay ) { FUpdateRegLastError( Status, "OpenRegKey", szKeyName ); }
while ( !FAddSymbolValueToSymTab( szNewHandle, LibraryHandleSTR ) ) { if ( !FHandleOOM( hwndFrame ) ) { if ( fOkay ) { RegCloseKey( hSubKey ); Status = 0; fOkay = fFalse; } break ; } }
return (cmo & cmoVital) ? fOkay : fTrue;}
/*
* FFlushRegKey * * Flushes a key in the registry * * Arguments: * */BOOL FFlushRegKey( SZ szHandle, CMO cmo ){ BOOL fOkay; HKEY hKey;
hKey = (HKEY)LongToHandle(atol( szHandle + 1 ));
fOkay = !RegFlushKey( hKey );
return (cmo & cmoVital) ? fOkay : fTrue;}
/*
* FCloseRegKey * * Close a key in the registry * * Arguments: * */BOOL FCloseRegKey( SZ szHandle, CMO cmo ){ BOOL fOkay; HKEY hKey; LONG Status;
if ( szHandle[0] != '|' ) return fTrue;
hKey = (HKEY)LongToHandle(atol( szHandle + 1 ));
if ( hKey == NULL ) return fTrue ;
DEBUGREGKEY( szHandle+1, "closed ", NULL ) ;
fOkay = !( Status = RegCloseKey( hKey ) );
if ( !fOkay ) { FUpdateRegLastError( Status, "CloseRegKey", NULL ); }
return (cmo & cmoVital) ? fOkay : fTrue;}
/*
* FDeleteRegKey * * Deletes a key from the registry * * Arguments: * */BOOL FDeleteRegKey( SZ szHandle, SZ szKeyName, CMO cmo ){ BOOL fOkay; HKEY hKey; LONG Status;
hKey = (HKEY)LongToHandle(atol( szHandle + 1 ));
fOkay = !( Status = RegDeleteKey( hKey, szKeyName ) );
if ( !fOkay ) {
FUpdateRegLastError( Status, "DeleteRegKey", NULL ); }
return (cmo & cmoVital) ? fOkay : fTrue;}
/*
* FDeleteRegTree * * Deletes a key and all its descentants from the registry * * Arguments: * */BOOL FDeleteRegTree( SZ szHandle, SZ szKeyName, CMO cmo ){ BOOL fOkay; HKEY hKey; HKEY hSubKey; LONG Status;
hKey = (HKEY)LongToHandle(atol( szHandle + 1 ));
//
// Open the key
//
fOkay = !( Status = RegOpenKeyEx( hKey, szKeyName, 0, KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS, &hSubKey ) ); if ( !fOkay ) {
FUpdateRegLastError( Status, "DeleteRegTree", szKeyName );
} else {
fOkay = FDeleteTree( hSubKey ); }
//
// Now delete the key
//
if ( fOkay ) {
fOkay = !( Status = RegCloseKey( hSubKey ) );
if ( !fOkay ) {
FUpdateRegLastError( Status, "DeleteRegTree", szKeyName );
} else {
fOkay = !RegDeleteKey( hKey, szKeyName ); } }
return (cmo & cmoVital) ? fOkay : fTrue;}
/*
* FDeleteTree * * Recursively deletes all the descendants of a key * * Arguments: * */BOOL FDeleteTree( HKEY KeyHandle ){ BOOL fOkay; DWORD Index; HKEY ChildHandle; CHAR KeyName[ cchlFullPathMax ]; DWORD KeyNameLength; CHAR ClassName[ cchlFullPathMax ]; DWORD ClassNameLength; DWORD TitleIndex = 0 ; DWORD NumberOfSubKeys; DWORD MaxSubKeyLength; DWORD MaxClassLength; DWORD NumberOfValues; DWORD MaxValueNameLength; DWORD MaxValueDataLength; DWORD SizeSecurityDescriptor; FILETIME LastWriteTime; LONG Status;
ClassNameLength = cchlFullPathMax;
if ( Status = RegQueryInfoKey( KeyHandle, ClassName, &ClassNameLength, NULL, &NumberOfSubKeys, &MaxSubKeyLength, &MaxClassLength, &NumberOfValues, &MaxValueNameLength, &MaxValueDataLength, &SizeSecurityDescriptor, &LastWriteTime ) ) {
FUpdateRegLastError( Status, "DeleteTree", NULL ); return fFalse; }
for ( Index = 0; Index < NumberOfSubKeys; Index++ ) {
KeyNameLength = cchlFullPathMax;
if ( Status = RegEnumKey( KeyHandle, 0, KeyName, KeyNameLength ) ) {
FUpdateRegLastError( Status, "DeleteTree", NULL ); return fFalse; }
#ifdef BUGBUG
// BUGBUG This should work when MAXIMUM_ALLOWED access works.
if ( Status = RegOpenKey( KeyHandle, KeyName, &ChildHandle ) ) {
FUpdateRegLastError( Status, "DeleteTree", NULL ); return fFalse; }#else
if ( Status = RegOpenKeyEx( KeyHandle, KeyName, 0, KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS, &ChildHandle ) ) {
FUpdateRegLastError( Status, "DeleteTree", NULL ); return fFalse; }
#endif // ROBERTRE
fOkay = FDeleteTree( ChildHandle );
//
// Whether DeleteTree of the ChildHandle succeeded or not, we'll
// try to close it.
//
RegCloseKey( ChildHandle );
if ( fOkay ) { if ( fOkay = !(Status = RegDeleteKey( KeyHandle, KeyName ) )) { FUpdateRegLastError( Status, "DeleteTree", NULL ); } }
if ( !fOkay ) { return fFalse; } }
return fTrue;}
/*
* FEnumRegKey * * Obtains subkey enumeration * * Arguments: * */BOOL FEnumRegKey( SZ szHandle, SZ szInfVar, CMO cmo ){ BOOL fOkay = fTrue; HKEY hKey; CHAR KeyName[ cbFullPathMax ]; CHAR Class[ cbFullPathMax ]; DWORD cbKeyName; DWORD cbClass; DWORD TitleIndex = 0 ; FILETIME FileTime; RGSZ rgszEnum; UINT EnumSize; RGSZ rgszKey; SZ szInfo; char szTitle[25]; UINT Index; LONG Status; DWORD NumberOfSubKeys; DWORD MaxSubKeyLength; DWORD MaxClassLength; DWORD NumberOfValues; DWORD MaxValueNameLength; DWORD MaxValueDataLength; DWORD SizeSecurityDescriptor; FILETIME LastWriteTime;
hKey = (HKEY)LongToHandle(atol( szHandle + 1 ));
while ( (rgszEnum = (RGSZ)SAlloc( (CB)( 1 * sizeof(SZ)))) == NULL ) { if ( !FHandleOOM( hwndFrame ) ) { fOkay = fFalse; break; } }
if ( fOkay ) {
rgszEnum[0] = NULL; EnumSize = 0; cbClass = cbFullPathMax;
if ( Status = RegQueryInfoKey( hKey, Class, &cbClass, NULL, &NumberOfSubKeys, &MaxSubKeyLength, &MaxClassLength, &NumberOfValues, &MaxValueNameLength, &MaxValueDataLength, &SizeSecurityDescriptor, &LastWriteTime ) ) {
FUpdateRegLastError( Status, "EnumRegKey", NULL ); return fFalse; }
for ( Index = 0 ; Index < NumberOfSubKeys; Index++ ) {
cbKeyName = cbFullPathMax; cbClass = cbFullPathMax;
if ( Status = RegEnumKeyEx( hKey, Index, KeyName, &cbKeyName, NULL, (LPSTR)&Class, &cbClass, &FileTime ) ) {
FUpdateRegLastError( Status, "EnumRegKey", NULL ); break; }
//
// Get a list in which to put the key information.
//
while ( (rgszKey = (RGSZ)SAlloc( (CB)( 4 * sizeof(SZ)))) == NULL ) { if ( !FHandleOOM( hwndFrame ) ) { fOkay = fFalse; break; } }
if ( fOkay ) {
//
// Put the information in the list
//
_ultoa( TitleIndex, szTitle, 10 );
rgszKey[0] = KeyName; rgszKey[1] = szTitle; rgszKey[2] = Class; rgszKey[3] = NULL;
//
// Transform the list into a string so that it can be added to the
// symbol table.
//
while ( (szInfo = SzListValueFromRgsz( rgszKey )) == (SZ)NULL ) { if ( !FHandleOOM( hwndFrame ) ) { fOkay = fFalse; break; } }
if ( fOkay ) {
while ( (rgszEnum = (RGSZ)SRealloc( rgszEnum, (CB)( (EnumSize+2) * sizeof(SZ))) ) == NULL ) {
if ( !FHandleOOM( hwndFrame ) ) { fOkay = fFalse; break; } }
if ( fOkay ) { rgszEnum[EnumSize] = szInfo; EnumSize++; rgszEnum[EnumSize] = NULL; } }
SFree(rgszKey); } }
//
// Convert to SZ
//
while ( (szInfo = SzListValueFromRgsz( rgszEnum )) == (SZ)NULL ) { if ( !FHandleOOM( hwndFrame ) ) { fOkay = fFalse; break; } }
if ( fOkay ) { //
// Add it to the symbol table.
//
while ( !FAddSymbolValueToSymTab( szInfVar, szInfo ) ) {
if ( !FHandleOOM( hwndFrame ) ) {
fOkay = fFalse; break; } }
SFree(szInfo); }
FFreeRgsz( rgszEnum ); }
return (cmo & cmoVital) ? fOkay : fTrue;}
/*
* FSetRegValue * * Sets a value under the given key * * Arguments: * */BOOL FSetRegValue( SZ szHandle, SZ szValueName, UINT TitleIndex, UINT ValueType, SZ szValueData, CMO cmo ){ BOOL fOkay; HKEY hKey;
hKey = (HKEY)LongToHandle(atol( szHandle + 1 ));
switch ( ValueType ) {
case REG_MULTI_SZ: fOkay = FSetRegValueMultiSz( hKey, szValueName, TitleIndex, REG_MULTI_SZ, szValueData ); break;
case REG_SZ: fOkay = FSetRegValueSz( hKey, szValueName, TitleIndex, szValueData ); break;
case REG_EXPAND_SZ: fOkay = FSetRegValueExpandSz( hKey, szValueName, TitleIndex, szValueData ); break;
case REG_DWORD: fOkay = FSetRegValueDword( hKey, szValueName, TitleIndex, szValueData ); break;
case REG_BINARY: fOkay = FSetRegValueBin( hKey, szValueName, TitleIndex, REG_BINARY, szValueData ); break;
case REG_RESOURCE_LIST: fOkay = FSetRegValueBin( hKey, szValueName, TitleIndex, REG_RESOURCE_LIST, szValueData ); break;
case REG_FULL_RESOURCE_DESCRIPTOR: fOkay = FSetRegValueBin( hKey, szValueName, TitleIndex, REG_FULL_RESOURCE_DESCRIPTOR, szValueData ); break;
case REG_RESOURCE_REQUIREMENTS_LIST: fOkay = FSetRegValueBin( hKey, szValueName, TitleIndex, REG_RESOURCE_REQUIREMENTS_LIST, szValueData ); break;
default: fOkay = FSetRegValueBin( hKey, szValueName, TitleIndex, ValueType, szValueData ); break;
}
return (cmo & cmoVital) ? fOkay : fTrue;}
/*
* FGetRegValue * * Gets the specified value under the given key * * Arguments: * */BOOL FGetRegValue( SZ szHandle, SZ szValueName, SZ szInfVar, CMO cmo ){ BOOL fOkay; HKEY hKey; DWORD cbData; DWORD TitleIndex = 0 ; DWORD ValueType; PVOID ValueData; SZ szValueData; RGSZ rgszValue; SZ szInfo; LONG Status; char szTitle[25]; char szValueType[25];
char szKClass[ MAX_PATH ]; DWORD cbKClass; DWORD KTitleIndex = 0 ; DWORD KSubKeys; DWORD cbKMaxSubKeyLen; DWORD cbKMaxClassLen; DWORD KValues; DWORD cbKMaxValueNameLen; DWORD SizeSecurityDescriptor; FILETIME KLastWriteTime;
hKey = (HKEY)LongToHandle(atol( szHandle + 1 ));
//
// Get the size of the buffer needed
//
cbKClass = MAX_PATH; fOkay = !( Status = RegQueryInfoKey ( hKey, szKClass, &cbKClass, NULL, &KSubKeys, &cbKMaxSubKeyLen, &cbKMaxClassLen, &KValues, &cbKMaxValueNameLen, &cbData, &SizeSecurityDescriptor, &KLastWriteTime ) );
//cbData = 0;
//fOkay = !RegQueryValueEx( hKey,
// szValueName,
// NULL,
// NULL,
// NULL,
// &cbData );
if ( !fOkay ) {
FUpdateRegLastError( Status, "GetRegValue", szValueName );
} else {
//
// Allocate the buffer and get the data
//
while ( (ValueData = (PVOID)SAlloc( (CB)( cbData ))) == NULL ) { if ( !FHandleOOM( hwndFrame ) ) { fOkay = fFalse; break; } }
if ( fOkay ) {
fOkay = !( Status = RegQueryValueEx( hKey, szValueName, NULL, &ValueType, ValueData, &cbData ) ); if ( !fOkay ) {
FUpdateRegLastError( Status, "GetRegValue", szValueName );
} else {
//
// Get a list in which to put the key information.
//
while ( (rgszValue = (RGSZ)SAlloc( (CB)( 5 * sizeof(SZ)))) == NULL ) { if ( !FHandleOOM( hwndFrame ) ) { fOkay = fFalse; break; } }
if ( fOkay ) {
//
// Put the information in the list
//
if ( (fOkay = (szValueData = ValueDataToSz( ValueType, ValueData, cbData)) != NULL) ) {
_ultoa( TitleIndex, szTitle, 10 ); _ultoa( ValueType, szValueType, 10 );
rgszValue[0] = szValueName; rgszValue[1] = szTitle; rgszValue[2] = szValueType; rgszValue[3] = szValueData; rgszValue[4] = NULL;
//
// Transform the list into a string so that it can be added to the
// symbol table.
//
while ( (szInfo = SzListValueFromRgsz( rgszValue )) == (SZ)NULL ) { if ( !FHandleOOM( hwndFrame ) ) { fOkay = fFalse; break; } }
if ( fOkay ) {
//
// Add it to the symbol table.
//
while ( !FAddSymbolValueToSymTab( szInfVar, szInfo ) ) { if ( !FHandleOOM( hwndFrame ) ) { fOkay = fFalse; break; } }
SFree(szInfo); }
SFree( szValueData ); }
SFree( rgszValue ); } }
SFree( ValueData ); } }
return (cmo & cmoVital) ? fOkay : fTrue;}
/*
* FDeleteRegValue * * Deletes a value under the given key * * Arguments: * */BOOL FDeleteRegValue( SZ szHandle, SZ szValueName, CMO cmo ){ BOOL fOkay; HKEY hKey; LONG Status;
hKey = (HKEY)LongToHandle(atol( szHandle + 1 ));
fOkay = !( Status = RegDeleteValue( hKey, szValueName ) );
if ( !fOkay ) {
FUpdateRegLastError( Status, "DeleteRegValue", szValueName ); }
return (cmo & cmoVital) ? fOkay : fTrue;
}
/*
* FEnumRegValue * * Obtains information for a value with a certain index. * * Arguments: * */BOOL FEnumRegValue( SZ szHandle, SZ szInfVar, CMO cmo ){ BOOL fOkay; HKEY hKey; DWORD cbData; DWORD cbName; DWORD TitleIndex = 0 ; DWORD ValueType; PVOID ValueData; SZ szValueData; DWORD cbValueData; RGSZ rgszValue; RGSZ rgszEnum; UINT EnumSize; SZ szInfo; SZ szValueName; DWORD cbValueName; UINT Index; LONG Status; char szTitle[25]; char szValueType[25];
char szKClass[ cchlFullPathMax ]; DWORD cbKClass; DWORD KTitleIndex = 0 ; DWORD KSubKeys; DWORD cbKMaxSubKeyLen; DWORD cbKMaxClassLen; DWORD SizeSecurityDescriptor; DWORD KValues; FILETIME KLastWriteTime;
hKey = (HKEY)LongToHandle(atol( szHandle + 1 ));
//
// Get the size of the buffer needed
//
cbKClass = MAX_PATH; fOkay = !( Status = RegQueryInfoKey ( hKey, szKClass, &cbKClass, NULL, &KSubKeys, &cbKMaxSubKeyLen, &cbKMaxClassLen, &KValues, &cbName, &cbData, &SizeSecurityDescriptor, &KLastWriteTime ) );
if ( !fOkay ) {
FUpdateRegLastError( Status, "EnumRegValue", NULL );
} else {
//
// Allocate the buffer to get the data.
//
while ( (ValueData = (PVOID)SAlloc( (CB)( cbData ))) == NULL ) { if ( !FHandleOOM( hwndFrame ) ) { fOkay = fFalse; break; } } if ( fOkay ) {
//
// Allocate a buffer to get the name. Allow for the string terminator.
//
while ( (szValueName = (SZ)SAlloc( (CB)( ( ++cbName ) * sizeof( TCHAR ) ))) == NULL ) { if ( !FHandleOOM( hwndFrame ) ) { fOkay = fFalse; break; } }
if ( fOkay ) {
//
// Allocate empty enum list.
//
while ( (rgszEnum = (RGSZ)SAlloc( (CB)( 1 * sizeof(SZ)))) == NULL ) { if ( !FHandleOOM( hwndFrame ) ) { fOkay = fFalse; break; } }
if ( fOkay ) {
rgszEnum[0] = NULL; EnumSize = 0;
for ( Index = 0 ; ; Index++ ) {
cbValueName = cbName; cbValueData = cbData;
if ( Status = RegEnumValue( hKey, Index, szValueName, &cbValueName, NULL, &ValueType, ValueData, &cbValueData ) ) {
FUpdateRegLastError( Status, "EnumRegValue", NULL ); break; }
//
// Get a list in which to put the key information.
//
while ( (rgszValue = (RGSZ)SAlloc( (CB)( 5 * sizeof(SZ)))) == NULL ) { if ( !FHandleOOM( hwndFrame ) ) { fOkay = fFalse; break; } }
if ( fOkay ) {
//
// Put the information in the list
//
if ( (fOkay = (szValueData = ValueDataToSz( ValueType, ValueData, cbValueData)) != NULL) ) {
_ultoa( TitleIndex, szTitle, 10 ); _ultoa( ValueType, szValueType, 10 );
rgszValue[0] = szValueName; rgszValue[1] = szTitle; rgszValue[2] = szValueType; rgszValue[3] = szValueData; rgszValue[4] = NULL;
//
// Transform the list into a string so that it can be added to the
// symbol table.
//
while ( (szInfo = SzListValueFromRgsz( rgszValue )) == (SZ)NULL ) { if ( !FHandleOOM( hwndFrame ) ) { fOkay = fFalse; break; } }
if ( fOkay ) {
while ( (rgszEnum = (RGSZ)SRealloc( rgszEnum, (CB)( (EnumSize+2) * sizeof(SZ))) ) == NULL ) {
if ( !FHandleOOM( hwndFrame ) ) { fOkay = fFalse; break; } }
if ( fOkay ) { rgszEnum[EnumSize] = szInfo; EnumSize++; rgszEnum[EnumSize] = NULL; } }
SFree( szValueData ); }
SFree( rgszValue ); }
}
//
// Convert to SZ
//
while ( (szInfo = SzListValueFromRgsz( rgszEnum )) == (SZ)NULL ) { if ( !FHandleOOM( hwndFrame ) ) { fOkay = fFalse; break; } }
if ( fOkay ) { //
// Add it to the symbol table.
//
while ( !FAddSymbolValueToSymTab( szInfVar, szInfo ) ) {
if ( !FHandleOOM( hwndFrame ) ) {
fOkay = fFalse; break; } }
SFree( szInfo ); }
FFreeRgsz( rgszEnum ); }
SFree( szValueName ); }
SFree( ValueData ); } }
return (cmo & cmoVital) ? fOkay : fTrue;}
/*
* FSetRegValueSz * * Sets a value under the given key for SZ type * * Arguments: * */BOOL FSetRegValueSz( HKEY hKey, SZ szValueName, UINT TitleIndex, SZ szValueData ){
LONG Status;
Status = RegSetValueEx( hKey, szValueName, 0, REG_SZ, szValueData, lstrlen( szValueData ) + 1 );
if ( Status ) {
FUpdateRegLastError( Status,"SetRegValueSz", szValueName ); }
return !Status;}
/*
* FSetRegValueExpandSz * * Sets a value under the given key for expand SZ type * * Arguments: * */BOOLFSetRegValueExpandSz( HKEY hKey, SZ szValueName, UINT TitleIndex, SZ szValueData ){
LONG Status;
Status = RegSetValueEx( hKey, szValueName, 0, REG_EXPAND_SZ, szValueData, lstrlen( szValueData ) + 1 );
if ( Status ) {
FUpdateRegLastError( Status,"SetRegValueExpandSz", szValueName ); }
return !Status;}
/*
* FSetRegValueMultiSz * * Sets a value under the given key for REG_MULTI_SZ type * * Arguments: * */BOOLFSetRegValueMultiSz( HKEY hKey, SZ szValueName, UINT TitleIndex, UINT ValueType, SZ szValueData ){ BOOL fOkay = fFalse; PVOID Data; DWORD cbData; LONG Status;
Data = SzToMultiSz( szValueData, &cbData );
fOkay = !( Status = RegSetValueEx( hKey, szValueName, 0, ValueType, Data, cbData ) );
if ( !fOkay ) {
FUpdateRegLastError( Status,"SetRegValueMultiSz", szValueName ); }
if ( Data ) { SFree( Data ); }
return fOkay;}
/*
* FSetRegValueDword * * Sets a value under the given key for DWORD type * * Arguments: * */BOOL FSetRegValueDword( HKEY hKey, SZ szValueName, UINT TitleIndex, SZ szValueData ){
DWORD Data; LONG Status;
Data = (DWORD)atol(szValueData );
Status = RegSetValueEx( hKey, szValueName, 0, REG_DWORD, (LPBYTE)&Data, sizeof( DWORD ) ); if ( Status ) {
FUpdateRegLastError( Status,"SetRegValueDword", szValueName ); }
return !Status;}
/*
* FSetRegValueBin * * Sets a value under the given key for BINARY and unknown types * * Arguments: * */BOOL FSetRegValueBin( HKEY hKey, SZ szValueName, UINT TitleIndex, UINT ValueType, SZ szValueData ){ BOOL fOkay = fFalse; PVOID Data; DWORD cbData; LONG Status;
Data = SzToBin( szValueData, &cbData );
fOkay = !( Status = RegSetValueEx( hKey, szValueName, 0, ValueType, Data, cbData ) );
if ( !fOkay ) { switch( ValueType ) { case REG_BINARY: FUpdateRegLastError( Status,"SetRegValueBin", szValueName ); break;
case REG_RESOURCE_LIST: FUpdateRegLastError( Status,"SetRegValueResourceList", szValueName ); break;
case REG_FULL_RESOURCE_DESCRIPTOR: FUpdateRegLastError( Status,"SetRegValueFullResourceDescriptor", szValueName ); break;
case REG_RESOURCE_REQUIREMENTS_LIST: FUpdateRegLastError( Status,"SetRegValueResourceRequirementsList", szValueName ); break;
default: FUpdateRegLastError( Status,"SetRegValueUnknownType", szValueName ); break; } }
if ( Data ) { SFree( Data ); }
return fOkay;}
/*
* SzToMultiSz * * Converts a list of sz strings to a single multi sz string * * Arguments: * */PVOID SzToMultiSz( SZ sz, PDWORD cbData ){ RGSZ rgsz; SZ p = NULL, q; int i, j;
*cbData = 0;
if ( FListValue( sz )) {
if ( rgsz = RgszFromSzListValue( sz )) {
//
// Get size of required buffer
//
for (i = 0, j = 0; rgsz[i] != NULL; i++ ) { j = j + strlen( rgsz[i] ) + 1; } j = j + 1; // for the last null
//
// Allocate buffer
//
while ( (p = q = (SZ)SAlloc( (CB)( j * sizeof( CHAR )))) == NULL ) { if ( !FHandleOOM( hwndFrame ) ) { break; } }
if ( p ) {
for ( i=0; rgsz[i] != NULL; i++ ) { lstrcpy( q, rgsz[ i ] ); q = q + lstrlen( rgsz[ i ] ) + 1; } *q = '\0'; *cbData = j * sizeof( CHAR ); }
FFreeRgsz( rgsz ); } }
return (PVOID)p;}
/*
* MultiSzToSz * * Converts a block of memory to a list containing hex digits * * Arguments: * */
SZ MultiSzToSz( PVOID Data, DWORD cbData ){ RGSZ rgsz; SZ sz = NULL, szData, szEnd; DWORD i, cbList = 0;
//
// Count the number of list elements in the multi sz list. We do this
// by counting the number of '0's in the string and subtracting 1 from
// this
//
szData = (SZ)( Data ); szEnd = (SZ)( (PBYTE)Data + cbData ); while( szData < szEnd ) { if (*szData++ == '\0') { cbList++; } }
if( cbList > 0 ) {
cbList--; // remove the terminating null
//
// Allocate a rgsz list with cbList elements;
//
while ( (rgsz = (RGSZ)SAlloc( (CB)( (cbList + 1) * sizeof(SZ)))) == NULL ) { if ( !FHandleOOM( hwndFrame ) ) { break; } }
if( rgsz ) { //
// Go through the szList and fill the rgsz structure
//
szData = (SZ)( Data );
for ( i = 0; i < cbList; i++ ) { rgsz[i] = SzDupl( szData ); szData = szData + lstrlen( szData ) + 1; } rgsz[cbList] = NULL;
//
// Transform the list into a string.
//
while ( (sz = SzListValueFromRgsz( rgsz )) == (SZ)NULL ) { if ( !FHandleOOM( hwndFrame ) ) { break; } }
EvalAssert( FFreeRgsz( rgsz ) ); } }
return( sz );
}
/*
* SzToBin * * Converts a list of hex digits to binary * * Arguments: * */PVOID SzToBin( SZ sz, PDWORD cbData ){ RGSZ rgsz; PBYTE p, q = NULL; int i;
*cbData = 0;
if ( FListValue( sz )) {
if ( rgsz = RgszFromSzListValue( sz )) {
//
// Get size of required buffer
//
for (i=0; rgsz[i] != NULL; i++ );
//
// Allocate buffer
//
while ( (p = q = (PBYTE)SAlloc( (CB)( i ))) == NULL ) { if ( !FHandleOOM( hwndFrame ) ) { break; } }
if ( p ) {
for ( i=0; rgsz[i] != NULL; i++ ) { *p++ = (BYTE)atoi( rgsz[i] ); }
*cbData = i; }
FFreeRgsz( rgsz ); } }
return q;}
/*
* BinToSz * * Converts a block of memory to a list containing hex digits * * Arguments: * */SZ BinToSz( PVOID Data, DWORD cbData ){ RGSZ rgsz; SZ sz = NULL; SZ szElement; DWORD i; PBYTE pbData;
//
// The list will contain cbData elements
//
while ( (rgsz = (RGSZ)SAlloc( (CB)( (cbData+1) * sizeof(SZ)))) == NULL ) { if ( !FHandleOOM( hwndFrame ) ) { break; } }
if ( rgsz ) {
//
// For each element of the list, allocate a buffer and convert it
// to a string
//
pbData = (PBYTE)Data;
for (i=0; i<cbData; i++ ) {
while ( (szElement = (SZ)SAlloc( (CB)( 25 ))) == NULL ) { if ( !FHandleOOM( hwndFrame ) ) { break; } }
if ( szElement ) { _ultoa( *(pbData + i), szElement, 10 ); rgsz[i] = szElement;
} else { rgsz[i] = NULL; break; } }
if ( i == cbData ) {
rgsz[i] = NULL;
//
// Transform the list into a string.
//
while ( (sz = SzListValueFromRgsz( rgsz )) == (SZ)NULL ) { if ( !FHandleOOM( hwndFrame ) ) { break; } } }
FFreeRgsz( rgsz ); }
return sz;}
/*
* ValueDataToSz * * Converts a value data to its string form * * Arguments: * */SZ ValueDataToSz( DWORD ValueType, PVOID ValueData, DWORD cbData ){ SZ sz = NULL;
switch ( ValueType ) {
case REG_SZ: sz = SzDupl((SZ)ValueData); break;
case REG_EXPAND_SZ: sz = SzDupl((SZ)ValueData); break;
case REG_DWORD: while ( (sz = (SZ)SAlloc( (CB)( 25 ))) == NULL ) { if ( !FHandleOOM( hwndFrame ) ) { break; } }
if ( sz ) { _ultoa( *(PDWORD)ValueData, sz, 10 ); } break;
case REG_MULTI_SZ: sz = MultiSzToSz( ValueData, cbData ); break;
case REG_BINARY: default: sz = BinToSz( ValueData, cbData ); break; }
return sz;}
RGSZMultiSzToRgsz( IN PVOID MultiSz ){ PCHAR p; ULONG Count; RGSZ rgsz;
//
// First count the number of strings in the the multisz.
//
Count = 0; p = MultiSz;
while(*p) { Count++; p = strchr(p,'\0') + 1; }
//
// Allocate the rgsz.
//
rgsz = (RGSZ)SAlloc((Count + 1) * sizeof(PCHAR));
if(rgsz == NULL) { return(NULL); }
memset(rgsz,0,(Count + 1) * sizeof(PCHAR));
//
// Now place the strings in the rgsz.
//
p = MultiSz; Count = 0;
while(*p) {
if(rgsz[Count++] = SzDupl((SZ)p)) {
p = strchr(p,'\0') + 1;
} else {
FFreeRgsz(rgsz); return(NULL); } }
return(rgsz);}
PCHARRgszToMultiSz( IN RGSZ rgsz ){ ULONG Size; ULONG Str; PCHAR MultiSz;
//
// First determine the size of the block to hold the multisz.
//
Size = 0; Str = 0;
while(rgsz[Str]) {
Size += strlen(rgsz[Str++]) + 1; }
Size++; // for extra NUL to terminate the multisz.
MultiSz = SAlloc(Size);
if(MultiSz == NULL) { return(NULL); }
Str = 0; Size = 0;
while(rgsz[Str]) {
lstrcpy(MultiSz + Size, rgsz[Str]);
Size += lstrlen(rgsz[Str++]) + 1; }
MultiSz[Size] = 0;
return(MultiSz);}
|
