-/* $Id: registry.c 12852 2005-01-06 13:58:04Z mf $
- *
+/*
* COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS kernel
+ * PROJECT: ReactOS system libraries
* PURPOSE: Rtl registry functions
* FILE: lib/rtl/registry.c
* PROGRAMER: Eric Kohl
- * REVISION HISTORY:
- * 2000/08/11: Created
*/
/*
* - support RTL_QUERY_REGISTRY_DELETE
*/
-/* INCLUDES ****************************************************************/
+/* INCLUDES *****************************************************************/
-#define __NTDRIVER__
-#include <ddk/ntddk.h>
-#include <ntdll/rtl.h>
-#include <ntos/minmax.h>
+#include <rtl.h>
#define NDEBUG
-#include <ntdll/ntdll.h>
+#include <debug.h>
+#define TAG_RTLREGISTRY TAG('R', 't', 'l', 'R')
/* FUNCTIONS ***************************************************************/
if (RelativeTo & RTL_REGISTRY_HANDLE)
{
- Status = NtDuplicateObject(NtCurrentProcess(),
+ Status = ZwDuplicateObject(NtCurrentProcess(),
(HANDLE)Path,
NtCurrentProcess(),
KeyHandle,
0,
- FALSE,
+ 0,
DUPLICATE_SAME_ACCESS);
+#ifndef NDEBUG
+ if(!NT_SUCCESS(Status))
+ {
+ DPRINT("ZwDuplicateObject() failed! Status: 0x%x\n", Status);
+ }
+#endif
+
return(Status);
}
RelativeTo &= ~RTL_REGISTRY_OPTIONAL;
if (RelativeTo >= RTL_REGISTRY_MAXIMUM)
+ {
+ DPRINT("Invalid relative flag, parameter invalid!\n");
return(STATUS_INVALID_PARAMETER);
+ }
KeyName.Length = 0;
- KeyName.MaximumLength = MAX_PATH;
+ KeyName.MaximumLength = sizeof(KeyBuffer);
KeyName.Buffer = KeyBuffer;
KeyBuffer[0] = 0;
switch (RelativeTo)
{
case RTL_REGISTRY_ABSOLUTE:
- RtlAppendUnicodeToString(&KeyName,
- L"\\");
+ /* nothing to prefix! */
break;
case RTL_REGISTRY_SERVICES:
RtlAppendUnicodeToString (&KeyName,
L"\\");
break;
-
- /* ReactOS specific */
- case RTL_REGISTRY_ENUM:
- RtlAppendUnicodeToString(&KeyName,
- L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\");
- break;
}
- DPRINT("KeyName %wZ\n", &KeyName);
-
if (Path[0] == L'\\' && RelativeTo != RTL_REGISTRY_ABSOLUTE)
{
Path++;
NULL,
NULL);
- if (Create == TRUE)
+ if (Create)
{
- Status = NtCreateKey(KeyHandle,
+ Status = ZwCreateKey(KeyHandle,
KEY_ALL_ACCESS,
&ObjectAttributes,
0,
}
else
{
- Status = NtOpenKey(KeyHandle,
+ Status = ZwOpenKey(KeyHandle,
KEY_ALL_ACCESS,
&ObjectAttributes);
}
+#ifndef NDEBUG
+ if(!NT_SUCCESS(Status))
+ {
+ DPRINT("%s failed! Status: 0x%x\n", (Create ? "ZwCreateKey" : "ZwOpenKey"), Status);
+ }
+#endif
+
return(Status);
}
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
RtlCheckRegistryKey(IN ULONG RelativeTo,
IN PWSTR Path)
{
HANDLE KeyHandle;
NTSTATUS Status;
+ PAGED_CODE_RTL();
+
Status = RtlpGetRegistryHandle(RelativeTo,
Path,
FALSE,
if (!NT_SUCCESS(Status))
return(Status);
- NtClose(KeyHandle);
+ ZwClose(KeyHandle);
return(STATUS_SUCCESS);
}
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
RtlCreateRegistryKey(IN ULONG RelativeTo,
IN PWSTR Path)
{
HANDLE KeyHandle;
NTSTATUS Status;
+ PAGED_CODE_RTL();
+
Status = RtlpGetRegistryHandle(RelativeTo,
Path,
TRUE,
if (!NT_SUCCESS(Status))
return(Status);
- NtClose(KeyHandle);
+ ZwClose(KeyHandle);
return(STATUS_SUCCESS);
}
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
RtlDeleteRegistryValue(IN ULONG RelativeTo,
IN PCWSTR Path,
IN PCWSTR ValueName)
NTSTATUS Status;
UNICODE_STRING Name;
+ PAGED_CODE_RTL();
+
Status = RtlpGetRegistryHandle(RelativeTo,
(PWSTR)Path,
FALSE,
RtlInitUnicodeString(&Name,
ValueName);
- Status = NtDeleteValueKey(KeyHandle,
+ Status = ZwDeleteValueKey(KeyHandle,
&Name);
- NtClose(KeyHandle);
+ ZwClose(KeyHandle);
return(Status);
}
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
RtlFormatCurrentUserKeyPath (OUT PUNICODE_STRING KeyPath)
{
HANDLE TokenHandle;
UNICODE_STRING SidString;
NTSTATUS Status;
+ PAGED_CODE_RTL();
+
DPRINT ("RtlFormatCurrentUserKeyPath() called\n");
- Status = NtOpenThreadToken (NtCurrentThread (),
- TOKEN_READ,
+ Status = ZwOpenThreadToken (NtCurrentThread (),
+ TOKEN_QUERY,
TRUE,
&TokenHandle);
if (!NT_SUCCESS (Status))
{
if (Status != STATUS_NO_TOKEN)
{
- DPRINT1 ("NtOpenThreadToken() failed (Status %lx)\n", Status);
+ DPRINT1 ("ZwOpenThreadToken() failed (Status %lx)\n", Status);
return Status;
}
- Status = NtOpenProcessToken (NtCurrentProcess (),
- TOKEN_READ,
+ Status = ZwOpenProcessToken (NtCurrentProcess (),
+ TOKEN_QUERY,
&TokenHandle);
if (!NT_SUCCESS (Status))
{
- DPRINT1 ("NtOpenProcessToken() failed (Status %lx)\n", Status);
+ DPRINT1 ("ZwOpenProcessToken() failed (Status %lx)\n", Status);
return Status;
}
}
SidBuffer = (PSID_AND_ATTRIBUTES)Buffer;
- Status = NtQueryInformationToken (TokenHandle,
+ Status = ZwQueryInformationToken (TokenHandle,
TokenUser,
(PVOID)SidBuffer,
256,
&Length);
- NtClose (TokenHandle);
+ ZwClose (TokenHandle);
if (!NT_SUCCESS(Status))
{
- DPRINT1 ("NtQueryInformationToken() failed (Status %lx)\n", Status);
+ DPRINT1 ("ZwQueryInformationToken() failed (Status %lx)\n", Status);
return Status;
}
KeyPath->Length = 0;
KeyPath->MaximumLength = Length;
- KeyPath->Buffer = ExAllocatePool (NonPagedPool,
- KeyPath->MaximumLength);
+ KeyPath->Buffer = RtlpAllocateStringMemory(KeyPath->MaximumLength, TAG_USTR);
if (KeyPath->Buffer == NULL)
{
- DPRINT1 ("ExAllocatePool() failed\n");
+ DPRINT1 ("RtlpAllocateMemory() failed\n");
RtlFreeUnicodeString (&SidString);
return STATUS_NO_TOKEN;
}
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
RtlOpenCurrentUser(IN ACCESS_MASK DesiredAccess,
OUT PHANDLE KeyHandle)
{
UNICODE_STRING KeyPath;
NTSTATUS Status;
+ PAGED_CODE_RTL();
+
Status = RtlFormatCurrentUserKeyPath(&KeyPath);
if (NT_SUCCESS(Status))
{
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
- Status = NtOpenKey(KeyHandle,
+ Status = ZwOpenKey(KeyHandle,
DesiredAccess,
&ObjectAttributes);
RtlFreeUnicodeString(&KeyPath);
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
- Status = NtOpenKey(KeyHandle,
+ Status = ZwOpenKey(KeyHandle,
DesiredAccess,
&ObjectAttributes);
/*
* @unimplemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
RtlQueryRegistryValues(IN ULONG RelativeTo,
IN PCWSTR Path,
IN PRTL_QUERY_REGISTRY_TABLE QueryTable,
UNICODE_STRING EnvValue;
UNICODE_STRING EnvExpandedValue;
+ PAGED_CODE_RTL();
+
DPRINT("RtlQueryRegistryValues() called\n");
Status = RtlpGetRegistryHandle(RelativeTo,
if (((QueryEntry->Flags & (RTL_QUERY_REGISTRY_SUBKEY | RTL_QUERY_REGISTRY_TOPKEY)) != 0) &&
(BaseKeyHandle != CurrentKeyHandle))
{
- NtClose(CurrentKeyHandle);
+ ZwClose(CurrentKeyHandle);
CurrentKeyHandle = BaseKeyHandle;
}
OBJ_CASE_INSENSITIVE,
BaseKeyHandle,
NULL);
- Status = NtOpenKey(&CurrentKeyHandle,
+ Status = ZwOpenKey(&CurrentKeyHandle,
KEY_ALL_ACCESS,
&ObjectAttributes);
if (!NT_SUCCESS(Status))
QueryEntry->Name);
BufferSize = sizeof (KEY_VALUE_PARTIAL_INFORMATION) + 4096;
- ValueInfo = ExAllocatePool(PagedPool, BufferSize);
+ ValueInfo = RtlpAllocateMemory(BufferSize, TAG_RTLREGISTRY);
if (ValueInfo == NULL)
{
Status = STATUS_NO_MEMORY;
break;
}
- Status = NtQueryValueKey(CurrentKeyHandle,
+ Status = ZwQueryValueKey(CurrentKeyHandle,
&KeyName,
KeyValuePartialInformation,
ValueInfo,
{
if (QueryEntry->Flags & RTL_QUERY_REGISTRY_REQUIRED)
{
- ExFreePool(ValueInfo);
+ RtlpFreeMemory(ValueInfo, TAG_RTLREGISTRY);
Status = STATUS_OBJECT_NAME_NOT_FOUND;
break;
}
-
+
if (QueryEntry->DefaultType == REG_SZ)
{
PUNICODE_STRING ValueString;
{
ValueString->Length = SourceString->Length;
ValueString->MaximumLength = SourceString->MaximumLength;
- ValueString->Buffer = ExAllocatePool(PagedPool, BufferSize);
+ ValueString->Buffer = RtlpAllocateMemory(BufferSize, TAG_RTLREGISTRY);
if (!ValueString->Buffer)
break;
ValueString->Buffer[0] = 0;
if (ValueString->Buffer == NULL)
{
ValueString->MaximumLength = ValueInfo->DataLength;
- ValueString->Buffer = ExAllocatePool(PagedPool, ValueString->MaximumLength);
+ ValueString->Buffer = RtlpAllocateMemory(ValueString->MaximumLength, TAG_RTLREGISTRY);
if (ValueString->Buffer == NULL)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
ValueString = (PUNICODE_STRING)QueryEntry->EntryContext;
- ExpandBuffer = ExAllocatePool(PagedPool, ValueInfo->DataLength * 2);
+ ExpandBuffer = RtlpAllocateMemory(ValueInfo->DataLength * 2, TAG_RTLREGISTRY);
if (ExpandBuffer == NULL)
{
Status = STATUS_NO_MEMORY;
{
ValueString->MaximumLength = EnvExpandedValue.Length + sizeof(WCHAR);
ValueString->Length = EnvExpandedValue.Length;
- ValueString->Buffer = ExAllocatePool(PagedPool, ValueString->MaximumLength);
+ ValueString->Buffer = RtlpAllocateMemory(ValueString->MaximumLength, TAG_RTLREGISTRY);
if (ValueString->Buffer == NULL)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
ValueString->Length);
((PWSTR)ValueString->Buffer)[ValueString->Length / sizeof(WCHAR)] = 0;
- ExFreePool(ExpandBuffer);
+ RtlpFreeMemory(ExpandBuffer, TAG_RTLREGISTRY);
}
else
{
}
- ExFreePool(ValueInfo);
+ RtlpFreeMemory(ValueInfo, TAG_RTLREGISTRY);
}
else
{
QueryEntry->Name);
BufferSize = sizeof (KEY_VALUE_PARTIAL_INFORMATION) + 4096;
- ValueInfo = ExAllocatePool(PagedPool, BufferSize);
+ ValueInfo = RtlpAllocateMemory(BufferSize, TAG_RTLREGISTRY);
if (ValueInfo == NULL)
{
Status = STATUS_NO_MEMORY;
break;
}
- Status = NtQueryValueKey(CurrentKeyHandle,
+ Status = ZwQueryValueKey(CurrentKeyHandle,
&KeyName,
KeyValuePartialInformation,
ValueInfo,
{
DPRINT("Expand REG_EXPAND_SZ type\n");
- ExpandBuffer = ExAllocatePool(PagedPool, ValueInfo->DataLength * 2);
+ ExpandBuffer = RtlpAllocateMemory(ValueInfo->DataLength * 2, TAG_RTLREGISTRY);
if (ExpandBuffer == NULL)
{
Status = STATUS_NO_MEMORY;
Context,
QueryEntry->EntryContext);
- ExFreePool(ExpandBuffer);
+ RtlpFreeMemory(ExpandBuffer, TAG_RTLREGISTRY);
}
else
{
}
- ExFreePool(ValueInfo);
+ RtlpFreeMemory(ValueInfo, TAG_RTLREGISTRY);
if (!NT_SUCCESS(Status))
break;
}
DPRINT("Enumerate values\n");
BufferSize = sizeof(KEY_VALUE_FULL_INFORMATION) + 4096;
- FullValueInfo = ExAllocatePool(PagedPool, BufferSize);
+ FullValueInfo = RtlpAllocateMemory(BufferSize, TAG_RTLREGISTRY);
if (FullValueInfo == NULL)
{
Status = STATUS_NO_MEMORY;
break;
}
ValueNameSize = 256 * sizeof(WCHAR);
- ValueName = ExAllocatePool(PagedPool, ValueNameSize);
+ ValueName = RtlpAllocateMemory(ValueNameSize, TAG_RTLREGISTRY);
if (ValueName == NULL)
{
Status = STATUS_NO_MEMORY;
Index = 0;
while (TRUE)
{
- Status = NtEnumerateValueKey(CurrentKeyHandle,
+ Status = ZwEnumerateValueKey(CurrentKeyHandle,
Index,
KeyValueFullInformation,
FullValueInfo,
if (FullValueInfo->NameLength > ValueNameSize - sizeof(WCHAR))
{
/* Should not happen, because the name length is limited to 255 characters */
- ExFreePool(ValueName);
+ RtlpFreeMemory(ValueName, TAG_RTLREGISTRY);
ValueNameSize = FullValueInfo->NameLength + sizeof(WCHAR);
- ValueName = ExAllocatePool(PagedPool, ValueNameSize);
+ ValueName = RtlpAllocateMemory(ValueNameSize, TAG_RTLREGISTRY);
if (ValueName == NULL)
{
Status = STATUS_NO_MEMORY;
!(QueryEntry->Flags & RTL_QUERY_REGISTRY_NOEXPAND))
{
DPRINT("Expand REG_MULTI_SZ type\n");
- StringPtr = (PWSTR)((PVOID)FullValueInfo + FullValueInfo->DataOffset);
+ StringPtr = (PWSTR)((ULONG_PTR)FullValueInfo + FullValueInfo->DataOffset);
while (*StringPtr != 0)
{
StringLen = (wcslen(StringPtr) + 1) * sizeof(WCHAR);
{
DPRINT("Expand REG_EXPAND_SZ type\n");
- StringPtr = (PWSTR)((PVOID)FullValueInfo + FullValueInfo->DataOffset);
- ExpandBuffer = ExAllocatePool(PagedPool, FullValueInfo->DataLength * 2);
+ StringPtr = (PWSTR)((ULONG_PTR)FullValueInfo + FullValueInfo->DataOffset);
+ ExpandBuffer = RtlpAllocateMemory(FullValueInfo->DataLength * 2, TAG_RTLREGISTRY);
if (ExpandBuffer == NULL)
{
Status = STATUS_NO_MEMORY;
Context,
QueryEntry->EntryContext);
- ExFreePool(ExpandBuffer);
+ RtlpFreeMemory(ExpandBuffer, TAG_RTLREGISTRY);
}
else
{
Status = QueryEntry->QueryRoutine(ValueName,
FullValueInfo->Type,
- (PVOID)FullValueInfo + FullValueInfo->DataOffset,
+ (PVOID)((ULONG_PTR)FullValueInfo + FullValueInfo->DataOffset),
FullValueInfo->DataLength,
Context,
QueryEntry->EntryContext);
Index++;
}
- ExFreePool(FullValueInfo);
- ExFreePool(ValueName);
+ RtlpFreeMemory(FullValueInfo, TAG_RTLREGISTRY);
+ RtlpFreeMemory(ValueName, TAG_RTLREGISTRY);
if (!NT_SUCCESS(Status))
break;
}
}
if (CurrentKeyHandle != BaseKeyHandle)
- NtClose(CurrentKeyHandle);
+ ZwClose(CurrentKeyHandle);
- NtClose(BaseKeyHandle);
+ ZwClose(BaseKeyHandle);
return(Status);
}
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
RtlWriteRegistryValue(IN ULONG RelativeTo,
IN PCWSTR Path,
IN PCWSTR ValueName,
NTSTATUS Status;
UNICODE_STRING Name;
+ PAGED_CODE_RTL();
+
Status = RtlpGetRegistryHandle(RelativeTo,
(PWSTR)Path,
TRUE,
&KeyHandle);
if (!NT_SUCCESS(Status))
+ {
+ DPRINT("RtlpGetRegistryHandle() failed! Status: 0x%lx\n", Status);
return(Status);
+ }
RtlInitUnicodeString(&Name,
ValueName);
- Status = NtSetValueKey(KeyHandle,
+ Status = ZwSetValueKey(KeyHandle,
&Name,
0,
ValueType,
ValueData,
ValueLength);
- if (NT_SUCCESS(Status))
- NtClose(KeyHandle);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("ZwSetValueKey() failed! Status: 0x%lx\n", Status);
+ }
+
+ ZwClose(KeyHandle);
return(Status);
}
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
RtlpNtCreateKey(OUT HANDLE KeyHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes,
if (ObjectAttributes != NULL)
ObjectAttributes->Attributes &= ~(OBJ_PERMANENT | OBJ_EXCLUSIVE);
- return(NtCreateKey(KeyHandle,
+ return(ZwCreateKey(KeyHandle,
DesiredAccess,
ObjectAttributes,
0,
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
RtlpNtEnumerateSubKey(IN HANDLE KeyHandle,
OUT PUNICODE_STRING SubKeyName,
IN ULONG Index,
{
BufferLength = SubKeyName->MaximumLength +
sizeof(KEY_BASIC_INFORMATION);
- KeyInfo = ExAllocatePool(PagedPool, BufferLength);
+ KeyInfo = RtlpAllocateMemory(BufferLength, TAG_RTLREGISTRY);
if (KeyInfo == NULL)
return(STATUS_NO_MEMORY);
}
- Status = NtEnumerateKey(KeyHandle,
+ Status = ZwEnumerateKey(KeyHandle,
Index,
KeyBasicInformation,
KeyInfo,
if (KeyInfo != NULL)
{
- ExFreePool(KeyInfo);
+ RtlpFreeMemory(KeyInfo, TAG_RTLREGISTRY);
}
return(Status);
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
RtlpNtMakeTemporaryKey(IN HANDLE KeyHandle)
{
- return(NtDeleteKey(KeyHandle));
+ return(ZwDeleteKey(KeyHandle));
}
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
RtlpNtOpenKey(OUT HANDLE KeyHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes,
if (ObjectAttributes != NULL)
ObjectAttributes->Attributes &= ~(OBJ_PERMANENT | OBJ_EXCLUSIVE);
- return(NtOpenKey(KeyHandle,
+ return(ZwOpenKey(KeyHandle,
DesiredAccess,
ObjectAttributes));
}
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
RtlpNtQueryValueKey(IN HANDLE KeyHandle,
OUT PULONG Type OPTIONAL,
OUT PVOID Data OPTIONAL,
if (DataLength != NULL)
BufferLength = *DataLength;
- ValueInfo = ExAllocatePool(PagedPool, BufferLength);
+ ValueInfo = RtlpAllocateMemory(BufferLength, TAG_RTLREGISTRY);
if (ValueInfo == NULL)
return(STATUS_NO_MEMORY);
- Status = NtQueryValueKey(KeyHandle,
+ Status = ZwQueryValueKey(KeyHandle,
&ValueName,
KeyValuePartialInformation,
ValueInfo,
}
}
- ExFreePool(ValueInfo);
+ RtlpFreeMemory(ValueInfo, TAG_RTLREGISTRY);
return(Status);
}
/*
* @implemented
*/
-NTSTATUS STDCALL
+NTSTATUS NTAPI
RtlpNtSetValueKey(IN HANDLE KeyHandle,
IN ULONG Type,
IN PVOID Data,
RtlInitUnicodeString(&ValueName,
NULL);
- return(NtSetValueKey(KeyHandle,
+ return(ZwSetValueKey(KeyHandle,
&ValueName,
0,
Type,
projects / reactos.git / blobdiff