archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/base/ntos/config/hwprofil.c

2788 lines
89 KiB
Raw Permalink Blame History

/*++
Copyright (c) 1998 Microsoft Corporation
Module Name:
hwprofil.c
Abstract:
This module contains support for changing the Hardware profile
based on the current docking state, either at boot time or by
ACPI dock.
Author:
Kenneth D. Ray (kenray) Jan 1998
Revision History:
--*/
#include "cmp.h"
NTSTATUS
CmDeleteKeyRecursive(
HANDLE hKeyRoot,
PWSTR Key,
PVOID TemporaryBuffer,
ULONG LengthTemporaryBuffer,
BOOLEAN ThisKeyToo
);
NTSTATUS
CmpGetAcpiProfileInformation (
IN HANDLE IDConfigDB,
OUT PCM_HARDWARE_PROFILE_LIST * ProfileList,
OUT PCM_HARDWARE_PROFILE_ACPI_ALIAS_LIST * AliasList,
IN PWCHAR NameBuffer,
IN PUCHAR ValueBuffer,
IN ULONG Len
);
NTSTATUS
CmpFilterAcpiDockingState (
IN PPROFILE_ACPI_DOCKING_STATE NewDockState,
IN ULONG CurrentDockingState,
IN PWCHAR CurrentAcpiSN,
IN ULONG CurrentProfileNumber,
IN OUT PCM_HARDWARE_PROFILE_LIST ProfileList,
IN OUT PCM_HARDWARE_PROFILE_ACPI_ALIAS_LIST AliasList
);
NTSTATUS
CmpMoveBiosAliasTable (
IN HANDLE IDConfigDB,
IN HANDLE CurrentInfo,
IN ULONG CurrentProfileNumber,
IN ULONG NewProfileNumber,
IN PWCHAR nameBuffer,
IN PCHAR valueBuffer,
IN ULONG bufferLen
);
#pragma alloc_text(PAGE,CmDeleteKeyRecursive)
#pragma alloc_text(PAGE,CmpCloneHwProfile)
#pragma alloc_text(PAGE,CmSetAcpiHwProfile)
#pragma alloc_text(PAGE,CmpFilterAcpiDockingState)
#pragma alloc_text(PAGE,CmpGetAcpiProfileInformation)
#pragma alloc_text(PAGE,CmpAddAcpiAliasEntry)
#pragma alloc_text(PAGE,CmpMoveBiosAliasTable)
#pragma alloc_text(PAGE,CmpCreateHwProfileFriendlyName)
extern UNICODE_STRING CmSymbolicLinkValueName;
NTSTATUS
CmpGetAcpiProfileInformation (
IN HANDLE IDConfigDB,
OUT PCM_HARDWARE_PROFILE_LIST * ProfileList,
OUT PCM_HARDWARE_PROFILE_ACPI_ALIAS_LIST * AliasList,
IN PWCHAR nameBuffer,
IN PUCHAR valueBuffer,
IN ULONG bufferLen
)
/*++
Routine Description:
Obtain the alias and hardware profile information from the registry.
--*/
{
NTSTATUS status = STATUS_SUCCESS;
HANDLE acpiAlias = NULL;
HANDLE profiles = NULL;
HANDLE entry = NULL;
ULONG len = 0;
ULONG i, j;
OBJECT_ATTRIBUTES attributes;
UNICODE_STRING name;
KEY_FULL_INFORMATION keyInfo;
PKEY_VALUE_FULL_INFORMATION value;
PKEY_BASIC_INFORMATION basicInfo;
PAGED_CODE ();
UNREFERENCED_PARAMETER (nameBuffer);
*ProfileList = NULL;
*AliasList = NULL;
value = (PKEY_VALUE_FULL_INFORMATION) valueBuffer;
basicInfo = (PKEY_BASIC_INFORMATION) valueBuffer;
//
// Open a handle to the Profile information
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_HARDWARE_PROFILES);
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
IDConfigDB,
NULL);
status = ZwOpenKey (&profiles,
KEY_READ,
&attributes);
if (!NT_SUCCESS (status)) {
profiles = NULL;
goto Clean;
}
//
// Find the number of profile Sub Keys
//
status = ZwQueryKey (profiles,
KeyFullInformation,
&keyInfo,
sizeof (keyInfo),
&len);
if (!NT_SUCCESS (status)) {
goto Clean;
}
ASSERT (0 < keyInfo.SubKeys);
len = sizeof (CM_HARDWARE_PROFILE_LIST)
+ (sizeof (CM_HARDWARE_PROFILE) * (keyInfo.SubKeys - 1));
* ProfileList = ExAllocatePool (PagedPool, len);
if (NULL == *ProfileList) {
status = STATUS_INSUFFICIENT_RESOURCES;
goto Clean;
}
RtlZeroMemory (*ProfileList, len);
(*ProfileList)->MaxProfileCount = keyInfo.SubKeys;
(*ProfileList)->CurrentProfileCount = 0;
//
// Iterrate the profiles
//
for (i = 0; i < keyInfo.SubKeys; i++) {
CM_HARDWARE_PROFILE TempProfile;
//
// Get the first key in the list.
//
status = ZwEnumerateKey (profiles,
i,
KeyBasicInformation,
basicInfo,
bufferLen - sizeof (UNICODE_NULL), // term 0
&len);
if (!NT_SUCCESS (status)) {
//
// This should never happen.
//
break;
}
basicInfo->Name [basicInfo->NameLength/sizeof(WCHAR)] = 0;
name.Length = (USHORT) basicInfo->NameLength;
name.MaximumLength = (USHORT) basicInfo->NameLength + sizeof (UNICODE_NULL);
name.Buffer = basicInfo->Name;
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
profiles,
NULL);
status = ZwOpenKey (&entry,
KEY_READ,
&attributes);
if (!NT_SUCCESS (status)) {
break;
}
//
// Fill in the temporary profile structure with this
// profile's data.
//
RtlUnicodeStringToInteger(&name, 0, &TempProfile.Id);
//
// Find the pref order of this entry.
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_PREFERENCE_ORDER);
status = NtQueryValueKey(entry,
&name,
KeyValueFullInformation,
valueBuffer,
bufferLen,
&len);
if ((!NT_SUCCESS (status)) || (value->Type != REG_DWORD)) {
TempProfile.PreferenceOrder = (ULONG)-1;
} else {
TempProfile.PreferenceOrder
= * (PULONG) ((PUCHAR) value + value->DataOffset);
}
//
// Extract the friendly name
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_FRIENDLY_NAME);
status = NtQueryValueKey(entry,
&name,
KeyValueFullInformation,
valueBuffer,
bufferLen,
&len);
if (!NT_SUCCESS (status) || (value->Type != REG_SZ)) {
WCHAR tmpname[] = L"-------"; // as taken from cmboot.c
ULONG length;
PVOID buffer;
length = sizeof (tmpname);
buffer = ExAllocatePool (PagedPool, length);
TempProfile.NameLength = length;
TempProfile.FriendlyName = buffer;
if (NULL == buffer) {
status = STATUS_INSUFFICIENT_RESOURCES;
ZwClose (entry);
goto Clean;
}
RtlCopyMemory (buffer, tmpname, value->DataLength);
} else {
PVOID buffer;
buffer = ExAllocatePool (PagedPool, value->DataLength);
TempProfile.NameLength = value->DataLength;
TempProfile.FriendlyName = buffer;
if (NULL == buffer) {
status = STATUS_INSUFFICIENT_RESOURCES;
ZwClose (entry);
goto Clean;
}
RtlCopyMemory (buffer,
(PUCHAR) value + value->DataOffset,
value->DataLength);
}
TempProfile.Flags = 0;
//
// Is this aliasable?
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_ALIASABLE);
status = NtQueryValueKey(entry,
&name,
KeyValueFullInformation,
valueBuffer,
bufferLen,
&len);
if (NT_SUCCESS (status) && (value->Type == REG_DWORD)) {
if (* (PULONG) ((PUCHAR) value + value->DataOffset)) {
TempProfile.Flags |= CM_HP_FLAGS_ALIASABLE;
}
} else {
TempProfile.Flags |= CM_HP_FLAGS_ALIASABLE;
}
//
// Is this pristine?
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_PRISTINE);
status = NtQueryValueKey(entry,
&name,
KeyValueFullInformation,
valueBuffer,
bufferLen,
&len);
if (NT_SUCCESS (status) && (value->Type == REG_DWORD)) {
if (* (PULONG) ((PUCHAR) value + value->DataOffset)) {
TempProfile.Flags = CM_HP_FLAGS_PRISTINE;
// No other flags set;
}
}
//
// If we see a profile with the ID of zero (AKA an illegal)
// ID for a hardware profile to possess, then we know that this
// must be a pristine profile.
//
if (0 == TempProfile.Id) {
TempProfile.Flags = CM_HP_FLAGS_PRISTINE;
// NO other flags set.
TempProfile.PreferenceOrder = (ULONG)-1; // move to the end of the list.
}
//
// Insert this new profile into the appropriate spot in the
// profile array. Entries are sorted by preference order.
//
for (j=0; j < (*ProfileList)->CurrentProfileCount; j++) {
if ((*ProfileList)->Profile[j].PreferenceOrder >=
TempProfile.PreferenceOrder) {
//
// Insert at position j.
//
RtlMoveMemory(&(*ProfileList)->Profile[j+1],
&(*ProfileList)->Profile[j],
sizeof(CM_HARDWARE_PROFILE) *
((*ProfileList)->MaxProfileCount-j-1));
break;
}
}
(*ProfileList)->Profile[j] = TempProfile;
++(*ProfileList)->CurrentProfileCount;
ZwClose (entry);
}
//
// Open a handle to the ACPI Alias information
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_ACPI_ALIAS);
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
IDConfigDB,
NULL);
status = ZwOpenKey (&acpiAlias,
KEY_READ,
&attributes);
if (!NT_SUCCESS (status)) {
//
// So we don't have an alias table. This is ok.
//
status = STATUS_SUCCESS;
acpiAlias = NULL;
goto Clean;
}
//
// Find the number of Acpi Alias Sub Keys
//
status = ZwQueryKey (acpiAlias,
KeyFullInformation,
&keyInfo,
sizeof (keyInfo),
&len);
if (!NT_SUCCESS (status)) {
goto Clean;
}
ASSERT (0 < keyInfo.SubKeys);
* AliasList = ExAllocatePool (
PagedPool,
sizeof (CM_HARDWARE_PROFILE_LIST) +
(sizeof (CM_HARDWARE_PROFILE) * (keyInfo.SubKeys - 1)));
if (NULL == *AliasList) {
status = STATUS_INSUFFICIENT_RESOURCES;
goto Clean;
}
(*AliasList)->MaxAliasCount =
(*AliasList)->CurrentAliasCount = keyInfo.SubKeys;
//
// Iterrate the alias entries
//
for (i = 0; i < keyInfo.SubKeys; i++) {
//
// Get the first key in the list.
//
status = ZwEnumerateKey (acpiAlias,
i,
KeyBasicInformation,
basicInfo,
bufferLen - sizeof (UNICODE_NULL), // term 0
&len);
if (!NT_SUCCESS (status)) {
//
// This should never happen.
//
break;
}
basicInfo->Name [basicInfo->NameLength/sizeof(WCHAR)] = 0;
name.Length = (USHORT) basicInfo->NameLength;
name.MaximumLength = (USHORT) basicInfo->NameLength + sizeof (UNICODE_NULL);
name.Buffer = basicInfo->Name;
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
acpiAlias,
NULL);
status = ZwOpenKey (&entry,
KEY_READ,
&attributes);
if (!NT_SUCCESS (status)) {
break;
}
//
// Extract The Profile number to which this alias refers.
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_PROFILE_NUMBER);
status = NtQueryValueKey(entry,
&name,
KeyValueFullInformation,
valueBuffer,
bufferLen,
&len);
if (!NT_SUCCESS (status) || (value->Type != REG_DWORD)) {
status = STATUS_REGISTRY_CORRUPT;
ZwClose (entry);
goto Clean;
}
(*AliasList)->Alias[i].ProfileNumber =
* (PULONG) ((PUCHAR) value + value->DataOffset);
//
// Extract The Docking State.
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_DOCKING_STATE);
status = NtQueryValueKey(entry,
&name,
KeyValueFullInformation,
valueBuffer,
bufferLen,
&len);
if (!NT_SUCCESS (status) || (value->Type != REG_DWORD)) {
status = STATUS_REGISTRY_CORRUPT;
ZwClose (entry);
goto Clean;
}
(*AliasList)->Alias[i].DockState =
* (PULONG) ((PUCHAR) value + value->DataOffset);
//
// Find the SerialNumber
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_ACPI_SERIAL_NUMBER);
status = NtQueryValueKey(entry,
&name,
KeyValueFullInformation,
valueBuffer,
bufferLen,
&len);
if (!NT_SUCCESS (status) || (value->Type != REG_BINARY)) {
status = STATUS_REGISTRY_CORRUPT;
ZwClose (entry);
goto Clean;
}
(*AliasList)->Alias[i].SerialLength = value->DataLength;
(*AliasList)->Alias[i].SerialNumber =
(value->DataLength) ?
ExAllocatePool (PagedPool, value->DataLength) :
0;
if (value->DataLength && (NULL == (*AliasList)->Alias[i].SerialNumber)) {
status = STATUS_INSUFFICIENT_RESOURCES;
ZwClose (entry);
goto Clean;
}
if (value->DataLength) {
RtlCopyMemory ((*AliasList)->Alias[i].SerialNumber,
(PUCHAR) value + value->DataOffset,
value->DataLength);
}
ZwClose (entry);
}
Clean:
if (NULL != acpiAlias) {
NtClose (acpiAlias);
}
if (NULL != profiles) {
NtClose (profiles);
}
if (!NT_SUCCESS (status)) {
if (NULL != *ProfileList) {
for (i = 0; i < (*ProfileList)->CurrentProfileCount; i++) {
if ((*ProfileList)->Profile[i].FriendlyName) {
ExFreePool ((*ProfileList)->Profile[i].FriendlyName);
}
}
ExFreePool (*ProfileList);
*ProfileList = 0;
}
if (NULL != *AliasList) {
for (i = 0; i < (*AliasList)->CurrentAliasCount; i++) {
if ((*AliasList)->Alias[i].SerialNumber) {
ExFreePool ((*AliasList)->Alias[i].SerialNumber);
}
}
ExFreePool (*AliasList);
*AliasList = 0;
}
}
return status;
}
NTSTATUS
CmpAddAcpiAliasEntry (
IN HANDLE IDConfigDB,
IN PPROFILE_ACPI_DOCKING_STATE NewDockState,
IN ULONG ProfileNumber,
IN PWCHAR nameBuffer,
IN PVOID valueBuffer,
IN ULONG valueBufferLength,
IN BOOLEAN PreventDuplication
)
/*++
Routine Description:
Set the Acpi Alais entry.
Routine Description:
Create an alias entry in the IDConfigDB database for the given
hardware profile.
Create the "AcpiAlias" key if it does not exist.
Parameters:
IDConfigDB - Pointer to "..\CurrentControlSet\Control\IDConfigDB"
NewDockState - The new docking state for which this alias points.
ProfileNumber -The profile number to which this alias points.
nameBuffer - a temp scratch space for writing things.
(assumed to be at least 128 WCHARS)
--*/
{
OBJECT_ATTRIBUTES attributes;
NTSTATUS status = STATUS_SUCCESS;
UNICODE_STRING name;
HANDLE aliasKey = NULL;
HANDLE aliasEntry = NULL;
ULONG value;
ULONG disposition;
ULONG aliasNumber = 0;
ULONG len;
PKEY_VALUE_FULL_INFORMATION keyInfo;
PAGED_CODE ();
keyInfo = (PKEY_VALUE_FULL_INFORMATION) valueBuffer;
//
// Find the Alias Key or Create it if it does not already exist.
//
RtlInitUnicodeString (&name,CM_HARDWARE_PROFILE_STR_ACPI_ALIAS);
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
IDConfigDB,
NULL);
status = NtOpenKey (&aliasKey,
KEY_READ | KEY_WRITE,
&attributes);
if (STATUS_OBJECT_NAME_NOT_FOUND == status) {
status = NtCreateKey (&aliasKey,
KEY_READ | KEY_WRITE,
&attributes,
0, // no title
NULL, // no class
0, // no options
&disposition);
}
if (!NT_SUCCESS (status)) {
aliasKey = NULL;
goto Exit;
}
//
// Create an entry key
//
while (aliasNumber < 200) {
aliasNumber++;
swprintf (nameBuffer, L"%04d", aliasNumber);
RtlInitUnicodeString (&name, nameBuffer);
InitializeObjectAttributes(&attributes,
&name,
OBJ_CASE_INSENSITIVE,
aliasKey,
NULL);
status = NtOpenKey (&aliasEntry,
KEY_READ | KEY_WRITE,
&attributes);
if (NT_SUCCESS (status)) {
if (PreventDuplication) {
//
// If we have a matching DockingState, SerialNumber, and
// Profile Number, then we should not make this alias
//
//
// Extract The DockingState to which this alias refers.
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_DOCKING_STATE);
status = NtQueryValueKey(aliasEntry,
&name,
KeyValueFullInformation,
valueBuffer,
valueBufferLength,
&len);
if (!NT_SUCCESS (status) || (keyInfo->Type != REG_DWORD)) {
status = STATUS_REGISTRY_CORRUPT;
goto Exit;
}
if (NewDockState->DockingState !=
* (PULONG) ((PUCHAR) keyInfo + keyInfo->DataOffset)) {
//
// Not a dupe
//
NtClose (aliasEntry);
aliasEntry = NULL;
continue;
}
//
// Extract the SerialNumber
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_ACPI_SERIAL_NUMBER);
status = NtQueryValueKey(aliasEntry,
&name,
KeyValueFullInformation,
valueBuffer,
valueBufferLength,
&len);
if (!NT_SUCCESS (status) || (keyInfo->Type != REG_BINARY)) {
status = STATUS_REGISTRY_CORRUPT;
goto Exit;
}
if (NewDockState->SerialLength != keyInfo->DataLength) {
//
// Not a dupe
//
NtClose (aliasEntry);
aliasEntry = NULL;
continue;
}
if (!RtlEqualMemory (NewDockState->SerialNumber,
((PUCHAR) keyInfo + keyInfo->DataOffset),
NewDockState->SerialLength)) {
//
// Not a dupe
//
NtClose (aliasEntry);
aliasEntry = NULL;
continue;
}
status = STATUS_SUCCESS;
goto Exit;
}
} else if (STATUS_OBJECT_NAME_NOT_FOUND == status) {
status = STATUS_SUCCESS;
break;
} else {
break;
}
}
if (!NT_SUCCESS (status)) {
CmKdPrintEx((DPFLTR_CONFIG_ID,CML_BUGCHECK,"CM: cmpCreateAcpiAliasEntry error finding new set %08lx\n",status));
aliasEntry = 0;
goto Exit;
}
status = NtCreateKey (&aliasEntry,
KEY_READ | KEY_WRITE,
&attributes,
0,
NULL,
0,
&disposition);
if (!NT_SUCCESS (status)) {
CmKdPrintEx((DPFLTR_CONFIG_ID,CML_BUGCHECK,"CM: cmpCreateAcpiAliasEntry error creating new set %08lx\n",status));
aliasEntry = 0;
goto Exit;
}
//
// Write the Docking State;
//
value = NewDockState->DockingState;
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_DOCKING_STATE);
status = NtSetValueKey (aliasEntry,
&name,
0,
REG_DWORD,
&value,
sizeof (value));
//
// Write the Serial Number
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_ACPI_SERIAL_NUMBER);
status = NtSetValueKey (aliasEntry,
&name,
0,
REG_BINARY,
NewDockState->SerialNumber,
NewDockState->SerialLength);
//
// Write the Profile Number
//
value = ProfileNumber;
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_PROFILE_NUMBER);
status = NtSetValueKey (aliasEntry,
&name,
0,
REG_DWORD,
&value,
sizeof (value));
Exit:
if (aliasKey) {
NtClose (aliasKey);
}
if (aliasEntry) {
NtClose (aliasEntry);
}
return status;
}
NTSTATUS
CmSetAcpiHwProfile (
IN PPROFILE_ACPI_DOCKING_STATE NewDockState,
IN PCM_ACPI_SELECTION_ROUTINE Select,
IN PVOID Context,
OUT PHANDLE NewProfile,
OUT PBOOLEAN ProfileChanged
)
/*++
Routine Description:
The ACPI docking state of the machine has changed.
Based on the new change calculate the new HW Profile(s) consitent with the
new ACPI docking state.
Pass the list of known profiles to the callers selection routine.
Set the new current profile.
Patch up any ACPI alias entries if a new profile for this ACPI state has
been used.
Arguments:
NewDockStateArray - The list of possible Docking States that we might enter.
Select - Call back to select which profile to enter, given the list of
possible profiles.
--*/
{
NTSTATUS status = STATUS_SUCCESS;
HANDLE IDConfigDB = NULL;
HANDLE HardwareProfile = NULL;
HANDLE currentInfo = NULL;
HANDLE currentSymLink = NULL;
HANDLE parent = NULL;
WCHAR nameBuffer[128];
UNICODE_STRING name;
CHAR valueBuffer[256];
ULONG len;
ULONG i;
ULONG selectedElement;
ULONG profileNum;
ULONG currentDockingState;
ULONG currentProfileNumber;
ULONG disposition;
ULONG flags;
PWCHAR currentAcpiSN = NULL;
PCM_HARDWARE_PROFILE_ACPI_ALIAS_LIST AliasList = NULL;
PCM_HARDWARE_PROFILE_LIST ProfileList = NULL;
PKEY_VALUE_FULL_INFORMATION value;
OBJECT_ATTRIBUTES attributes;
PAGED_CODE ();
*ProfileChanged = FALSE;
value = (PKEY_VALUE_FULL_INFORMATION) valueBuffer;
//
// Open The Hardware Profile Database
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_DATABASE);
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
status = ZwOpenKey (&IDConfigDB,
KEY_READ,
&attributes);
if (!NT_SUCCESS (status)) {
IDConfigDB = NULL;
goto Clean;
}
//
// Obtain the total list of profiles
//
status = CmpGetAcpiProfileInformation (IDConfigDB,
&ProfileList,
&AliasList,
nameBuffer,
(PUCHAR) valueBuffer,
sizeof (valueBuffer));
if (!NT_SUCCESS (status)) {
goto Clean;
}
//
// Determine the current Dock information.
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_CCS_CURRENT);
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
status = ZwOpenKey (&HardwareProfile,
KEY_READ,
&attributes);
if (!NT_SUCCESS (status)) {
HardwareProfile = NULL;
goto Clean;
}
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_CURRENT_DOCK_INFO);
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
IDConfigDB,
NULL);
status = ZwOpenKey (&currentInfo,
KEY_READ,
&attributes);
if (!NT_SUCCESS (status)) {
currentInfo = NULL;
goto Clean;
}
//
// The current Docking State
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_DOCKING_STATE);
status = NtQueryValueKey (currentInfo,
&name,
KeyValueFullInformation,
valueBuffer,
sizeof (valueBuffer),
&len);
if (!NT_SUCCESS (status) || (value->Type != REG_DWORD)) {
status = STATUS_REGISTRY_CORRUPT;
goto Clean;
}
currentDockingState = * (PULONG) ((PUCHAR) value + value->DataOffset);
//
// The current ACPI Serial Number
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_ACPI_SERIAL_NUMBER);
status = NtQueryValueKey(currentInfo,
&name,
KeyValueFullInformation,
valueBuffer,
sizeof (valueBuffer),
&len);
if (NT_SUCCESS (status) && (value->Type == REG_BINARY)) {
currentAcpiSN = ExAllocatePool (PagedPool, value->DataLength);
if (NULL == currentAcpiSN) {
status = STATUS_INSUFFICIENT_RESOURCES;
goto Clean;
}
RtlCopyMemory (currentAcpiSN,
(PUCHAR) value + value->DataOffset,
value->DataLength);
} else {
currentAcpiSN = 0;
}
//
// The current Profile Number
//
RtlInitUnicodeString(&name, L"CurrentConfig");
status = NtQueryValueKey(IDConfigDB,
&name,
KeyValueFullInformation,
valueBuffer,
sizeof (valueBuffer),
&len);
if (!NT_SUCCESS(status) || (value->Type != REG_DWORD)) {
status = STATUS_REGISTRY_CORRUPT;
goto Clean;
}
currentProfileNumber = *(PULONG)((PUCHAR)value + value->DataOffset);
//
// Filter the current list of hardware profiles based on the current
// docking state, the new acpi state, and the acpi alias tables
//
status = CmpFilterAcpiDockingState (NewDockState,
currentDockingState,
currentAcpiSN,
currentProfileNumber,
ProfileList,
AliasList);
if (!NT_SUCCESS (status)) {
goto Clean;
}
//
// Allow the caller a chance to select from the filtered list.
//
status = Select (ProfileList, &selectedElement, Context);
//
// If the user selected -1 then he is not interested in selecting any of
// the profiles.
//
if (-1 == selectedElement) {
ASSERT (STATUS_MORE_PROCESSING_REQUIRED == status);
goto Clean;
}
if (!NT_SUCCESS (status)) {
goto Clean;
}
//
// Fine! We have finally made the new selection.
// Set it.
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_CCS_HWPROFILE);
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
status = ZwOpenKey (&parent, KEY_READ, &attributes);
if (!NT_SUCCESS (status)) {
parent = NULL;
goto Clean;
}
//
// How did we get here?
//
flags = ProfileList->Profile[selectedElement].Flags;
profileNum = ProfileList->Profile[selectedElement].Id;
//
// Check for duplicate
//
if (flags & CM_HP_FLAGS_DUPLICATE) {
//
// If there is a duplicate then we need to adjust the pnp
// bios alias table.
//
// This happens if we booted PnP bios detected docked, and then
// we received a set state for ACPI as docked, then we have the
// potential for duplicates. See Comment in CmpFilterAcpiDockingState
// for details.
//
// We need to find any pnp bios alias entries that match the current
// state and point them to the duplicate entry.
//
ASSERT (flags & CM_HP_FLAGS_TRUE_MATCH);
ASSERT (!(flags & CM_HP_FLAGS_PRISTINE));
status = CmpMoveBiosAliasTable (IDConfigDB,
currentInfo,
currentProfileNumber,
profileNum,
nameBuffer,
valueBuffer,
sizeof (valueBuffer));
if (!NT_SUCCESS (status)) {
goto Clean;
}
}
if ((flags & CM_HP_FLAGS_PRISTINE) || (profileNum != currentProfileNumber)){
//
// The profile Number Changed or will change.
//
*ProfileChanged = TRUE;
ASSERT (currentInfo);
ZwClose (currentInfo);
currentInfo = NULL;
if (flags & CM_HP_FLAGS_PRISTINE) {
//
// If the selected profile is pristine then we need to clone.
//
ASSERT (!(flags & CM_HP_FLAGS_TRUE_MATCH));
status = CmpCloneHwProfile (IDConfigDB,
parent,
HardwareProfile,
profileNum,
NewDockState->DockingState,
&HardwareProfile,
&profileNum);
if (!NT_SUCCESS (status)) {
HardwareProfile = 0;
goto Clean;
}
} else {
ASSERT (HardwareProfile);
ZwClose (HardwareProfile);
//
// Open the new profile
//
swprintf (nameBuffer, L"%04d\0", profileNum);
RtlInitUnicodeString (&name, nameBuffer);
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
parent,
NULL);
status = ZwOpenKey (&HardwareProfile, KEY_READ, &attributes);
if (!NT_SUCCESS (status)) {
HardwareProfile = NULL;
goto Clean;
}
}
ASSERT (currentProfileNumber != profileNum);
//
// Open the current info for the profile.
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_CURRENT_DOCK_INFO);
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
IDConfigDB,
NULL);
status = NtCreateKey (&currentInfo,
KEY_READ | KEY_WRITE,
&attributes,
0,
NULL,
REG_OPTION_VOLATILE,
&disposition);
if (!NT_SUCCESS (status)) {
currentInfo = NULL;
goto Clean;
}
//
// Set CurrentConfig in the Database
//
RtlInitUnicodeString(&name, L"CurrentConfig");
status = NtSetValueKey(IDConfigDB,
&name,
0,
REG_DWORD,
&profileNum,
sizeof (profileNum));
if (!NT_SUCCESS(status)) {
status = STATUS_REGISTRY_CORRUPT;
goto Clean;
}
}
//
// Write the new Docking State to the current Info key
//
i = NewDockState->DockingState;
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_DOCKING_STATE);
status = ZwSetValueKey (currentInfo,
&name,
0,
REG_DWORD,
&i,
sizeof (ULONG));
//
// Write the new ACPI information to the current Info key
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_ACPI_SERIAL_NUMBER);
status = ZwSetValueKey (currentInfo,
&name,
0,
REG_BINARY,
NewDockState->SerialNumber,
NewDockState->SerialLength);
if (!(flags & CM_HP_FLAGS_TRUE_MATCH)) {
//
// Add the alias entry for this profile.
//
status = CmpAddAcpiAliasEntry (IDConfigDB,
NewDockState,
profileNum,
nameBuffer,
valueBuffer,
sizeof (valueBuffer),
FALSE); // Don't Prevent Duplication
}
if (profileNum != currentProfileNumber) {
//
// Move the symbolic link.
//
RtlInitUnicodeString(&name, CM_HARDWARE_PROFILE_STR_CCS_CURRENT);
InitializeObjectAttributes(&attributes,
&name,
OBJ_CASE_INSENSITIVE | OBJ_OPENLINK,
NULL,
NULL);
status = NtCreateKey(&currentSymLink,
KEY_CREATE_LINK,
&attributes,
0,
NULL,
REG_OPTION_OPEN_LINK,
&disposition);
ASSERT (STATUS_SUCCESS == status);
ASSERT (REG_OPENED_EXISTING_KEY == disposition);
swprintf (nameBuffer,
L"\\Registry\\Machine\\System\\CurrentControlSet\\Hardware Profiles\\%04d",
profileNum);
RtlInitUnicodeString (&name, nameBuffer);
status = NtSetValueKey (currentSymLink,
&CmSymbolicLinkValueName,
0,
REG_LINK,
name.Buffer,
name.Length);
ASSERT (STATUS_SUCCESS == status);
}
Clean:
if (NT_SUCCESS (status)) {
// NB more process required is not a success code.
*NewProfile = HardwareProfile;
} else if (NULL != HardwareProfile) {
ZwClose (HardwareProfile);
}
if (NULL != IDConfigDB) {
ZwClose (IDConfigDB);
}
if (NULL != currentInfo) {
ZwClose (currentInfo);
}
if (NULL != parent) {
ZwClose (parent);
}
if (NULL != currentAcpiSN) {
ExFreePool (currentAcpiSN);
}
if (NULL != ProfileList) {
for (i = 0; i < ProfileList->CurrentProfileCount; i++) {
if (ProfileList->Profile[i].FriendlyName) {
ExFreePool (ProfileList->Profile[i].FriendlyName);
}
}
ExFreePool (ProfileList);
}
if (NULL != AliasList) {
for (i = 0; i < AliasList->CurrentAliasCount; i++) {
if (AliasList->Alias[i].SerialNumber) {
ExFreePool (AliasList->Alias[i].SerialNumber);
}
}
ExFreePool (AliasList);
}
return status;
}
NTSTATUS
CmpFilterAcpiDockingState (
IN PPROFILE_ACPI_DOCKING_STATE NewDockingState,
IN ULONG CurrentDockState,
IN PWCHAR CurrentAcpiSN,
IN ULONG CurrentProfileNumber,
IN OUT PCM_HARDWARE_PROFILE_LIST ProfileList,
IN OUT PCM_HARDWARE_PROFILE_ACPI_ALIAS_LIST AliasList
)
/*++
Routine Description:
Given the new state of things and the current state of things,
prune the given list of profiles.
--*/
{
NTSTATUS status = STATUS_SUCCESS;
ULONG i = 0;
ULONG j;
ULONG len;
ULONG mask = HW_PROFILE_DOCKSTATE_UNDOCKED | HW_PROFILE_DOCKSTATE_DOCKED;
ULONG flags;
PCM_HARDWARE_PROFILE_ACPI_ALIAS alias;
BOOLEAN trueMatch = FALSE;
BOOLEAN dupDetect = FALSE;
BOOLEAN currentListed = FALSE;
BOOLEAN keepCurrent = FALSE;
PAGED_CODE ();
//
// Check for duplicate:
//
// If the user boots undocked, and then hot docks. We will generate
// a profile alias for the pnp reported undocked state [A], and one for the
// ACPI reported docked state [B}. If the use subsequently reboots docked,
// then we will create a third pnp reported docked state [C] profile alias.
// {C] is really a duplicate of [B}, but we wont know this until such time
// as the ACPI state for {B] is reported.
//
// The same can happen for undocked scenerios.
//
// Detection: If the Current Dock State is the same as
// NewDockingState.DockingState then there is a potential for a duplicate.
// In order to also have a duplicate we must have an acpi already pointing
// to a profile different than the current one.
// This must also be the first ACPI change since we booted, therefore
// CurrentAcpiSn Should be Zero.
// In other words there must be at least one true match and none of the
// true matches can point to the current profile.
//
if (AliasList) {
while (i < AliasList->CurrentAliasCount) {
alias = &AliasList->Alias[i];
if (((alias->DockState & mask) != 0) &&
((alias->DockState & mask) !=
(NewDockingState->DockingState & mask))) {
//
// This alias claims to be docked or undocked, but does not
// match the current state. Therefore skip it.
//
;
} else if (alias->SerialLength != NewDockingState->SerialLength) {
//
// This alias has an incompatible serial number
//
;
} else if (alias->SerialLength ==
RtlCompareMemory (NewDockingState->SerialNumber,
alias->SerialNumber,
alias->SerialLength)) {
//
// NB RtlCompareMemory can work with zero length memory
// addresses. This is a requirement here.
//
//
// This alias matches so mark the profile.
//
for (j = 0; j < ProfileList->CurrentProfileCount; j++) {
if (ProfileList->Profile[j].Id == alias->ProfileNumber) {
//
// Alias entries should never point to a pristine profile
//
ASSERT (!(ProfileList->Profile[j].Flags &
CM_HP_FLAGS_PRISTINE));
ProfileList->Profile[j].Flags |= CM_HP_FLAGS_TRUE_MATCH;
trueMatch = TRUE;
}
if ((CurrentDockState == NewDockingState->DockingState) &&
(NULL == CurrentAcpiSN)) {
//
// The dock state did not change during this acpi
// event; therefore, we might just have a duplicate
// on our hands.
//
dupDetect = TRUE;
}
if (alias->ProfileNumber == CurrentProfileNumber) {
//
// There exists an entry in the acpi alias table that
// if chosen would result in no change of Hardware
// Profile. Therefore, we should chose this one, and
// ignore the duplicate.
//
currentListed = TRUE;
}
}
}
i++;
}
}
if ((!dupDetect) &&
(NULL == CurrentAcpiSN) &&
(!trueMatch) &&
(CurrentDockState == NewDockingState->DockingState)) {
//
// (1) The docking state did not change,
// (2) the current profile has not yet, on this boot, been marked with
// an ACPI serial number.
// (3) There was no Alias match.
//
// Therefore we should keep the current profile regardless of it being
// aliasable.
//
keepCurrent = TRUE;
trueMatch = TRUE; // prevent pristine from being listed.
}
i = 0;
while (i < ProfileList->CurrentProfileCount) {
flags = ProfileList->Profile[i].Flags;
if (dupDetect) {
if (flags & CM_HP_FLAGS_TRUE_MATCH) {
if (currentListed) {
if (ProfileList->Profile[i].Id == CurrentProfileNumber) {
//
// Let this one live. This results in no change of
// profile number.
//
i++;
continue;
}
//
// Bounce any true matches that do not result in no change
// of profile.
//
;
} else {
//
// We did not find the current one listed so we definately
// have a duplicate.
//
// Mark it as such. and list it live.
//
ProfileList->Profile[i].Flags |= CM_HP_FLAGS_DUPLICATE;
i++;
continue;
}
}
//
// Bounce all non True matches in a duplicate detected situation.
//
;
} else if ((flags & CM_HP_FLAGS_PRISTINE) && !trueMatch) {
//
// Leave this one in the list
//
i++;
continue;
} else if (flags & CM_HP_FLAGS_ALIASABLE) {
//
// Leave this one in the list
//
ASSERT (! (flags & CM_HP_FLAGS_PRISTINE));
i++;
continue;
} else if (flags & CM_HP_FLAGS_TRUE_MATCH) {
//
// Leave this one in the list
//
i++;
continue;
} else if (keepCurrent &&
(ProfileList->Profile[i].Id == CurrentProfileNumber)) {
//
// Leave this one in the list
//
i++;
continue;
}
//
// discard this profile by (1) shifting remaining profiles in
// array to fill in the space of this discarded profile
// and (2) decrementing profile count
//
len = ProfileList->CurrentProfileCount - i - 1;
if (0 < len) {
RtlMoveMemory(&ProfileList->Profile[i],
&ProfileList->Profile[i+1],
sizeof(CM_HARDWARE_PROFILE) * len);
}
--ProfileList->CurrentProfileCount;
}
return status;
}
NTSTATUS
CmpMoveBiosAliasTable (
IN HANDLE IDConfigDB,
IN HANDLE CurrentInfo,
IN ULONG CurrentProfileNumber,
IN ULONG NewProfileNumber,
IN PWCHAR nameBuffer,
IN PCHAR valueBuffer,
IN ULONG bufferLen
)
/*++
Routine Description:
Search the Alias table for bios entries which match the current
docking state, and point from current profile number to new profile number.
Assumption: If the profile is cloned (therefore created by
CmpCloneHwProfile, and we have just moved the bios table to point
away from this entry, then we *should* be able to safely delete
the old hardware profile key.
(in both IDConfigDB\HardwareProfiles and CCS\HardwareProfiles
--*/
{
NTSTATUS status = STATUS_SUCCESS;
HANDLE alias = NULL;
HANDLE entry = NULL;
HANDLE hwprofile = NULL;
UNICODE_STRING name;
ULONG currentDockId;
ULONG currentSerialNumber;
ULONG len;
ULONG i;
OBJECT_ATTRIBUTES attributes;
KEY_FULL_INFORMATION keyInfo;
PKEY_BASIC_INFORMATION basicInfo;
PKEY_VALUE_FULL_INFORMATION value;
PAGED_CODE ();
value = (PKEY_VALUE_FULL_INFORMATION) valueBuffer;
basicInfo = (PKEY_BASIC_INFORMATION) valueBuffer;
//
// Extract the current Serial Number and DockID
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_SERIAL_NUMBER);
status = NtQueryValueKey(CurrentInfo,
&name,
KeyValueFullInformation,
valueBuffer,
bufferLen,
&len);
if (!NT_SUCCESS (status) || (value->Type != REG_DWORD)) {
status = STATUS_REGISTRY_CORRUPT;
goto Clean;
}
currentSerialNumber = * (PULONG) ((PUCHAR) value + value->DataOffset);
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_DOCKID);
status = NtQueryValueKey(CurrentInfo,
&name,
KeyValueFullInformation,
valueBuffer,
bufferLen,
&len);
if (!NT_SUCCESS (status) || (value->Type != REG_DWORD)) {
status = STATUS_REGISTRY_CORRUPT;
goto Clean;
}
currentDockId = * (PULONG) ((PUCHAR) value + value->DataOffset);
//
// Open a handle to the Alias information
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_ALIAS);
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
IDConfigDB,
NULL);
status = ZwOpenKey (&alias,
KEY_READ,
&attributes);
if (!NT_SUCCESS (status)) {
//
// So we don't have an alias table. This is ok, albeit a bit strange
//
status = STATUS_SUCCESS;
alias = NULL;
goto Clean;
}
status = ZwQueryKey (alias,
KeyFullInformation,
&keyInfo,
sizeof (keyInfo),
&len);
if (!NT_SUCCESS (status)) {
goto Clean;
}
ASSERT (0 < keyInfo.SubKeys);
//
// Iterrate the alias entries
//
for (i = 0; i < keyInfo.SubKeys; i++) {
//
// Get the first key in the list.
//
status = ZwEnumerateKey (alias,
i,
KeyBasicInformation,
basicInfo,
bufferLen - sizeof (UNICODE_NULL), // term 0
&len);
if (!NT_SUCCESS (status)) {
//
// This should never happen.
//
break;
}
basicInfo->Name [basicInfo->NameLength/sizeof(WCHAR)] = 0;
name.Length = (USHORT) basicInfo->NameLength;
name.MaximumLength = (USHORT) basicInfo->NameLength + sizeof (UNICODE_NULL);
name.Buffer = basicInfo->Name;
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
alias,
NULL);
status = ZwOpenKey (&entry,
KEY_READ | KEY_WRITE,
&attributes);
if (!NT_SUCCESS (status)) {
break;
}
//
// Extract The Profile number to which this alias refers.
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_PROFILE_NUMBER);
status = NtQueryValueKey(entry,
&name,
KeyValueFullInformation,
valueBuffer,
bufferLen,
&len);
if (!NT_SUCCESS (status) || (value->Type != REG_DWORD)) {
status = STATUS_REGISTRY_CORRUPT;
goto Clean;
}
if (CurrentProfileNumber != *(PULONG)((PUCHAR)value + value->DataOffset)) {
//
// Not a match
//
ZwClose (entry);
entry = NULL;
continue;
}
//
// Compare the Dock ID
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_DOCKID);
status = NtQueryValueKey(entry,
&name,
KeyValueFullInformation,
valueBuffer,
bufferLen,
&len);
if (!NT_SUCCESS (status) || (value->Type != REG_DWORD)) {
status = STATUS_REGISTRY_CORRUPT;
goto Clean;
}
if (currentDockId != * (PULONG) ((PUCHAR) value + value->DataOffset)) {
//
// Not a match
//
ZwClose (entry);
entry = NULL;
continue;
}
//
// Compare the SerialNumber
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_SERIAL_NUMBER);
status = NtQueryValueKey(entry,
&name,
KeyValueFullInformation,
valueBuffer,
bufferLen,
&len);
if (!NT_SUCCESS (status) || (value->Type != REG_DWORD)) {
status = STATUS_REGISTRY_CORRUPT;
goto Clean;
}
if (currentSerialNumber != *(PULONG)((PUCHAR)value + value->DataOffset)) {
//
// Not a match
//
ZwClose (entry);
entry = NULL;
continue;
}
//
// This must be a match.
// move the profile number
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_PROFILE_NUMBER);
status = NtSetValueKey (entry,
&name,
0,
REG_DWORD,
&NewProfileNumber,
sizeof (NewProfileNumber));
ASSERT (STATUS_SUCCESS == status);
ZwClose (entry);
entry = NULL;
//
// We most likely have left a dangling profile here.
// Try to attempt to clean it up.
//
// If this profile is cloned then we created it and can therefore
// get rid of it.
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_HARDWARE_PROFILES);
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
IDConfigDB,
NULL);
status = ZwOpenKey (&hwprofile, KEY_READ | KEY_WRITE, &attributes);
if (!NT_SUCCESS (status)) {
hwprofile = NULL;
status = STATUS_REGISTRY_CORRUPT;
goto Clean;
}
swprintf (nameBuffer, L"%04d\0", CurrentProfileNumber);
RtlInitUnicodeString (&name, nameBuffer);
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
hwprofile,
NULL);
status = ZwOpenKey (&entry, KEY_ALL_ACCESS, &attributes);
if (!NT_SUCCESS (status)) {
entry = NULL;
status = STATUS_REGISTRY_CORRUPT;
goto Clean;
}
//
// Test for the Cloned Bit.
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_CLONED);
status = NtQueryValueKey(entry,
&name,
KeyValueFullInformation,
valueBuffer,
bufferLen,
&len);
if (!NT_SUCCESS (status) || (value->Type != REG_DWORD)) {
status = STATUS_REGISTRY_CORRUPT;
goto Clean;
}
if (*(PULONG)((PUCHAR)value + value->DataOffset)) {
//
// We cloned this one.
//
status = ZwDeleteKey (entry);
ASSERT (NT_SUCCESS (status));
ZwClose (entry);
ZwClose (hwprofile);
entry = hwprofile = NULL;
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_CCS_HWPROFILE);
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
status = ZwOpenKey (&hwprofile, KEY_READ | KEY_WRITE, &attributes);
if (!NT_SUCCESS (status)) {
hwprofile = NULL;
status = STATUS_REGISTRY_CORRUPT;
goto Clean;
}
swprintf (nameBuffer, L"%04d\0", CurrentProfileNumber);
status = CmDeleteKeyRecursive (hwprofile,
nameBuffer,
valueBuffer,
bufferLen,
TRUE);
ASSERT (NT_SUCCESS (status));
ZwClose (hwprofile);
hwprofile = NULL;
} else {
//
// We didn't clone this one.
// don't do anything else.
//
ZwClose (entry);
ZwClose (hwprofile);
entry = hwprofile = NULL;
}
CM_HARDWARE_PROFILE_STR_CCS_HWPROFILE;
}
Clean:
if (alias) {
ZwClose (alias);
}
if (entry) {
ZwClose (entry);
}
if (hwprofile) {
ZwClose (hwprofile);
}
return status;
}
NTSTATUS
CmpCloneHwProfile (
IN HANDLE IDConfigDB,
IN HANDLE Parent,
IN HANDLE OldProfile,
IN ULONG OldProfileNumber,
IN USHORT DockingState,
OUT PHANDLE NewProfile,
OUT PULONG NewProfileNumber
)
/*++
Routine Description
The given hardware profile key needs cloning.
Clone the key and then return the new profile.
Return:
STATUS_SUCCESS - if the profile has been cloned, in which case the new
profile key has been opened for read / write privs. The old profile
will be closed.
<unsuccessful> - for a given error. NewProfile is invalid and the Old
Profile has also been closed.
(Copied lovingly from CmpCloneControlSet)
--*/
{
NTSTATUS status = STATUS_SUCCESS;
UNICODE_STRING newProfileName;
UNICODE_STRING name;
UNICODE_STRING friendlyName;
UNICODE_STRING guidStr;
PCM_KEY_BODY oldProfileKey;
PCM_KEY_BODY newProfileKey;
OBJECT_ATTRIBUTES attributes;
PSECURITY_DESCRIPTOR security;
ULONG securityLength;
WCHAR nameBuffer [64];
HANDLE IDConfigDBEntry = NULL;
ULONG disposition;
ULONG value;
UUID uuid;
PKEY_BASIC_INFORMATION keyBasicInfo;
PKEY_FULL_INFORMATION keyFullInfo;
PKEY_VALUE_FULL_INFORMATION keyValueInfo;
ULONG length, profileSubKeys, i;
UCHAR valueBuffer[256];
HANDLE hardwareProfiles=NULL;
HANDLE profileEntry=NULL;
PAGED_CODE ();
keyFullInfo = (PKEY_FULL_INFORMATION) valueBuffer;
keyBasicInfo = (PKEY_BASIC_INFORMATION) valueBuffer;
keyValueInfo = (PKEY_VALUE_FULL_INFORMATION) valueBuffer;
*NewProfile = 0;
*NewProfileNumber = OldProfileNumber;
//
// Find the new profile number.
//
while (*NewProfileNumber < 200) {
(*NewProfileNumber)++;
swprintf (nameBuffer, L"%04d", *NewProfileNumber);
RtlInitUnicodeString (&newProfileName, nameBuffer);
InitializeObjectAttributes(&attributes,
&newProfileName,
OBJ_CASE_INSENSITIVE,
Parent,
NULL);
status = NtOpenKey (NewProfile,
KEY_READ | KEY_WRITE,
&attributes);
if (NT_SUCCESS (status)) {
NtClose (*NewProfile);
} else if (STATUS_OBJECT_NAME_NOT_FOUND == status) {
status = STATUS_SUCCESS;
break;
} else {
break;
}
}
if (!NT_SUCCESS (status)) {
CmKdPrintEx((DPFLTR_CONFIG_ID,CML_BUGCHECK,"CM: CmpCloneHwProfile error finding new profile key %08lx\n", status));
goto Exit;
}
//
// Get the security descriptor from the old key to create the new clone one.
//
status = NtQuerySecurityObject (OldProfile,
DACL_SECURITY_INFORMATION,
NULL,
0,
&securityLength);
if (STATUS_BUFFER_TOO_SMALL == status) {
security = ExAllocatePool (PagedPool, securityLength);
if (security != NULL) {
status = NtQuerySecurityObject(OldProfile,
DACL_SECURITY_INFORMATION,
security,
securityLength,
&securityLength);
if (!NT_SUCCESS (status)) {
CmKdPrintEx((DPFLTR_CONFIG_ID,CML_BUGCHECK,"CM: CmpCloneHwProfile"
" - NtQuerySecurityObject failed %08lx\n", status));
ExFreePool(security);
security=NULL;
}
}
} else {
CmKdPrintEx((DPFLTR_CONFIG_ID,CML_BUGCHECK,"CM: CmpCloneHwProfile"
" - NtQuerySecurityObject returned %08lx\n", status));
security=NULL;
}
//
// Create the new key
//
InitializeObjectAttributes (&attributes,
&newProfileName,
OBJ_CASE_INSENSITIVE,
Parent,
security);
status = NtCreateKey (NewProfile,
KEY_READ | KEY_WRITE,
&attributes,
0,
NULL,
0,
&disposition);
if (NULL != security) {
ExFreePool (security);
}
if (!NT_SUCCESS (status)) {
CmKdPrintEx((DPFLTR_CONFIG_ID,CML_BUGCHECK,"CM: CmpCloneHwProfile couldn't create Clone %08lx\n",status));
goto Exit;
}
//
// Check to make sure the key was created. If it already exists,
// something is wrong.
//
if (disposition != REG_CREATED_NEW_KEY) {
CmKdPrintEx((DPFLTR_CONFIG_ID,CML_BUGCHECK,"CM: CmpCloneHwProfile: Clone tree already exists!\n"));
//
// WARNNOTE:
// If somebody somehow managed to create a key in our way,
// they'll thwart duplication of the prestine. Tough luck.
// Claim it worked and go on.
//
status = STATUS_SUCCESS;
goto Exit;
}
//
// Create the IDConfigDB Entry
//
swprintf (nameBuffer, L"Hardware Profiles\\%04d", *NewProfileNumber);
RtlInitUnicodeString (&name, nameBuffer);
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
IDConfigDB,
NULL);
status = NtCreateKey (&IDConfigDBEntry,
KEY_READ | KEY_WRITE,
&attributes,
0,
NULL,
0,
&disposition);
if (!NT_SUCCESS (status)) {
CmKdPrintEx((DPFLTR_CONFIG_ID,CML_BUGCHECK,"CM: CmpCloneHwProfile couldn't create Clone %08lx\n",status));
IDConfigDBEntry = NULL;
goto Exit;
}
//
// Determine the next PreferenceOrder for the new profile. (The
// PrefenceOrder for the new profile will be incrementally next from the
// greatest PreferenceOrder value of all the current profiles; assumes
// current set of PreferenceOrder values is incremental)
//
//
// Open the Hardware Profiles key
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_HARDWARE_PROFILES);
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
IDConfigDB,
NULL);
status = ZwOpenKey (&hardwareProfiles,
KEY_READ,
&attributes);
if (!NT_SUCCESS (status)) {
hardwareProfiles = NULL;
goto Exit;
}
//
// Find the number of profile Sub Keys
//
status = ZwQueryKey (hardwareProfiles,
KeyFullInformation,
valueBuffer,
sizeof (valueBuffer),
&length);
if (!NT_SUCCESS (status)) {
goto Exit;
}
//
// At very least, the Pristine and the new profile key we just created,
// should be there.
//
profileSubKeys = keyFullInfo->SubKeys;
ASSERT (1 < profileSubKeys);
//
// Initialize the highest PreferenceOrder value found to -1.
//
value = (ULONG)-1;
//
// Iterrate the profiles
//
for (i = 0; i < profileSubKeys; i++) {
//
// Enumerate all profile subkeys, noting their PreferenceOrder values.
//
status = ZwEnumerateKey (hardwareProfiles,
i,
KeyBasicInformation,
valueBuffer,
sizeof(valueBuffer) - sizeof (UNICODE_NULL), //term 0
&length);
if(!NT_SUCCESS(status)) {
break;
}
//
// Zero-terminate the subkey name just in case.
//
keyBasicInfo->Name[keyBasicInfo->NameLength/sizeof(WCHAR)] = 0;
//
// If this is the Pristine, or the NewProfile key, ignore it.
//
if ((!_wtoi(keyBasicInfo->Name)) ||
((ULONG)(_wtoi(keyBasicInfo->Name)) == *NewProfileNumber)) {
continue;
}
//
// Open this profile key
//
name.Length = (USHORT) keyBasicInfo->NameLength;
name.MaximumLength = (USHORT) keyBasicInfo->NameLength + sizeof (UNICODE_NULL);
name.Buffer = keyBasicInfo->Name;
InitializeObjectAttributes (&attributes,
&name,
OBJ_CASE_INSENSITIVE,
hardwareProfiles,
NULL);
status = ZwOpenKey (&profileEntry,
KEY_READ,
&attributes);
if (!NT_SUCCESS (status)) {
profileEntry = NULL;
continue;
}
//
// Extract The PreferenceOrder value for this Profile.
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_PREFERENCE_ORDER);
status = NtQueryValueKey(profileEntry,
&name,
KeyValueFullInformation,
valueBuffer,
sizeof(valueBuffer),
&length);
if (!NT_SUCCESS (status) || (keyValueInfo->Type != REG_DWORD)) {
//
// No PreferenceOrder; continue on as best we can
//
ZwClose(profileEntry);
profileEntry=NULL;
continue;
}
//
// If this is a the highest PreferenceOrder so far, reassign value to
// this PreferenceOrder, OR assign it this valid PreferenceOrder if
// value is still unassigned.
//
if (((*(PULONG) ((PUCHAR)keyValueInfo + keyValueInfo->DataOffset)) > value) ||
(value == -1)) {
value = (* (PULONG) ((PUCHAR)keyValueInfo + keyValueInfo->DataOffset));
}
ZwClose(profileEntry);
profileEntry=NULL;
}
//
// Increment value one above the greatest PreferenceOrder found.
// (If no other profiles were found, (value+=1) == 0, the most preferred
// profile)
//
value += 1;
//
// Give the new profile a preference order.
//
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_PREFERENCE_ORDER);
status = NtSetValueKey (IDConfigDBEntry,
&name,
0,
REG_DWORD,
&value,
sizeof (value));
//
// Give the new profile a friendly name, based on the DockingState
//
status = CmpCreateHwProfileFriendlyName(IDConfigDB,
DockingState,
*NewProfileNumber,
&friendlyName);
if (NT_SUCCESS(status)) {
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_FRIENDLY_NAME);
status = NtSetValueKey (IDConfigDBEntry,
&name,
0,
REG_SZ,
friendlyName.Buffer,
friendlyName.Length + sizeof(UNICODE_NULL));
RtlFreeUnicodeString(&friendlyName);
}
//
// Set the aliasable flag on the new "cloned profile" to be false
//
value = FALSE;
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_ALIASABLE);
status = NtSetValueKey (IDConfigDBEntry,
&name,
0,
REG_DWORD,
&value,
sizeof (value));
//
// Set the cloned profile on the new "cloned profile" to be true;
//
value = TRUE;
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_CLONED);
status = NtSetValueKey (IDConfigDBEntry,
&name,
0,
REG_DWORD,
&value,
sizeof (value));
//
// Set the HwProfileGuid for the brand new profile
//
status = ExUuidCreate (&uuid);
if (NT_SUCCESS (status)) {
status = RtlStringFromGUID (&uuid, &guidStr);
if (NT_SUCCESS (status)) {
RtlInitUnicodeString (&name, CM_HARDWARE_PROFILE_STR_HW_PROFILE_GUID);
status = NtSetValueKey (IDConfigDBEntry,
&name,
0,
REG_SZ,
guidStr.Buffer,
guidStr.MaximumLength);
RtlFreeUnicodeString(&guidStr);
} else {
//
// What's a fella to do?
// let's just go on.
//
status = STATUS_SUCCESS;
}
} else {
//
// let's just go on.
//
status = STATUS_SUCCESS;
}
//
// Clone the key
//
// (Copied lovingly from CmpCloneControlSet)
//
//
status = ObReferenceObjectByHandle (OldProfile,
KEY_READ,
CmpKeyObjectType,
KernelMode,
(PVOID *)(&oldProfileKey),
NULL);
if (!NT_SUCCESS(status)) {
CmKdPrintEx((DPFLTR_CONFIG_ID,CML_BUGCHECK,"CM: CmpCloneHWProfile: couldn't reference CurrentHandle %08lx\n",
status));
goto Exit;
}
status = ObReferenceObjectByHandle (*NewProfile,
KEY_WRITE,
CmpKeyObjectType,
KernelMode,
(PVOID *)(&newProfileKey),
NULL);
if (!NT_SUCCESS(status)) {
CmKdPrintEx((DPFLTR_CONFIG_ID,CML_BUGCHECK,"CM: CmpCloneHWProfile: couldn't reference CurrentHandle %08lx\n",
status));
goto Exit;
}
CmpLockRegistryExclusive();
//
// Note: This copy tree command does not copy the values in the
// root keys. We are relying on this, since the values stored there
// are things like "pristine" which we do not wish to have moved to the
// new tree.
//
if (CmpCopyTree(oldProfileKey->KeyControlBlock->KeyHive,
oldProfileKey->KeyControlBlock->KeyCell,
newProfileKey->KeyControlBlock->KeyHive,
newProfileKey->KeyControlBlock->KeyCell)) {
//
// Set the max subkey name property for the new target key.
//
PCM_KEY_NODE SourceNode;
PCM_KEY_NODE DestNode;
SourceNode = (PCM_KEY_NODE)HvGetCell(oldProfileKey->KeyControlBlock->KeyHive,oldProfileKey->KeyControlBlock->KeyCell);
if( SourceNode != NULL ) {
DestNode = (PCM_KEY_NODE)HvGetCell(newProfileKey->KeyControlBlock->KeyHive,newProfileKey->KeyControlBlock->KeyCell);
if( DestNode != NULL ) {
//
// CmpCopyTree doesn't do this.
//
ASSERT_CELL_DIRTY(newProfileKey->KeyControlBlock->KeyHive,newProfileKey->KeyControlBlock->KeyCell);
DestNode->MaxNameLen = SourceNode->MaxNameLen;
DestNode->MaxClassLen = SourceNode->MaxClassLen;
HvReleaseCell(newProfileKey->KeyControlBlock->KeyHive,newProfileKey->KeyControlBlock->KeyCell);
CmpRebuildKcbCache(newProfileKey->KeyControlBlock);
status = STATUS_SUCCESS;
} else {
status = STATUS_INSUFFICIENT_RESOURCES;
}
HvReleaseCell(oldProfileKey->KeyControlBlock->KeyHive,oldProfileKey->KeyControlBlock->KeyCell);
} else {
status = STATUS_INSUFFICIENT_RESOURCES;
}
} else {
CmKdPrintEx((DPFLTR_CONFIG_ID,CML_BUGCHECK,"CM: CmpCloneHwProfile: tree copy failed.\n"));
status = STATUS_REGISTRY_CORRUPT;
}
CmpUnlockRegistry();
Exit:
NtClose (OldProfile);
if (IDConfigDBEntry) {
NtClose (IDConfigDBEntry);
}
if (hardwareProfiles) {
NtClose (hardwareProfiles);
}
if (!NT_SUCCESS (status)) {
if (*NewProfile) {
NtClose (*NewProfile);
}
}
return status;
}
NTSTATUS
CmDeleteKeyRecursive(
HANDLE hKeyRoot,
PWSTR Key,
PVOID TemporaryBuffer,
ULONG LengthTemporaryBuffer,
BOOLEAN ThisKeyToo
)
/*++
Routine Description:
Routine to recursively delete all subkeys under the given
key, including the key given.
Arguments:
hKeyRoot: Handle to root relative to which the key to be deleted is
specified.
Key: Root relative path of the key which is to be recursively deleted.
ThisKeyToo: Whether after deletion of all subkeys, this key itself is to
be deleted.
Return Value:
Status is returned.
--*/
{
ULONG ResultLength;
PKEY_BASIC_INFORMATION KeyInfo;
NTSTATUS Status;
UNICODE_STRING UnicodeString;
OBJECT_ATTRIBUTES Obja;
PWSTR SubkeyName;
HANDLE hKey;
//
// Initialize
//
KeyInfo = (PKEY_BASIC_INFORMATION)TemporaryBuffer;
//
// Open the key
//
RtlInitUnicodeString (&UnicodeString,Key);
InitializeObjectAttributes(&Obja,
&UnicodeString,
OBJ_CASE_INSENSITIVE,
hKeyRoot,
NULL);
Status = ZwOpenKey(&hKey,KEY_ALL_ACCESS,&Obja);
if( !NT_SUCCESS(Status) ) {
return(Status);
}
//
// Enumerate all subkeys of the current key. if any exist they should
// be deleted first. since deleting the subkey affects the subkey
// index, we always enumerate on subkeyindex 0
//
while(1) {
Status = ZwEnumerateKey(
hKey,
0,
KeyBasicInformation,
TemporaryBuffer,
LengthTemporaryBuffer,
&ResultLength
);
if(!NT_SUCCESS(Status)) {
break;
}
//
// Zero-terminate the subkey name just in case.
//
KeyInfo->Name[KeyInfo->NameLength/sizeof(WCHAR)] = 0;
//
// Make a duplicate of the subkey name because the name is
// in TemporaryBuffer, which might get clobbered by recursive
// calls to this routine.
//
SubkeyName = ExAllocatePool (PagedPool,
((wcslen (KeyInfo->Name) + 1) *
sizeof (WCHAR)));
if (!SubkeyName) {
Status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
wcscpy(SubkeyName, KeyInfo->Name);
Status = CmDeleteKeyRecursive( hKey,
SubkeyName,
TemporaryBuffer,
LengthTemporaryBuffer,
TRUE);
ExFreePool(SubkeyName);
if(!NT_SUCCESS(Status)) {
break;
}
}
//
// Check the status, if the status is anything other than
// STATUS_NO_MORE_ENTRIES we failed in deleting some subkey,
// so we cannot delete this key too
//
if( Status == STATUS_NO_MORE_ENTRIES) {
Status = STATUS_SUCCESS;
}
if (!NT_SUCCESS (Status)) {
ZwClose(hKey);
return (Status);
}
//
// else delete the current key if asked to do so
//
if( ThisKeyToo ) {
Status = ZwDeleteKey (hKey);
}
ZwClose(hKey);
return(Status);
}
NTSTATUS
CmpCreateHwProfileFriendlyName (
IN HANDLE IDConfigDB,
IN ULONG DockingState,
IN ULONG NewProfileNumber,
OUT PUNICODE_STRING FriendlyName
)
/*++
Routine Description:
Create a new FriendlyName for a new Hardware Profile, given the DockState.
If a new profile name based on the DockState cannot be created, an attempt
is made to create a default FriendlyName based on NewProfileNumber. If
successful, a unicode string with the new profile friendlyName is created.
It is the responsibility of the caller to free this using
RtlFreeUnicodeString. If unsuccesful, no string is returned.
Arguments:
IDConfigDB: Handle to the IDConfigDB registry key.
DockingState: The Docking State of the profile for which the new
FriendlyName is being created. This should be one of:
HW_PROFILE_DOCKSTATE_DOCKED,
HW_PROFILE_DOCKSTATE_UNDOCKED, or
HW_PROFILE_DOCKSTATE_UNKNOWN
NewProfileNumber: The number of the new profile being created. If unable to
create a DockState specific FriendlyName, this value will
be used to create a (not-so) FriendlyName.
FriendlyName: Supplies a unicode string to receive the FriendlyName for this
new profile. The caller is expected to free this with
RtlFreeUnicodeString.
Return:
NTSTATUS code. Currently returns STATUS_SUCCESS, or STATUS_UNSUCCESSFUL.
Notes:
The new FriendlyName is generated from the DockState and appropriate
counter, and may not necessarily be unique among the existing Hardware
Profiles.
The naming scheme used here (including the localized strings in the kernel
message table) should be kept in sync with that provided to the user through
the Hardware Profile control panel applet.
--*/
{
NTSTATUS status = STATUS_SUCCESS;
ANSI_STRING ansiString;
UNICODE_STRING unicodeString;
UNICODE_STRING labelName, keyName;
PMESSAGE_RESOURCE_ENTRY messageEntry;
PKLDR_DATA_TABLE_ENTRY dataTableEntry;
ULONG messageId;
UCHAR valueBuffer[256];
WCHAR friendlyNameBuffer[MAX_FRIENDLY_NAME_LENGTH/sizeof(WCHAR)];
PKEY_VALUE_FULL_INFORMATION keyValueInfo;
ULONG length, index;
HANDLE hardwareProfiles=NULL;
OBJECT_ATTRIBUTES attributes;
PAGED_CODE ();
//
// Make sure we were given a place to put the FriendlyName
//
if (!FriendlyName) {
return STATUS_INVALID_PARAMETER;
}
//
// If we don't have a handle to IDConfigDB, try to assign a default
// FriendlyName on the way out.
//
if (!IDConfigDB) {
status = STATUS_INVALID_PARAMETER;
goto Exit;
}
//
// Determine the appropriate message to use, based on the DockState.
//
if ((DockingState & HW_PROFILE_DOCKSTATE_UNKNOWN) == HW_PROFILE_DOCKSTATE_UNKNOWN){
messageId = HARDWARE_PROFILE_UNKNOWN_STRING;
RtlInitUnicodeString(&labelName, CM_HARDWARE_PROFILE_STR_UNKNOWN);
} else if (DockingState & HW_PROFILE_DOCKSTATE_DOCKED) {
messageId = HARDWARE_PROFILE_DOCKED_STRING;
RtlInitUnicodeString(&labelName, CM_HARDWARE_PROFILE_STR_DOCKED);
} else if (DockingState & HW_PROFILE_DOCKSTATE_UNDOCKED) {
messageId = HARDWARE_PROFILE_UNDOCKED_STRING;
RtlInitUnicodeString(&labelName, CM_HARDWARE_PROFILE_STR_UNDOCKED);
} else {
messageId = HARDWARE_PROFILE_UNKNOWN_STRING;
RtlInitUnicodeString(&labelName, CM_HARDWARE_PROFILE_STR_UNKNOWN);
}
//
// Find the message entry in the kernel's own message table. KeLoaderBlock
// is available when we're creating hardware profiles during system
// initialization only; for profiles created thereafter, use the the first
// entry of the PsLoadedModuleList to get the image base of the kernel.
//
if (KeLoaderBlock) {
dataTableEntry = CONTAINING_RECORD(KeLoaderBlock->LoadOrderListHead.Flink,
KLDR_DATA_TABLE_ENTRY,
InLoadOrderLinks);
} else if (PsLoadedModuleList.Flink) {
dataTableEntry = CONTAINING_RECORD(PsLoadedModuleList.Flink,
KLDR_DATA_TABLE_ENTRY,
InLoadOrderLinks);
} else {
status = STATUS_UNSUCCESSFUL;
goto Exit;
}
status = RtlFindMessage(dataTableEntry->DllBase,
(ULONG_PTR)11, // RT_MESSAGETABLE
MAKELANGID(LANG_NEUTRAL,SUBLANG_SYS_DEFAULT), // System default language
messageId,
&messageEntry);
if (!NT_SUCCESS(status)) {
goto Exit;
}
if(!(messageEntry->Flags & MESSAGE_RESOURCE_UNICODE)) {
//
// If the message is not unicode, convert to unicode.
// Let the conversion routine allocate the buffer.
//
RtlInitAnsiString(&ansiString,(PCSZ)messageEntry->Text);
status = RtlAnsiStringToUnicodeString(&unicodeString,&ansiString,TRUE);
} else {
//
// Message is already unicode. Make a copy.
//
status = RtlCreateUnicodeString(&unicodeString,(PWSTR)messageEntry->Text);
}
if(!NT_SUCCESS(status)) {
goto Exit;
}
//
// Strip the trailing CRLF.
//
if (unicodeString.Length > 2 * sizeof(WCHAR)) {
unicodeString.Length -= 2 * sizeof(WCHAR);
unicodeString.Buffer[unicodeString.Length / sizeof(WCHAR)] = UNICODE_NULL;
}
//
// Check that the size of the label, with any numeric tag that may
// potentially be added (up to 4 digits, preceded by a space) is not too
// big.
//
if ((unicodeString.Length + 5*sizeof(WCHAR) + sizeof(UNICODE_NULL)) >
MAX_FRIENDLY_NAME_LENGTH) {
status = STATUS_UNSUCCESSFUL;
goto Clean;
}
//
// Open the Hardware Profiles key.
//
RtlInitUnicodeString(&keyName, CM_HARDWARE_PROFILE_STR_HARDWARE_PROFILES);
InitializeObjectAttributes(&attributes,
&keyName,
OBJ_CASE_INSENSITIVE,
IDConfigDB,
NULL);
status = ZwOpenKey(&hardwareProfiles,
KEY_READ,
&attributes);
if (!NT_SUCCESS(status)) {
hardwareProfiles = NULL;
goto Clean;
}
//
// Retrieve the counter of FriendlyNames we have previously assigned, based
// on this DockState.
//
keyValueInfo = (PKEY_VALUE_FULL_INFORMATION) valueBuffer;
status = ZwQueryValueKey(hardwareProfiles,
&labelName,
KeyValueFullInformation,
valueBuffer,
sizeof(valueBuffer),
&length);
if (NT_SUCCESS(status) && (keyValueInfo->Type == REG_DWORD)) {
//
// Increment the counter.
//
index = (* (PULONG) ((PUCHAR)keyValueInfo + keyValueInfo->DataOffset));
index++;
} else {
//
// Missing or invalid counter value; start the counter at "1".
//
index = 1;
}
//
// Update the counter in the registry.
//
status = ZwSetValueKey(hardwareProfiles,
&labelName,
0,
REG_DWORD,
&index,
sizeof(index));
if (!NT_SUCCESS(status)) {
goto Clean;
}
//
// Copy the FriendlyName, adding the index if necessary.
//
if ((messageId == HARDWARE_PROFILE_UNKNOWN_STRING) || (index > 1)) {
swprintf(friendlyNameBuffer, L"%s %u",
unicodeString.Buffer, index);
} else {
wcscpy(friendlyNameBuffer, unicodeString.Buffer);
}
Clean:
RtlFreeUnicodeString(&unicodeString);
if (hardwareProfiles!=NULL) {
ZwClose(hardwareProfiles);
}
Exit:
if (!NT_SUCCESS(status)) {
//
// If we failed to assign a counter-based FriendlyName for whatever
// reason, give the new profile a new (not so) friendly name as a last
// resort.
//
swprintf (friendlyNameBuffer, L"%04d", NewProfileNumber);
status = STATUS_SUCCESS;
}
//
// Create the unicode string to return to the caller.
//
if (!RtlCreateUnicodeString(FriendlyName, (PWSTR)friendlyNameBuffer)) {
status = STATUS_UNSUCCESSFUL;
}
return status;
} // CmpCreateHwProfileFriendlyName