/*++
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"
#include <malloc.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