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.
406 lines
12 KiB
406 lines
12 KiB
/*++
|
|
|
|
Copyright (c) 1991 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
Regekey.c
|
|
|
|
Abstract:
|
|
|
|
This module contains the server side implementation for the Win32
|
|
Registry API to enumerate keys. That is:
|
|
|
|
- BaseRegEnumKey
|
|
|
|
Author:
|
|
|
|
David J. Gilman (davegi) 23-Dec-1991
|
|
|
|
Notes:
|
|
|
|
See the Notes in Regkey.c.
|
|
|
|
--*/
|
|
|
|
#include <rpc.h>
|
|
#include "regrpc.h"
|
|
#include "localreg.h"
|
|
#include "regclass.h"
|
|
#include "regecls.h"
|
|
#include <malloc.h>
|
|
|
|
#define DEFAULT_KEY_NAME_SIZE 128
|
|
#define DEFAULT_CLASS_SIZE 128
|
|
|
|
|
|
|
|
error_status_t
|
|
BaseRegEnumKey (
|
|
IN HKEY hKey,
|
|
IN DWORD dwIndex,
|
|
OUT PUNICODE_STRING lpName,
|
|
OUT PUNICODE_STRING lpClass OPTIONAL,
|
|
OUT PFILETIME lpftLastWriteTime OPTIONAL
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Used to enumerate subkeys of an open key. This function copies the
|
|
dwIndex-th subkey of hKey.
|
|
|
|
Arguments:
|
|
|
|
hKey - A handle to the open key. The keys returned are relative to
|
|
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.
|
|
|
|
dwIndex - The index of the subkey to return. Note that this is for
|
|
convenience, subkeys are not ordered (a new subkey has an arbitrary
|
|
index). Indexes start at 0.
|
|
|
|
lpName - Provides a pointer to a buffer to receive the name of the
|
|
key.
|
|
|
|
lpClass - If present, provides a pointer to a buffer to receive the
|
|
class of the key.
|
|
|
|
lpftLastWriteTime - The time when the value was last written (set or
|
|
created).
|
|
|
|
Return Value:
|
|
|
|
Returns ERROR_SUCCESS (0) for success; error-code for failure.
|
|
|
|
Notes:
|
|
|
|
This function is guaranteed to operate correctly only if dwIndex
|
|
starts at 0 and is incremented on successive calls without intervening
|
|
calls to other registration APIs that will change the key.
|
|
KEY_ENUMERATE_SUB_KEYS access is required.
|
|
|
|
When lpName->Buffer is NULL the api must return STATUS_BUFFER_OVERFLOW.
|
|
Failure to do so will break other components.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status;
|
|
ULONG BufferLength;
|
|
KEY_INFORMATION_CLASS KeyInformationClass;
|
|
PVOID KeyInformation;
|
|
ULONG ResultLength;
|
|
BOOL fClassKey;
|
|
|
|
BYTE PrivateKeyInformation[ sizeof( KEY_NODE_INFORMATION ) +
|
|
DEFAULT_KEY_NAME_SIZE +
|
|
DEFAULT_CLASS_SIZE ];
|
|
|
|
ASSERT( lpName != NULL );
|
|
|
|
//
|
|
// Protect ourselves against malicious callers passing NULL
|
|
// pointers.
|
|
//
|
|
if( (lpName == NULL ) ||
|
|
(lpName->Length != 0) ||
|
|
((lpName->MaximumLength % sizeof(WCHAR)) != 0) ||
|
|
(lpClass == NULL) ) {
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
//
|
|
// Call out to Perflib if the HKEY is HKEY_PERFOMANCE_DATA or
|
|
// HKEY_PERFORMANCE_TEXT or HKEY_PERFORMANCE_NLSTEXT
|
|
|
|
if (hKey == HKEY_PERFORMANCE_DATA ||
|
|
hKey == HKEY_PERFORMANCE_TEXT ||
|
|
hKey == HKEY_PERFORMANCE_NLSTEXT ) {
|
|
// if( hKey == HKEY_PERFORMANCE_DATA ) {
|
|
return (error_status_t)PerfRegEnumKey (
|
|
hKey,
|
|
dwIndex,
|
|
lpName,
|
|
NULL,
|
|
lpClass,
|
|
lpftLastWriteTime
|
|
);
|
|
}
|
|
|
|
|
|
//
|
|
// First we assume that the information we want will fit on
|
|
// PrivateKeyValueInformattion
|
|
//
|
|
|
|
KeyInformationClass = (ARGUMENT_PRESENT( lpClass->Buffer ))?
|
|
KeyNodeInformation :
|
|
KeyBasicInformation;
|
|
|
|
|
|
KeyInformation = PrivateKeyInformation;
|
|
BufferLength = sizeof( PrivateKeyInformation );
|
|
|
|
fClassKey = FALSE;
|
|
Status = STATUS_SUCCESS;
|
|
|
|
//
|
|
// Query for the necessary information about the supplied key.
|
|
//
|
|
|
|
#ifdef LOCAL
|
|
//
|
|
// For hkcr, we need to do special enumeration
|
|
//
|
|
if (REG_CLASS_IS_SPECIAL_KEY(hKey)) {
|
|
|
|
Status = EnumTableGetNextEnum( &gClassesEnumTable,
|
|
hKey,
|
|
dwIndex,
|
|
KeyInformationClass,
|
|
KeyInformation,
|
|
BufferLength,
|
|
&ResultLength);
|
|
|
|
if (!NT_SUCCESS(Status) || (NT_SUCCESS(Status) && ResultLength)) {
|
|
fClassKey = TRUE;
|
|
}
|
|
}
|
|
#endif // LOCAL
|
|
|
|
if (!fClassKey) {
|
|
|
|
Status = NtEnumerateKey( hKey,
|
|
dwIndex,
|
|
KeyInformationClass,
|
|
KeyInformation,
|
|
BufferLength,
|
|
&ResultLength
|
|
);
|
|
}
|
|
|
|
//
|
|
// A return value of STATUS_BUFFER_TOO_SMALL would mean that there
|
|
// was not enough room for even the fixed portions of the structure.
|
|
//
|
|
|
|
ASSERT( Status != STATUS_BUFFER_TOO_SMALL );
|
|
|
|
|
|
if( Status == STATUS_BUFFER_OVERFLOW ) {
|
|
//
|
|
// The buffer defined in the stack wasn't big enough to hold
|
|
// the Key information.
|
|
// If the caller's buffer are big enough to hold the key name
|
|
// and key class, then allocate a new buffer, and call the
|
|
// NT API again.
|
|
//
|
|
if( ( ( KeyInformationClass == KeyBasicInformation ) &&
|
|
( (ULONG)( lpName->MaximumLength ) >=
|
|
(( PKEY_BASIC_INFORMATION )
|
|
KeyInformation )->NameLength + sizeof(UNICODE_NULL)
|
|
)
|
|
) ||
|
|
( ( KeyInformationClass == KeyNodeInformation ) &&
|
|
( (ULONG)(lpName->MaximumLength) >=
|
|
(( PKEY_NODE_INFORMATION )
|
|
KeyInformation )->NameLength + sizeof(UNICODE_NULL)
|
|
) &&
|
|
(
|
|
ARGUMENT_PRESENT( lpClass->Buffer )
|
|
) &&
|
|
(
|
|
(ULONG)(lpClass->MaximumLength) >= (( PKEY_NODE_INFORMATION )
|
|
KeyInformation )->ClassLength + sizeof(UNICODE_NULL)
|
|
)
|
|
)
|
|
) {
|
|
BufferLength = ResultLength;
|
|
|
|
KeyInformation = RtlAllocateHeap( RtlProcessHeap( ), 0,
|
|
BufferLength
|
|
);
|
|
//
|
|
// If the memory allocation fails, return a Registry error.
|
|
//
|
|
|
|
if( ! KeyInformation ) {
|
|
return ERROR_OUTOFMEMORY;
|
|
}
|
|
|
|
//
|
|
// Query for the necessary information about the supplied key.
|
|
// This may or may not include the class depending on lpClass->Buffer
|
|
// as determined above.
|
|
//
|
|
|
|
#ifdef LOCAL
|
|
if (fClassKey) {
|
|
//
|
|
// For hkcr, we need to do special enumeration
|
|
//
|
|
Status = EnumTableGetNextEnum( &gClassesEnumTable,
|
|
hKey,
|
|
dwIndex,
|
|
KeyInformationClass,
|
|
KeyInformation,
|
|
BufferLength,
|
|
&ResultLength);
|
|
|
|
} else
|
|
#endif // LOCAL
|
|
{
|
|
Status = NtEnumerateKey( hKey,
|
|
dwIndex,
|
|
KeyInformationClass,
|
|
KeyInformation,
|
|
BufferLength,
|
|
&ResultLength
|
|
);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if( NT_SUCCESS( Status ) ) {
|
|
//
|
|
// Copy key name
|
|
//
|
|
|
|
if( KeyInformationClass == KeyBasicInformation ) {
|
|
//
|
|
// Return the name length and the name of the key.
|
|
// Note that the NUL byte is included so that RPC copies the
|
|
// correct number of bytes. It is decremented on the client
|
|
// side.
|
|
//
|
|
|
|
if( lpName->Buffer && ((ULONG)(lpName->MaximumLength) >=
|
|
(( PKEY_BASIC_INFORMATION )
|
|
KeyInformation )->NameLength + sizeof( UNICODE_NULL ) )) {
|
|
|
|
lpName->Length = ( USHORT )
|
|
(( PKEY_BASIC_INFORMATION )
|
|
KeyInformation )->NameLength;
|
|
|
|
RtlMoveMemory( lpName->Buffer,
|
|
(( PKEY_BASIC_INFORMATION )
|
|
KeyInformation )->Name,
|
|
lpName->Length
|
|
);
|
|
|
|
//
|
|
// NUL terminate the value name.
|
|
//
|
|
|
|
lpName->Buffer[ lpName->Length >> 1 ] = UNICODE_NULL;
|
|
lpName->Length += sizeof( UNICODE_NULL );
|
|
|
|
} else {
|
|
Status = STATUS_BUFFER_OVERFLOW;
|
|
}
|
|
|
|
//
|
|
// If requested, return the last write time.
|
|
//
|
|
|
|
if( ARGUMENT_PRESENT( lpftLastWriteTime )) {
|
|
|
|
*lpftLastWriteTime
|
|
= *( PFILETIME )
|
|
&(( PKEY_BASIC_INFORMATION ) KeyInformation )
|
|
->LastWriteTime;
|
|
}
|
|
|
|
} else {
|
|
//
|
|
// Return the name length and the name of the key.
|
|
// Note that the NUL byte is included so that RPC copies the
|
|
// correct number of bytes. It is decremented on the client
|
|
// side.
|
|
//
|
|
|
|
if( lpName->Buffer &&
|
|
( (ULONG)(lpName->MaximumLength) >=
|
|
(( PKEY_NODE_INFORMATION )
|
|
KeyInformation )->NameLength + sizeof( UNICODE_NULL ) ) &&
|
|
( (ULONG)(lpClass->MaximumLength) >=
|
|
(( PKEY_NODE_INFORMATION )
|
|
KeyInformation )->ClassLength + sizeof( UNICODE_NULL) )
|
|
) {
|
|
//
|
|
// Copy the key name
|
|
//
|
|
lpName->Length = ( USHORT )
|
|
(( PKEY_NODE_INFORMATION )
|
|
KeyInformation )->NameLength;
|
|
|
|
RtlMoveMemory( lpName->Buffer,
|
|
(( PKEY_NODE_INFORMATION )
|
|
KeyInformation )->Name,
|
|
lpName->Length
|
|
);
|
|
|
|
//
|
|
// NUL terminate the key name.
|
|
//
|
|
|
|
lpName->Buffer[ lpName->Length >> 1 ] = UNICODE_NULL;
|
|
lpName->Length += sizeof( UNICODE_NULL );
|
|
|
|
|
|
//
|
|
// Copy the key class
|
|
//
|
|
|
|
lpClass->Length = (USHORT)
|
|
((( PKEY_NODE_INFORMATION ) KeyInformation )->ClassLength );
|
|
|
|
RtlMoveMemory(
|
|
lpClass->Buffer,
|
|
( PBYTE ) KeyInformation
|
|
+ (( PKEY_NODE_INFORMATION ) KeyInformation )->ClassOffset,
|
|
(( PKEY_NODE_INFORMATION ) KeyInformation )->ClassLength
|
|
);
|
|
|
|
//
|
|
// NUL terminate the class.
|
|
//
|
|
|
|
lpClass->Buffer[ lpClass->Length >> 1 ] = UNICODE_NULL;
|
|
|
|
lpClass->Length += sizeof( UNICODE_NULL );
|
|
|
|
|
|
} else {
|
|
Status = STATUS_BUFFER_OVERFLOW;
|
|
}
|
|
|
|
//
|
|
// If requested, return the last write time.
|
|
//
|
|
|
|
if( ARGUMENT_PRESENT( lpftLastWriteTime )) {
|
|
|
|
*lpftLastWriteTime
|
|
= *( PFILETIME )
|
|
&(( PKEY_NODE_INFORMATION ) KeyInformation )
|
|
->LastWriteTime;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if( KeyInformation != PrivateKeyInformation ) {
|
|
//
|
|
// Free the buffer allocated.
|
|
//
|
|
|
|
RtlFreeHeap( RtlProcessHeap( ), 0, KeyInformation );
|
|
}
|
|
|
|
return (error_status_t)RtlNtStatusToDosError( Status );
|
|
}
|