Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-05 08:03:01 +00:00
Code Issues Projects Releases Packages Wiki Activity

Fixed some bugs in the registry

Browse source 
Improved registry test app

svn path=/trunk/; revision=1343
This commit is contained in:
Eric Kohl 2000-09-06 19:59:54 +00:00
parent e7365f8b00
commit d7d755265d
5 changed files with 238 additions and 105 deletions
Download patch file Download diff file Expand all files Collapse all files

74
reactos/apps/tests/regtest/regtest.c
View file

@ -22,22 +22,78 @@ int main(int argc, char* argv[])
{ {
HKEY hKey = NULL; HKEY hKey = NULL;
DWORD dwDisposition; DWORD dwDisposition;
DWORD dwError;
AllocConsole(); AllocConsole();
InputHandle = GetStdHandle(STD_INPUT_HANDLE); InputHandle = GetStdHandle(STD_INPUT_HANDLE);
OutputHandle = GetStdHandle(STD_OUTPUT_HANDLE); OutputHandle = GetStdHandle(STD_OUTPUT_HANDLE);
dprintf ("RegCreateKeyExW:\n"); dprintf ("RegCreateKeyExW:\n");
RegCreateKeyExW (HKEY_LOCAL_MACHINE, dwError = RegCreateKeyExW (HKEY_LOCAL_MACHINE,
L"Test", L"Test",
0, 0,
L"", L"",
REG_OPTION_VOLATILE, REG_OPTION_VOLATILE,
KEY_ALL_ACCESS, KEY_ALL_ACCESS,
NULL, NULL,
&hKey, &hKey,
&dwDisposition); &dwDisposition);
dprintf ("dwError %x\n", dwError);
if (dwError != ERROR_SUCCESS)
return 0;
dprintf ("dwDisposition %x\n", dwDisposition);
dprintf ("RegSetValueExW:\n");
dwError = RegSetValueExW (hKey,
L"TestValue",
0,
REG_SZ,
L"TestString",
20);
dprintf ("dwError %x\n", dwError);
if (dwError != ERROR_SUCCESS)
return 0;
dprintf ("RegCloseKey:\n");
dwError = RegCloseKey (hKey);
dprintf ("dwError %x\n", dwError);
if (dwError != ERROR_SUCCESS)
return 0;
dprintf ("\n\n");
hKey = NULL;
dprintf ("RegCreateKeyExW:\n");
dwError = RegCreateKeyExW (HKEY_LOCAL_MACHINE,
L"Test",
0,
L"",
REG_OPTION_VOLATILE,
KEY_ALL_ACCESS,
NULL,
&hKey,
&dwDisposition);
dprintf ("dwError %x\n", dwError);
if (dwError != ERROR_SUCCESS)
return 0;
dprintf ("dwDisposition %x\n", dwDisposition);
#if 0
dprintf ("RegQueryKeyExW:\n");
#endif
dprintf ("RegCloseKey:\n");
dwError = RegCloseKey (hKey);
dprintf ("dwError %x\n", dwError);
if (dwError != ERROR_SUCCESS)
return 0;
dprintf ("\nTests done...\n"); dprintf ("\nTests done...\n");

2
reactos/include/base.h
View file

@ -211,7 +211,7 @@ typedef char *PTSTR;
/* /*
typedef PWSTR; typedef PWSTR;
*/ */
typedef PVOID REGSAM; typedef DWORD REGSAM;
typedef short RETCODE; typedef short RETCODE;

8
reactos/lib/advapi32/advapi32.edf
View file

@ -1,4 +1,4 @@
; $Id: advapi32.edf,v 1.8 2000/04/06 02:29:43 ekohl Exp $ ; $Id: advapi32.edf,v 1.9 2000/09/06 19:57:58 ekohl Exp $
; ;
; advapi32.def ; advapi32.def
; ;
@ -297,7 +297,7 @@ RegCreateKeyW=RegCreateKeyW@12
RegDeleteKeyA=RegDeleteKeyA@8 RegDeleteKeyA=RegDeleteKeyA@8
RegDeleteKeyW=RegDeleteKeyW@8 RegDeleteKeyW=RegDeleteKeyW@8
RegDeleteValueA=RegDeleteValueA@8 RegDeleteValueA=RegDeleteValueA@8
;RegDeleteValueW=RegDeleteValueW@8 RegDeleteValueW=RegDeleteValueW@8
RegEnumKeyA=RegEnumKeyA@16 RegEnumKeyA=RegEnumKeyA@16
RegEnumKeyExA=RegEnumKeyExA@32 RegEnumKeyExA=RegEnumKeyExA@32
;RegEnumKeyExW=RegEnumKeyExW@32 ;RegEnumKeyExW=RegEnumKeyExW@32
@ -330,8 +330,8 @@ RegSaveKeyA=RegSaveKeyA@12
;RegSetKeySecurity=RegSetKeySecurity@12 ;RegSetKeySecurity=RegSetKeySecurity@12
RegSetValueA=RegSetValueA@20 RegSetValueA=RegSetValueA@20
RegSetValueExA=RegSetValueExA@24 RegSetValueExA=RegSetValueExA@24
;RegSetValueExW=RegSetValueExW@24 RegSetValueExW=RegSetValueExW@24
;RegSetValueW=RegSetValueW@20 RegSetValueW=RegSetValueW@20
RegUnLoadKeyA=RegUnLoadKeyA@8 RegUnLoadKeyA=RegUnLoadKeyA@8
;RegUnLoadKeyW=RegUnLoadKeyW@8 ;RegUnLoadKeyW=RegUnLoadKeyW@8
;RegisterEventSourceA=RegisterEventSourceA@8 ;RegisterEventSourceA=RegisterEventSourceA@8

114
reactos/lib/advapi32/reg/reg.c
View file

@ -1,4 +1,4 @@
/* $Id: reg.c,v 1.8 2000/09/05 23:00:27 ekohl Exp $ /* $Id: reg.c,v 1.9 2000/09/06 19:58:47 ekohl Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
@ -28,7 +28,7 @@ static HANDLE DefaultHandleTable[MAX_DEFAULT_HANDLES];
/* PROTOTYPES ****************************************************************/ /* PROTOTYPES ****************************************************************/
static NTSTATUS MapDefaultKey (PHKEY ParentKey, HKEY Key); static NTSTATUS MapDefaultKey (PHKEY ParentKey, HKEY Key);
static VOID CloseDefaultHandles(VOID); static VOID CloseDefaultKeys(VOID);
static NTSTATUS OpenLocalMachineKey (PHANDLE KeyHandle); static NTSTATUS OpenLocalMachineKey (PHANDLE KeyHandle);
@ -60,7 +60,7 @@ RegCleanup(VOID)
{ {
DPRINT1("RegCleanup()\n"); DPRINT1("RegCleanup()\n");
CloseDefaultHandles(); CloseDefaultKeys();
RtlDeleteCriticalSection(&HandleTableCS); RtlDeleteCriticalSection(&HandleTableCS);
return TRUE; return TRUE;
} }
@ -120,7 +120,7 @@ DPRINT1("Status %x\n", Status);
} }
static VOID CloseDefaultHandles(VOID) static VOID CloseDefaultKeys (VOID)
{ {
ULONG i; ULONG i;
@ -130,7 +130,7 @@ static VOID CloseDefaultHandles(VOID)
{ {
if (DefaultHandleTable[i] != NULL) if (DefaultHandleTable[i] != NULL)
{ {
// NtClose (DefaultHandleTable[i]); NtClose (DefaultHandleTable[i]);
DefaultHandleTable[i] = NULL; DefaultHandleTable[i] = NULL;
} }
} }
@ -156,7 +156,9 @@ OpenLocalMachineKey (PHANDLE KeyHandle)
NULL, NULL,
NULL); NULL);
return (NtOpenKey (KeyHandle, 0x200000, &Attributes)); return (NtOpenKey (KeyHandle,
KEY_ALL_ACCESS,
&Attributes));
} }
@ -169,11 +171,22 @@ RegCloseKey(
HKEY hKey HKEY hKey
) )
{ {
if (!hKey) NTSTATUS Status;
/* don't close null handle or a pseudo handle */
if ((!hKey) || (((ULONG)hKey & 0xF0000000) == 0x80000000))
return ERROR_INVALID_HANDLE; return ERROR_INVALID_HANDLE;
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); Status = NtClose (hKey);
return ERROR_CALL_NOT_IMPLEMENTED; if (!NT_SUCCESS(Status))
{
LONG ErrorCode = RtlNtStatusToDosError(Status);
SetLastError (ErrorCode);
return ErrorCode;
}
return ERROR_SUCCESS;
} }
@ -290,8 +303,10 @@ RegCreateKeyExW(
Status = MapDefaultKey (&ParentKey, hKey); Status = MapDefaultKey (&ParentKey, hKey);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError(Status)); LONG ErrorCode = RtlNtStatusToDosError(Status);
return (RtlNtStatusToDosError(Status));
SetLastError (ErrorCode);
return ErrorCode;
} }
DPRINT1("ParentKey %x\n", (ULONG)ParentKey); DPRINT1("ParentKey %x\n", (ULONG)ParentKey);
@ -315,8 +330,10 @@ RegCreateKeyExW(
DPRINT1("Status %x\n", Status); DPRINT1("Status %x\n", Status);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError(Status)); LONG ErrorCode = RtlNtStatusToDosError(Status);
return (RtlNtStatusToDosError(Status));
SetLastError (ErrorCode);
return ErrorCode;
} }
DPRINT1("Returned handle %x\n", (ULONG)*phkResult); DPRINT1("Returned handle %x\n", (ULONG)*phkResult);
@ -369,6 +386,21 @@ RegDeleteValueA(
} }
/************************************************************************
* RegDeleteValueW
*/
LONG
STDCALL
RegDeleteValueW(
HKEY hKey,
LPCWSTR lpValueName
)
{
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return ERROR_CALL_NOT_IMPLEMENTED;
}
/************************************************************************ /************************************************************************
* RegEnumKeyA * RegEnumKeyA
*/ */
@ -831,6 +863,62 @@ RegSetValueExA(
} }
/************************************************************************
* RegSetValueExW
*/
LONG
STDCALL
RegSetValueExW(
HKEY hKey,
LPCWSTR lpValueName,
DWORD Reserved,
DWORD dwType,
CONST BYTE *lpData,
DWORD cbData
)
{
UNICODE_STRING ValueName;
NTSTATUS Status;
RtlInitUnicodeString (&ValueName,
lpValueName);
Status = NtSetValueKey (hKey,
&ValueName,
0,
dwType,
(PVOID)lpData,
(ULONG)cbData);
if (!NT_SUCCESS(Status))
{
LONG ErrorCode = RtlNtStatusToDosError(Status);
SetLastError (ErrorCode);
return ErrorCode;
}
return ERROR_SUCCESS;
}
/************************************************************************
* RegSetValueW
*/
LONG
STDCALL
RegSetValueW(
HKEY hKey,
LPCWSTR lpSubKey,
DWORD dwType,
LPCWSTR lpData,
DWORD cbData
)
{
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return ERROR_CALL_NOT_IMPLEMENTED;
}
/************************************************************************ /************************************************************************
* RegUnLoadKeyA * RegUnLoadKeyA
*/ */

145
reactos/ntoskrnl/cm/registry.c
View file

@ -1,4 +1,4 @@
/* $Id: registry.c,v 1.27 2000/09/05 23:03:09 ekohl Exp $ /* $Id: registry.c,v 1.28 2000/09/06 19:59:54 ekohl Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -373,11 +373,11 @@ CHECKPOINT;
#endif #endif
} }
VOID VOID
CmImportHive(PCHAR Chunk) CmImportHive(PCHAR Chunk)
{ {
/* FIXME: implemement this */ /* FIXME: implemement this */
return; return;
} }
NTSTATUS NTSTATUS
@ -385,7 +385,7 @@ STDCALL
NtCreateKey ( NtCreateKey (
OUT PHANDLE KeyHandle, OUT PHANDLE KeyHandle,
IN ACCESS_MASK DesiredAccess, IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes, IN POBJECT_ATTRIBUTES ObjectAttributes,
IN ULONG TitleIndex, IN ULONG TitleIndex,
IN PUNICODE_STRING Class, IN PUNICODE_STRING Class,
IN ULONG CreateOptions, IN ULONG CreateOptions,
@ -408,7 +408,6 @@ NtCreateKey (
Status = CmiBuildKeyPath(&KeyNameBuf, ObjectAttributes); Status = CmiBuildKeyPath(&KeyNameBuf, ObjectAttributes);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
CHECKPOINT1;
return Status; return Status;
} }
@ -429,8 +428,11 @@ CHECKPOINT1;
FALSE, FALSE,
KeyHandle); KeyHandle);
ExFreePool(KeyNameBuf); ExFreePool(KeyNameBuf);
if (NT_SUCCESS(Status))
CHECKPOINT1; {
*Disposition = REG_OPENED_EXISTING_KEY;
}
DPRINT1("KeyHandle (opened) %x\n", *KeyHandle);
return Status; return Status;
} }
@ -439,26 +441,24 @@ CHECKPOINT1;
KeyNameBuf, KeyNameBuf,
&KeyBlock, &KeyBlock,
DesiredAccess, DesiredAccess,
TitleIndex, TitleIndex,
Class, Class,
CreateOptions, CreateOptions,
Disposition); Disposition);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
ExFreePool(KeyNameBuf); ExFreePool(KeyNameBuf);
CHECKPOINT1;
return Status; return Status;
} }
/* Create new key object and put into linked list */ /* Create new key object and put into linked list */
NewKey = ObCreateObject(KeyHandle, NewKey = ObCreateObject(KeyHandle,
DesiredAccess, DesiredAccess,
NULL, NULL,
CmiKeyType); CmiKeyType);
if (NewKey == NULL) if (NewKey == NULL)
{ {
CHECKPOINT1;
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
} }
NewKey->Flags = 0; NewKey->Flags = 0;
@ -467,12 +467,17 @@ CHECKPOINT1;
NewKey->RegistryFile = FileToUse; NewKey->RegistryFile = FileToUse;
CmiAddKeyToList(NewKey); CmiAddKeyToList(NewKey);
Status = ObCreateHandle(PsGetCurrentProcess(), Status = ObCreateHandle(PsGetCurrentProcess(),
CurKey, NewKey,
DesiredAccess, DesiredAccess,
FALSE, FALSE,
KeyHandle); KeyHandle);
CHECKPOINT1; DPRINT1("Status %x KeyHandle (created) %x\n", Status, *KeyHandle);
if (NT_SUCCESS(Status))
{
*Disposition = REG_CREATED_NEW_KEY;
}
return Status; return Status;
#else #else
UNIMPLEMENTED; UNIMPLEMENTED;
@ -480,7 +485,7 @@ CHECKPOINT1;
} }
NTSTATUS NTSTATUS
STDCALL STDCALL
NtDeleteKey ( NtDeleteKey (
IN HANDLE KeyHandle IN HANDLE KeyHandle
@ -745,11 +750,12 @@ NtOpenKey (
KeyHandle); KeyHandle);
ExFreePool(KeyNameBuf); ExFreePool(KeyNameBuf);
DPRINT1("Status %x KeyHandle (opened) %x\n", Status, *KeyHandle);
return Status; return Status;
} }
/* Open the key in the registry file */ /* Open the key in the registry file */
CHECKPOINT1;
FileToUse = CmiSystemFile; FileToUse = CmiSystemFile;
Status = CmiFindKey(FileToUse, Status = CmiFindKey(FileToUse,
KeyNameBuf, KeyNameBuf,
@ -757,10 +763,8 @@ CHECKPOINT1;
DesiredAccess, DesiredAccess,
0, 0,
NULL); NULL);
CHECKPOINT1;
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
CHECKPOINT1;
FileToUse = CmiVolatileFile; FileToUse = CmiVolatileFile;
Status = CmiFindKey(FileToUse, Status = CmiFindKey(FileToUse,
KeyNameBuf, KeyNameBuf,
@ -768,21 +772,18 @@ CHECKPOINT1;
DesiredAccess, DesiredAccess,
0, 0,
NULL); NULL);
CHECKPOINT1;
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
CHECKPOINT1;
ExFreePool(KeyNameBuf); ExFreePool(KeyNameBuf);
return Status; return Status;
} }
} }
CHECKPOINT1;
/* Create new key object and put into linked list */ /* Create new key object and put into linked list */
NewKey = ObCreateObject(KeyHandle, NewKey = ObCreateObject(KeyHandle,
DesiredAccess, DesiredAccess,
NULL, NULL,
CmiKeyType); CmiKeyType);
if (NewKey == NULL) if (NewKey == NULL)
{ {
@ -793,12 +794,15 @@ CHECKPOINT1;
NewKey->RegistryFile = FileToUse; NewKey->RegistryFile = FileToUse;
NewKey->KeyBlock = KeyBlock; NewKey->KeyBlock = KeyBlock;
CmiAddKeyToList(NewKey); CmiAddKeyToList(NewKey);
DPRINT1("KeyHandle (created) %x\n", *KeyHandle);
Status = ObCreateHandle(PsGetCurrentProcess(), Status = ObCreateHandle(PsGetCurrentProcess(),
CurKey, NewKey,
DesiredAccess, DesiredAccess,
FALSE, FALSE,
KeyHandle); KeyHandle);
DPRINT1("Status %x KeyHandle (created) %x\n", Status, *KeyHandle);
return Status; return Status;
#else #else
UNIMPLEMENTED; UNIMPLEMENTED;
@ -806,10 +810,10 @@ CHECKPOINT1;
} }
NTSTATUS NTSTATUS
STDCALL STDCALL
NtQueryKey ( NtQueryKey (
IN HANDLE KeyHandle, IN HANDLE KeyHandle,
IN KEY_INFORMATION_CLASS KeyInformationClass, IN KEY_INFORMATION_CLASS KeyInformationClass,
OUT PVOID KeyInformation, OUT PVOID KeyInformation,
IN ULONG Length, IN ULONG Length,
@ -985,7 +989,7 @@ NtQueryValueKey (
RegistryFile = KeyObject->RegistryFile; RegistryFile = KeyObject->RegistryFile;
/* Get Value block of interest */ /* Get Value block of interest */
Status = CmiScanKeyForValue(RegistryFile, Status = CmiScanKeyForValue(RegistryFile,
KeyBlock, KeyBlock,
ValueName->Buffer, ValueName->Buffer,
&ValueBlock); &ValueBlock);
@ -1024,7 +1028,7 @@ NtQueryValueKey (
} }
else else
{ {
ValuePartialInformation = (PKEY_VALUE_PARTIAL_INFORMATION) ValuePartialInformation = (PKEY_VALUE_PARTIAL_INFORMATION)
KeyValueInformation; KeyValueInformation;
ValuePartialInformation->TitleIndex = 0; ValuePartialInformation->TitleIndex = 0;
ValuePartialInformation->Type = ValueBlock->DataType; ValuePartialInformation->Type = ValueBlock->DataType;
@ -1077,13 +1081,13 @@ NtQueryValueKey (
} }
NTSTATUS NTSTATUS
STDCALL STDCALL
NtSetValueKey ( NtSetValueKey (
IN HANDLE KeyHandle, IN HANDLE KeyHandle,
IN PUNICODE_STRING ValueName, IN PUNICODE_STRING ValueName,
IN ULONG TitleIndex, IN ULONG TitleIndex,
IN ULONG Type, IN ULONG Type,
IN PVOID Data, IN PVOID Data,
IN ULONG DataSize IN ULONG DataSize
) )
@ -1097,7 +1101,7 @@ NtSetValueKey (
/* Verify that the handle is valid and is a registry key */ /* Verify that the handle is valid and is a registry key */
Status = ObReferenceObjectByHandle(KeyHandle, Status = ObReferenceObjectByHandle(KeyHandle,
KEY_QUERY_VALUE, KEY_SET_VALUE,
CmiKeyType, CmiKeyType,
UserMode, UserMode,
(PVOID *)&KeyObject, (PVOID *)&KeyObject,
@ -1106,7 +1110,6 @@ NtSetValueKey (
{ {
return Status; return Status;
} }
/* Get pointer to KeyBlock */ /* Get pointer to KeyBlock */
KeyBlock = KeyObject->KeyBlock; KeyBlock = KeyObject->KeyBlock;
RegistryFile = KeyObject->RegistryFile; RegistryFile = KeyObject->RegistryFile;
@ -1116,6 +1119,7 @@ NtSetValueKey (
&ValueBlock); &ValueBlock);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
ObDereferenceObject (KeyObject);
return Status; return Status;
} }
if (ValueBlock == NULL) if (ValueBlock == NULL)
@ -1135,6 +1139,7 @@ NtSetValueKey (
Data, Data,
DataSize); DataSize);
} }
ObDereferenceObject (KeyObject);
return Status; return Status;
#else #else
@ -1515,7 +1520,7 @@ DbgPrint ("KeyName %wZ\n", ObjectAttributes->ObjectName);
Status = ObReferenceObjectByHandle(ObjectAttributes->RootDirectory, Status = ObReferenceObjectByHandle(ObjectAttributes->RootDirectory,
KEY_READ, KEY_READ,
NULL, NULL,
UserMode, KernelMode,
(PVOID *)&ObjectBody, (PVOID *)&ObjectBody,
NULL); NULL);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
@ -1688,7 +1693,7 @@ CmiScanKeyList(PWSTR KeyName)
return CurKey; return CurKey;
} }
static PREGISTRY_FILE static PREGISTRY_FILE
CmiCreateRegistry(PWSTR Filename) CmiCreateRegistry(PWSTR Filename)
{ {
PREGISTRY_FILE RegistryFile; PREGISTRY_FILE RegistryFile;
@ -1747,8 +1752,8 @@ CmiCreateKey(IN PREGISTRY_FILE RegistryFile,
OUT PKEY_BLOCK *KeyBlock, OUT PKEY_BLOCK *KeyBlock,
IN ACCESS_MASK DesiredAccess, IN ACCESS_MASK DesiredAccess,
IN ULONG TitleIndex, IN ULONG TitleIndex,
IN PUNICODE_STRING Class, IN PUNICODE_STRING Class,
IN ULONG CreateOptions, IN ULONG CreateOptions,
OUT PULONG Disposition) OUT PULONG Disposition)
{ {
/* FIXME: this should be allocated based on the largest subkey name */ /* FIXME: this should be allocated based on the largest subkey name */
@ -1760,13 +1765,11 @@ CmiCreateKey(IN PREGISTRY_FILE RegistryFile,
/* FIXME: Should handle search by Class/TitleIndex */ /* FIXME: Should handle search by Class/TitleIndex */
CHECKPOINT;
/* Loop through each key level and find or build the needed subkey */ /* Loop through each key level and find or build the needed subkey */
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
/* FIXME: this access of RootKeyBlock should be guarded by spinlock */ /* FIXME: this access of RootKeyBlock should be guarded by spinlock */
CurKeyBlock = CmiGetKeyBlock(RegistryFile, CurKeyBlock = CmiGetKeyBlock(RegistryFile,
RegistryFile->HeaderBlock->RootKeyBlock); RegistryFile->HeaderBlock->RootKeyBlock);
CHECKPOINT;
Remainder = KeyNameBuf; Remainder = KeyNameBuf;
while (NT_SUCCESS(Status) && while (NT_SUCCESS(Status) &&
(NextSlash = wcschr(Remainder, L'\\')) != NULL) (NextSlash = wcschr(Remainder, L'\\')) != NULL)
@ -1853,7 +1856,7 @@ CHECKPOINT;
return Status; return Status;
} }
static NTSTATUS static NTSTATUS
CmiFindKey(IN PREGISTRY_FILE RegistryFile, CmiFindKey(IN PREGISTRY_FILE RegistryFile,
IN PWSTR KeyNameBuf, IN PWSTR KeyNameBuf,
OUT PKEY_BLOCK *KeyBlock, OUT PKEY_BLOCK *KeyBlock,
@ -1867,12 +1870,8 @@ CmiFindKey(IN PREGISTRY_FILE RegistryFile,
PWSTR Remainder, NextSlash; PWSTR Remainder, NextSlash;
PKEY_BLOCK CurKeyBlock, SubKeyBlock; PKEY_BLOCK CurKeyBlock, SubKeyBlock;
DbgPrint("KeyNameBuf %S\n", KeyNameBuf);
CHECKPOINT1;
if (RegistryFile == NULL) if (RegistryFile == NULL)
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
CHECKPOINT1;
/* FIXME: Should handle search by Class/TitleIndex */ /* FIXME: Should handle search by Class/TitleIndex */
@ -1888,11 +1887,10 @@ CHECKPOINT1;
/* Copy just the current subkey name to a buffer */ /* Copy just the current subkey name to a buffer */
wcsncpy(CurKeyName, Remainder, NextSlash - Remainder); wcsncpy(CurKeyName, Remainder, NextSlash - Remainder);
CurKeyName[NextSlash - Remainder] = 0; CurKeyName[NextSlash - Remainder] = 0;
DbgPrint("CurKeyName %S\n", CurKeyName);
/* Verify existance of CurKeyName */ /* Verify existance of CurKeyName */
Status = CmiScanForSubKey(RegistryFile, Status = CmiScanForSubKey(RegistryFile,
CurKeyBlock, CurKeyBlock,
&SubKeyBlock, &SubKeyBlock,
CurKeyName, CurKeyName,
DesiredAccess); DesiredAccess);
@ -1902,7 +1900,6 @@ DbgPrint("CurKeyName %S\n", CurKeyName);
} }
if (SubKeyBlock == NULL) if (SubKeyBlock == NULL)
{ {
CHECKPOINT1;
Status = STATUS_UNSUCCESSFUL; Status = STATUS_UNSUCCESSFUL;
continue; continue;
} }
@ -1913,9 +1910,8 @@ CHECKPOINT1;
} }
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
{ {
DbgPrint("CurKeyName %S\n", CurKeyName); Status = CmiScanForSubKey(RegistryFile,
Status = CmiScanForSubKey(RegistryFile, CurKeyBlock,
CurKeyBlock,
&SubKeyBlock, &SubKeyBlock,
CurKeyName, CurKeyName,
DesiredAccess); DesiredAccess);
@ -1923,7 +1919,6 @@ DbgPrint("CurKeyName %S\n", CurKeyName);
{ {
if (SubKeyBlock == NULL) if (SubKeyBlock == NULL)
{ {
CHECKPOINT1;
Status = STATUS_UNSUCCESSFUL; Status = STATUS_UNSUCCESSFUL;
} }
else else
@ -1933,12 +1928,11 @@ CHECKPOINT1;
} }
} }
CmiReleaseBlock(RegistryFile, CurKeyBlock); CmiReleaseBlock(RegistryFile, CurKeyBlock);
CHECKPOINT1;
return Status; return Status;
} }
static ULONG static ULONG
CmiGetMaxNameLength(PREGISTRY_FILE RegistryFile, CmiGetMaxNameLength(PREGISTRY_FILE RegistryFile,
PKEY_BLOCK KeyBlock) PKEY_BLOCK KeyBlock)
{ {
@ -2079,27 +2073,21 @@ CmiScanForSubKey(IN PREGISTRY_FILE RegistryFile,
PHASH_TABLE_BLOCK HashBlock; PHASH_TABLE_BLOCK HashBlock;
PKEY_BLOCK CurSubKeyBlock; PKEY_BLOCK CurSubKeyBlock;
CHECKPOINT1;
HashBlock = CmiGetHashTableBlock(RegistryFile, KeyBlock->HashTableOffset); HashBlock = CmiGetHashTableBlock(RegistryFile, KeyBlock->HashTableOffset);
*SubKeyBlock = NULL; *SubKeyBlock = NULL;
if (HashBlock == 0) if (HashBlock == 0)
{ {
CHECKPOINT1;
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
CHECKPOINT1;
for (Idx = 0; Idx < HashBlock->HashTableSize; Idx++) for (Idx = 0; Idx < HashBlock->HashTableSize; Idx++)
{ {
DbgPrint ("KeyName %S HashValue %x\n", KeyName, HashBlock->Table[Idx].HashValue);
if (HashBlock->Table[Idx].KeyOffset != 0 && if (HashBlock->Table[Idx].KeyOffset != 0 &&
!wcsncmp(KeyName, (PWSTR) &HashBlock->Table[Idx].HashValue, 2)) !wcsncmp(KeyName, (PWSTR) &HashBlock->Table[Idx].HashValue, 2))
// !wcsncmp(KeyName, (PWSTR) &HashBlock->Table[Idx].HashValue, 4))
{ {
CurSubKeyBlock = CmiGetKeyBlock(RegistryFile, CurSubKeyBlock = CmiGetKeyBlock(RegistryFile,
HashBlock->Table[Idx].KeyOffset); HashBlock->Table[Idx].KeyOffset);
if (!wcscmp(KeyName, CurSubKeyBlock->Name)) if (!wcscmp(KeyName, CurSubKeyBlock->Name))
{ {
CHECKPOINT1;
*SubKeyBlock = CurSubKeyBlock; *SubKeyBlock = CurSubKeyBlock;
break; break;
} }
@ -2222,11 +2210,11 @@ CmiScanKeyForValue(IN PREGISTRY_FILE RegistryFile,
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
static NTSTATUS static NTSTATUS
CmiAddValueToKey(IN PREGISTRY_FILE RegistryFile, CmiAddValueToKey(IN PREGISTRY_FILE RegistryFile,
IN PKEY_BLOCK KeyBlock, IN PKEY_BLOCK KeyBlock,
IN PWSTR ValueNameBuf, IN PWSTR ValueNameBuf,
IN ULONG Type, IN ULONG Type,
IN PVOID Data, IN PVOID Data,
IN ULONG DataSize) IN ULONG DataSize)
{ {
@ -2244,7 +2232,7 @@ CmiAddValueToKey(IN PREGISTRY_FILE RegistryFile,
{ {
return Status; return Status;
} }
ValueListBlock = CmiGetBlock(RegistryFile, ValueListBlock = CmiGetBlock(RegistryFile,
KeyBlock->ValuesOffset); KeyBlock->ValuesOffset);
if (ValueListBlock == NULL) if (ValueListBlock == NULL)
{ {
@ -2264,7 +2252,7 @@ CmiAddValueToKey(IN PREGISTRY_FILE RegistryFile,
Status = CmiAllocateBlock(RegistryFile, Status = CmiAllocateBlock(RegistryFile,
(PVOID) &NewValueListBlock, (PVOID) &NewValueListBlock,
sizeof(BLOCK_OFFSET) * sizeof(BLOCK_OFFSET) *
(KeyBlock->NumberOfValues + (KeyBlock->NumberOfValues +
REG_VALUE_LIST_BLOCK_MULTIPLE)); REG_VALUE_LIST_BLOCK_MULTIPLE));
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
@ -2272,24 +2260,24 @@ CmiAddValueToKey(IN PREGISTRY_FILE RegistryFile,
ValueBlock); ValueBlock);
return Status; return Status;
} }
RtlCopyMemory(NewValueListBlock, RtlCopyMemory(NewValueListBlock,
ValueListBlock, ValueListBlock,
sizeof(BLOCK_OFFSET) * KeyBlock->NumberOfValues); sizeof(BLOCK_OFFSET) * KeyBlock->NumberOfValues);
KeyBlock->ValuesOffset = CmiGetBlockOffset(RegistryFile, KeyBlock->ValuesOffset = CmiGetBlockOffset(RegistryFile,
NewValueListBlock); NewValueListBlock);
CmiDestroyBlock(RegistryFile, ValueListBlock); CmiDestroyBlock(RegistryFile, ValueListBlock);
ValueListBlock = NewValueListBlock; ValueListBlock = NewValueListBlock;
} }
ValueListBlock->Values[KeyBlock->NumberOfValues] = ValueListBlock->Values[KeyBlock->NumberOfValues] =
CmiGetBlockOffset(RegistryFile, ValueBlock); CmiGetBlockOffset(RegistryFile, ValueBlock);
KeyBlock->NumberOfValues++; KeyBlock->NumberOfValues++;
CmiReleaseBlock(RegistryFile, ValueBlock);
CmiReleaseBlock(RegistryFile, ValueListBlock); CmiReleaseBlock(RegistryFile, ValueListBlock);
CmiReleaseBlock(RegistryFile, ValueBlock);
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
static NTSTATUS static NTSTATUS
CmiDeleteValueFromKey(IN PREGISTRY_FILE RegistryFile, CmiDeleteValueFromKey(IN PREGISTRY_FILE RegistryFile,
IN PKEY_BLOCK KeyBlock, IN PKEY_BLOCK KeyBlock,
IN PWSTR ValueName) IN PWSTR ValueName)
@ -2298,7 +2286,7 @@ CmiDeleteValueFromKey(IN PREGISTRY_FILE RegistryFile,
PVALUE_LIST_BLOCK ValueListBlock; PVALUE_LIST_BLOCK ValueListBlock;
PVALUE_BLOCK CurValueBlock; PVALUE_BLOCK CurValueBlock;
ValueListBlock = CmiGetBlock(RegistryFile, ValueListBlock = CmiGetBlock(RegistryFile,
KeyBlock->ValuesOffset); KeyBlock->ValuesOffset);
if (ValueListBlock == 0) if (ValueListBlock == 0)
{ {
@ -2315,7 +2303,7 @@ CmiDeleteValueFromKey(IN PREGISTRY_FILE RegistryFile,
{ {
RtlCopyMemory(&ValueListBlock->Values[Idx], RtlCopyMemory(&ValueListBlock->Values[Idx],
&ValueListBlock->Values[Idx + 1], &ValueListBlock->Values[Idx + 1],
sizeof(BLOCK_OFFSET) * sizeof(BLOCK_OFFSET) *
(KeyBlock->NumberOfValues - 1 - Idx)); (KeyBlock->NumberOfValues - 1 - Idx));
} }
else else
@ -2554,7 +2542,7 @@ CmiDestroyHashTableBlock(PREGISTRY_FILE RegistryFile,
ExFreePool(HashBlock); ExFreePool(HashBlock);
} }
else else
{ {
Status = STATUS_NOT_IMPLEMENTED; Status = STATUS_NOT_IMPLEMENTED;
} }
@ -2579,7 +2567,7 @@ CmiAllocateValueBlock(PREGISTRY_FILE RegistryFile,
/* Handle volatile files first */ /* Handle volatile files first */
if (RegistryFile->Filename == NULL) if (RegistryFile->Filename == NULL)
{ {
NewValueSize = sizeof(VALUE_BLOCK) + wcslen(ValueNameBuf); NewValueSize = sizeof(VALUE_BLOCK) + wcslen(ValueNameBuf)* sizeof(WCHAR);
NewValueBlock = ExAllocatePool(NonPagedPool, NewValueSize); NewValueBlock = ExAllocatePool(NonPagedPool, NewValueSize);
if (NewValueBlock == NULL) if (NewValueBlock == NULL)
{ {
@ -2619,7 +2607,7 @@ CmiAllocateValueBlock(PREGISTRY_FILE RegistryFile,
return Status; return Status;
} }
static NTSTATUS static NTSTATUS
CmiReplaceValueData(IN PREGISTRY_FILE RegistryFile, CmiReplaceValueData(IN PREGISTRY_FILE RegistryFile,
IN PVALUE_BLOCK ValueBlock, IN PVALUE_BLOCK ValueBlock,
IN ULONG Type, IN ULONG Type,
@ -2664,6 +2652,7 @@ CmiDestroyValueBlock(PREGISTRY_FILE RegistryFile,
{ {
NTSTATUS Status; NTSTATUS Status;
CHECKPOINT1;
Status = CmiDestroyBlock(RegistryFile, Status = CmiDestroyBlock(RegistryFile,
CmiGetBlock(RegistryFile, CmiGetBlock(RegistryFile,
ValueBlock->DataOffset)); ValueBlock->DataOffset));