[ion] 26072: - Rewrite RtlQueryRegistryValues and implement all the features it requires. This is one of the most important kernel-mode API for driver support. - Fix code in the kernel which was incorrectly calling it.
Author: ion Date: Wed Mar 14 04:44:38 2007 New Revision: 26072
URL: http://svn.reactos.org/svn/reactos?rev=26072&view=rev Log: - Rewrite RtlQueryRegistryValues and implement all the features it requires. This is one of the most important kernel-mode API for driver support. - Fix code in the kernel which was incorrectly calling it.
Modified: trunk/reactos/lib/rtl/registry.c trunk/reactos/ntoskrnl/io/iomgr/driver.c
Modified: trunk/reactos/lib/rtl/registry.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/rtl/registry.c?rev=2607... ============================================================================== --- trunk/reactos/lib/rtl/registry.c (original) +++ trunk/reactos/lib/rtl/registry.c Wed Mar 14 04:44:38 2007 @@ -3,22 +3,17 @@ * PROJECT: ReactOS system libraries * PURPOSE: Rtl registry functions * FILE: lib/rtl/registry.c - * PROGRAMER: Eric Kohl + * PROGRAMER: Alex Ionescu (alex.ionescu@reactos.org) + * Eric Kohl */
-/* - * TODO: - * - finish RtlQueryRegistryValues() - */ - /* INCLUDES *****************************************************************/
#include <rtl.h> - #define NDEBUG #include <debug.h>
-#define TAG_RTLREGISTRY TAG('R', 't', 'l', 'R') +#define TAG_RTLREGISTRY TAG('R', 'q', 'r', 'v')
/* DATA **********************************************************************/
@@ -33,6 +28,411 @@ };
/* PRIVATE FUNCTIONS *********************************************************/ + +NTSTATUS +NTAPI +RtlpQueryRegistryDirect(IN ULONG ValueType, + IN PVOID ValueData, + IN ULONG ValueLength, + IN PVOID Buffer) +{ + USHORT ActualLength = (USHORT)ValueLength; + PUNICODE_STRING ReturnString = Buffer; + PULONG Length = Buffer; + ULONG RealLength; + + /* Check if this is a string */ + if ((ValueType == REG_SZ) || + (ValueType == REG_EXPAND_SZ) || + (ValueType == REG_MULTI_SZ)) + { + /* Normalize the length */ + if (ValueLength > MAXUSHORT) ValueLength = MAXUSHORT; + + /* Check if the return string has been allocated */ + if (!ReturnString->Buffer) + { + /* Allocate it */ + ReturnString->Buffer = RtlpAllocateMemory(ActualLength, TAG_RTLREGISTRY); + if (!ReturnString->Buffer) return STATUS_NO_MEMORY; + ReturnString->MaximumLength = ActualLength; + } + else if (ActualLength > ReturnString->MaximumLength) + { + /* The string the caller allocated is too small */ + return STATUS_BUFFER_TOO_SMALL; + } + + /* Copy the data */ + RtlCopyMemory(ReturnString->Buffer, ValueData, ActualLength); + ReturnString->Length = ActualLength - sizeof(UNICODE_NULL); + } + else if (ValueLength <= sizeof(ULONG)) + { + /* Check if we can just copy the data */ + if ((Buffer != ValueData) && (ValueLength)) + { + /* Copy it */ + RtlCopyMemory(Buffer, ValueData, ValueLength); + } + } + else + { + /* Check if the length is negative */ + if ((LONG)*Length < 0) + { + /* Get the real length and copy the buffer */ + RealLength = -(LONG)*Length; + if (RealLength < ValueLength) return STATUS_BUFFER_TOO_SMALL; + RtlCopyMemory(Buffer, ValueData, ValueLength); + } + else + { + /* Check if there's space for the length and type, plus data */ + if (*Length < (2 * sizeof(ULONG) + ValueLength)) + { + /* Nope, fail */ + return STATUS_BUFFER_TOO_SMALL; + } + + /* Return the data */ + *Length++ = ValueLength; + *Length++ = ValueType; + RtlCopyMemory(Length, ValueData, ValueLength); + } + } + + /* All done */ + return STATUS_SUCCESS; +} + +NTSTATUS +NTAPI +RtlpCallQueryRegistryRoutine(IN PRTL_QUERY_REGISTRY_TABLE QueryTable, + IN PKEY_VALUE_FULL_INFORMATION KeyValueInfo, + IN OUT PULONG InfoSize, + IN PVOID Context, + IN PVOID Environment) +{ + ULONG InfoLength, Length, c; + LONG RequiredLength, SpareLength; + PCHAR SpareData, DataEnd; + ULONG Type; + PWCHAR Name, p, ValueEnd; + PVOID Data; + NTSTATUS Status; + BOOLEAN FoundExpander = FALSE; + UNICODE_STRING Source, Destination; + + /* Setup defaults */ + InfoLength = *InfoSize; + *InfoSize = 0; + + /* Check if there's no data */ + if (KeyValueInfo->DataOffset == (ULONG)-1) + { + /* Return proper status code */ + return (QueryTable->Flags & RTL_QUERY_REGISTRY_REQUIRED) ? + STATUS_OBJECT_NAME_NOT_FOUND : STATUS_SUCCESS; + } + + /* Setup spare data pointers */ + SpareData = (PCHAR)KeyValueInfo; + SpareLength = InfoLength; + DataEnd = SpareData + SpareLength; + + /* Check if there's no value or data */ + if ((KeyValueInfo->Type == REG_NONE) || + (!(KeyValueInfo->DataLength) && + (KeyValueInfo->Type == QueryTable->DefaultType))) + { + /* Check if there's no value */ + if (QueryTable->DefaultType == REG_NONE) + { + /* Return proper status code */ + return (QueryTable->Flags & RTL_QUERY_REGISTRY_REQUIRED) ? + STATUS_OBJECT_NAME_NOT_FOUND : STATUS_SUCCESS; + } + + /* We can setup a default value... capture the defaults */ + Name = QueryTable->Name; + Type = QueryTable->DefaultType; + Data = QueryTable->DefaultData; + Length = QueryTable->DefaultLength; + if (!Length) + { + /* No default length given, try to calculate it */ + p = Data; + if ((Type == REG_SZ) || (Type == REG_EXPAND_SZ)) + { + /* This is a string, count the characters */ + while (*p++); + Length = (ULONG_PTR)p - (ULONG_PTR)Data; + } + else if (Type == REG_MULTI_SZ) + { + /* This is a multi-string, calculate all characters */ + while (*p) while (*p++); + Length = (ULONG_PTR)p - (ULONG_PTR)Data + sizeof(UNICODE_NULL); + } + } + } + else + { + /* Check if this isn't a direct return */ + if (!(QueryTable->Flags & RTL_QUERY_REGISTRY_DIRECT)) + { + /* Check if we have length */ + if (KeyValueInfo->DataLength) + { + /* Increase the spare data */ + SpareData += KeyValueInfo->DataOffset + + KeyValueInfo->DataLength; + } + else + { + /* Otherwise, the spare data only has the name data */ + SpareData += FIELD_OFFSET(KEY_VALUE_FULL_INFORMATION, Name) + + KeyValueInfo->NameLength; + } + + /* Align the pointer and get new size of spare data */ + SpareData = (PVOID)(((ULONG_PTR)SpareData + 7) & ~7); + SpareLength = DataEnd - SpareData; + + /* Check if we have space to copy the data */ + RequiredLength = KeyValueInfo->NameLength + sizeof(UNICODE_NULL); + if (SpareLength < RequiredLength) + { + /* Fail and return the missing length */ + *InfoSize = SpareData - (PCHAR)KeyValueInfo + RequiredLength; + return STATUS_BUFFER_TOO_SMALL; + } + + /* Copy the data and null-terminate it */ + Name = (PWCHAR)SpareData; + RtlCopyMemory(Name, KeyValueInfo->Name, KeyValueInfo->NameLength); + Name[KeyValueInfo->NameLength / sizeof(WCHAR)] = UNICODE_NULL; + + /* Update the spare data information */ + SpareData += RequiredLength; + SpareData = (PVOID)(((ULONG_PTR)SpareData + 7) & ~7); + SpareLength = DataEnd - SpareData; + } + else + { + /* Just return the name */ + Name = QueryTable->Name; + } + + /* Capture key data */ + Type = KeyValueInfo->Type; + Data = (PVOID)((ULONG_PTR)KeyValueInfo + KeyValueInfo->DataOffset); + Length = KeyValueInfo->DataLength; + } + + /* Check if we're expanding */ + if (!(QueryTable->Flags & RTL_QUERY_REGISTRY_NOEXPAND)) + { + /* Check if it's a multi-string */ + if (Type == REG_MULTI_SZ) + { + /* Prepare defaults */ + Status = STATUS_SUCCESS; + ValueEnd = (PWSTR)((ULONG_PTR)Data + Length) - sizeof(UNICODE_NULL); + p = Data; + + /* Loop all strings */ + while (p < ValueEnd) + { + /* Go to the next string */ + while (*p++); + + /* Get the length and check if this is direct */ + Length = (ULONG_PTR)p - (ULONG_PTR)Data; + if (QueryTable->Flags & RTL_QUERY_REGISTRY_DIRECT) + { + /* Do the query */ + Status = RtlpQueryRegistryDirect(REG_SZ, + Data, + Length, + QueryTable->EntryContext); + QueryTable->EntryContext = (PVOID)((ULONG_PTR)QueryTable-> + EntryContext + + sizeof(UNICODE_STRING)); + } + else + { + /* Call the custom routine */ + Status = QueryTable->QueryRoutine(Name, + REG_SZ, + Data, + Length, + Context, + QueryTable->EntryContext); + } + + /* Normalize status */ + if (Status == STATUS_BUFFER_TOO_SMALL) Status = STATUS_SUCCESS; + if (!NT_SUCCESS(Status)) break; + + /* Update data pointer */ + Data = p; + } + + /* Return */ + return Status; + } + + /* Check if this is an expand string */ + if ((Type == REG_EXPAND_SZ) && (Length >= sizeof(WCHAR))) + { + /* Try to find the expander */ + c = Length - sizeof(UNICODE_NULL); + p = (PWCHAR)Data; + while (c) + { + /* Check if this is one */ + if (*p == L'%') + { + /* Yup! */ + FoundExpander = TRUE; + break; + } + + /* Continue in the buffer */ + p++; + c -= sizeof(WCHAR); + } + + /* So check if we have one */ + if (FoundExpander) + { + /* Setup the source string */ + RtlInitEmptyUnicodeString(&Source, Data, Length); + Source.Length = Source.MaximumLength - sizeof(UNICODE_NULL); + + /* Setup the desination string */ + RtlInitEmptyUnicodeString(&Destination, (PWCHAR)SpareData, 0); + + /* Check if we're out of space */ + if (SpareLength <= 0) + { + /* Then we don't have any space in our string */ + Destination.MaximumLength = 0; + } + else if (SpareLength <= MAXUSHORT) + { + /* This is the good case, where we fit into a string */ + Destination.MaximumLength = SpareLength; + Destination.Buffer[SpareLength / 2 - 1] = UNICODE_NULL; + } + else + { + /* We can't fit into a string, so truncate */ + Destination.MaximumLength = MAXUSHORT; + Destination.Buffer[MAXUSHORT / 2 - 1] = UNICODE_NULL; + } + + /* Expand the strings and set our type as one string */ + Status = RtlExpandEnvironmentStrings_U(Environment, + &Source, + &Destination, + (PULONG)&RequiredLength); + Type = REG_SZ; + + /* Check for success */ + if (NT_SUCCESS(Status)) + { + /* Set the value name and length to our string */ + Data = Destination.Buffer; + Length = Destination.Length + sizeof(UNICODE_NULL); + } + else + { + /* Check if our buffer is too small */ + if (Status == STATUS_BUFFER_TOO_SMALL) + { + /* Set the required missing length */ + *InfoSize = SpareData - + (PCHAR)KeyValueInfo + + RequiredLength; + + /* Notify debugger */ + DPRINT1("RTL: Expand variables for %wZ failed - " + "Status == %lx Size %x > %x <%x>\n", + &Source, + Status, + *InfoSize, + InfoLength, + Destination.MaximumLength); + } + else + { + /* Notify debugger */ + DPRINT1("RTL: Expand variables for %wZ failed - " + "Status == %lx\n", + &Source, + Status); + } + + /* Return the status */ + return Status; + } + } + } + } + + /* Check if this is a direct query */ + if (QueryTable->Flags & RTL_QUERY_REGISTRY_DIRECT) + { + /* Return the data */ + Status = RtlpQueryRegistryDirect(Type, + Data, + Length, + QueryTable->EntryContext); + } + else + { + /* Call the query routine */ + Status = QueryTable->QueryRoutine(Name, + Type, + Data, + Length, + Context, + QueryTable->EntryContext); + } + + /* Normalize and return status */ + return (Status == STATUS_BUFFER_TOO_SMALL) ? STATUS_SUCCESS : Status; +} + +PVOID +NTAPI +RtlpAllocDeallocQueryBuffer(IN OUT PSIZE_T BufferSize, + IN PVOID OldBuffer, + IN SIZE_T OldBufferSize, + OUT PNTSTATUS Status) +{ + PVOID Buffer = NULL; + + /* Assume success */ + if (Status) *Status = STATUS_SUCCESS; + + /* Free the old buffer */ + if (OldBuffer) RtlpFreeMemory(OldBuffer, TAG_RTLREGISTRY); + + /* Check if we need to allocate a new one */ + if (BufferSize) + { + /* Allocate */ + Buffer = RtlpAllocateMemory(*BufferSize, TAG_RTLREGISTRY); + if (!(Buffer) && (Status)) *Status = STATUS_NO_MEMORY; + } + + /* Return the pointer */ + return Buffer; +}
NTSTATUS NTAPI @@ -557,507 +957,345 @@ }
/* - * @unimplemented + * @implemented */ -NTSTATUS NTAPI +NTSTATUS +NTAPI RtlQueryRegistryValues(IN ULONG RelativeTo, - IN PCWSTR Path, - IN PRTL_QUERY_REGISTRY_TABLE QueryTable, - IN PVOID Context, - IN PVOID Environment OPTIONAL) -{ - NTSTATUS Status; - HANDLE BaseKeyHandle; - HANDLE CurrentKeyHandle; - PRTL_QUERY_REGISTRY_TABLE QueryEntry; - OBJECT_ATTRIBUTES ObjectAttributes; - UNICODE_STRING KeyName; - PKEY_VALUE_PARTIAL_INFORMATION ValueInfo; - PKEY_VALUE_FULL_INFORMATION FullValueInfo; - ULONG BufferSize; - ULONG ResultSize; - ULONG Index; - ULONG StringLen; - ULONG ValueNameSize; - PWSTR StringPtr; - PWSTR ExpandBuffer; - PWSTR ValueName; - UNICODE_STRING EnvValue; - UNICODE_STRING EnvExpandedValue; - ULONG DataSize = 0; - - PAGED_CODE_RTL(); - - DPRINT("RtlQueryRegistryValues() called\n"); - - Status = RtlpGetRegistryHandle(RelativeTo, - (PWSTR)Path, - FALSE, - &BaseKeyHandle); - if (!NT_SUCCESS(Status)) - { - DPRINT("RtlpGetRegistryHandle() failed (Status %lx)\n", Status); - return(Status); - } - - CurrentKeyHandle = BaseKeyHandle; - QueryEntry = QueryTable; - while ((QueryEntry->QueryRoutine != NULL) || - (QueryEntry->Name != NULL)) - { - if (((QueryEntry->Flags & (RTL_QUERY_REGISTRY_SUBKEY | RTL_QUERY_REGISTRY_TOPKEY)) != 0) && - (BaseKeyHandle != CurrentKeyHandle)) - { - ZwClose(CurrentKeyHandle); - CurrentKeyHandle = BaseKeyHandle; - } - - if (QueryEntry->Flags & RTL_QUERY_REGISTRY_SUBKEY) - { - DPRINT("Open new subkey: %S\n", QueryEntry->Name); - - RtlInitUnicodeString(&KeyName, - QueryEntry->Name); - InitializeObjectAttributes(&ObjectAttributes, - &KeyName, - OBJ_CASE_INSENSITIVE, - BaseKeyHandle, - NULL); - Status = ZwOpenKey(&CurrentKeyHandle, - KEY_ALL_ACCESS, - &ObjectAttributes); - if (!NT_SUCCESS(Status)) - break; - } - else if (QueryEntry->Flags & RTL_QUERY_REGISTRY_DIRECT) - { - DPRINT("Query value directly: %S\n", QueryEntry->Name); - - RtlInitUnicodeString(&KeyName, - QueryEntry->Name); - - BufferSize = sizeof (KEY_VALUE_PARTIAL_INFORMATION) + 4096; - ValueInfo = RtlpAllocateMemory(BufferSize, TAG_RTLREGISTRY); - if (ValueInfo == NULL) - { - Status = STATUS_NO_MEMORY; - break; - } - - Status = ZwQueryValueKey(CurrentKeyHandle, - &KeyName, - KeyValuePartialInformation, - ValueInfo, - BufferSize, - &ResultSize); - if (!NT_SUCCESS(Status)) - { - if (QueryEntry->Flags & RTL_QUERY_REGISTRY_REQUIRED) - { - RtlpFreeMemory(ValueInfo, TAG_RTLREGISTRY); - Status = STATUS_OBJECT_NAME_NOT_FOUND; - break; - } - - if (QueryEntry->DefaultType == REG_SZ) - { - PUNICODE_STRING ValueString; - PUNICODE_STRING SourceString; - - SourceString = (PUNICODE_STRING)QueryEntry->DefaultData; - ValueString = (PUNICODE_STRING)QueryEntry->EntryContext; - if (ValueString->Buffer == NULL) - { - ValueString->Length = SourceString->Length; - ValueString->MaximumLength = SourceString->MaximumLength; - ValueString->Buffer = RtlpAllocateMemory(BufferSize, TAG_RTLREGISTRY); - if (!ValueString->Buffer) - break; - ValueString->Buffer[0] = 0; - memcpy(ValueString->Buffer, - SourceString->Buffer, - SourceString->MaximumLength); - } - else - { - ValueString->Length = min(SourceString->Length, - ValueString->MaximumLength - sizeof(WCHAR)); - memcpy(ValueString->Buffer, - SourceString->Buffer, - ValueString->Length); - ((PWSTR)ValueString->Buffer)[ValueString->Length / sizeof(WCHAR)] = 0; - } - } - else - { - memcpy(QueryEntry->EntryContext, - QueryEntry->DefaultData, - QueryEntry->DefaultLength); - } - Status = STATUS_SUCCESS; - } - else - { - if ((ValueInfo->Type == REG_SZ) || - (ValueInfo->Type == REG_MULTI_SZ) || - (ValueInfo->Type == REG_EXPAND_SZ && (QueryEntry->Flags & RTL_QUERY_REGISTRY_NOEXPAND))) - { - PUNICODE_STRING ValueString; - - ValueString = (PUNICODE_STRING)QueryEntry->EntryContext; - if (ValueString->Buffer == NULL) - { - ValueString->MaximumLength = ValueInfo->DataLength; - ValueString->Buffer = RtlpAllocateMemory(ValueString->MaximumLength, TAG_RTLREGISTRY); - if (ValueString->Buffer == NULL) - { - Status = STATUS_INSUFFICIENT_RESOURCES; - break; - } - ValueString->Buffer[0] = 0; - } - ValueString->Length = min(ValueInfo->DataLength, - ValueString->MaximumLength) - sizeof(WCHAR); - memcpy(ValueString->Buffer, - ValueInfo->Data, - ValueString->Length); - ((PWSTR)ValueString->Buffer)[ValueString->Length / sizeof(WCHAR)] = 0; - } - else if (ValueInfo->Type == REG_EXPAND_SZ) - { - PUNICODE_STRING ValueString; - - DPRINT("Expand REG_EXPAND_SZ type\n"); - - ValueString = (PUNICODE_STRING)QueryEntry->EntryContext; - - ExpandBuffer = RtlpAllocateMemory(ValueInfo->DataLength * 2, TAG_RTLREGISTRY); - if (ExpandBuffer == NULL) - { - Status = STATUS_NO_MEMORY; - break; - } - - RtlInitUnicodeString(&EnvValue, - (PWSTR)ValueInfo->Data); - EnvExpandedValue.Length = 0; - EnvExpandedValue.MaximumLength = ValueInfo->DataLength * 2; - EnvExpandedValue.Buffer = ExpandBuffer; - *ExpandBuffer = 0; - - RtlExpandEnvironmentStrings_U(Environment, - &EnvValue, - &EnvExpandedValue, - &StringLen); - - if (ValueString->Buffer == NULL) - { - ValueString->MaximumLength = EnvExpandedValue.Length + sizeof(WCHAR); - ValueString->Length = EnvExpandedValue.Length; - ValueString->Buffer = RtlpAllocateMemory(ValueString->MaximumLength, TAG_RTLREGISTRY); - if (ValueString->Buffer == NULL) - { - Status = STATUS_INSUFFICIENT_RESOURCES; - break; - } - } - else - { - ValueString->Length = min(EnvExpandedValue.Length, - ValueString->MaximumLength - sizeof(WCHAR)); - } - - memcpy(ValueString->Buffer, - EnvExpandedValue.Buffer, - ValueString->Length); - ((PWSTR)ValueString->Buffer)[ValueString->Length / sizeof(WCHAR)] = 0; - - RtlpFreeMemory(ExpandBuffer, TAG_RTLREGISTRY); - } - else - { - memcpy(QueryEntry->EntryContext, - ValueInfo->Data, - ValueInfo->DataLength); - } - } - - if (QueryEntry->Flags & RTL_QUERY_REGISTRY_DELETE) - { - Status = ZwDeleteValueKey(CurrentKeyHandle, &KeyName); - - } - - RtlpFreeMemory(ValueInfo, TAG_RTLREGISTRY); - } - else - { - DPRINT("Query value via query routine: %S\n", QueryEntry->Name); - if (QueryEntry->Name != NULL) - { - RtlInitUnicodeString(&KeyName, - QueryEntry->Name); - - BufferSize = sizeof (KEY_VALUE_PARTIAL_INFORMATION) + 4096; - ValueInfo = RtlpAllocateMemory(BufferSize, TAG_RTLREGISTRY); - if (ValueInfo == NULL) - { - Status = STATUS_NO_MEMORY; - break; - } - - Status = ZwQueryValueKey(CurrentKeyHandle, - &KeyName, - KeyValuePartialInformation, - ValueInfo, - BufferSize, - &ResultSize); - if (!NT_SUCCESS(Status)) - { - if (!(QueryEntry->Flags & RTL_QUERY_REGISTRY_REQUIRED)) - { - Status = QueryEntry->QueryRoutine(QueryEntry->Name, - QueryEntry->DefaultType, - QueryEntry->DefaultData, - QueryEntry->DefaultLength, - Context, - QueryEntry->EntryContext); - } - } - else if ((ValueInfo->Type == REG_MULTI_SZ) && - !(QueryEntry->Flags & RTL_QUERY_REGISTRY_NOEXPAND)) - { - DPRINT("Expand REG_MULTI_SZ type\n"); - StringPtr = (PWSTR)ValueInfo->Data; - while (DataSize < (ValueInfo->DataLength-2)) - { - StringLen = (wcslen(StringPtr) + 1) * sizeof(WCHAR); - Status = QueryEntry->QueryRoutine(QueryEntry->Name, - REG_SZ, - (PVOID)StringPtr, - StringLen, - Context, - QueryEntry->EntryContext); - if(!NT_SUCCESS(Status)) - break; - StringPtr = (PWSTR)((PUCHAR)StringPtr + StringLen); - DataSize += StringLen; - } - } - else if ((ValueInfo->Type == REG_EXPAND_SZ) && - !(QueryEntry->Flags & RTL_QUERY_REGISTRY_NOEXPAND)) - { - DPRINT("Expand REG_EXPAND_SZ type\n"); - - ExpandBuffer = RtlpAllocateMemory(ValueInfo->DataLength * 2, TAG_RTLREGISTRY); - if (ExpandBuffer == NULL) - { - Status = STATUS_NO_MEMORY; - break; - } - - RtlInitUnicodeString(&EnvValue, - (PWSTR)ValueInfo->Data); - EnvExpandedValue.Length = 0; - EnvExpandedValue.MaximumLength = ValueInfo->DataLength * 2 * sizeof(WCHAR); - EnvExpandedValue.Buffer = ExpandBuffer; - *ExpandBuffer = 0; - - RtlExpandEnvironmentStrings_U(Environment, - &EnvValue, - &EnvExpandedValue, - &StringLen); - - StringLen = (wcslen(ExpandBuffer) + 1) * sizeof(WCHAR); - Status = QueryEntry->QueryRoutine(QueryEntry->Name, - REG_SZ, - (PVOID)ExpandBuffer, - StringLen, - Context, - QueryEntry->EntryContext); - - RtlpFreeMemory(ExpandBuffer, TAG_RTLREGISTRY); - } - else - { - Status = QueryEntry->QueryRoutine(QueryEntry->Name, - ValueInfo->Type, - ValueInfo->Data, - ValueInfo->DataLength, - Context, - QueryEntry->EntryContext); - } - - if (QueryEntry->Flags & RTL_QUERY_REGISTRY_DELETE) - { - Status = ZwDeleteValueKey(CurrentKeyHandle, &KeyName); - } - - RtlpFreeMemory(ValueInfo, TAG_RTLREGISTRY); - if (!NT_SUCCESS(Status)) - break; - } - else if (QueryEntry->Flags & RTL_QUERY_REGISTRY_NOVALUE) - { - DPRINT("Simple callback\n"); - Status = QueryEntry->QueryRoutine(NULL, - REG_NONE, - NULL, - 0, - Context, - QueryEntry->EntryContext); - if (!NT_SUCCESS(Status)) - break; - } - else - { - DPRINT("Enumerate values\n"); - - BufferSize = sizeof(KEY_VALUE_FULL_INFORMATION) + 4096; - FullValueInfo = RtlpAllocateMemory(BufferSize, TAG_RTLREGISTRY); - if (FullValueInfo == NULL) - { - Status = STATUS_NO_MEMORY; - break; - } - ValueNameSize = 256 * sizeof(WCHAR); - ValueName = RtlpAllocateMemory(ValueNameSize, TAG_RTLREGISTRY); - if (ValueName == NULL) - { - Status = STATUS_NO_MEMORY; - break; - } - Index = 0; - while (TRUE) - { - Status = ZwEnumerateValueKey(CurrentKeyHandle, - Index, - KeyValueFullInformation, - FullValueInfo, - BufferSize, - &ResultSize); - if (!NT_SUCCESS(Status)) - { - if ((Status == STATUS_NO_MORE_ENTRIES) && - (Index == 0) && - (QueryEntry->Flags & RTL_QUERY_REGISTRY_REQUIRED)) - { - Status = STATUS_OBJECT_NAME_NOT_FOUND; - } - else if (Status == STATUS_NO_MORE_ENTRIES) - { - Status = STATUS_SUCCESS; - } - break; - } - - if (FullValueInfo->NameLength > ValueNameSize - sizeof(WCHAR)) - { - /* Should not happen, because the name length is limited to 255 characters */ - RtlpFreeMemory(ValueName, TAG_RTLREGISTRY); - ValueNameSize = FullValueInfo->NameLength + sizeof(WCHAR); - ValueName = RtlpAllocateMemory(ValueNameSize, TAG_RTLREGISTRY); - if (ValueName == NULL) - { - Status = STATUS_NO_MEMORY; - break; - } - } - - memcpy(ValueName, - FullValueInfo->Name, - FullValueInfo->NameLength); - ValueName[FullValueInfo->NameLength / sizeof(WCHAR)] = 0; - - DPRINT("FullValueInfo->Type: %lu\n", FullValueInfo->Type); - if ((FullValueInfo->Type == REG_MULTI_SZ) && - !(QueryEntry->Flags & RTL_QUERY_REGISTRY_NOEXPAND)) - { - DPRINT("Expand REG_MULTI_SZ type\n"); - StringPtr = (PWSTR)((ULONG_PTR)FullValueInfo + FullValueInfo->DataOffset); - while (*StringPtr != 0) - { - StringLen = (wcslen(StringPtr) + 1) * sizeof(WCHAR); - Status = QueryEntry->QueryRoutine(ValueName, - REG_SZ, - (PVOID)StringPtr, - StringLen, - Context, - QueryEntry->EntryContext); - if(!NT_SUCCESS(Status)) - break; - StringPtr = (PWSTR)((PUCHAR)StringPtr + StringLen); - } - } - else if ((FullValueInfo->Type == REG_EXPAND_SZ) && - !(QueryEntry->Flags & RTL_QUERY_REGISTRY_NOEXPAND)) - { - DPRINT("Expand REG_EXPAND_SZ type\n"); - - StringPtr = (PWSTR)((ULONG_PTR)FullValueInfo + FullValueInfo->DataOffset); - ExpandBuffer = RtlpAllocateMemory(FullValueInfo->DataLength * 2, TAG_RTLREGISTRY); - if (ExpandBuffer == NULL) - { - Status = STATUS_NO_MEMORY; - break; - } - - RtlInitUnicodeString(&EnvValue, - StringPtr); - EnvExpandedValue.Length = 0; - EnvExpandedValue.MaximumLength = FullValueInfo->DataLength * 2; - EnvExpandedValue.Buffer = ExpandBuffer; - *ExpandBuffer = 0; - - RtlExpandEnvironmentStrings_U(Environment, - &EnvValue, - &EnvExpandedValue, - &StringLen); - - StringLen = (wcslen(ExpandBuffer) + 1) * sizeof(WCHAR); - Status = QueryEntry->QueryRoutine(ValueName, - REG_SZ, - (PVOID)ExpandBuffer, - StringLen, - Context, - QueryEntry->EntryContext); - - RtlpFreeMemory(ExpandBuffer, TAG_RTLREGISTRY); - } - else - { - Status = QueryEntry->QueryRoutine(ValueName, - FullValueInfo->Type, - (PVOID)((ULONG_PTR)FullValueInfo + FullValueInfo->DataOffset), - FullValueInfo->DataLength, - Context, - QueryEntry->EntryContext); - } - - if (!NT_SUCCESS(Status)) - break; - - /* FIXME: How will these be deleted? */ - - Index++; - } - - RtlpFreeMemory(FullValueInfo, TAG_RTLREGISTRY); - RtlpFreeMemory(ValueName, TAG_RTLREGISTRY); - if (!NT_SUCCESS(Status)) - break; - } - } - - QueryEntry++; - } - - if (CurrentKeyHandle != BaseKeyHandle) - ZwClose(CurrentKeyHandle); - - ZwClose(BaseKeyHandle); - - return(Status); + IN PCWSTR Path, + IN PRTL_QUERY_REGISTRY_TABLE QueryTable, + IN PVOID Context, + IN PVOID Environment OPTIONAL) +{ + NTSTATUS Status; + PKEY_VALUE_FULL_INFORMATION KeyValueInfo = NULL; + HANDLE KeyHandle, CurrentKey; + SIZE_T BufferSize = 128, InfoSize; + UNICODE_STRING KeyPath, KeyValueName; + OBJECT_ATTRIBUTES ObjectAttributes; + ULONG i, Value; + ULONG ResultLength; + + /* Get the registry handle */ + Status = RtlpGetRegistryHandle(RelativeTo, Path, FALSE, &KeyHandle); + if (!NT_SUCCESS(Status)) return Status; + + /* Initialize the path */ + RtlInitUnicodeString(&KeyPath, + (RelativeTo & RTL_REGISTRY_HANDLE) ? NULL : Path); + + /* Allocate a query buffer */ + KeyValueInfo = RtlpAllocDeallocQueryBuffer(&BufferSize, NULL, 0, &Status); + if (!KeyValueInfo) + { + /* Close the handle if we have one and fail */ + if (!(RelativeTo & RTL_REGISTRY_HANDLE)) ZwClose(KeyHandle); + return Status; + } + + /* Set defaults */ + KeyValueInfo->DataOffset = 0; + InfoSize = BufferSize - sizeof(UNICODE_NULL); + CurrentKey = KeyHandle; + + /* Loop the query table */ + while ((QueryTable->QueryRoutine) || + (QueryTable->Flags & (RTL_QUERY_REGISTRY_SUBKEY | + RTL_QUERY_REGISTRY_DIRECT))) + { + /* Check if the request is invalid */ + if ((QueryTable->Flags & RTL_QUERY_REGISTRY_DIRECT) && + (!(QueryTable->Name) || + (QueryTable->Flags & RTL_QUERY_REGISTRY_SUBKEY) || + (QueryTable->QueryRoutine))) + { + /* Fail */ + Status = STATUS_INVALID_PARAMETER; + break; + } + + /* Check if we want a specific key */ + if (QueryTable->Flags & (RTL_QUERY_REGISTRY_TOPKEY | + RTL_QUERY_REGISTRY_SUBKEY)) + { + /* Check if we're working with another handle */ + if (CurrentKey != KeyHandle) + { + /* Close our current key and use the top */ + NtClose(CurrentKey); + CurrentKey = KeyHandle; + } + } + + /* Check if we're querying the subkey */ + if (QueryTable->Flags & RTL_QUERY_REGISTRY_SUBKEY) + { + /* Make sure we have a name */ + if (!QueryTable->Name) + { + /* Fail */ + Status = STATUS_INVALID_PARAMETER; + } + else + { + /* Initialize the name */ + RtlInitUnicodeString(&KeyPath, QueryTable->Name); + + /* Get the key handle */ + InitializeObjectAttributes(&ObjectAttributes, + &KeyPath, + OBJ_CASE_INSENSITIVE | + OBJ_KERNEL_HANDLE, + KeyHandle, + NULL); + Status = ZwOpenKey(&CurrentKey, + MAXIMUM_ALLOWED, + &ObjectAttributes); + if (NT_SUCCESS(Status)) + { + /* If we have a query routine, go enumerate values */ + if (QueryTable->QueryRoutine) goto ProcessValues; + } + } + } + else if (QueryTable->Name) + { + /* Initialize the path */ + RtlInitUnicodeString(&KeyValueName, QueryTable->Name); + + /* Start query loop */ + i = 0; + while (TRUE) + { + /* Make sure we didn't retry too many times */ + if (i++ > 4) + { + /* Fail */ + DPRINT1("RtlQueryRegistryValues: Miscomputed buffer size " + "at line %d\n", __LINE__); + break; + } + + /* Query key information */ + Status = ZwQueryValueKey(CurrentKey, + &KeyValueName, + KeyValueFullInformation, + KeyValueInfo, + InfoSize, + &ResultLength); + if (Status == STATUS_BUFFER_OVERFLOW) + { + /* Normalize status code */ + Status = STATUS_BUFFER_TOO_SMALL; + } + + /* Check for failure */ + if (!NT_SUCCESS(Status)) + { + /* Check if we didn't find it */ + if (Status == STATUS_OBJECT_NAME_NOT_FOUND) + { + /* Setup a default */ + KeyValueInfo->Type = REG_NONE; + KeyValueInfo->DataLength = 0; + ResultLength = InfoSize; + + /* Call the query routine */ + Status = RtlpCallQueryRegistryRoutine(QueryTable, + KeyValueInfo, + &ResultLength, + Context, + Environment); + } + + /* Check for buffer being too small */ + if (Status == STATUS_BUFFER_TOO_SMALL) + { + /* Increase allocation size */ + BufferSize = ResultLength + + sizeof(ULONG_PTR) + + sizeof(UNICODE_NULL); + KeyValueInfo = RtlpAllocDeallocQueryBuffer(&BufferSize, + KeyValueInfo, + BufferSize, + &Status); + if (!KeyValueInfo) break; + + /* Update the data */ + KeyValueInfo->DataOffset = 0; + InfoSize = BufferSize - sizeof(UNICODE_NULL); + continue; + } + } + else + { + /* Check if this is a multi-string */ + if (KeyValueInfo->Type == REG_MULTI_SZ) + { + /* Add a null-char */ + ((PWCHAR)KeyValueInfo)[ResultLength / 2] = UNICODE_NULL; + KeyValueInfo->DataLength += sizeof(UNICODE_NULL); + } + + /* Call the query routine */ + ResultLength = InfoSize; + Status = RtlpCallQueryRegistryRoutine(QueryTable, + KeyValueInfo, + &ResultLength, + Context, + Environment); + + /* Check for buffer being too small */ + if (Status == STATUS_BUFFER_TOO_SMALL) + { + /* Increase allocation size */ + BufferSize = ResultLength + + sizeof(ULONG_PTR) + + sizeof(UNICODE_NULL); + KeyValueInfo = RtlpAllocDeallocQueryBuffer(&BufferSize, + KeyValueInfo, + BufferSize, + &Status); + if (!KeyValueInfo) break; + + /* Update the data */ + KeyValueInfo->DataOffset = 0; + InfoSize = BufferSize - sizeof(UNICODE_NULL); + continue; + } + + /* Check if we need to delete the key */ + if ((NT_SUCCESS(Status)) && + (QueryTable->Flags & RTL_QUERY_REGISTRY_DELETE)) + { + /* Delete it */ + ZwDeleteValueKey(CurrentKey, &KeyValueName); + } + } + + /* We're done, break out */ + break; + } + } + else if (QueryTable->Flags & RTL_QUERY_REGISTRY_NOVALUE) + { + /* Just call the query routine */ + Status = QueryTable->QueryRoutine(NULL, + REG_NONE, + NULL, + 0, + Context, + QueryTable->EntryContext); + } + else + { +ProcessValues: + /* Loop every value */ + i = Value = 0; + while (TRUE) + { + /* Enumerate the keys */ + Status = ZwEnumerateValueKey(CurrentKey, + Value, + KeyValueFullInformation, + KeyValueInfo, + InfoSize, + &ResultLength); + if (Status == STATUS_BUFFER_OVERFLOW) + { + /* Normalize the status */ + Status = STATUS_BUFFER_TOO_SMALL; + } + + /* Check if we found all the entries */ + if (Status == STATUS_NO_MORE_ENTRIES) + { + /* Check if this was the first entry and caller needs it */ + if (!(Value) && + (QueryTable->Flags & RTL_QUERY_REGISTRY_REQUIRED)) + { + /* Fail */ + Status = STATUS_OBJECT_NAME_NOT_FOUND; + } + else + { + /* Otherwise, it's ok */ + Status = STATUS_SUCCESS; + } + break; + } + + /* Check if enumeration worked */ + if (NT_SUCCESS(Status)) + { + /* Call the query routine */ + ResultLength = InfoSize; + Status = RtlpCallQueryRegistryRoutine(QueryTable, + KeyValueInfo, + &ResultLength, + Context, + Environment); + } + + /* Check if the query failed */ + if (Status == STATUS_BUFFER_TOO_SMALL) + { + /* Increase allocation size */ + BufferSize = ResultLength + + sizeof(ULONG_PTR) + + sizeof(UNICODE_NULL); + KeyValueInfo = RtlpAllocDeallocQueryBuffer(&BufferSize, + KeyValueInfo, + BufferSize, + &Status); + if (!KeyValueInfo) break; + + /* Update the data */ + KeyValueInfo->DataOffset = 0; + InfoSize = BufferSize - sizeof(UNICODE_NULL); + + /* Try the value again unless it's been too many times */ + if (i++ <= 4) continue; + break; + } + + /* Break out if we failed */ + if (!NT_SUCCESS(Status)) break; + + /* Reset the number of retries and check if we need to delete */ + i = 0; + if (QueryTable->Flags & RTL_QUERY_REGISTRY_DELETE) + { + /* Build the name */ + RtlInitEmptyUnicodeString(&KeyValueName, + KeyValueInfo->Name, + (USHORT)KeyValueInfo->NameLength); + KeyValueName.Length = KeyValueName.MaximumLength; + + /* Delete the key */ + Status = ZwDeleteValueKey(CurrentKey, &KeyValueName); + if (NT_SUCCESS(Status)) Value--; + } + + /* Go to the next value */ + Value++; + } + } + + /* Check if we failed anywhere along the road */ + if (!NT_SUCCESS(Status)) break; + + /* Continue */ + QueryTable++; + } + + /* Check if we need to close our handle */ + if ((KeyHandle) && !(RelativeTo & RTL_REGISTRY_HANDLE)) ZwClose(KeyHandle); + if ((CurrentKey) && (CurrentKey != KeyHandle)) ZwClose(CurrentKey); + + /* Free our buffer and return status */ + RtlpAllocDeallocQueryBuffer(NULL, KeyValueInfo, BufferSize, NULL); + return Status; }
/* EOF */
Modified: trunk/reactos/ntoskrnl/io/iomgr/driver.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/io/iomgr/driver.c?... ============================================================================== --- trunk/reactos/ntoskrnl/io/iomgr/driver.c (original) +++ trunk/reactos/ntoskrnl/io/iomgr/driver.c Wed Mar 14 04:44:38 2007 @@ -542,7 +542,7 @@ PDEVICE_NODE DeviceNode, BOOLEAN Lower) { - RTL_QUERY_REGISTRY_TABLE QueryTable[2]; + RTL_QUERY_REGISTRY_TABLE QueryTable[2] = {{0}}; PWCHAR KeyBuffer; UNICODE_STRING Class; WCHAR ClassBuffer[40]; @@ -557,10 +557,7 @@ QueryTable[0].Name = L"LowerFilters"; else QueryTable[0].Name = L"UpperFilters"; - QueryTable[0].EntryContext = NULL; QueryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED; - QueryTable[1].QueryRoutine = NULL; - QueryTable[1].Name = NULL;
KeyBuffer = ExAllocatePool( PagedPool,
-
ion＠svn.reactos.org