-/* $Id: registry.c,v 1.29 2000/09/08 22:55:14 ekohl Exp $
+/* $Id: registry.c,v 1.30 2000/09/12 10:12:10 jean Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
#include <internal/ob.h>
#include <wchar.h>
-#define NDEBUG
+//#define NDEBUG
#include <internal/debug.h>
#define PROTO_REG 1 /* Comment out to disable */
IN PKEY_BLOCK KeyBlock,
IN PWSTR ValueName,
OUT PVALUE_BLOCK *ValueBlock);
-static NTSTATUS CmiGetValueFromKeyByIndex(IN PREGISTRY_FILE RegistryFile,
- IN PKEY_BLOCK KeyBlock,
- IN ULONG Index,
- OUT PVALUE_BLOCK *ValueBlock);
static NTSTATUS CmiAddValueToKey(IN PREGISTRY_FILE RegistryFile,
IN PKEY_BLOCK KeyBlock,
IN PWSTR ValueNameBuf,
{
return;
}
+CHECKPOINT;
CmiReleaseBlock(CmiVolatileFile, KeyBlock);
/* FIXME: create remaining structure needed for default handles */
#endif
}
-
-VOID
+VOID
CmImportHive(PCHAR Chunk)
{
/* FIXME: implemement this */
- return;
+ return;
}
-
-NTSTATUS
+NTSTATUS
STDCALL
NtCreateKey (
OUT PHANDLE KeyHandle,
IN ACCESS_MASK DesiredAccess,
- IN POBJECT_ATTRIBUTES ObjectAttributes,
+ IN POBJECT_ATTRIBUTES ObjectAttributes,
IN ULONG TitleIndex,
IN PUNICODE_STRING Class,
IN ULONG CreateOptions,
FALSE,
KeyHandle);
ExFreePool(KeyNameBuf);
- if (NT_SUCCESS(Status))
- {
- *Disposition = REG_OPENED_EXISTING_KEY;
- }
+
return Status;
}
KeyNameBuf,
&KeyBlock,
DesiredAccess,
- TitleIndex,
- Class,
- CreateOptions,
+ TitleIndex,
+ Class,
+ CreateOptions,
Disposition);
if (!NT_SUCCESS(Status))
{
}
/* Create new key object and put into linked list */
- NewKey = ObCreateObject(KeyHandle,
- DesiredAccess,
- NULL,
+ NewKey = ObCreateObject(KeyHandle,
+ DesiredAccess,
+ NULL,
CmiKeyType);
if (NewKey == NULL)
{
NewKey->RegistryFile = FileToUse;
CmiAddKeyToList(NewKey);
Status = ObCreateHandle(PsGetCurrentProcess(),
- NewKey,
+ CurKey,
DesiredAccess,
FALSE,
KeyHandle);
- if (NT_SUCCESS(Status))
- {
- *Disposition = REG_CREATED_NEW_KEY;
- }
-
return Status;
#else
UNIMPLEMENTED;
}
-NTSTATUS
+NTSTATUS
STDCALL
NtDeleteKey (
IN HANDLE KeyHandle
}
-NTSTATUS
-STDCALL
-NtDeleteValueKey (
- IN HANDLE KeyHandle,
- IN PUNICODE_STRING ValueName
- )
-{
-#ifdef PROTO_REG
- NTSTATUS Status;
- PKEY_OBJECT KeyObject;
- PREGISTRY_FILE RegistryFile;
- PKEY_BLOCK KeyBlock;
-
- /* Verify that the handle is valid and is a registry key */
- Status = ObReferenceObjectByHandle(KeyHandle,
- KEY_QUERY_VALUE,
- CmiKeyType,
- UserMode,
- (PVOID *)&KeyObject,
- NULL);
- if (!NT_SUCCESS(Status))
- {
- return Status;
- }
-
- /* Get pointer to KeyBlock */
- KeyBlock = KeyObject->KeyBlock;
- RegistryFile = KeyObject->RegistryFile;
- Status = CmiDeleteValueFromKey(RegistryFile,
- KeyBlock,
- ValueName->Buffer);
-
- ObDereferenceObject(KeyObject);
-
- return Status;
-#else
- UNIMPLEMENTED;
-#endif
-}
-
-
-NTSTATUS
+NTSTATUS
STDCALL
NtEnumerateKey (
IN HANDLE KeyHandle,
PKEY_BASIC_INFORMATION BasicInformation;
PKEY_NODE_INFORMATION NodeInformation;
PKEY_FULL_INFORMATION FullInformation;
-
+
/* Verify that the handle is valid and is a registry key */
Status = ObReferenceObjectByHandle(KeyHandle,
KEY_ENUMERATE_SUB_KEYS,
/* Get pointer to KeyBlock */
KeyBlock = KeyObject->KeyBlock;
RegistryFile = KeyObject->RegistryFile;
-
+
/* Get pointer to SubKey */
HashTableBlock = CmiGetHashTableBlock(RegistryFile, KeyBlock->HashTableOffset);
- SubKeyBlock = CmiGetKeyFromHashByIndex(RegistryFile,
- HashTableBlock,
+ SubKeyBlock = CmiGetKeyFromHashByIndex(RegistryFile,
+ HashTableBlock,
Index);
if (SubKeyBlock == NULL)
{
case KeyBasicInformation:
/* Check size of buffer */
if (Length < sizeof(KEY_BASIC_INFORMATION) +
- (SubKeyBlock->NameSize + 1) * sizeof(WCHAR))
+ SubKeyBlock->NameSize * sizeof(WCHAR))
{
Status = STATUS_BUFFER_OVERFLOW;
}
BasicInformation = (PKEY_BASIC_INFORMATION) KeyInformation;
BasicInformation->LastWriteTime = SubKeyBlock->LastWriteTime;
BasicInformation->TitleIndex = Index;
- BasicInformation->NameLength = (SubKeyBlock->NameSize + 1) * sizeof(WCHAR);
+ BasicInformation->NameLength = SubKeyBlock->NameSize;
wcsncpy(BasicInformation->Name,
SubKeyBlock->Name,
SubKeyBlock->NameSize);
case KeyNodeInformation:
/* Check size of buffer */
if (Length < sizeof(KEY_NODE_INFORMATION) +
- (SubKeyBlock->NameSize + 1) * sizeof(WCHAR) +
+ SubKeyBlock->NameSize * sizeof(WCHAR) +
(SubKeyBlock->ClassSize + 1) * sizeof(WCHAR))
{
Status = STATUS_BUFFER_OVERFLOW;
NodeInformation->ClassOffset = sizeof(KEY_NODE_INFORMATION) +
SubKeyBlock->NameSize * sizeof(WCHAR);
NodeInformation->ClassLength = SubKeyBlock->ClassSize;
- NodeInformation->NameLength = (SubKeyBlock->NameSize + 1) * sizeof(WCHAR);
+ NodeInformation->NameLength = SubKeyBlock->NameSize;
wcsncpy(NodeInformation->Name,
SubKeyBlock->Name,
SubKeyBlock->NameSize);
break;
}
CmiReleaseBlock(RegistryFile, SubKeyBlock);
- ObDereferenceObject (KeyObject);
return Status;
#else
}
-NTSTATUS
+NTSTATUS
STDCALL
NtEnumerateValueKey (
IN HANDLE KeyHandle,
IN ULONG Index,
- IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,
- OUT PVOID KeyValueInformation,
+ IN KEY_VALUE_INFORMATION_CLASS KeyInformationClass,
+ OUT PVOID KeyInformation,
IN ULONG Length,
OUT PULONG ResultLength
)
{
#ifdef PROTO_REG
- NTSTATUS Status;
- PKEY_OBJECT KeyObject;
- PREGISTRY_FILE RegistryFile;
- PKEY_BLOCK KeyBlock;
- PVALUE_BLOCK ValueBlock;
- PVOID DataBlock;
- PKEY_VALUE_BASIC_INFORMATION ValueBasicInformation;
- PKEY_VALUE_PARTIAL_INFORMATION ValuePartialInformation;
- PKEY_VALUE_FULL_INFORMATION ValueFullInformation;
-
- /* Verify that the handle is valid and is a registry key */
- Status = ObReferenceObjectByHandle(KeyHandle,
- KEY_QUERY_VALUE,
- CmiKeyType,
- UserMode,
- (PVOID *)&KeyObject,
- NULL);
- if (!NT_SUCCESS(Status))
- {
- return Status;
- }
-
- /* Get pointer to KeyBlock */
- KeyBlock = KeyObject->KeyBlock;
- RegistryFile = KeyObject->RegistryFile;
-
- /* Get Value block of interest */
- Status = CmiGetValueFromKeyByIndex(RegistryFile,
- KeyBlock,
- Index,
- &ValueBlock);
- if (!NT_SUCCESS(Status))
- {
- return Status;
- }
- else if (ValueBlock != NULL)
- {
- switch (KeyValueInformationClass)
- {
- case KeyValueBasicInformation:
- *ResultLength = sizeof(KEY_VALUE_BASIC_INFORMATION) +
- (ValueBlock->NameSize + 1) * sizeof(WCHAR);
- if (Length < *ResultLength)
- {
- Status = STATUS_BUFFER_OVERFLOW;
- }
- else
- {
- ValueBasicInformation = (PKEY_VALUE_BASIC_INFORMATION)
- KeyValueInformation;
- ValueBasicInformation->TitleIndex = 0;
- ValueBasicInformation->Type = ValueBlock->DataType;
- ValueBasicInformation->NameLength =
- (ValueBlock->NameSize + 1) * sizeof(WCHAR);
- wcscpy(ValueBasicInformation->Name, ValueBlock->Name);
- }
- break;
-
- case KeyValuePartialInformation:
- *ResultLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) +
- ValueBlock->DataSize;
- if (Length < *ResultLength)
- {
- Status = STATUS_BUFFER_OVERFLOW;
- }
- else
- {
- ValuePartialInformation = (PKEY_VALUE_PARTIAL_INFORMATION)
- KeyValueInformation;
- ValuePartialInformation->TitleIndex = 0;
- ValuePartialInformation->Type = ValueBlock->DataType;
- ValuePartialInformation->DataLength = ValueBlock->DataSize;
- DataBlock = CmiGetBlock(RegistryFile, ValueBlock->DataOffset);
- RtlCopyMemory(ValuePartialInformation->Data,
- DataBlock,
- ValueBlock->DataSize);
- CmiReleaseBlock(RegistryFile, DataBlock);
- }
- break;
-
- case KeyValueFullInformation:
- *ResultLength = sizeof(KEY_VALUE_FULL_INFORMATION) +
- (ValueBlock->NameSize + 1) * sizeof(WCHAR) + ValueBlock->DataSize;
- if (Length < *ResultLength)
- {
- Status = STATUS_BUFFER_OVERFLOW;
- }
- else
- {
- ValueFullInformation = (PKEY_VALUE_FULL_INFORMATION)
- KeyValueInformation;
- ValueFullInformation->TitleIndex = 0;
- ValueFullInformation->Type = ValueBlock->DataType;
- ValueFullInformation->DataOffset =
- sizeof(KEY_VALUE_FULL_INFORMATION) +
- ValueBlock->NameSize * sizeof(WCHAR);
- ValueFullInformation->DataLength = ValueBlock->DataSize;
- ValueFullInformation->NameLength =
- (ValueBlock->NameSize + 1) * sizeof(WCHAR);
- wcscpy(ValueFullInformation->Name, ValueBlock->Name);
- DataBlock = CmiGetBlock(RegistryFile, ValueBlock->DataOffset);
- RtlCopyMemory(&ValueFullInformation->Name[ValueBlock->NameSize + 1],
- DataBlock,
- ValueBlock->DataSize);
- CmiReleaseBlock(RegistryFile, DataBlock);
- }
- break;
- }
- }
- else
- {
- Status = STATUS_UNSUCCESSFUL;
- }
- ObDereferenceObject(KeyObject);
-
- return Status;
+ UNIMPLEMENTED;
#else
UNIMPLEMENTED;
#endif
}
-NTSTATUS
+NTSTATUS
STDCALL
NtFlushKey (
IN HANDLE KeyHandle
}
-NTSTATUS
+NTSTATUS
STDCALL
NtOpenKey (
- OUT PHANDLE KeyHandle,
+ OUT PHANDLE KeyHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes
)
}
/* Create new key object and put into linked list */
- NewKey = ObCreateObject(KeyHandle,
- DesiredAccess,
- NULL,
+ NewKey = ObCreateObject(KeyHandle,
+ DesiredAccess,
+ NULL,
CmiKeyType);
if (NewKey == NULL)
{
NewKey->RegistryFile = FileToUse;
NewKey->KeyBlock = KeyBlock;
CmiAddKeyToList(NewKey);
-
Status = ObCreateHandle(PsGetCurrentProcess(),
- NewKey,
+ CurKey,
DesiredAccess,
FALSE,
KeyHandle);
}
-NTSTATUS
+NTSTATUS
STDCALL
NtQueryKey (
- IN HANDLE KeyHandle,
+ IN HANDLE KeyHandle,
IN KEY_INFORMATION_CLASS KeyInformationClass,
OUT PVOID KeyInformation,
IN ULONG Length,
PKEY_BASIC_INFORMATION BasicInformation;
PKEY_NODE_INFORMATION NodeInformation;
PKEY_FULL_INFORMATION FullInformation;
-
+
/* Verify that the handle is valid and is a registry key */
Status = ObReferenceObjectByHandle(KeyHandle,
KEY_READ,
/* Get pointer to KeyBlock */
KeyBlock = KeyObject->KeyBlock;
RegistryFile = KeyObject->RegistryFile;
-
+
Status = STATUS_SUCCESS;
switch (KeyInformationClass)
{
case KeyBasicInformation:
/* Check size of buffer */
- if (Length < sizeof(KEY_BASIC_INFORMATION) +
+ if (Length < sizeof(KEY_BASIC_INFORMATION) +
KeyBlock->NameSize * sizeof(WCHAR))
{
Status = STATUS_BUFFER_OVERFLOW;
BasicInformation->LastWriteTime = KeyBlock->LastWriteTime;
BasicInformation->TitleIndex = 0;
BasicInformation->NameLength = KeyBlock->NameSize;
- wcsncpy(BasicInformation->Name,
- KeyBlock->Name,
+ wcsncpy(BasicInformation->Name,
+ KeyBlock->Name,
KeyBlock->NameSize);
BasicInformation->Name[KeyBlock->NameSize] = 0;
- *ResultLength = sizeof(KEY_BASIC_INFORMATION) +
+ *ResultLength = sizeof(KEY_BASIC_INFORMATION) +
KeyBlock->NameSize * sizeof(WCHAR);
}
break;
NodeInformation = (PKEY_NODE_INFORMATION) KeyInformation;
NodeInformation->LastWriteTime = KeyBlock->LastWriteTime;
NodeInformation->TitleIndex = 0;
- NodeInformation->ClassOffset = sizeof(KEY_NODE_INFORMATION) +
+ NodeInformation->ClassOffset = sizeof(KEY_NODE_INFORMATION) +
KeyBlock->NameSize * sizeof(WCHAR);
NodeInformation->ClassLength = KeyBlock->ClassSize;
NodeInformation->NameLength = KeyBlock->NameSize;
- wcsncpy(NodeInformation->Name,
- KeyBlock->Name,
+ wcsncpy(NodeInformation->Name,
+ KeyBlock->Name,
KeyBlock->NameSize);
NodeInformation->Name[KeyBlock->NameSize] = 0;
if (KeyBlock->ClassSize != 0)
FullInformation = (PKEY_FULL_INFORMATION) KeyInformation;
FullInformation->LastWriteTime = KeyBlock->LastWriteTime;
FullInformation->TitleIndex = 0;
- FullInformation->ClassOffset = sizeof(KEY_FULL_INFORMATION) -
+ FullInformation->ClassOffset = sizeof(KEY_FULL_INFORMATION) -
sizeof(WCHAR);
FullInformation->ClassLength = KeyBlock->ClassSize;
FullInformation->SubKeys = KeyBlock->NumberOfSubKeys;
}
break;
}
- ObDereferenceObject (KeyObject);
return Status;
#else
}
-NTSTATUS
+NTSTATUS
STDCALL
NtQueryValueKey (
IN HANDLE KeyHandle,
RegistryFile = KeyObject->RegistryFile;
/* Get Value block of interest */
- Status = CmiScanKeyForValue(RegistryFile,
+ Status = CmiScanKeyForValue(RegistryFile,
KeyBlock,
ValueName->Buffer,
&ValueBlock);
}
else
{
- ValuePartialInformation = (PKEY_VALUE_PARTIAL_INFORMATION)
+ ValuePartialInformation = (PKEY_VALUE_PARTIAL_INFORMATION)
KeyValueInformation;
ValuePartialInformation->TitleIndex = 0;
ValuePartialInformation->Type = ValueBlock->DataType;
{
Status = STATUS_UNSUCCESSFUL;
}
- ObDereferenceObject(KeyObject);
-
+
return Status;
#else
UNIMPLEMENTED;
}
-NTSTATUS
+NTSTATUS
STDCALL
NtSetValueKey (
- IN HANDLE KeyHandle,
+ IN HANDLE KeyHandle,
IN PUNICODE_STRING ValueName,
IN ULONG TitleIndex,
- IN ULONG Type,
+ IN ULONG Type,
IN PVOID Data,
IN ULONG DataSize
)
/* Verify that the handle is valid and is a registry key */
Status = ObReferenceObjectByHandle(KeyHandle,
- KEY_SET_VALUE,
+ KEY_QUERY_VALUE,
CmiKeyType,
UserMode,
(PVOID *)&KeyObject,
{
return Status;
}
+
/* Get pointer to KeyBlock */
KeyBlock = KeyObject->KeyBlock;
RegistryFile = KeyObject->RegistryFile;
&ValueBlock);
if (!NT_SUCCESS(Status))
{
- ObDereferenceObject (KeyObject);
return Status;
}
if (ValueBlock == NULL)
Data,
DataSize);
}
- ObDereferenceObject (KeyObject);
return Status;
#else
#endif
}
-
NTSTATUS
STDCALL
+NtDeleteValueKey (
+ IN HANDLE KeyHandle,
+ IN PUNICODE_STRING ValueName
+ )
+{
+#ifdef PROTO_REG
+ NTSTATUS Status;
+ PKEY_OBJECT KeyObject;
+ PREGISTRY_FILE RegistryFile;
+ PKEY_BLOCK KeyBlock;
+
+ /* Verify that the handle is valid and is a registry key */
+ Status = ObReferenceObjectByHandle(KeyHandle,
+ KEY_QUERY_VALUE,
+ CmiKeyType,
+ UserMode,
+ (PVOID *)&KeyObject,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ return Status;
+ }
+
+ /* Get pointer to KeyBlock */
+ KeyBlock = KeyObject->KeyBlock;
+ RegistryFile = KeyObject->RegistryFile;
+ Status = CmiDeleteValueFromKey(RegistryFile,
+ KeyBlock,
+ ValueName->Buffer);
+
+ return Status;
+#else
+ UNIMPLEMENTED;
+#endif
+}
+
+NTSTATUS
+STDCALL
NtLoadKey (
PHANDLE KeyHandle,
OBJECT_ATTRIBUTES ObjectAttributes
)
{
- return NtLoadKey2(KeyHandle,
- ObjectAttributes,
- 0);
+ UNIMPLEMENTED;
}
NTSTATUS
STDCALL
-NtLoadKey2 (
- PHANDLE KeyHandle,
- OBJECT_ATTRIBUTES ObjectAttributes,
- ULONG Unknown3
- )
+NtLoadKey2(VOID)
{
UNIMPLEMENTED;
}
NtNotifyChangeKey (
IN HANDLE KeyHandle,
IN HANDLE Event,
- IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
- IN PVOID ApcContext OPTIONAL,
+ IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
+ IN PVOID ApcContext OPTIONAL,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN ULONG CompletionFilter,
- IN BOOLEAN Asynchroneous,
+ IN BOOLEAN Asynchroneous,
OUT PVOID ChangeBuffer,
IN ULONG Length,
IN BOOLEAN WatchSubtree
NTSTATUS
-STDCALL
+STDCALL
NtUnloadKey (
HANDLE KeyHandle
)
NTSTATUS
-STDCALL
+STDCALL
NtInitializeRegistry (
BOOLEAN SetUpBoot
)
return Status;
}
- CurKeyBlock = CmiGetKeyBlock(RegistryFile,
+ CurKeyBlock = CmiGetKeyBlock(RegistryFile,
RegistryFile->HeaderBlock->RootKeyBlock);
/* Loop through each key level and find the needed subkey */
}
/* Verify existance of CurKeyName */
- Status = CmiScanForSubKey(RegistryFile,
- CurKeyBlock,
+ Status = CmiScanForSubKey(RegistryFile,
+ CurKeyBlock,
&SubKeyBlock,
CurKeyName,
STANDARD_RIGHTS_REQUIRED);
Status = ObReferenceObjectByHandle(ObjectAttributes->RootDirectory,
KEY_READ,
NULL,
- KernelMode,
+ UserMode,
(PVOID *)&ObjectBody,
NULL);
if (!NT_SUCCESS(Status))
KeReleaseSpinLock(&CmiKeyListLock, OldIrql);
}
-static VOID
+static VOID
CmiRemoveKeyFromList(PKEY_OBJECT KeyToRemove)
{
KIRQL OldIrql;
return CurKey;
}
-static PREGISTRY_FILE
+static PREGISTRY_FILE
CmiCreateRegistry(PWSTR Filename)
{
PREGISTRY_FILE RegistryFile;
OUT PKEY_BLOCK *KeyBlock,
IN ACCESS_MASK DesiredAccess,
IN ULONG TitleIndex,
- IN PUNICODE_STRING Class,
- IN ULONG CreateOptions,
+ IN PUNICODE_STRING Class,
+ IN ULONG CreateOptions,
OUT PULONG Disposition)
{
/* FIXME: this should be allocated based on the largest subkey name */
/* FIXME: Should handle search by Class/TitleIndex */
+CHECKPOINT;
/* Loop through each key level and find or build the needed subkey */
Status = STATUS_SUCCESS;
/* FIXME: this access of RootKeyBlock should be guarded by spinlock */
CurKeyBlock = CmiGetKeyBlock(RegistryFile,
RegistryFile->HeaderBlock->RootKeyBlock);
+CHECKPOINT;
Remainder = KeyNameBuf;
while (NT_SUCCESS(Status) &&
(NextSlash = wcschr(Remainder, L'\\')) != NULL)
return Status;
}
-static NTSTATUS
+static NTSTATUS
CmiFindKey(IN PREGISTRY_FILE RegistryFile,
IN PWSTR KeyNameBuf,
OUT PKEY_BLOCK *KeyBlock,
PWSTR Remainder, NextSlash;
PKEY_BLOCK CurKeyBlock, SubKeyBlock;
- if (RegistryFile == NULL)
- return STATUS_UNSUCCESSFUL;
-
/* FIXME: Should handle search by Class/TitleIndex */
/* Loop through each key level and find the needed subkey */
/* FIXME: this access of RootKeyBlock should be guarded by spinlock */
CurKeyBlock = CmiGetKeyBlock(RegistryFile, RegistryFile->HeaderBlock->RootKeyBlock);
Remainder = KeyNameBuf;
- wcscpy(CurKeyName, Remainder);
while (NT_SUCCESS(Status) &&
(NextSlash = wcschr(Remainder, L'\\')) != NULL)
{
CurKeyName[NextSlash - Remainder] = 0;
/* Verify existance of CurKeyName */
- Status = CmiScanForSubKey(RegistryFile,
- CurKeyBlock,
+ Status = CmiScanForSubKey(RegistryFile,
+ CurKeyBlock,
&SubKeyBlock,
CurKeyName,
DesiredAccess);
}
if (NT_SUCCESS(Status))
{
- Status = CmiScanForSubKey(RegistryFile,
- CurKeyBlock,
+ Status = CmiScanForSubKey(RegistryFile,
+ CurKeyBlock,
&SubKeyBlock,
CurKeyName,
DesiredAccess);
return Status;
}
-static ULONG
+static ULONG
CmiGetMaxNameLength(PREGISTRY_FILE RegistryFile,
PKEY_BLOCK KeyBlock)
{
for (Idx = 0; Idx < HashBlock->HashTableSize; Idx++)
{
if (HashBlock->Table[Idx].KeyOffset != 0 &&
- !wcsncmp(KeyName, (PWSTR) &HashBlock->Table[Idx].HashValue, 2))
+ !wcsncmp(KeyName, (PWSTR) &HashBlock->Table[Idx].HashValue, 4))
{
CurSubKeyBlock = CmiGetKeyBlock(RegistryFile,
HashBlock->Table[Idx].KeyOffset);
}
static NTSTATUS
-CmiAddSubKey(PREGISTRY_FILE RegistryFile,
+CmiAddSubKey(PREGISTRY_FILE RegistryFile,
PKEY_BLOCK KeyBlock,
PKEY_BLOCK *SubKeyBlock,
PWSTR NewSubKeyName,
ULONG TitleIndex,
- PWSTR Class,
+ PWSTR Class,
ULONG CreateOptions)
{
NTSTATUS Status;
}
if (KeyBlock->HashTableOffset == 0)
{
- Status = CmiAllocateHashTableBlock(RegistryFile,
+ Status = CmiAllocateHashTableBlock(RegistryFile,
&HashBlock,
REG_INIT_HASH_TABLE_SIZE);
if (!NT_SUCCESS(Status))
return Status;
}
-static NTSTATUS
+static NTSTATUS
CmiScanKeyForValue(IN PREGISTRY_FILE RegistryFile,
IN PKEY_BLOCK KeyBlock,
IN PWSTR ValueName,
PVALUE_LIST_BLOCK ValueListBlock;
PVALUE_BLOCK CurValueBlock;
- ValueListBlock = CmiGetBlock(RegistryFile,
+ ValueListBlock = CmiGetBlock(RegistryFile,
KeyBlock->ValuesOffset);
*ValueBlock = NULL;
- if (ValueListBlock == NULL)
+ if (ValueListBlock == 0)
{
return STATUS_SUCCESS;
}
return STATUS_SUCCESS;
}
-
-static NTSTATUS
-CmiGetValueFromKeyByIndex(IN PREGISTRY_FILE RegistryFile,
- IN PKEY_BLOCK KeyBlock,
- IN ULONG Index,
- OUT PVALUE_BLOCK *ValueBlock)
-{
- PVALUE_LIST_BLOCK ValueListBlock;
- PVALUE_BLOCK CurValueBlock;
-
- ValueListBlock = CmiGetBlock(RegistryFile,
- KeyBlock->ValuesOffset);
- *ValueBlock = NULL;
- if (ValueListBlock == NULL)
- {
- return STATUS_NO_MORE_ENTRIES;
- }
- if (Index >= KeyBlock->NumberOfValues)
- {
- return STATUS_NO_MORE_ENTRIES;
- }
- CurValueBlock = CmiGetBlock(RegistryFile,
- ValueListBlock->Values[Index]);
- if (CurValueBlock != NULL)
- {
- *ValueBlock = CurValueBlock;
- }
- CmiReleaseBlock(RegistryFile, CurValueBlock);
- CmiReleaseBlock(RegistryFile, ValueListBlock);
-
- return STATUS_SUCCESS;
-}
-
-
-static NTSTATUS
+static NTSTATUS
CmiAddValueToKey(IN PREGISTRY_FILE RegistryFile,
IN PKEY_BLOCK KeyBlock,
IN PWSTR ValueNameBuf,
- IN ULONG Type,
+ IN ULONG Type,
IN PVOID Data,
IN ULONG DataSize)
{
{
return Status;
}
- ValueListBlock = CmiGetBlock(RegistryFile,
+ ValueListBlock = CmiGetBlock(RegistryFile,
KeyBlock->ValuesOffset);
if (ValueListBlock == NULL)
{
ValueBlock);
return Status;
}
- KeyBlock->ValuesOffset = CmiGetBlockOffset(RegistryFile,
- ValueListBlock);
}
else if (KeyBlock->NumberOfValues % REG_VALUE_LIST_BLOCK_MULTIPLE)
{
Status = CmiAllocateBlock(RegistryFile,
(PVOID) &NewValueListBlock,
sizeof(BLOCK_OFFSET) *
- (KeyBlock->NumberOfValues +
+ (KeyBlock->NumberOfValues +
REG_VALUE_LIST_BLOCK_MULTIPLE));
if (!NT_SUCCESS(Status))
{
ValueBlock);
return Status;
}
- RtlCopyMemory(NewValueListBlock,
+ RtlCopyMemory(NewValueListBlock,
ValueListBlock,
sizeof(BLOCK_OFFSET) * KeyBlock->NumberOfValues);
- KeyBlock->ValuesOffset = CmiGetBlockOffset(RegistryFile,
+ KeyBlock->ValuesOffset = CmiGetBlockOffset(RegistryFile,
NewValueListBlock);
CmiDestroyBlock(RegistryFile, ValueListBlock);
ValueListBlock = NewValueListBlock;
}
-
- ValueListBlock->Values[KeyBlock->NumberOfValues] =
+ ValueListBlock->Values[KeyBlock->NumberOfValues] =
CmiGetBlockOffset(RegistryFile, ValueBlock);
KeyBlock->NumberOfValues++;
- CmiReleaseBlock(RegistryFile, ValueListBlock);
CmiReleaseBlock(RegistryFile, ValueBlock);
+ CmiReleaseBlock(RegistryFile, ValueListBlock);
return STATUS_SUCCESS;
}
-static NTSTATUS
+static NTSTATUS
CmiDeleteValueFromKey(IN PREGISTRY_FILE RegistryFile,
IN PKEY_BLOCK KeyBlock,
IN PWSTR ValueName)
PVALUE_LIST_BLOCK ValueListBlock;
PVALUE_BLOCK CurValueBlock;
- ValueListBlock = CmiGetBlock(RegistryFile,
+ ValueListBlock = CmiGetBlock(RegistryFile,
KeyBlock->ValuesOffset);
if (ValueListBlock == 0)
{
{
RtlCopyMemory(&ValueListBlock->Values[Idx],
&ValueListBlock->Values[Idx + 1],
- sizeof(BLOCK_OFFSET) *
+ sizeof(BLOCK_OFFSET) *
(KeyBlock->NumberOfValues - 1 - Idx));
}
else
NewKeySize = sizeof(KEY_BLOCK) +
(wcslen(KeyName) + 1) * sizeof(WCHAR) +
(Class != NULL ? (wcslen(Class) + 1) * sizeof(WCHAR) : 0);
- DPRINT ("NewKeySize: %lu\n", NewKeySize);
+DPRINT ("NewKeySize: %lu\n", NewKeySize);
//CHECKPOINT;
NewKeyBlock = ExAllocatePool(NonPagedPool, NewKeySize);
//CHECKPOINT;
ExFreePool(KeyBlock);
}
else
- {
+ {
UNIMPLEMENTED;
}
return Status;
}
-static PHASH_TABLE_BLOCK
+static PHASH_TABLE_BLOCK
CmiGetHashTableBlock(PREGISTRY_FILE RegistryFile,
BLOCK_OFFSET HashBlockOffset)
{
return HashBlock;
}
-static PKEY_BLOCK
+static PKEY_BLOCK
CmiGetKeyFromHashByIndex(PREGISTRY_FILE RegistryFile,
PHASH_TABLE_BLOCK HashBlock,
ULONG Index)
return KeyBlock;
}
-static NTSTATUS
+static NTSTATUS
CmiAddKeyToHashTable(PREGISTRY_FILE RegistryFile,
PHASH_TABLE_BLOCK HashBlock,
PKEY_BLOCK NewKeyBlock)
ExFreePool(HashBlock);
}
else
- {
+ {
Status = STATUS_NOT_IMPLEMENTED;
}
CmiAllocateValueBlock(PREGISTRY_FILE RegistryFile,
PVALUE_BLOCK *ValueBlock,
IN PWSTR ValueNameBuf,
- IN ULONG Type,
+ IN ULONG Type,
IN PVOID Data,
IN ULONG DataSize)
{
/* Handle volatile files first */
if (RegistryFile->Filename == NULL)
{
- NewValueSize = sizeof(VALUE_BLOCK) + wcslen(ValueNameBuf)* sizeof(WCHAR);
+ NewValueSize = sizeof(VALUE_BLOCK) + wcslen(ValueNameBuf);
NewValueBlock = ExAllocatePool(NonPagedPool, NewValueSize);
if (NewValueBlock == NULL)
{
return Status;
}
-static NTSTATUS
+static NTSTATUS
CmiReplaceValueData(IN PREGISTRY_FILE RegistryFile,
IN PVALUE_BLOCK ValueBlock,
- IN ULONG Type,
+ IN ULONG Type,
IN PVOID Data,
IN ULONG DataSize)
{
{
NTSTATUS Status;
- Status = CmiDestroyBlock(RegistryFile,
+ Status = CmiDestroyBlock(RegistryFile,
CmiGetBlock(RegistryFile,
ValueBlock->DataOffset));
if (!NT_SUCCESS(Status))
ExFreePool(Block);
}
else
- {
+ {
Status = STATUS_NOT_IMPLEMENTED;
}
return BlockOffset;
}
-static VOID
+static VOID
CmiLockBlock(PREGISTRY_FILE RegistryFile,
PVOID Block)
{
}
}
-static VOID
+static VOID
CmiReleaseBlock(PREGISTRY_FILE RegistryFile,
PVOID Block)
{