hwprofil.c File Reference

#include "cmp.h"

Go to the source code of this file.

Functions
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)
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)
NTSTATUS	CmSetAcpiHwProfile (IN PPROFILE_ACPI_DOCKING_STATE NewDockState, IN PCM_ACPI_SELECTION_ROUTINE Select, IN PVOID Context, OUT PHANDLE NewProfile, OUT PBOOLEAN ProfileChanged)
NTSTATUS	CmpCloneHwProfile (IN HANDLE IDConfigDB, IN HANDLE Parent, IN HANDLE OldProfile, IN ULONG OldProfileNumber, IN USHORT DockingState, OUT PHANDLE NewProfile, OUT PULONG NewProfileNumber)
NTSTATUS	CmpCreateHwProfileFriendlyName (IN HANDLE IDConfigDB, IN ULONG DockingState, IN ULONG NewProfileNumber, OUT PUNICODE_STRING FriendlyName)
Variables
UNICODE_STRING	CmSymbolicLinkValueName

---

Function Documentation

NTSTATUS CmDeleteKeyRecursive (  HANDLE  hKeyRoot, PWSTR  Key, PVOID  TemporaryBuffer, ULONG  LengthTemporaryBuffer, BOOLEAN  ThisKeyToo )

Definition at line 2394 of file hwprofil.c. References ExAllocatePool, ExFreePool(), Key, NT_SUCCESS, NTSTATUS(), NULL, PagedPool, RtlInitUnicodeString(), Status, and TRUE. Referenced by CmpMoveBiosAliasTable(). : 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 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 )

Definition at line 544 of file hwprofil.c. References CM_HARDWARE_PROFILE_STR_ACPI_ALIAS, CM_HARDWARE_PROFILE_STR_ACPI_SERIAL_NUMBER, CM_HARDWARE_PROFILE_STR_DOCKING_STATE, CM_HARDWARE_PROFILE_STR_PROFILE_NUMBER, CML_BUGCHECK, CMLOG, CMS_INIT, L, NT_SUCCESS, NtClose(), NtCreateKey(), NtOpenKey(), NtQueryValueKey(), NtSetValueKey(), NTSTATUS(), NULL, PAGED_CODE, and RtlInitUnicodeString(). Referenced by CmpCreateControlSet(), and CmSetAcpiHwProfile(). : 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; ANSI_STRING ansiString; 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)) { CMLOG(CML_BUGCHECK, CMS_INIT) { KdPrint(("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)) { CMLOG(CML_BUGCHECK, CMS_INIT) { KdPrint(("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 CmpCloneHwProfile (  IN HANDLE  IDConfigDB, IN HANDLE  Parent, IN HANDLE  OldProfile, IN ULONG  OldProfileNumber, IN USHORT  DockingState, OUT PHANDLE  NewProfile, OUT PULONG  NewProfileNumber )

Definition at line 1869 of file hwprofil.c. References ASSERT, CM_HARDWARE_PROFILE_STR_ALIASABLE, CM_HARDWARE_PROFILE_STR_CLONED, CM_HARDWARE_PROFILE_STR_FRIENDLY_NAME, CM_HARDWARE_PROFILE_STR_HARDWARE_PROFILES, CM_HARDWARE_PROFILE_STR_HW_PROFILE_GUID, CM_HARDWARE_PROFILE_STR_PREFERENCE_ORDER, CML_BUGCHECK, CMLOG, CmpCopyTree, CmpCreateHwProfileFriendlyName(), CmpKeyObjectType, CmpLockRegistryExclusive(), CmpUnlockRegistry(), CMS_INIT, ExAllocatePool, ExFreePool(), ExUuidCreate(), FALSE, KernelMode, L, NT_SUCCESS, NtClose(), NtCreateKey(), NtOpenKey(), NtQuerySecurityObject(), NtQueryValueKey(), NtSetValueKey(), NTSTATUS(), NULL, ObReferenceObjectByHandle(), PAGED_CODE, PagedPool, RtlFreeUnicodeString(), RtlInitUnicodeString(), RtlStringFromGUID(), TRUE, USHORT, and UUID. Referenced by CmpCreateControlSet(), and CmSetAcpiHwProfile(). : 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)) { CMLOG(CML_BUGCHECK, CMS_INIT) { KdPrint(("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)) { CMLOG(CML_BUGCHECK, CMS_INIT) { KdPrint(("CM: CmpCloneHwProfile" " - NtQuerySecurityObject failed %08lx\n", status)); } ExFreePool(security); security=NULL; } } } else { CMLOG(CML_BUGCHECK, CMS_INIT) { KdPrint(("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)) { CMLOG(CML_BUGCHECK, CMS_INIT) { KdPrint(("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) { CMLOG(CML_BUGCHECK, CMS_INIT) { // KdPrint(("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)) { CMLOG(CML_BUGCHECK, CMS_INIT) { KdPrint(("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 = -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)) { CMLOG(CML_BUGCHECK, CMS_INIT) { KdPrint(("CM: CmpCloneHWProfile: couldn't reference CurrentHandle %08lx\n", status)); } goto Exit; } ObReferenceObjectByHandle (*NewProfile, KEY_WRITE, CmpKeyObjectType, KernelMode, (PVOID *)(&newProfileKey), NULL); if (!NT_SUCCESS(status)) { CMLOG(CML_BUGCHECK, CMS_INIT) { KdPrint(("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. // newProfileKey->KeyControlBlock->KeyNode->MaxNameLen = oldProfileKey->KeyControlBlock->KeyNode->MaxNameLen; status = STATUS_SUCCESS; } else { CMLOG(CML_BUGCHECK, CMS_INIT) { KdPrint(("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 CmpCreateHwProfileFriendlyName (  IN HANDLE  IDConfigDB, IN ULONG  DockingState, IN ULONG  NewProfileNumber, OUT PUNICODE_STRING  FriendlyName )

Definition at line 2529 of file hwprofil.c. References CM_HARDWARE_PROFILE_STR_DOCKED, CM_HARDWARE_PROFILE_STR_HARDWARE_PROFILES, CM_HARDWARE_PROFILE_STR_UNDOCKED, CM_HARDWARE_PROFILE_STR_UNKNOWN, HW_PROFILE_DOCKSTATE_DOCKED, HW_PROFILE_DOCKSTATE_UNDOCKED, HW_PROFILE_DOCKSTATE_UNKNOWN, KeLoaderBlock, L, _LOADER_PARAMETER_BLOCK::LoadOrderListHead, MAX_FRIENDLY_NAME_LENGTH, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, PsLoadedModuleList, RtlAnsiStringToUnicodeString(), RtlCreateUnicodeString(), RtlFindMessage(), RtlFreeUnicodeString(), RtlInitAnsiString(), RtlInitUnicodeString(), and TRUE. Referenced by CmpCloneHwProfile(). 02537 : 02538 02539 Create a new FriendlyName for a new Hardware Profile, given the DockState. 02540 If a new profile name based on the DockState cannot be created, an attempt 02541 is made to create a default FriendlyName based on NewProfileNumber. If 02542 successful, a unicode string with the new profile friendlyName is created. 02543 It is the responsibility of the caller to free this using 02544 RtlFreeUnicodeString. If unsuccesful, no string is returned. 02545 02546 Arguments: 02547 02548 IDConfigDB: Handle to the IDConfigDB registry key. 02549 02550 DockingState: The Docking State of the profile for which the new 02551 FriendlyName is being created. This should be one of: 02552 HW_PROFILE_DOCKSTATE_DOCKED, 02553 HW_PROFILE_DOCKSTATE_UNDOCKED, or 02554 HW_PROFILE_DOCKSTATE_UNKNOWN 02555 02556 NewProfileNumber: The number of the new profile being created. If unable to 02557 create a DockState specific FriendlyName, this value will 02558 be used to create a (not-so) FriendlyName. 02559 02560 FriendlyName: Supplies a unicode string to receive the FriendlyName for this 02561 new profile. The caller is expected to free this with 02562 RtlFreeUnicodeString. 02563 02564 Return: 02565 02566 NTSTATUS code. Currently returns STATUS_SUCCESS, or STATUS_UNSUCCESSFUL. 02567 02568 Notes: 02569 02570 The new FriendlyName is generated from the DockState and appropriate 02571 counter, and may not necessarily be unique among the existing Hardware 02572 Profiles. 02573 02574 The naming scheme used here (including the localized strings in the kernel 02575 message table) should be kept in sync with that provided to the user through 02576 the Hardware Profile control panel applet. 02577 02578 --*/ 02579 { 02580 NTSTATUS status = STATUS_SUCCESS; 02581 ANSI_STRING ansiString; 02582 UNICODE_STRING unicodeString; 02583 UNICODE_STRING labelName, keyName; 02584 PMESSAGE_RESOURCE_ENTRY messageEntry; 02585 PLDR_DATA_TABLE_ENTRY dataTableEntry; 02586 ULONG messageId; 02587 UCHAR valueBuffer[256]; 02588 WCHAR friendlyNameBuffer[MAX_FRIENDLY_NAME_LENGTH/sizeof(WCHAR)]; 02589 PKEY_VALUE_FULL_INFORMATION keyValueInfo; 02590 ULONG length, index; 02591 HANDLE hardwareProfiles=NULL; 02592 OBJECT_ATTRIBUTES attributes; 02593 02594 PAGED_CODE (); 02595 02596 // 02597 // Make sure we were given a place to put the FriendlyName 02598 // 02599 if (!FriendlyName) { 02600 return STATUS_INVALID_PARAMETER; 02601 } 02602 02603 // 02604 // If we don't have a handle to IDConfigDB, try to assign a default 02605 // FriendlyName on the way out. 02606 // 02607 if (!IDConfigDB) { 02608 status = STATUS_INVALID_PARAMETER; 02609 goto Exit; 02610 } 02611 02612 // 02613 // Determine the appropriate message to use, based on the DockState. 02614 // 02615 if ((DockingState & HW_PROFILE_DOCKSTATE_UNKNOWN) == HW_PROFILE_DOCKSTATE_UNKNOWN){ 02616 messageId = HARDWARE_PROFILE_UNKNOWN_STRING; 02617 RtlInitUnicodeString(&labelName, CM_HARDWARE_PROFILE_STR_UNKNOWN); 02618 } else if (DockingState & HW_PROFILE_DOCKSTATE_DOCKED) { 02619 messageId = HARDWARE_PROFILE_DOCKED_STRING; 02620 RtlInitUnicodeString(&labelName, CM_HARDWARE_PROFILE_STR_DOCKED); 02621 } else if (DockingState & HW_PROFILE_DOCKSTATE_UNDOCKED) { 02622 messageId = HARDWARE_PROFILE_UNDOCKED_STRING; 02623 RtlInitUnicodeString(&labelName, CM_HARDWARE_PROFILE_STR_UNDOCKED); 02624 } else { 02625 messageId = HARDWARE_PROFILE_UNKNOWN_STRING; 02626 RtlInitUnicodeString(&labelName, CM_HARDWARE_PROFILE_STR_UNKNOWN); 02627 } 02628 02629 // 02630 // Find the message entry in the kernel's own message table. KeLoaderBlock 02631 // is available when we're creating hardware profiles during system 02632 // initialization only; for profiles created thereafter, use the the first 02633 // entry of the PsLoadedModuleList to get the image base of the kernel. 02634 // 02635 if (KeLoaderBlock) { 02636 dataTableEntry = CONTAINING_RECORD(KeLoaderBlock->LoadOrderListHead.Flink, 02637 LDR_DATA_TABLE_ENTRY, 02638 InLoadOrderLinks); 02639 } else if (PsLoadedModuleList.Flink) { 02640 dataTableEntry = CONTAINING_RECORD(PsLoadedModuleList.Flink, 02641 LDR_DATA_TABLE_ENTRY, 02642 InLoadOrderLinks); 02643 } else { 02644 status = STATUS_UNSUCCESSFUL; 02645 goto Exit; 02646 } 02647 02648 status = RtlFindMessage(dataTableEntry->DllBase, 02649 (ULONG_PTR)11, // RT_MESSAGETABLE 02650 MAKELANGID(LANG_NEUTRAL,SUBLANG_SYS_DEFAULT), // System default language 02651 messageId, 02652 &messageEntry); 02653 02654 if (!NT_SUCCESS(status)) { 02655 goto Exit; 02656 } 02657 02658 if(!(messageEntry->Flags & MESSAGE_RESOURCE_UNICODE)) { 02659 // 02660 // If the message is not unicode, convert to unicode. 02661 // Let the conversion routine allocate the buffer. 02662 // 02663 RtlInitAnsiString(&ansiString,messageEntry->Text); 02664 status = RtlAnsiStringToUnicodeString(&unicodeString,&ansiString,TRUE); 02665 } else { 02666 // 02667 // Message is already unicode. Make a copy. 02668 // 02669 status = RtlCreateUnicodeString(&unicodeString,(PWSTR)messageEntry->Text); 02670 } 02671 02672 if(!NT_SUCCESS(status)) { 02673 goto Exit; 02674 } 02675 02676 // 02677 // Strip the trailing CRLF. 02678 // 02679 if (unicodeString.Length > 2 * sizeof(WCHAR)) { 02680 unicodeString.Length -= 2 * sizeof(WCHAR); 02681 unicodeString.Buffer[unicodeString.Length / sizeof(WCHAR)] = UNICODE_NULL; 02682 } 02683 02684 // 02685 // Check that the size of the label, with any numeric tag that may 02686 // potentially be added (up to 4 digits, preceded by a space) is not too 02687 // big. 02688 // 02689 if ((unicodeString.Length + 5*sizeof(WCHAR) + sizeof(UNICODE_NULL)) > 02690 MAX_FRIENDLY_NAME_LENGTH) { 02691 status = STATUS_UNSUCCESSFUL; 02692 goto Clean; 02693 } 02694 02695 // 02696 // Open the Hardware Profiles key. 02697 // 02698 RtlInitUnicodeString(&keyName, CM_HARDWARE_PROFILE_STR_HARDWARE_PROFILES); 02699 InitializeObjectAttributes(&attributes, 02700 &keyName, 02701 OBJ_CASE_INSENSITIVE, 02702 IDConfigDB, 02703 NULL); 02704 status = ZwOpenKey(&hardwareProfiles, 02705 KEY_READ, 02706 &attributes); 02707 if (!NT_SUCCESS(status)) { 02708 hardwareProfiles = NULL; 02709 goto Clean; 02710 } 02711 02712 // 02713 // Retrieve the counter of FriendlyNames we have previously assigned, based 02714 // on this DockState. 02715 // 02716 keyValueInfo = (PKEY_VALUE_FULL_INFORMATION) valueBuffer; 02717 status = ZwQueryValueKey(hardwareProfiles, 02718 &labelName, 02719 KeyValueFullInformation, 02720 valueBuffer, 02721 sizeof(valueBuffer), 02722 &length); 02723 02724 if (NT_SUCCESS(status) && (keyValueInfo->Type == REG_DWORD)) { 02725 // 02726 // Increment the counter. 02727 // 02728 index = (* (PULONG) ((PUCHAR)keyValueInfo + keyValueInfo->DataOffset)); 02729 index++; 02730 } else { 02731 // 02732 // Missing or invalid counter value; start the counter at "1". 02733 // 02734 index = 1; 02735 } 02736 02737 // 02738 // Update the counter in the registry. 02739 // 02740 status = ZwSetValueKey(hardwareProfiles, 02741 &labelName, 02742 0, 02743 REG_DWORD, 02744 &index, 02745 sizeof(index)); 02746 if (!NT_SUCCESS(status)) { 02747 goto Clean; 02748 } 02749 02750 // 02751 // Copy the FriendlyName, adding the index if necessary. 02752 // 02753 if ((messageId == HARDWARE_PROFILE_UNKNOWN_STRING) || (index > 1)) { 02754 swprintf(friendlyNameBuffer, L"%s %u", 02755 unicodeString.Buffer, index); 02756 } else { 02757 wcscpy(friendlyNameBuffer, unicodeString.Buffer); 02758 } 02759 02760 Clean: 02761 02762 RtlFreeUnicodeString(&unicodeString); 02763 02764 if (hardwareProfiles!=NULL) { 02765 ZwClose(hardwareProfiles); 02766 } 02767 02768 Exit: 02769 02770 if (!NT_SUCCESS(status)) { 02771 // 02772 // If we failed to assign a counter-based FriendlyName for whatever 02773 // reason, give the new profile a new (not so) friendly name as a last 02774 // resort. 02775 // 02776 swprintf (friendlyNameBuffer, L"%04d", NewProfileNumber); 02777 status = STATUS_SUCCESS; 02778 } 02779 02780 // 02781 // Create the unicode string to return to the caller. 02782 // 02783 if (!RtlCreateUnicodeString(FriendlyName, (PWSTR)friendlyNameBuffer)) { 02784 status = STATUS_UNSUCCESSFUL; 02785 } 02786 02787 return status; 02788 02789 } // CmpCreateHwProfileFriendlyName } // CmpCreateHwProfileFriendlyName

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 )

Definition at line 1282 of file hwprofil.c. References ASSERT, CM_HP_FLAGS_ALIASABLE, CM_HP_FLAGS_DUPLICATE, CM_HP_FLAGS_PRISTINE, CM_HP_FLAGS_TRUE_MATCH, _CM_HARDWARE_PROFILE_ACPI_ALIAS::DockState, FALSE, HW_PROFILE_DOCKSTATE_DOCKED, HW_PROFILE_DOCKSTATE_UNDOCKED, NTSTATUS(), NULL, PAGED_CODE, _CM_HARDWARE_PROFILE_ACPI_ALIAS::ProfileNumber, _CM_HARDWARE_PROFILE_ACPI_ALIAS::SerialLength, _CM_HARDWARE_PROFILE_ACPI_ALIAS::SerialNumber, and TRUE. Referenced by CmSetAcpiHwProfile(). : 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 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 )

Definition at line 76 of file hwprofil.c. References ASSERT, CM_HARDWARE_PROFILE_STR_ACPI_ALIAS, CM_HARDWARE_PROFILE_STR_ACPI_SERIAL_NUMBER, CM_HARDWARE_PROFILE_STR_ALIASABLE, CM_HARDWARE_PROFILE_STR_DOCKING_STATE, CM_HARDWARE_PROFILE_STR_FRIENDLY_NAME, CM_HARDWARE_PROFILE_STR_HARDWARE_PROFILES, CM_HARDWARE_PROFILE_STR_PREFERENCE_ORDER, CM_HARDWARE_PROFILE_STR_PRISTINE, CM_HARDWARE_PROFILE_STR_PROFILE_NUMBER, CM_HP_FLAGS_ALIASABLE, CM_HP_FLAGS_PRISTINE, ExAllocatePool, ExFreePool(), _CM_HARDWARE_PROFILE::Flags, _CM_HARDWARE_PROFILE::FriendlyName, _CM_HARDWARE_PROFILE::Id, KeyName, L, _CM_HARDWARE_PROFILE::NameLength, NT_SUCCESS, NtClose(), NtQueryValueKey(), NTSTATUS(), NULL, PAGED_CODE, PagedPool, _CM_HARDWARE_PROFILE::PreferenceOrder, RtlInitUnicodeString(), RtlUnicodeStringToInteger(), and USHORT. Referenced by CmSetAcpiHwProfile(). : 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 (); *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; UNICODE_STRING KeyName; ULONG realsize; // // 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 = -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 len; PVOID buffer; len = sizeof (tmpname); buffer = ExAllocatePool (PagedPool, len); TempProfile.NameLength = len; 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 = -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 CmpMoveBiosAliasTable (  IN HANDLE  IDConfigDB, IN HANDLE  CurrentInfo, IN ULONG  CurrentProfileNumber, IN ULONG  NewProfileNumber, IN PWCHAR  nameBuffer, IN PCHAR  valueBuffer, IN ULONG  bufferLen )

Definition at line 1513 of file hwprofil.c. References ASSERT, CM_HARDWARE_PROFILE_STR_ALIAS, CM_HARDWARE_PROFILE_STR_CCS_HWPROFILE, CM_HARDWARE_PROFILE_STR_CLONED, CM_HARDWARE_PROFILE_STR_DOCKID, CM_HARDWARE_PROFILE_STR_HARDWARE_PROFILES, CM_HARDWARE_PROFILE_STR_PROFILE_NUMBER, CM_HARDWARE_PROFILE_STR_SERIAL_NUMBER, CmDeleteKeyRecursive(), L, NT_SUCCESS, NtQueryValueKey(), NtSetValueKey(), NTSTATUS(), NULL, PAGED_CODE, RtlInitUnicodeString(), TRUE, and USHORT. Referenced by CmSetAcpiHwProfile(). : 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 CmSetAcpiHwProfile (  IN PPROFILE_ACPI_DOCKING_STATE  NewDockState, IN PCM_ACPI_SELECTION_ROUTINE  Select, IN PVOID  Context, OUT PHANDLE  NewProfile, OUT PBOOLEAN  ProfileChanged )

Definition at line 805 of file hwprofil.c. References _CM_HARDWARE_PROFILE_ACPI_ALIAS_LIST::Alias, ASSERT, CM_HARDWARE_PROFILE_STR_ACPI_SERIAL_NUMBER, CM_HARDWARE_PROFILE_STR_CCS_CURRENT, CM_HARDWARE_PROFILE_STR_CCS_HWPROFILE, CM_HARDWARE_PROFILE_STR_CURRENT_DOCK_INFO, CM_HARDWARE_PROFILE_STR_DATABASE, CM_HARDWARE_PROFILE_STR_DOCKING_STATE, CM_HP_FLAGS_DUPLICATE, CM_HP_FLAGS_PRISTINE, CM_HP_FLAGS_TRUE_MATCH, CmpAddAcpiAliasEntry(), CmpCloneHwProfile(), CmpFilterAcpiDockingState(), CmpGetAcpiProfileInformation(), CmpMoveBiosAliasTable(), CmSymbolicLinkValueName, _CM_HARDWARE_PROFILE_ACPI_ALIAS_LIST::CurrentAliasCount, _CM_HARDWARE_PROFILE_LIST::CurrentProfileCount, ExAllocatePool, ExFreePool(), FALSE, _CM_HARDWARE_PROFILE::Flags, _CM_HARDWARE_PROFILE::FriendlyName, _CM_HARDWARE_PROFILE::Id, L, NT_SUCCESS, NtCreateKey(), NtQueryValueKey(), NtSetValueKey(), NTSTATUS(), NULL, PAGED_CODE, PagedPool, _CM_HARDWARE_PROFILE_LIST::Profile, RtlInitUnicodeString(), _CM_HARDWARE_PROFILE_ACPI_ALIAS::SerialNumber, and TRUE. Referenced by CmpCreateControlSet(), and IopExecuteHardwareProfileChange(). : 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; UCHAR 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, 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; }

---

Variable Documentation

UNICODE_STRING CmSymbolicLinkValueName

Definition at line 73 of file hwprofil.c.

---