BOOL SFRegistry::OpenRegistryKey(const TCHAR* szSubKey)
{
CloseRegistryKey();
if (RegOpenKey(m_hRootKey, szSubKey, &m_hRegKey) != ERROR_SUCCESS)
return FALSE;
return TRUE;
}
BOOL SFRegistry::DeleteKey(const TCHAR* szSubKey )
{
CloseRegistryKey();
if( ERROR_SUCCESS != RegDeleteKey( m_hRootKey, szSubKey ))
{
return false;
}
return true;
}
SFRegistry::~SFRegistry()
{
CloseRegistryKey();
}
BOOL
MemoryProc(
)
/*++
Routine Description:
MemoryDlgProc supports the display of the memory dialog which displays
information about total memory, available memory and paging file location.
Arguments:
Standard PROC entry.
Return Value:
BOOL - Depending on input message and processing options.
--*/
{
BOOL Success;
static
int PercentUtilization;
MEMORYSTATUS MemoryStatus;
HREGKEY hRegKey;
LPTSTR PagingFile;
TCHAR Buffer[ MAX_PATH ];
//
// Query the memory status from the system.
//
MemoryStatus.dwLength = sizeof( MemoryStatus );
GlobalMemoryStatus( &MemoryStatus );
//
// Remember the memory utilization.
//
PercentUtilization = MemoryStatus.dwMemoryLoad;
//
// Display the total and available physical memory and paging file
// space in KB and in bytes.
//
PrintToFile((LPCTSTR)FormatBigInteger(MemoryStatus.dwTotalPhys,FALSE),IDC_EDIT_TOTAL_PHYSICAL_MEMORY,TRUE);
PrintToFile((LPCTSTR)FormatBigInteger(MemoryStatus.dwAvailPhys,FALSE),IDC_EDIT_AVAILABLE_PHYSICAL_MEMORY,TRUE);
PrintToFile((LPCTSTR)FormatBigInteger(MemoryStatus.dwTotalPageFile,FALSE),IDC_EDIT_TOTAL_PAGING_FILE_SPACE,TRUE);
PrintToFile((LPCTSTR)FormatBigInteger(MemoryStatus.dwAvailPageFile,FALSE),IDC_EDIT_AVAILABLE_PAGING_FILE_SPACE,TRUE);
/*WFormatMessage(
Buffer,
sizeof( Buffer ),
IDS_FORMAT_MEMORY_IN_USE,
PercentUtilization
);*/
PrintDwordToFile(PercentUtilization,IDC_FORMAT_MEMORY_IN_USE);
//
// Open the registry key that contains the location of the paging
// files.
//
hRegKey = OpenRegistryKey( &MemKey );
DbgHandleAssert( hRegKey );
if( hRegKey == NULL ) {
return TRUE;
}
//
// Retrieve the location of the paging files.
//
Success = QueryNextValue( hRegKey );
DbgAssert( Success );
if( Success == FALSE ) {
Success = CloseRegistryKey( hRegKey );
DbgAssert( Success );
return TRUE;
}
//
// PagingFile points to a series of NUL terminated string terminated
// by an additional NUL (i.e. a MULTI_SZ string). THerefore walk
// this list of strings adding each to the list box.
//
PagingFile = ( LPTSTR ) hRegKey->Data;
while(( PagingFile != NULL ) && ( PagingFile[ 0 ] != TEXT( '\0' ))) {
PrintToFile((LPCTSTR)PagingFile,IDC_LIST_PAGING_FILES,TRUE);
PagingFile += _tcslen( PagingFile ) + 1;
}
//
// Close the registry key.
//
Success = CloseRegistryKey( hRegKey );
DbgAssert( Success );
return TRUE;
}
LPENV_VAR
FindNextRegistryEnvironmentVariableW(
)
/*++
Routine Description:
FindNextRegistryEnvironmentVariable continues an enumeration that has been
initialized by a previous call to FindFirstRegistryEnvironmentVariable. For
each environment variable that it finds it converts it to two simple
strings, the variable and the value.
Arguments:
None.
Return Value:
LPENV_VAR - Returns a pointer to a static ENV_VAR object containing the next
environment variable in the list, NULL if there are none.
--*/
{
BOOL Success;
DWORD Length;
static
WCHAR Buffer[ MAX_PATH ];
static
ENV_VAR EnvVar;
//
// If there is another environment variable...
//
if( QueryNextValue( hRegEnvironKey )) {
//
// Remember the environment variable's name.
//
EnvVar.Variable = hRegEnvironKey->ValueName;
switch( hRegEnvironKey->Type ) {
case REG_SZ:
//
// Remember the environment variable's value.
//
EnvVar.Value = ( LPWSTR ) hRegEnvironKey->Data;
break;
case REG_EXPAND_SZ:
//
// Replace the variable portion of the environment variable by
// expanding into the static buffer.
//
EnvVar.Value = Buffer;
Length = ExpandEnvironmentStrings(
( LPTSTR ) hRegEnvironKey->Data,
Buffer,
sizeof( Buffer )
);
DbgAssert( Length <= sizeof( Buffer ));
break;
default:
DbgAssert( FALSE );
}
//
// Return the curent environment variable.
//
return &EnvVar;
} else {
//
// There are no more environment variables so close the key and
// return NULL.
//
Success = CloseRegistryKey( hRegEnvironKey );
DbgAssert( Success );
return NULL;
}
DbgAssert( FALSE );
}
LPSYSTEM_RESOURCES
CreateSystemResourceLists(
)
/*++
Routine Description:
CreateSystemResourceLists opens the appropriate Registry key where the
device/driver resource lists begin and builds lists of these which can then
be displayed in a variety of ways (i.e. by resource or device/driver).
Arguments:
None.
Return Value:
LPSYSTEM_RESOURCES - Retunrs a pointer to a RESOURCE_LIST
--*/
{
BOOL Success;
BOOL RegSuccess;
KEY ResourceMapKey;
HREGKEY hRegKey;
//
// Set all of the list pointers to NULL.
//
ZeroMemory( &_SystemResourceLists, sizeof( _SystemResourceLists ));
//
// Make a local copy of the Registry key that points at the device/driver
// resource list.
//
CopyMemory( &ResourceMapKey, &_ResourceMapKey, sizeof( ResourceMapKey ));
//
// Open the Registry key which contains the root of the device/driver
// resource list.
//
hRegKey = OpenRegistryKey( &ResourceMapKey );
DbgHandleAssert( hRegKey );
if( hRegKey == NULL ) {
return NULL;
}
//
// Build the lists of device/driver and resources used by
// these device/driver
//
Success = InitializeSystemResourceLists( hRegKey );
DbgAssert( Success );
//
// Close the Registry key.
//
RegSuccess = CloseRegistryKey( hRegKey );
DbgAssert( RegSuccess );
//
// Return a pointer to the resource lists or NULL if an error occurred.
//
return ( Success ) ? _SystemResourceLists : NULL;
}
BOOL InitializeSystemResourceLists(
IN HREGKEY hRegKey
)
/*++
Routine Description:
InitializeSystemResourceLists recursively walks the resource map in the
registry and builds the SYSTEM_RESOURCE lists. This is a data structure
that links all resources of the same type together, as well as linking all
resources belonging to a specific device/driver together. Lastly each
resource is independently linked to the device/driver that owns it. This
leds to a 'mesh' of linked lists with back pointers to the owning
device/driver object.
Arguments:
hRegKey - Supplies a handle to a REGKEY object where the search is to
continue.
Return Value:
BOOL - returns TRUE if the resource lists are succesfully built.
--*/
{
BOOL Success;
HREGKEY hRegSubkey;
DbgHandleAssert( hRegKey );
//
// While there are still more device/driver resource descriptors...
//
while( QueryNextValue( hRegKey )) {
PCM_FULL_RESOURCE_DESCRIPTOR FullResource;
LPSYSTEM_RESOURCES SystemResource;
LPDEVICE Device;
LPTSTR Extension;
DWORD Count;
DWORD i;
DWORD j;
//
// Based on the type of key, prepare to walk the list of
// RESOURCE_DESCRIPTORS (the list may be one in length).
//
if( hRegKey->Type == REG_FULL_RESOURCE_DESCRIPTOR ) {
Count = 1;
FullResource = ( PCM_FULL_RESOURCE_DESCRIPTOR ) hRegKey->Data;
} else if( hRegKey->Type == REG_RESOURCE_LIST ) {
Count = (( PCM_RESOURCE_LIST ) hRegKey->Data )->Count;
FullResource = (( PCM_RESOURCE_LIST ) hRegKey->Data )->List;
} else {
DbgAssert( FALSE );
continue;
}
//
// Allocate a DEVICE object.
//
Device = AllocateObject( DEVICE, 1 );
DbgPointerAssert( Device );
if( Device == NULL ) {
Success = DestroySystemResourceLists( _SystemResourceLists );
DbgAssert( Success );
return FALSE;
}
//
// Allocate a buffer for the device/driver name. The maximum size of
// the name will be the number of characters in both the key and
// value name.
//
Device->Name = AllocateObject(
TCHAR,
_tcslen( hRegKey->Name )
+ _tcslen( hRegKey->ValueName )
+ sizeof( TCHAR )
);
DbgPointerAssert( Device->Name );
if( Device->Name == NULL ) {
Success = DestroySystemResourceLists( _SystemResourceLists );
DbgAssert( Success );
return FALSE;
}
//
// Rationalize the device name such that it is of the form Device.Raw
// or Device.Translated.
//
Device->Name[ 0 ] = TEXT( '\0' );
if( ( _tcsnicmp( hRegKey->ValueName, TEXT( ".Raw" ), 4 ) == 0 )
|| ( _tcsnicmp( hRegKey->ValueName, TEXT( ".Translated" ), 11 ) == 0 )) {
_tcscpy( Device->Name, hRegKey->Name );
}
_tcscat( Device->Name, hRegKey->ValueName );
//
// Based on the device name, determine if the resource descriptors
// should be added to the RAW or TRANSLATED lists.
//
if( Extension = _tcsstr( Device->Name, TEXT( ".Raw" ))) {
SystemResource = &_SystemResourceLists[ RAW ];
} else if( Extension = _tcsstr( Device->Name, TEXT( ".Translated" ))) {
SystemResource = &_SystemResourceLists[ TRANSLATED ];
} else {
DbgAssert( FALSE );
Success = DestroySystemResourceLists( _SystemResourceLists );
DbgAssert( Success );
return FALSE;
}
//
// Strip off the extension (.Raw or .Translated) from the device name.
//
Device->Name[ Extension - Device->Name ] = TEXT( '\0' );
//
// Set the signature in the DEVICE object.
//
SetSignature( Device );
//
// If the DEVICE object list is empty, add the device to the beginning
// of the list else add it to the end of the list.
//
if( SystemResource->DeviceHead == NULL ) {
SystemResource->DeviceHead = Device;
SystemResource->DeviceTail = Device;
} else {
LPDEVICE ExistingDevice;
//
// See if the DEVICE object is already in the list.
//
ExistingDevice = SystemResource->DeviceHead;
while( ExistingDevice ) {
if( _tcsicmp( ExistingDevice->Name, Device->Name ) == 0 ) {
break;
}
ExistingDevice = ExistingDevice->Next;
}
//
// If the DEVICE object is not already in the list, add it else
// free the DEICE object.
//
if( ExistingDevice == NULL ) {
SystemResource->DeviceTail->Next = Device;
SystemResource->DeviceTail = Device;
} else {
Success = FreeObject( Device );
DbgAssert( Success );
}
}
//
// NULL terminate the DEVICE object list.
//
SystemResource->DeviceTail->Next = NULL;
//
// For each CM_FULL_RESOURCE DESCRIPTOR in the current value...
//
for( i = 0; i < Count; i++ ) {
PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialResourceDescriptor;
//
// For each CM_PARTIAL_RESOURCE_DESCRIPTOR in the list...
//
for( j = 0; j < FullResource->PartialResourceList.Count; j++ ) {
LPRESOURCE_DESCRIPTOR ResourceDescriptor;
LPRESOURCE_DESCRIPTOR* Head;
LPRESOURCE_DESCRIPTOR* Tail;
//
// Allocate a RESOURCE_DESCRIPTOR object.
//
ResourceDescriptor = AllocateObject( RESOURCE_DESCRIPTOR, 1 );
DbgPointerAssert( ResourceDescriptor );
if( ResourceDescriptor == NULL ) {
Success = DestroySystemResourceLists( _SystemResourceLists );
DbgAssert( Success );
return FALSE;
}
//
// Get a pointer to the current CM_PARTIAL_RESOURCE_DESCRIPTOR
// in the current CM_FULLRESOURCE_DESCRIPTOR in the list.
//
PartialResourceDescriptor = &( FullResource[ i ].PartialResourceList.PartialDescriptors[ j ]);
//
// Based on the resource type grab the pointers to the head and
// tail of the appropriate list.
//
switch( PartialResourceDescriptor->Type ) {
case CmResourceTypePort:
Head = &SystemResource->PortHead;
Tail = &SystemResource->PortTail;
break;
case CmResourceTypeInterrupt:
Head = &SystemResource->InterruptHead;
Tail = &SystemResource->InterruptTail;
break;
case CmResourceTypeMemory:
Head = &SystemResource->MemoryHead;
Tail = &SystemResource->MemoryTail;
break;
case CmResourceTypeDma:
Head = &SystemResource->DmaHead;
Tail = &SystemResource->DmaTail;
break;
case CmResourceTypeDeviceSpecific:
//
// Since device specific data is not be collected, free the
// associated RESOURCCE_DESCRIPTOR object.
//
Success = FreeObject( ResourceDescriptor );
DbgAssert( Success );
break;
default:
DbgPrintf(( L"Winmsd : Unknown PartialResourceDescriptor->Type == %1!d!\n", PartialResourceDescriptor->Type ));
continue;
}
//
// If the list is empty add the RESOURCE_DESCRIPTOR object to
// the beginning of the list, else add it to the end.
//
if( *Head == NULL ) {
*Head = ResourceDescriptor;
*Tail = ResourceDescriptor;
} else {
( *Tail )->NextSame = ResourceDescriptor;
*Tail = ResourceDescriptor;
}
//
// NULL terminate the list.
//
( *Tail )->NextSame = NULL;
//
// Make a copy of the actual resource descriptor data.
//
CopyMemory(
&ResourceDescriptor->CmResourceDescriptor,
PartialResourceDescriptor,
sizeof( CM_PARTIAL_RESOURCE_DESCRIPTOR )
);
//
// Note the owner (device/driver) of this resource descriptor.
//
ResourceDescriptor->Owner = SystemResource->DeviceTail;
//
// The RESOURCE_DESCRIPTOR is complete so set its signature.
//
SetSignature( ResourceDescriptor );
//
// Add the RESOURCE_DESCRIPTOR to the list of resources owned
// by the current DEVICE.
//
if( SystemResource->DeviceTail->ResourceDescriptorHead == NULL ) {
SystemResource->DeviceTail->ResourceDescriptorHead
= ResourceDescriptor;
SystemResource->DeviceTail->ResourceDescriptorTail
= ResourceDescriptor;
} else {
SystemResource->DeviceTail->ResourceDescriptorTail->NextDiff
= ResourceDescriptor;
SystemResource->DeviceTail->ResourceDescriptorTail
= ResourceDescriptor;
}
//
// NULL terminate the list.
//
SystemResource->DeviceTail->ResourceDescriptorTail->NextDiff
= NULL;
}
//
// Get the next CM_FULL_RESOURCE_DESCRIPTOR from the list.
//
FullResource = ( PCM_FULL_RESOURCE_DESCRIPTOR )( PartialResourceDescriptor + 1 );
}
}
//
// Traverse the list of keys in the resource descriptor portion of the
// registry and continue building the lists.
//
while(( hRegSubkey = QueryNextSubkey( hRegKey )) != NULL ) {
Success = InitializeSystemResourceLists( hRegSubkey );
DbgAssert( Success );
if( Success == FALSE ) {
Success = DestroySystemResourceLists( _SystemResourceLists );
DbgAssert( Success );
return FALSE;
}
Success = CloseRegistryKey( hRegSubkey );
DbgAssert( Success );
if( Success == FALSE ) {
Success = DestroySystemResourceLists( _SystemResourceLists );
DbgAssert( Success );
return FALSE;
}
}
//
// Set the signatures in both of the fully initialized lists.
//
SetSignature( &_SystemResourceLists[ RAW ]);
SetSignature( &_SystemResourceLists[ TRANSLATED ]);
return TRUE;
}
