Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-05-28 21:48:19 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Partially revert 31467 to unbreak devices installation.

Browse source 
svn path=/trunk/; revision=31495
This commit is contained in:
Aleksey Bragin 2007-12-29 21:39:15 +00:00
parent a701dd6a99
commit 6cda2ec675
1 changed files with 292 additions and 279 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

291
reactos/ntoskrnl/io/pnpmgr/pnpmgr.c
View file

@ -405,13 +405,12 @@ IoGetDeviceProperty(IN PDEVICE_OBJECT DeviceObject,
case DevicePropertyLocationInformation: case DevicePropertyLocationInformation:
case DevicePropertyUINumber: case DevicePropertyUINumber:
{ {
LPCWSTR RegistryPropertyName; LPWSTR RegistryPropertyName, KeyNameBuffer;
UNICODE_STRING EnumU = RTL_CONSTANT_STRING(ENUM_ROOT); UNICODE_STRING KeyName, ValueName;
UNICODE_STRING ValueName;
OBJECT_ATTRIBUTES ObjectAttributes; OBJECT_ATTRIBUTES ObjectAttributes;
KEY_VALUE_PARTIAL_INFORMATION *ValueInformation; KEY_VALUE_PARTIAL_INFORMATION *ValueInformation;
ULONG ValueInformationLength; ULONG ValueInformationLength;
HANDLE hEnum, KeyHandle; HANDLE KeyHandle;
NTSTATUS Status; NTSTATUS Status;
switch (DeviceProperty) switch (DeviceProperty)
@ -437,64 +436,56 @@ IoGetDeviceProperty(IN PDEVICE_OBJECT DeviceObject,
case DevicePropertyUINumber: case DevicePropertyUINumber:
RegistryPropertyName = L"UINumber"; break; RegistryPropertyName = L"UINumber"; break;
default: default:
/* Should not happen */ RegistryPropertyName = NULL; break;
ASSERT(FALSE);
return STATUS_UNSUCCESSFUL;
} }
DPRINT("Registry property %S\n", RegistryPropertyName); KeyNameBuffer = ExAllocatePool(PagedPool,
(49 * sizeof(WCHAR)) + DeviceNode->InstancePath.Length);
/* Open Enum key */ DPRINT("KeyNameBuffer: 0x%p, value %S\n", KeyNameBuffer, RegistryPropertyName);
InitializeObjectAttributes(&ObjectAttributes, &EnumU,
OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL); if (KeyNameBuffer == NULL)
Status = ZwOpenKey(&hEnum, 0, &ObjectAttributes); return STATUS_INSUFFICIENT_RESOURCES;
if (!NT_SUCCESS(Status))
return Status; wcscpy(KeyNameBuffer, L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\");
wcscat(KeyNameBuffer, DeviceNode->InstancePath.Buffer);
RtlInitUnicodeString(&KeyName, KeyNameBuffer);
InitializeObjectAttributes(&ObjectAttributes, &KeyName,
OBJ_CASE_INSENSITIVE, NULL, NULL);
/* Open instance key */
InitializeObjectAttributes(&ObjectAttributes, &DeviceNode->InstancePath,
OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, hEnum, NULL);
Status = ZwOpenKey(&KeyHandle, KEY_READ, &ObjectAttributes); Status = ZwOpenKey(&KeyHandle, KEY_READ, &ObjectAttributes);
ZwClose(hEnum); ExFreePool(KeyNameBuffer);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
return Status; return Status;
/* Allocate buffer to read as much data as required by the caller */ RtlInitUnicodeString(&ValueName, RegistryPropertyName);
ValueInformationLength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, ValueInformationLength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,
Data[0]) + BufferLength; Data[0]) + BufferLength;
ValueInformation = ExAllocatePool(PagedPool, ValueInformationLength); ValueInformation = ExAllocatePool(PagedPool, ValueInformationLength);
if (!ValueInformation) if (ValueInformation == NULL)
{ {
ZwClose(KeyHandle); ZwClose(KeyHandle);
return STATUS_INSUFFICIENT_RESOURCES; return STATUS_INSUFFICIENT_RESOURCES;
} }
/* Read the value */
RtlInitUnicodeString(&ValueName, RegistryPropertyName);
Status = ZwQueryValueKey(KeyHandle, &ValueName, Status = ZwQueryValueKey(KeyHandle, &ValueName,
KeyValuePartialInformation, ValueInformation, KeyValuePartialInformation, ValueInformation,
ValueInformationLength, ValueInformationLength,
&ValueInformationLength); &ValueInformationLength);
*ResultLength = ValueInformation->DataLength;
ZwClose(KeyHandle); ZwClose(KeyHandle);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
ExFreePool(ValueInformation); ExFreePool(ValueInformation);
if (Status == STATUS_BUFFER_OVERFLOW) if (Status == STATUS_BUFFER_OVERFLOW)
{
*ResultLength = ValueInformation->DataLength;
return STATUS_BUFFER_TOO_SMALL; return STATUS_BUFFER_TOO_SMALL;
}
else else
{
*ResultLength = 0;
return Status; return Status;
} }
}
/* Return data */
*ResultLength = ValueInformation->DataLength;
/* FIXME: Verify the value (NULL-terminated, correct format). */ /* FIXME: Verify the value (NULL-terminated, correct format). */
RtlCopyMemory(PropertyBuffer, ValueInformation->Data, RtlCopyMemory(PropertyBuffer, ValueInformation->Data,
ValueInformation->DataLength); ValueInformation->DataLength);
ExFreePool(ValueInformation); ExFreePool(ValueInformation);
@ -522,17 +513,21 @@ IoGetDeviceProperty(IN PDEVICE_OBJECT DeviceObject,
break; break;
case DevicePropertyEnumeratorName: case DevicePropertyEnumeratorName:
/* A buffer overflow can't happen here, since InstancePath
* always contains the enumerator name followed by \\ */
Ptr = wcschr(DeviceNode->InstancePath.Buffer, L'\\'); Ptr = wcschr(DeviceNode->InstancePath.Buffer, L'\\');
ASSERT(Ptr); if (Ptr != NULL)
Length = (Ptr - DeviceNode->InstancePath.Buffer + 1) * sizeof(WCHAR); {
Length = (ULONG)((ULONG_PTR)Ptr - (ULONG_PTR)DeviceNode->InstancePath.Buffer) + sizeof(WCHAR);
Data = DeviceNode->InstancePath.Buffer; Data = DeviceNode->InstancePath.Buffer;
}
else
{
Length = 0;
Data = NULL;
}
break; break;
case DevicePropertyPhysicalDeviceObjectName: case DevicePropertyPhysicalDeviceObjectName:
/* InstancePath buffer is NULL terminated, so we can do this */ Length = DeviceNode->InstancePath.Length + sizeof(WCHAR);
Length = DeviceNode->InstancePath.MaximumLength;
Data = DeviceNode->InstancePath.Buffer; Data = DeviceNode->InstancePath.Buffer;
break; break;
@ -540,15 +535,18 @@ IoGetDeviceProperty(IN PDEVICE_OBJECT DeviceObject,
return STATUS_INVALID_PARAMETER_2; return STATUS_INVALID_PARAMETER_2;
} }
/* Prepare returned values */
*ResultLength = Length; *ResultLength = Length;
if (BufferLength < Length) if (BufferLength < Length)
return STATUS_BUFFER_TOO_SMALL; return STATUS_BUFFER_TOO_SMALL;
RtlCopyMemory(PropertyBuffer, Data, Length); RtlCopyMemory(PropertyBuffer, Data, Length);
/* NULL terminate the string (if required) */ /* Terminate the string */
if (DeviceProperty == DevicePropertyEnumeratorName) if (DeviceProperty == DevicePropertyEnumeratorName
((LPWSTR)PropertyBuffer)[Length / sizeof(WCHAR)] = UNICODE_NULL; || DeviceProperty == DevicePropertyPhysicalDeviceObjectName)
{
Ptr = (PWSTR)PropertyBuffer;
Ptr[(Length / sizeof(WCHAR)) - 1] = 0;
}
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
@ -1603,78 +1601,78 @@ NTSTATUS
IopGetParentIdPrefix(PDEVICE_NODE DeviceNode, IopGetParentIdPrefix(PDEVICE_NODE DeviceNode,
PUNICODE_STRING ParentIdPrefix) PUNICODE_STRING ParentIdPrefix)
{ {
ULONG BufferLength; ULONG KeyNameBufferLength;
UNICODE_STRING EnumU = RTL_CONSTANT_STRING(ENUM_ROOT); PWSTR KeyNameBuffer = NULL;
PKEY_VALUE_PARTIAL_INFORMATION ParentIdPrefixInformation; PKEY_VALUE_PARTIAL_INFORMATION ParentIdPrefixInformation = NULL;
UNICODE_STRING KeyName;
UNICODE_STRING KeyValue; UNICODE_STRING KeyValue;
UNICODE_STRING ValueName = RTL_CONSTANT_STRING(L"ParentIdPrefix"); UNICODE_STRING ValueName;
OBJECT_ATTRIBUTES ObjectAttributes; OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE hEnum, hKey = NULL; HANDLE hKey = NULL;
ULONG crc32; ULONG crc32;
NTSTATUS Status; NTSTATUS Status;
/* Allocate a buffer big enough to read a MAX_PATH prefix */ /* HACK: As long as some devices have a NULL device
BufferLength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data[0]) + MAX_PATH * sizeof(WCHAR); * instance path, the following test is required :(
ParentIdPrefixInformation = ExAllocatePool(PagedPool, BufferLength + sizeof(WCHAR)); */
if (DeviceNode->Parent->InstancePath.Length == 0)
/* Check if allocation succeeded */
if (!ParentIdPrefixInformation)
{ {
Status = STATUS_NO_MEMORY; DPRINT1("Parent of %wZ has NULL Instance path, please report!\n",
goto cleanup; &DeviceNode->InstancePath);
return STATUS_UNSUCCESSFUL;
} }
/* Open enum key */ /* 1. Try to retrieve ParentIdPrefix from registry */
InitializeObjectAttributes(&ObjectAttributes, &EnumU, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL); KeyNameBufferLength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data[0]) + MAX_PATH * sizeof(WCHAR);
Status = ZwOpenKey(&hEnum, 0, &ObjectAttributes); ParentIdPrefixInformation = ExAllocatePool(PagedPool, KeyNameBufferLength + sizeof(WCHAR));
if (!NT_SUCCESS(Status)) if (!ParentIdPrefixInformation)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
goto cleanup; goto cleanup;
}
/* Open instance key */ KeyNameBuffer = ExAllocatePool(PagedPool, (49 * sizeof(WCHAR)) + DeviceNode->Parent->InstancePath.Length);
InitializeObjectAttributes(&ObjectAttributes, &DeviceNode->Parent->InstancePath, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, hEnum, NULL); if (!KeyNameBuffer)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
goto cleanup;
}
wcscpy(KeyNameBuffer, L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\");
wcscat(KeyNameBuffer, DeviceNode->Parent->InstancePath.Buffer);
RtlInitUnicodeString(&KeyName, KeyNameBuffer);
InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
Status = ZwOpenKey(&hKey, KEY_QUERY_VALUE | KEY_SET_VALUE, &ObjectAttributes); Status = ZwOpenKey(&hKey, KEY_QUERY_VALUE | KEY_SET_VALUE, &ObjectAttributes);
ZwClose(hEnum);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
goto cleanup; goto cleanup;
RtlInitUnicodeString(&ValueName, L"ParentIdPrefix");
/* Read the prefix */
Status = ZwQueryValueKey( Status = ZwQueryValueKey(
hKey, &ValueName, hKey, &ValueName,
KeyValuePartialInformation, ParentIdPrefixInformation, KeyValuePartialInformation, ParentIdPrefixInformation,
BufferLength, &BufferLength); KeyNameBufferLength, &KeyNameBufferLength);
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
{ {
/* Yes, we read something */
if (ParentIdPrefixInformation->Type != REG_SZ) if (ParentIdPrefixInformation->Type != REG_SZ)
/* Hm, it was of the wrong type. Fail */
Status = STATUS_UNSUCCESSFUL; Status = STATUS_UNSUCCESSFUL;
else else
{ {
/* OK, value is correct ; prepare to return it */
KeyValue.Length = KeyValue.MaximumLength = (USHORT)ParentIdPrefixInformation->DataLength; KeyValue.Length = KeyValue.MaximumLength = (USHORT)ParentIdPrefixInformation->DataLength;
KeyValue.Buffer = (PWSTR)ParentIdPrefixInformation->Data; KeyValue.Buffer = (PWSTR)ParentIdPrefixInformation->Data;
if (KeyValue.Length && KeyValue.Buffer[KeyValue.Length / sizeof(WCHAR) - 1] == UNICODE_NULL);
KeyValue.Length -= sizeof(WCHAR);
} }
/* We're done */
goto cleanup; goto cleanup;
} }
/* Check if we failed due to value not calculated */
if (Status != STATUS_OBJECT_NAME_NOT_FOUND) if (Status != STATUS_OBJECT_NAME_NOT_FOUND)
/* Another reason, fail */ {
KeyValue.Length = KeyValue.MaximumLength = (USHORT)ParentIdPrefixInformation->DataLength;
KeyValue.Buffer = (PWSTR)ParentIdPrefixInformation->Data;
goto cleanup; goto cleanup;
}
/* Compute the prefix string of the parent */ /* 2. Create the ParentIdPrefix value */
crc32 = RtlComputeCrc32(0, crc32 = RtlComputeCrc32(0,
(PUCHAR)DeviceNode->Parent->InstancePath.Buffer, (PUCHAR)DeviceNode->Parent->InstancePath.Buffer,
DeviceNode->Parent->InstancePath.Length); DeviceNode->Parent->InstancePath.Length);
/* Prepare the value to return */ swprintf((PWSTR)ParentIdPrefixInformation->Data, L"%lx&%lx", DeviceNode->Parent->Level, crc32);
/* (yes, it's safe to reuse ParentIdPrefixInformation buffer, which is at least MAX_PATH WCHARs long */ RtlInitUnicodeString(&KeyValue, (PWSTR)ParentIdPrefixInformation->Data);
swprintf((PWSTR)ParentIdPrefixInformation, L"%lx&%lx", DeviceNode->Parent->Level, crc32);
RtlInitUnicodeString(&KeyValue, (PWSTR)ParentIdPrefixInformation);
/* 3. Try to write the ParentIdPrefix to registry */ /* 3. Try to write the ParentIdPrefix to registry */
Status = ZwSetValueKey(hKey, Status = ZwSetValueKey(hKey,
@ -1682,7 +1680,7 @@ IopGetParentIdPrefix(PDEVICE_NODE DeviceNode,
0, 0,
REG_SZ, REG_SZ,
(PVOID)KeyValue.Buffer, (PVOID)KeyValue.Buffer,
KeyValue.MaximumLength); (wcslen(KeyValue.Buffer) + 1) * sizeof(WCHAR));
cleanup: cleanup:
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
@ -1690,8 +1688,8 @@ cleanup:
/* Duplicate the string to return it */ /* Duplicate the string to return it */
Status = RtlDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE, &KeyValue, ParentIdPrefix); Status = RtlDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE, &KeyValue, ParentIdPrefix);
} }
/* General cleanup */
ExFreePool(ParentIdPrefixInformation); ExFreePool(ParentIdPrefixInformation);
ExFreePool(KeyNameBuffer);
if (hKey != NULL) if (hKey != NULL)
ZwClose(hKey); ZwClose(hKey);
return Status; return Status;
@ -1724,9 +1722,9 @@ IopActionInterrogateDeviceStack(PDEVICE_NODE DeviceNode,
IO_STATUS_BLOCK IoStatusBlock; IO_STATUS_BLOCK IoStatusBlock;
PDEVICE_NODE ParentDeviceNode; PDEVICE_NODE ParentDeviceNode;
WCHAR InstancePath[MAX_PATH]; WCHAR InstancePath[MAX_PATH];
UNICODE_STRING InstancePathU = { 0, sizeof(InstancePath), InstancePath };
IO_STACK_LOCATION Stack; IO_STACK_LOCATION Stack;
NTSTATUS Status; NTSTATUS Status;
PWSTR KeyBuffer;
PWSTR Ptr; PWSTR Ptr;
USHORT Length; USHORT Length;
USHORT TotalLength; USHORT TotalLength;
@ -1788,7 +1786,12 @@ IopActionInterrogateDeviceStack(PDEVICE_NODE DeviceNode,
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
{ {
/* Copy the device id string */ /* Copy the device id string */
RtlAppendUnicodeToString(&InstancePathU, (PWSTR)IoStatusBlock.Information); wcscpy(InstancePath, (PWSTR)IoStatusBlock.Information);
/*
* FIXME: Check for valid characters, if there is invalid characters
* then bugcheck.
*/
} }
else else
{ {
@ -1826,16 +1829,21 @@ IopActionInterrogateDeviceStack(PDEVICE_NODE DeviceNode,
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
{ {
/* Append the instance id string */ /* Append the instance id string */
RtlAppendUnicodeToString(&InstancePathU, L"\\"); wcscat(InstancePath, L"\\");
if (ParentIdPrefix.Length > 0) if (ParentIdPrefix.Length > 0)
{ {
/* Add information from parent bus device to InstancePath */ /* Add information from parent bus device to InstancePath */
RtlAppendUnicodeStringToString(&InstancePathU, &ParentIdPrefix); wcscat(InstancePath, ParentIdPrefix.Buffer);
if (IoStatusBlock.Information && *(PWSTR)IoStatusBlock.Information) if (IoStatusBlock.Information && *(PWSTR)IoStatusBlock.Information)
RtlAppendUnicodeToString(&InstancePathU, L"&"); wcscat(InstancePath, L"&");
} }
if (IoStatusBlock.Information) if (IoStatusBlock.Information)
RtlAppendUnicodeToString(&InstancePathU, (PWSTR)IoStatusBlock.Information); wcscat(InstancePath, (PWSTR)IoStatusBlock.Information);
/*
* FIXME: Check for valid characters, if there is invalid characters
* then bugcheck
*/
} }
else else
{ {
@ -1843,25 +1851,29 @@ IopActionInterrogateDeviceStack(PDEVICE_NODE DeviceNode,
} }
RtlFreeUnicodeString(&ParentIdPrefix); RtlFreeUnicodeString(&ParentIdPrefix);
/* if (!RtlCreateUnicodeString(&DeviceNode->InstancePath, InstancePath))
* FIXME: Check for valid characters, if there is invalid characters
* then bugcheck.
*/
Status = RtlDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
&InstancePathU, &DeviceNode->InstancePath);
if (!NT_SUCCESS(Status))
{ {
DPRINT("No resources\n"); DPRINT("No resources\n");
/* FIXME: Cleanup and disable device */ /* FIXME: Cleanup and disable device */
} }
DPRINT("InstancePath is %wZ\n", &DeviceNode->InstancePath); DPRINT("InstancePath is %S\n", DeviceNode->InstancePath.Buffer);
/* Create registry key for the instance id, if it doesn't exist yet */ /*
Status = IopCreateDeviceKeyPath(&DeviceNode->InstancePath, &InstanceKey); * Create registry key for the instance id, if it doesn't exist yet
*/
KeyBuffer = ExAllocatePool(
PagedPool,
(49 * sizeof(WCHAR)) + DeviceNode->InstancePath.Length);
wcscpy(KeyBuffer, L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\");
wcscat(KeyBuffer, DeviceNode->InstancePath.Buffer);
Status = IopCreateDeviceKeyPath(/*KeyBuffer*/&DeviceNode->InstancePath, &InstanceKey);
ExFreePool(KeyBuffer);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
DPRINT1("IopCreateDeviceKeyPath('%wZ') failed (Status 0x%08lx)\n", &DeviceNode->InstancePath, Status); {
DPRINT1("Failed to create the instance key! (Status %lx)\n", Status);
}
{ {
/* Set 'Capabilities' value */ /* Set 'Capabilities' value */
@ -2312,7 +2324,7 @@ NTSTATUS
IopActionConfigureChildServices(PDEVICE_NODE DeviceNode, IopActionConfigureChildServices(PDEVICE_NODE DeviceNode,
PVOID Context) PVOID Context)
{ {
RTL_QUERY_REGISTRY_TABLE QueryTable[4]; RTL_QUERY_REGISTRY_TABLE QueryTable[3];
PDEVICE_NODE ParentDeviceNode; PDEVICE_NODE ParentDeviceNode;
PUNICODE_STRING Service; PUNICODE_STRING Service;
UNICODE_STRING ClassGUID; UNICODE_STRING ClassGUID;
@ -2336,52 +2348,49 @@ IopActionConfigureChildServices(PDEVICE_NODE DeviceNode,
* Make sure this device node is a direct child of the parent device node * Make sure this device node is a direct child of the parent device node
* that is given as an argument * that is given as an argument
*/ */
ASSERT(DeviceNode->Parent == ParentDeviceNode); if (DeviceNode->Parent != ParentDeviceNode)
{
/* Stop the traversal immediately and indicate successful operation */
DPRINT("Stop\n");
return STATUS_UNSUCCESSFUL;
}
if (!IopDeviceNodeHasFlag(DeviceNode, DNF_DISABLED)) if (!IopDeviceNodeHasFlag(DeviceNode, DNF_DISABLED))
{ {
OBJECT_ATTRIBUTES ObjectAttributes; WCHAR RegKeyBuffer[MAX_PATH];
UNICODE_STRING EnumU = RTL_CONSTANT_STRING(ENUM_ROOT); UNICODE_STRING RegKey;
HANDLE hEnum;
/* Open Enum key */ RegKey.Length = 0;
InitializeObjectAttributes(&ObjectAttributes, &EnumU, RegKey.MaximumLength = sizeof(RegKeyBuffer);
OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL) RegKey.Buffer = RegKeyBuffer;
Status = ZwOpenKey(&hEnum, 0, &ObjectAttributes);
if (!NT_SUCCESS(Status)) /*
{ * Retrieve configuration from Enum key
/* FIXME: Log the error */ */
IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
return Status;
}
/* Prepare query table */
RtlZeroMemory(QueryTable, sizeof(QueryTable));
Service = &DeviceNode->ServiceName; Service = &DeviceNode->ServiceName;
RtlZeroMemory(QueryTable, sizeof(QueryTable));
RtlInitUnicodeString(Service, NULL); RtlInitUnicodeString(Service, NULL);
RtlInitUnicodeString(&ClassGUID, NULL); RtlInitUnicodeString(&ClassGUID, NULL);
/* Hopefully, this string is always NULL terminated */ QueryTable[0].Name = L"Service";
QueryTable[0].Name = DeviceNode->InstancePath.Buffer; QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
QueryTable[0].Flags = RTL_QUERY_REGISTRY_SUBKEY; QueryTable[0].EntryContext = Service;
QueryTable[1].Name = L"Service"; QueryTable[1].Name = L"ClassGUID";
QueryTable[1].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED; QueryTable[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
QueryTable[1].EntryContext = Service; QueryTable[1].EntryContext = &ClassGUID;
QueryTable[1].DefaultType = REG_SZ;
QueryTable[1].DefaultData = L"";
QueryTable[1].DefaultLength = 0;
QueryTable[2].Name = L"ClassGUID"; RtlAppendUnicodeToString(&RegKey, L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\");
QueryTable[2].Flags = RTL_QUERY_REGISTRY_DIRECT; RtlAppendUnicodeStringToString(&RegKey, &DeviceNode->InstancePath);
QueryTable[2].EntryContext = &ClassGUID;
QueryTable[2].DefaultType = REG_SZ;
QueryTable[2].DefaultData = L"";
QueryTable[2].DefaultLength = 0;
/* Read registry */ Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
Status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE, (PWSTR)hEnum, RegKey.Buffer, QueryTable, NULL, NULL);
QueryTable, NULL, NULL);
ZwClose(hEnum);
/* Check for an error */
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
/* FIXME: Log the error */ /* FIXME: Log the error */
@ -2391,8 +2400,7 @@ IopActionConfigureChildServices(PDEVICE_NODE DeviceNode,
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
/* Check for a NULL service */ if (Service->Buffer == NULL)
if (Service->Length == 0)
{ {
IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED); IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
@ -2408,7 +2416,7 @@ IopActionConfigureChildServices(PDEVICE_NODE DeviceNode,
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
DPRINT("Got Service %wZ\n", Service); DPRINT("Got Service %S\n", Service->Buffer);
} }
return STATUS_SUCCESS; return STATUS_SUCCESS;
@ -2463,11 +2471,16 @@ IopActionInitChildServices(PDEVICE_NODE DeviceNode,
* Make sure this device node is a direct child of the parent device node * Make sure this device node is a direct child of the parent device node
* that is given as an argument * that is given as an argument
*/ */
#if 0
if (DeviceNode->Parent != ParentDeviceNode) if (DeviceNode->Parent != ParentDeviceNode)
{ {
DPRINT("Not a direct child\n"); /*
* Stop the traversal immediately and indicate unsuccessful operation
*/
DPRINT("Stop\n");
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
} }
#endif
if (!IopDeviceNodeHasFlag(DeviceNode, DNF_DISABLED) && if (!IopDeviceNodeHasFlag(DeviceNode, DNF_DISABLED) &&
!IopDeviceNodeHasFlag(DeviceNode, DNF_ADDED) && !IopDeviceNodeHasFlag(DeviceNode, DNF_ADDED) &&
@ -2545,8 +2558,8 @@ IopActionInitChildServices(PDEVICE_NODE DeviceNode,
IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED); IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
IopDeviceNodeSetFlag(DeviceNode, DNF_START_FAILED); IopDeviceNodeSetFlag(DeviceNode, DNF_START_FAILED);
/* FIXME: Log the error (possibly in IopInitializeDeviceNodeService) */ /* FIXME: Log the error (possibly in IopInitializeDeviceNodeService) */
DPRINT("Initialization of service %wZ failed (Status %x)\n", CPRINT("Initialization of service %S failed (Status %x)\n",
&DeviceNode->ServiceName, Status); DeviceNode->ServiceName.Buffer, Status);
} }
} }
} }