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.
1227 lines
30 KiB
1227 lines
30 KiB
/*++
|
|
|
|
|
|
Copyright (c) 1991 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
RegvCls.c
|
|
|
|
Abstract:
|
|
|
|
This module contains helper functions for enumerating,
|
|
setting, and querying registry values in win32
|
|
|
|
Author:
|
|
|
|
Adam Edwards (adamed) 06-May-1998
|
|
|
|
Key Functions:
|
|
|
|
Notes:
|
|
|
|
|
|
--*/
|
|
|
|
|
|
#ifdef LOCAL
|
|
|
|
#include <rpc.h>
|
|
#include "regrpc.h"
|
|
#include "localreg.h"
|
|
#include "regclass.h"
|
|
#include "regvcls.h"
|
|
|
|
|
|
|
|
void ValStateGetPhysicalIndexFromLogical(
|
|
ValueState* pValState,
|
|
HKEY hkLogicalKey,
|
|
DWORD dwLogicalIndex,
|
|
PHKEY phkPhysicalKey,
|
|
DWORD* pdwPhysicalIndex)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Retrieves a logical index for a value to a physical index
|
|
|
|
Arguments:
|
|
|
|
pValState - value state containing values for a logical key
|
|
hkLogicalKey - logical key we wish to index
|
|
dwLogicalIndex - logical index to map
|
|
phkPhysicalKey - handle to key where value is physically located
|
|
pdwPhysicalIndex - index of value in physical key
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
Notes:
|
|
|
|
--*/
|
|
{
|
|
//
|
|
// If no value state is supplied, this means no merging is necessary
|
|
// and we can return the supplied logical index as the correct
|
|
// physical index
|
|
//
|
|
if (!pValState) {
|
|
*pdwPhysicalIndex = dwLogicalIndex;
|
|
*phkPhysicalKey = hkLogicalKey;
|
|
} else {
|
|
*pdwPhysicalIndex = pValState->rgIndex[dwLogicalIndex].dwOffset;
|
|
*phkPhysicalKey = pValState->rgIndex[dwLogicalIndex].fUser ?
|
|
pValState->hkUser :
|
|
pValState->hkMachine;
|
|
}
|
|
}
|
|
|
|
|
|
NTSTATUS ValStateSetPhysicalIndexFromLogical(
|
|
ValueState* pValState,
|
|
DWORD dwLogicalIndex)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Updates a state's mapping of logical indexes to physical indexes
|
|
|
|
Arguments:
|
|
|
|
pValState - value state containing values for a logical key
|
|
dwLogicalIndex - logical index used as a clue for whether
|
|
or not we can used cached values or need to refresh the state --
|
|
gives us an idea of what index the caller will be interested in
|
|
mapping after this call.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
Notes:
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status;
|
|
|
|
Status = STATUS_SUCCESS;
|
|
|
|
//
|
|
// If no value state is supplied, this means no merging is necessary
|
|
// and we can return the supplied logical index as the correct
|
|
// physical index
|
|
//
|
|
if (!pValState) {
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
if (dwLogicalIndex >= pValState->cValues) {
|
|
|
|
pValState->fDelete = TRUE;
|
|
return STATUS_NO_MORE_ENTRIES;
|
|
}
|
|
|
|
//
|
|
// Always reset if they try to go backward, or
|
|
// if they skip by more than 1, or if they
|
|
// ask for the same index twice and we're
|
|
// not expecting it
|
|
//
|
|
if ((dwLogicalIndex < pValState->dwCurrent) ||
|
|
(dwLogicalIndex > (pValState->dwCurrent + 1)) ||
|
|
((dwLogicalIndex == pValState->dwCurrent) && !(pValState->fIgnoreResetOnRetry))) {
|
|
|
|
Status = ValStateUpdate(pValState);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
return Status;
|
|
}
|
|
|
|
pValState->fIgnoreResetOnRetry = FALSE;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
void ValStateRelease(
|
|
ValueState* pValState)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Frees resources (handles, memory) associated with a value state
|
|
|
|
Arguments:
|
|
|
|
pValState - value state containing values for a logical key
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
Notes:
|
|
|
|
--*/
|
|
{
|
|
if (!pValState) {
|
|
return;
|
|
}
|
|
|
|
if (pValState->hkUser && (pValState->hkUser != pValState->hkLogical)) {
|
|
NtClose(pValState->hkUser);
|
|
}
|
|
|
|
if (pValState->hkMachine && (pValState->hkMachine != pValState->hkLogical)) {
|
|
NtClose(pValState->hkMachine);
|
|
}
|
|
|
|
if (pValState->rgIndex) {
|
|
RegClassHeapFree(pValState->rgIndex);
|
|
}
|
|
|
|
RegClassHeapFree(pValState);
|
|
}
|
|
|
|
|
|
NTSTATUS ValStateUpdate(ValueState* pValState)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Updates the value state to reflect the current state
|
|
of the logical key's physical state -- it retrieves
|
|
the names of the values for the logical key from
|
|
the kernel, and re-indexes the table to properly
|
|
merge user and machine state
|
|
|
|
Arguments:
|
|
|
|
pValState - value state containing values for a logical key
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS for success, error code otherwise.
|
|
|
|
Notes:
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status;
|
|
DWORD cUserValues;
|
|
DWORD cMachineValues;
|
|
DWORD cMaxValues;
|
|
DWORD cbMaxNameLen;
|
|
DWORD cbMaxDataLen;
|
|
DWORD cbBufferLen;
|
|
ValueLocation* rgIndex;
|
|
PKEY_VALUE_BASIC_INFORMATION* ppValueInfo;
|
|
|
|
//
|
|
// Init locals
|
|
//
|
|
cUserValues = 0;
|
|
cMachineValues = 0;
|
|
cbMaxNameLen = 0;
|
|
rgIndex = NULL;
|
|
|
|
pValState->cValues = 0;
|
|
|
|
//
|
|
// Get information about this value
|
|
//
|
|
Status = GetFixedKeyInfo(
|
|
pValState->hkUser,
|
|
pValState->hkMachine,
|
|
&cUserValues,
|
|
&cMachineValues,
|
|
NULL,
|
|
NULL,
|
|
&cbMaxNameLen);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
return Status;
|
|
}
|
|
|
|
cMaxValues = cUserValues + cMachineValues;
|
|
|
|
//
|
|
// Nothing to do if there are no Values
|
|
//
|
|
if (!cMaxValues) {
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Now allocate necessary memory
|
|
// First get memory for index vector
|
|
//
|
|
rgIndex = (ValueLocation*) RegClassHeapAlloc(cMaxValues * sizeof(*rgIndex));
|
|
|
|
if (!rgIndex) {
|
|
return STATUS_NO_MEMORY;
|
|
}
|
|
|
|
//
|
|
// Now get memory for retrieving names -- first allocate an array
|
|
// of pointers to values
|
|
//
|
|
ppValueInfo = (PKEY_VALUE_BASIC_INFORMATION*) RegClassHeapAlloc(
|
|
sizeof(*ppValueInfo) * cMaxValues);
|
|
|
|
if (!ppValueInfo) {
|
|
|
|
RegClassHeapFree(rgIndex);
|
|
|
|
return STATUS_NO_MEMORY;
|
|
}
|
|
|
|
RtlZeroMemory(ppValueInfo, sizeof(*ppValueInfo) * cMaxValues);
|
|
|
|
cbBufferLen = sizeof(**ppValueInfo) + cbMaxNameLen;
|
|
|
|
//
|
|
// Now allocate each individual value
|
|
//
|
|
{
|
|
DWORD dwValue;
|
|
|
|
for (dwValue = 0; dwValue < cMaxValues; dwValue++)
|
|
{
|
|
ppValueInfo[dwValue] = (PKEY_VALUE_BASIC_INFORMATION) RegClassHeapAlloc(
|
|
cbBufferLen);
|
|
|
|
if (!(ppValueInfo)[dwValue]) {
|
|
Status = STATUS_NO_MEMORY;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now fetch the values. From this point on we are assuming success
|
|
// and updating the index table
|
|
//
|
|
{
|
|
|
|
HKEY hKeyPhysical;
|
|
DWORD dwLimit;
|
|
DWORD dwLogical;
|
|
BOOL fUser;
|
|
|
|
//
|
|
// Free the existing index table
|
|
//
|
|
if (pValState->rgIndex) {
|
|
RegClassHeapFree(pValState->rgIndex);
|
|
}
|
|
|
|
pValState->rgIndex = rgIndex;
|
|
|
|
dwLogical = 0;
|
|
|
|
for( hKeyPhysical = pValState->hkUser, fUser = TRUE,
|
|
dwLimit = cUserValues;
|
|
;
|
|
hKeyPhysical = pValState->hkMachine, fUser = FALSE,
|
|
dwLimit = cMachineValues)
|
|
{
|
|
DWORD dwPhysical;
|
|
|
|
for (dwPhysical = 0; dwPhysical < dwLimit; dwPhysical++)
|
|
{
|
|
BOOL fNewValue;
|
|
|
|
//
|
|
// Ask the kernel for the value
|
|
//
|
|
Status = EnumerateValue(
|
|
hKeyPhysical,
|
|
dwPhysical,
|
|
ppValueInfo[dwLogical],
|
|
cbBufferLen,
|
|
NULL);
|
|
|
|
//
|
|
// If we encounter an error, just keep going and try to get
|
|
// as many values as we can
|
|
//
|
|
if (!NT_SUCCESS(Status)) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Mark certain attributes about this value that will
|
|
// be important later
|
|
//
|
|
ppValueInfo[dwLogical]->TitleIndex = dwPhysical;
|
|
ppValueInfo[dwLogical]->Type = fUser;
|
|
|
|
|
|
//
|
|
// This will add the value to our sorted list. Since
|
|
// the list is sorted, it is easy to eliminated duplicates --
|
|
// don't add duplicates -- since we add
|
|
// user keys first, this allows us to give user values precedence
|
|
// over machine values of the same name. The logical key
|
|
// index is also incremented if a key is added.
|
|
//
|
|
fNewValue = ValStateAddValueToSortedValues(
|
|
ppValueInfo,
|
|
dwLogical);
|
|
|
|
if (fNewValue) {
|
|
dwLogical++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Break out of this loop if we just added the user values
|
|
// since those are the last values we add
|
|
//
|
|
if (!fUser) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
pValState->cValues = dwLogical;
|
|
}
|
|
|
|
//
|
|
// Now copy the results back to the state's index array
|
|
//
|
|
{
|
|
|
|
DWORD dwLogical;
|
|
|
|
for (dwLogical = 0; dwLogical < pValState->cValues; dwLogical++)
|
|
{
|
|
|
|
pValState->rgIndex[dwLogical].dwOffset =
|
|
ppValueInfo[dwLogical]->TitleIndex;
|
|
|
|
pValState->rgIndex[dwLogical].fUser =
|
|
ppValueInfo[dwLogical]->Type;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Release this
|
|
//
|
|
ValStateReleaseValues(
|
|
ppValueInfo,
|
|
cMaxValues);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
void ValStateReleaseValues(
|
|
PKEY_VALUE_BASIC_INFORMATION* ppValueInfo,
|
|
DWORD cMaxValues)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Releases resources associated with the values stored
|
|
in the value state.
|
|
|
|
Arguments:
|
|
|
|
pValState - value state containing values for a logical key
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
Notes:
|
|
|
|
--*/
|
|
{
|
|
DWORD dwValue;
|
|
|
|
//
|
|
// First, free each individual value
|
|
//
|
|
for (dwValue = 0; dwValue < cMaxValues; dwValue++)
|
|
{
|
|
//
|
|
// Free memory for this value
|
|
//
|
|
if (ppValueInfo[dwValue]) {
|
|
RegClassHeapFree(ppValueInfo[dwValue]);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now free the array that held all the values
|
|
//
|
|
RegClassHeapFree(ppValueInfo);
|
|
}
|
|
|
|
|
|
|
|
NTSTATUS ValStateInitialize(
|
|
ValueState** ppValState,
|
|
HKEY hKey)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Initializes a value state
|
|
|
|
Arguments:
|
|
|
|
pValState - value state containing values for a logical key
|
|
hKey - logical key whose state this value state will represent
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS for success, error code otherwise.
|
|
|
|
Notes:
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status;
|
|
ValueState* pValState;
|
|
HKEY hkUser;
|
|
HKEY hkMachine;
|
|
|
|
//
|
|
// Initialize conditionally freed resources
|
|
//
|
|
hkUser = NULL;
|
|
hkMachine = NULL;
|
|
|
|
pValState = NULL;
|
|
|
|
//
|
|
// Get the user and machine keys
|
|
//
|
|
Status = BaseRegGetUserAndMachineClass(
|
|
NULL,
|
|
hKey,
|
|
MAXIMUM_ALLOWED,
|
|
&hkMachine,
|
|
&hkUser);
|
|
|
|
if (NT_SUCCESS(Status)) {
|
|
|
|
ASSERT(hkUser || hkMachine);
|
|
|
|
//
|
|
// We only need to create a state if there are
|
|
// two keys -- if only one exists, we don't
|
|
// need to do merging
|
|
//
|
|
if (!hkUser || !hkMachine) {
|
|
*ppValState = NULL;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Get memory for the value state
|
|
//
|
|
pValState = RegClassHeapAlloc( sizeof(*pValState) +
|
|
sizeof(DWORD) * DEFAULT_VALUESTATE_SUBKEY_ALLOC );
|
|
|
|
//
|
|
// Be sure to release acquired resources on failure
|
|
//
|
|
if (!pValState) {
|
|
|
|
if (hkUser != hKey) {
|
|
NtClose(hkUser);
|
|
} else {
|
|
NtClose(hkMachine);
|
|
}
|
|
|
|
return STATUS_NO_MEMORY;
|
|
}
|
|
|
|
RtlZeroMemory(pValState, sizeof(*pValState));
|
|
|
|
pValState->hkUser = hkUser;
|
|
pValState->hkMachine = hkMachine;
|
|
pValState->hkLogical = hKey;
|
|
pValState->fIgnoreResetOnRetry = TRUE;
|
|
|
|
//
|
|
// Now update the state to reflect the current registry
|
|
//
|
|
Status = ValStateUpdate(pValState);
|
|
}
|
|
|
|
//
|
|
// On success, set our out param
|
|
//
|
|
if (NT_SUCCESS(Status)) {
|
|
*ppValState = pValState;
|
|
} else {
|
|
|
|
if (pValState) {
|
|
ValStateRelease(pValState);
|
|
}
|
|
}
|
|
|
|
return Status;
|
|
|
|
}
|
|
|
|
|
|
BOOL ValStateAddValueToSortedValues(
|
|
PKEY_VALUE_BASIC_INFORMATION* ppValueInfo,
|
|
LONG lNewValue)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Inserts a retrieved value into the sorted list
|
|
of values in a value state
|
|
|
|
Arguments:
|
|
|
|
pValState - value state containing values for a logical key
|
|
lNewValue - index of newly added value in the sorted list --
|
|
this value needs to be moved elsewhere in the list to maintain
|
|
the sorted nature of the list
|
|
|
|
Return Value:
|
|
|
|
TRUE if the state was added, FALSE if not.
|
|
|
|
Notes:
|
|
|
|
--*/
|
|
{
|
|
PKEY_VALUE_BASIC_INFORMATION pNewValue;
|
|
LONG lFinalSpot;
|
|
LONG lCurrent;
|
|
UNICODE_STRING NewKeyName;
|
|
|
|
lFinalSpot = 0;
|
|
|
|
pNewValue = ppValueInfo[lNewValue];
|
|
|
|
NewKeyName.Buffer = pNewValue->Name;
|
|
NewKeyName.Length = (USHORT) pNewValue->NameLength;
|
|
|
|
for (lCurrent = lNewValue - 1; lCurrent >= 0; lCurrent--)
|
|
{
|
|
UNICODE_STRING CurrentValueName;
|
|
PKEY_VALUE_BASIC_INFORMATION pCurrentValue;
|
|
LONG lCompareResult;
|
|
|
|
pCurrentValue = ppValueInfo[lCurrent];
|
|
|
|
CurrentValueName.Buffer = pCurrentValue->Name;
|
|
CurrentValueName.Length = (USHORT) pCurrentValue->NameLength;
|
|
|
|
lCompareResult = RtlCompareUnicodeString(
|
|
&NewKeyName,
|
|
&CurrentValueName,
|
|
TRUE);
|
|
|
|
if (lCompareResult < 0) {
|
|
|
|
continue;
|
|
|
|
} else if (0 == lCompareResult) {
|
|
//
|
|
// If it's a duplicate, don't add it
|
|
//
|
|
return FALSE;
|
|
|
|
} else {
|
|
|
|
lFinalSpot = lCurrent + 1;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now we know the final spot, add the value
|
|
//
|
|
|
|
//
|
|
// Move everything up to make room for the new value
|
|
//
|
|
for (lCurrent = lNewValue - 1; lCurrent >= lFinalSpot; lCurrent--)
|
|
{
|
|
//
|
|
// Move the current value up one
|
|
//
|
|
ppValueInfo[lCurrent + 1] = ppValueInfo[lCurrent];
|
|
}
|
|
|
|
//
|
|
// Copy the value to its final destination
|
|
//
|
|
ppValueInfo[lFinalSpot] = pNewValue;
|
|
|
|
//
|
|
// This means we've found no duplicate value
|
|
// so we add it
|
|
//
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
NTSTATUS KeyStateGetValueState(
|
|
HKEY hKey,
|
|
ValueState** ppValState)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Gets the value state for a particular key
|
|
|
|
Arguments:
|
|
|
|
hKey - key whose state we need to retrieve
|
|
ppValState - out param pointing to a pointer to the
|
|
retrieved state.
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS for success, error code otherwise.
|
|
|
|
Notes:
|
|
|
|
ATENTION: Right now, this always creates a new state -- in the future,
|
|
we may want to change this to be cached in a table to avoid reconstructing
|
|
on every call.
|
|
|
|
--*/
|
|
{
|
|
//
|
|
// Now build the value state
|
|
//
|
|
return ValStateInitialize(
|
|
ppValState,
|
|
hKey);
|
|
}
|
|
|
|
|
|
NTSTATUS BaseRegGetClassKeyValueState(
|
|
HKEY hKey,
|
|
DWORD dwLogicalIndex,
|
|
ValueState** ppValState)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Gets the value state for a particular key and optimizes
|
|
it for a given index
|
|
|
|
Arguments:
|
|
|
|
hKey - key whose state we need to retrieve
|
|
dwLogicalIndex - hint that helps us to optimize the state for this
|
|
index so the caller's use of the state is more efficient
|
|
ppValState - out param pointing to a pointer to the
|
|
retrieved state.
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS for success, error code otherwise.
|
|
|
|
Notes:
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status;
|
|
ValueState* pValState;
|
|
|
|
//
|
|
// First retrieve the state for this key
|
|
//
|
|
Status = KeyStateGetValueState(hKey, &pValState);
|
|
|
|
if (NT_SUCCESS(Status)) {
|
|
|
|
//
|
|
// Now map the logical index to a physical one
|
|
//
|
|
Status = ValStateSetPhysicalIndexFromLogical(pValState, dwLogicalIndex);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
ValStateRelease(pValState);
|
|
} else {
|
|
*ppValState = pValState;
|
|
}
|
|
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
NTSTATUS EnumerateValue(
|
|
HKEY hKey,
|
|
DWORD dwValue,
|
|
PKEY_VALUE_BASIC_INFORMATION pSuggestedBuffer,
|
|
DWORD dwSuggestedBufferLength,
|
|
PKEY_VALUE_BASIC_INFORMATION* ppResult)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Retrieves a value for a physical key from the kernel
|
|
|
|
Arguments:
|
|
|
|
hKey - physical key for which we're trying to read a value
|
|
dwValue - physical index of value to read
|
|
pSuggestedBuffer - basinc info buffer to use by default, may not be large enough
|
|
dwSuggestedBufferLength - size of suggested buffer
|
|
ppResult - pointer to result basic info -- may be allocated by this function if
|
|
suggested buffer was insufficient, which means caller will have to free
|
|
this if it is not the same as the suggested buffer
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS for success, error code otherwise.
|
|
|
|
Notes:
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status;
|
|
PKEY_VALUE_BASIC_INFORMATION pKeyValueInformation;
|
|
DWORD dwResultLength;
|
|
|
|
pKeyValueInformation = pSuggestedBuffer;
|
|
|
|
//
|
|
// Query for the necessary information about the supplied value.
|
|
//
|
|
Status = NtEnumerateValueKey( hKey,
|
|
dwValue,
|
|
KeyValueBasicInformation,
|
|
pKeyValueInformation,
|
|
dwSuggestedBufferLength,
|
|
&dwResultLength);
|
|
//
|
|
// A return value of STATUS_BUFFER_TOO_SMALL would mean that there
|
|
// was not enough room for even the known (i.e. fixed length portion)
|
|
// of the structure.
|
|
//
|
|
|
|
ASSERT( Status != STATUS_BUFFER_TOO_SMALL );
|
|
|
|
if (ppResult && (STATUS_BUFFER_OVERFLOW == Status)) {
|
|
|
|
pKeyValueInformation = (PKEY_VALUE_BASIC_INFORMATION) RegClassHeapAlloc(
|
|
dwResultLength);
|
|
|
|
if (!pKeyValueInformation) {
|
|
return STATUS_NO_MEMORY;
|
|
}
|
|
|
|
//
|
|
// Query for the necessary information about the supplied value.
|
|
//
|
|
Status = NtEnumerateValueKey( hKey,
|
|
dwValue,
|
|
KeyValueBasicInformation,
|
|
pKeyValueInformation,
|
|
dwResultLength,
|
|
&dwResultLength);
|
|
|
|
ASSERT( Status != STATUS_BUFFER_TOO_SMALL );
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
RegClassHeapFree(pKeyValueInformation);
|
|
}
|
|
}
|
|
|
|
if (NT_SUCCESS(Status) && ppResult) {
|
|
*ppResult = pKeyValueInformation;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
NTSTATUS BaseRegQueryMultipleClassKeyValues(
|
|
HKEY hKey,
|
|
PRVALENT val_list,
|
|
DWORD num_vals,
|
|
LPSTR lpvalueBuf,
|
|
LPDWORD ldwTotsize,
|
|
PULONG ldwRequiredLength)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Gets the value state for a particular key and optimizes
|
|
it for a given index
|
|
|
|
Arguments:
|
|
|
|
hKey - Supplies a handle to the open key. The value entries returned
|
|
are contained in the key pointed to by this key handle. Any of
|
|
the predefined reserved handles or a previously opened key handle
|
|
may be used for hKey.
|
|
|
|
val_list - Supplies a pointer to an array of RVALENT structures, one for
|
|
each value to be queried.
|
|
|
|
num_vals - Supplies the size in bytes of the val_list array.
|
|
|
|
lpValueBuf - Returns the data for each value
|
|
|
|
ldwTotsize - Supplies the length of lpValueBuf. Returns the number of bytes
|
|
written into lpValueBuf.
|
|
|
|
ldwRequiredLength - If lpValueBuf is not large enough to
|
|
contain all the data, returns the size of lpValueBuf required
|
|
to return all the requested data.
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS for success, error code otherwise.
|
|
|
|
Notes:
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status;
|
|
HKEY hkUser;
|
|
HKEY hkMachine;
|
|
HKEY hkQuery;
|
|
|
|
//
|
|
// Initialize conditionally freed resources
|
|
//
|
|
hkUser = NULL;
|
|
hkMachine = NULL;
|
|
|
|
//
|
|
// First, get both user and machine keys
|
|
//
|
|
Status = BaseRegGetUserAndMachineClass(
|
|
NULL,
|
|
hKey,
|
|
MAXIMUM_ALLOWED,
|
|
&hkMachine,
|
|
&hkUser);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// If we have both, we call a routine
|
|
// to merge the values
|
|
//
|
|
if (hkMachine && hkUser) {
|
|
|
|
Status = BaseRegQueryAndMergeValues(
|
|
hkUser,
|
|
hkMachine,
|
|
val_list,
|
|
num_vals,
|
|
lpvalueBuf,
|
|
ldwTotsize,
|
|
ldwRequiredLength);
|
|
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// We have only one key -- query the one with the
|
|
// highest precedence
|
|
//
|
|
hkQuery = hkUser ? hkUser : hkMachine;
|
|
|
|
Status = NtQueryMultipleValueKey(hkQuery,
|
|
(PKEY_VALUE_ENTRY)val_list,
|
|
num_vals,
|
|
lpvalueBuf,
|
|
ldwTotsize,
|
|
ldwRequiredLength);
|
|
|
|
cleanup:
|
|
|
|
//
|
|
// Close extra kernel object
|
|
//
|
|
if (hKey != hkUser) {
|
|
NtClose(hkUser);
|
|
} else {
|
|
NtClose(hkMachine);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
NTSTATUS BaseRegQueryAndMergeValues(
|
|
HKEY hkUser,
|
|
HKEY hkMachine,
|
|
PRVALENT val_list,
|
|
DWORD num_vals,
|
|
LPSTR lpvalueBuf,
|
|
LPDWORD ldwTotsize,
|
|
PULONG ldwRequiredLength)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Gets the value state for a particular key and optimizes
|
|
it for a given index
|
|
|
|
Arguments:
|
|
|
|
hkUser - user key to query for values
|
|
hkMachine - machine key to query for values
|
|
|
|
val_list - Supplies a pointer to an array of RVALENT structures, one for
|
|
each value to be queried.
|
|
|
|
num_vals - Supplies the size in bytes of the val_list array.
|
|
|
|
lpValueBuf - Returns the data for each value
|
|
|
|
ldwTotsize - Supplies the length of lpValueBuf. Returns the number of bytes
|
|
written into lpValueBuf.
|
|
|
|
ldwRequiredLength - If lpValueBuf is not large enough to
|
|
contain all the data, returns the size of lpValueBuf required
|
|
to return all the requested data.
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS for success, error code otherwise.
|
|
|
|
Notes:
|
|
|
|
ATTENTION: this is non-atomic, unlike the regular RegQueryMultipleValues
|
|
call. In the future, implementing this in the kernel would make this
|
|
atomic again.
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status;
|
|
DWORD dwVal;
|
|
BOOL fOverflow;
|
|
DWORD dwBufferLength;
|
|
DWORD dwRequired;
|
|
DWORD dwKeyInfoLength;
|
|
DWORD dwBufferUsed;
|
|
|
|
PKEY_VALUE_PARTIAL_INFORMATION pKeyInfo;
|
|
|
|
//
|
|
// Initialize locals
|
|
//
|
|
dwBufferLength = *ldwTotsize;
|
|
dwRequired = 0;
|
|
dwBufferUsed = 0;
|
|
|
|
fOverflow = FALSE;
|
|
|
|
//
|
|
// Validate out params -- we assume that ldwTotsize and
|
|
// ldwRequiredLength were given to us by winreg client,
|
|
// so they should be safe to read / write from. lpValueBuf
|
|
// comes from the caller of the win32 api, so we need to
|
|
// validate it -- in previous versions of NT, this parameter
|
|
// went straight to the kernel, which did the validation and
|
|
// returned an error if it was pointing to inaccessible memory.
|
|
// Since we're accessing it here in user mode, we need to do
|
|
// our own validation
|
|
//
|
|
if (IsBadWritePtr( lpvalueBuf, dwBufferLength))
|
|
{
|
|
return STATUS_ACCESS_VIOLATION;
|
|
}
|
|
|
|
//
|
|
// First, we need to allocate enough memory to retrieve
|
|
// all the values -- we can't just use lpvalueBuf
|
|
// because it doesn't include the overhead of the
|
|
// KEY_VALUE_PARTIAL_INFORMATION structure. If we allocate
|
|
// for the size of lpvalueBuf + the structure overhead,
|
|
// we will always have enough for our queries.
|
|
//
|
|
dwKeyInfoLength = sizeof(*pKeyInfo) * num_vals + *ldwTotsize;
|
|
|
|
pKeyInfo = (PKEY_VALUE_PARTIAL_INFORMATION)
|
|
RegClassHeapAlloc( dwKeyInfoLength);
|
|
|
|
if (!pKeyInfo) {
|
|
return STATUS_NO_MEMORY;
|
|
}
|
|
|
|
//
|
|
// For each value requested by the caller, try
|
|
// to retrieve it from user or machine
|
|
//
|
|
for (dwVal = 0; dwVal < num_vals; dwVal++)
|
|
{
|
|
DWORD dwResultLength;
|
|
|
|
//
|
|
// Round up the used and required lengths to a ULONG boundary --
|
|
// this means that the required size returned to the caller of the win32
|
|
// api can be an overestimation, as much as 3 bytes per requested value.
|
|
// We could do some work to avoid this, but since the kernel returns a rounded
|
|
// up value in dwResultLength, the kernel api is itself overestimating, although
|
|
// it only overestimates by at most 3 bytes over all the values. We could avoid
|
|
// this by allocating enough memory ahead of time to query the largest value, either
|
|
// as one large preallocation or continually allocating and reallocating, but this will
|
|
// be slower and / or consume more memory
|
|
//
|
|
dwBufferUsed = (dwBufferUsed + sizeof(ULONG)-1) & ~(sizeof(ULONG)-1);
|
|
dwRequired = (dwRequired + sizeof(ULONG)-1) & ~(sizeof(ULONG)-1);
|
|
|
|
//
|
|
// Query the user key first since it has highest precedence
|
|
//
|
|
Status = NtQueryValueKey(
|
|
hkUser,
|
|
val_list[dwVal].rv_valuename,
|
|
KeyValuePartialInformation,
|
|
pKeyInfo,
|
|
dwKeyInfoLength,
|
|
&dwResultLength);
|
|
|
|
//
|
|
// Check for errors -- if the value didn't exist, we'll look
|
|
// in machine -- for buffer overflow, we'll proceed as if
|
|
// this succeeded so that we can calculate the required
|
|
// buffer size
|
|
//
|
|
if (!NT_SUCCESS(Status) &&
|
|
(STATUS_BUFFER_OVERFLOW != Status)) {
|
|
|
|
if (STATUS_OBJECT_NAME_NOT_FOUND != Status) {
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// If there is no user value, query the machine key
|
|
//
|
|
Status = NtQueryValueKey(
|
|
hkMachine,
|
|
val_list[dwVal].rv_valuename,
|
|
KeyValuePartialInformation,
|
|
pKeyInfo,
|
|
dwKeyInfoLength,
|
|
&dwResultLength);
|
|
|
|
//
|
|
// Similar error handling to above -- if we don't have enough
|
|
// buffer, pretend we've succeeded so we can calc the required size
|
|
//
|
|
if (!NT_SUCCESS(Status) &&
|
|
(STATUS_BUFFER_OVERFLOW != Status)) {
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
ASSERT(NT_SUCCESS(Status) || (STATUS_BUFFER_OVERFLOW == Status));
|
|
|
|
if (NT_SUCCESS(Status)) {
|
|
dwResultLength = pKeyInfo->DataLength;
|
|
}
|
|
|
|
//
|
|
// Check for buffer overflow
|
|
//
|
|
if ( ( (dwBufferUsed + pKeyInfo->DataLength) <= dwBufferLength) && !fOverflow) {
|
|
|
|
ASSERT(NT_SUCCESS(Status));
|
|
|
|
//
|
|
// Copy the data to the fixed part of the client's structure
|
|
//
|
|
val_list[dwVal].rv_valuelen = dwResultLength;
|
|
val_list[dwVal].rv_valueptr = dwRequired;
|
|
val_list[dwVal].rv_type = pKeyInfo->Type;
|
|
|
|
//
|
|
// We didn't overflow, so we still have enough room to copy
|
|
// the latest value
|
|
//
|
|
RtlCopyMemory(
|
|
(BYTE*)lpvalueBuf + val_list[dwVal].rv_valueptr,
|
|
&(pKeyInfo->Data),
|
|
dwResultLength);
|
|
|
|
dwBufferUsed += pKeyInfo->DataLength;
|
|
|
|
} else {
|
|
//
|
|
// We're out of buffer -- set this flag to
|
|
// signal this state
|
|
//
|
|
fOverflow = TRUE;
|
|
}
|
|
|
|
//
|
|
// Update our required length with the size
|
|
// of the data from the current value
|
|
//
|
|
dwRequired += dwResultLength;
|
|
}
|
|
|
|
//
|
|
// At this point, we've succeeded in the sense that
|
|
// we've copied all the data or we couldn't due to
|
|
// insufficient buffer but we were able to calculate
|
|
// the required size
|
|
//
|
|
Status = STATUS_SUCCESS;
|
|
|
|
cleanup:
|
|
|
|
//
|
|
// Free the allocated memory
|
|
//
|
|
RegClassHeapFree(pKeyInfo);
|
|
|
|
//
|
|
// If we succeeded, this means we've either copied
|
|
// the data or overflowed and copied the size -- handle
|
|
// both below
|
|
//
|
|
if (NT_SUCCESS(Status)) {
|
|
|
|
//
|
|
// Always set this so the caller knows how much
|
|
// was copied or needs to be allocated
|
|
//
|
|
*ldwRequiredLength = dwRequired;
|
|
|
|
//
|
|
// Return the appropriate error if we overflowed
|
|
//
|
|
if (fOverflow) {
|
|
return STATUS_BUFFER_OVERFLOW;
|
|
}
|
|
|
|
//
|
|
// Setting this, although winreg client actually
|
|
// ignores this quantity
|
|
//
|
|
*ldwTotsize = dwBufferUsed;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
#endif LOCAL
|
|
|
|
|
|
|
|
|
|
|