[NTOSKRNL][USETUP][UMPNPMGR] Pass user response data to NtPlugPlayControl(PlugPlayCon...
[reactos.git] / ntoskrnl / io / pnpmgr / plugplay.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * COPYRIGHT: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/io/pnpmgr/plugplay.c
5 * PURPOSE: Plug-and-play interface routines
6 * PROGRAMMERS: Eric Kohl <eric.kohl@t-online.de>
7 */
8
9 /* INCLUDES *****************************************************************/
10
11 #include <ntoskrnl.h>
12 #define NDEBUG
13 #include <debug.h>
14
15 #if defined (ALLOC_PRAGMA)
16 #pragma alloc_text(INIT, IopInitPlugPlayEvents)
17 #endif
18
19 typedef struct _PNP_EVENT_ENTRY
20 {
21 LIST_ENTRY ListEntry;
22 PLUGPLAY_EVENT_BLOCK Event;
23 } PNP_EVENT_ENTRY, *PPNP_EVENT_ENTRY;
24
25
26 /* GLOBALS *******************************************************************/
27
28 static LIST_ENTRY IopPnpEventQueueHead;
29 static KEVENT IopPnpNotifyEvent;
30
31 /* FUNCTIONS *****************************************************************/
32
33 NTSTATUS INIT_FUNCTION
34 IopInitPlugPlayEvents(VOID)
35 {
36 InitializeListHead(&IopPnpEventQueueHead);
37
38 KeInitializeEvent(&IopPnpNotifyEvent,
39 SynchronizationEvent,
40 FALSE);
41
42 return STATUS_SUCCESS;
43 }
44
45 NTSTATUS
46 IopQueueTargetDeviceEvent(const GUID *Guid,
47 PUNICODE_STRING DeviceIds)
48 {
49 PPNP_EVENT_ENTRY EventEntry;
50 UNICODE_STRING Copy;
51 ULONG TotalSize;
52 NTSTATUS Status;
53
54 ASSERT(DeviceIds);
55
56 /* Allocate a big enough buffer */
57 Copy.Length = 0;
58 Copy.MaximumLength = DeviceIds->Length + sizeof(UNICODE_NULL);
59 TotalSize =
60 FIELD_OFFSET(PLUGPLAY_EVENT_BLOCK, TargetDevice.DeviceIds) +
61 Copy.MaximumLength;
62
63 EventEntry = ExAllocatePool(NonPagedPool,
64 TotalSize + FIELD_OFFSET(PNP_EVENT_ENTRY, Event));
65 if (!EventEntry)
66 return STATUS_INSUFFICIENT_RESOURCES;
67
68 /* Fill the buffer with the event GUID */
69 RtlCopyMemory(&EventEntry->Event.EventGuid,
70 Guid,
71 sizeof(GUID));
72 EventEntry->Event.EventCategory = TargetDeviceChangeEvent;
73 EventEntry->Event.TotalSize = TotalSize;
74
75 /* Fill the device id */
76 Copy.Buffer = EventEntry->Event.TargetDevice.DeviceIds;
77 Status = RtlAppendUnicodeStringToString(&Copy, DeviceIds);
78 if (!NT_SUCCESS(Status))
79 {
80 ExFreePool(EventEntry);
81 return Status;
82 }
83
84 InsertHeadList(&IopPnpEventQueueHead,
85 &EventEntry->ListEntry);
86 KeSetEvent(&IopPnpNotifyEvent,
87 0,
88 FALSE);
89
90 return STATUS_SUCCESS;
91 }
92
93
94 /*
95 * Remove the current PnP event from the tail of the event queue
96 * and signal IopPnpNotifyEvent if there is yet another event in the queue.
97 */
98 static NTSTATUS
99 IopRemovePlugPlayEvent(VOID)
100 {
101 /* Remove a pnp event entry from the tail of the queue */
102 if (!IsListEmpty(&IopPnpEventQueueHead))
103 {
104 ExFreePool(CONTAINING_RECORD(RemoveTailList(&IopPnpEventQueueHead), PNP_EVENT_ENTRY, ListEntry));
105 }
106
107 /* Signal the next pnp event in the queue */
108 if (!IsListEmpty(&IopPnpEventQueueHead))
109 {
110 KeSetEvent(&IopPnpNotifyEvent,
111 0,
112 FALSE);
113 }
114
115 return STATUS_SUCCESS;
116 }
117
118 static PDEVICE_OBJECT
119 IopTraverseDeviceNode(PDEVICE_NODE Node, PUNICODE_STRING DeviceInstance)
120 {
121 PDEVICE_OBJECT DeviceObject;
122 PDEVICE_NODE ChildNode;
123
124 if (RtlEqualUnicodeString(&Node->InstancePath,
125 DeviceInstance, TRUE))
126 {
127 ObReferenceObject(Node->PhysicalDeviceObject);
128 return Node->PhysicalDeviceObject;
129 }
130
131 /* Traversal of all children nodes */
132 for (ChildNode = Node->Child;
133 ChildNode != NULL;
134 ChildNode = ChildNode->Sibling)
135 {
136 DeviceObject = IopTraverseDeviceNode(ChildNode, DeviceInstance);
137 if (DeviceObject != NULL)
138 {
139 return DeviceObject;
140 }
141 }
142
143 return NULL;
144 }
145
146
147 PDEVICE_OBJECT
148 IopGetDeviceObjectFromDeviceInstance(PUNICODE_STRING DeviceInstance)
149 {
150 if (IopRootDeviceNode == NULL)
151 return NULL;
152
153 if (DeviceInstance == NULL ||
154 DeviceInstance->Length == 0)
155 {
156 if (IopRootDeviceNode->PhysicalDeviceObject)
157 {
158 ObReferenceObject(IopRootDeviceNode->PhysicalDeviceObject);
159 return IopRootDeviceNode->PhysicalDeviceObject;
160 }
161 else
162 return NULL;
163 }
164
165 return IopTraverseDeviceNode(IopRootDeviceNode, DeviceInstance);
166 }
167
168 static NTSTATUS
169 IopCaptureUnicodeString(PUNICODE_STRING DstName, PUNICODE_STRING SrcName)
170 {
171 NTSTATUS Status = STATUS_SUCCESS;
172 volatile UNICODE_STRING Name;
173
174 Name.Buffer = NULL;
175 _SEH2_TRY
176 {
177 Name.Length = SrcName->Length;
178 Name.MaximumLength = SrcName->MaximumLength;
179 if (Name.Length > Name.MaximumLength)
180 {
181 Status = STATUS_INVALID_PARAMETER;
182 _SEH2_LEAVE;
183 }
184
185 if (Name.MaximumLength)
186 {
187 ProbeForRead(SrcName->Buffer,
188 Name.MaximumLength,
189 sizeof(WCHAR));
190 Name.Buffer = ExAllocatePool(NonPagedPool, Name.MaximumLength);
191 if (Name.Buffer == NULL)
192 {
193 Status = STATUS_INSUFFICIENT_RESOURCES;
194 _SEH2_LEAVE;
195 }
196
197 memcpy(Name.Buffer, SrcName->Buffer, Name.MaximumLength);
198 }
199
200 *DstName = Name;
201 }
202 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
203 {
204 if (Name.Buffer)
205 {
206 ExFreePool(Name.Buffer);
207 }
208 Status = _SEH2_GetExceptionCode();
209 }
210 _SEH2_END;
211
212 return Status;
213 }
214
215 static NTSTATUS
216 IopPnpEnumerateDevice(PPLUGPLAY_CONTROL_ENUMERATE_DEVICE_DATA DeviceData)
217 {
218 PDEVICE_OBJECT DeviceObject;
219 UNICODE_STRING DeviceInstance;
220 NTSTATUS Status = STATUS_SUCCESS;
221
222 Status = IopCaptureUnicodeString(&DeviceInstance, &DeviceData->DeviceInstance);
223 if (!NT_SUCCESS(Status))
224 {
225 return Status;
226 }
227
228 DPRINT("IopPnpEnumerateDevice(%wZ)\n", &DeviceInstance);
229
230 /* Get the device object */
231 DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
232 if (DeviceInstance.Buffer != NULL)
233 {
234 ExFreePool(DeviceInstance.Buffer);
235 }
236 if (DeviceObject == NULL)
237 {
238 return STATUS_NO_SUCH_DEVICE;
239 }
240
241 Status = IopEnumerateDevice(DeviceObject);
242
243 ObDereferenceObject(DeviceObject);
244
245 return Status;
246 }
247
248 static NTSTATUS
249 IopGetInterfaceDeviceList(PPLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA DeviceList)
250 {
251 NTSTATUS Status;
252 PLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA StackList;
253 UNICODE_STRING DeviceInstance;
254 PDEVICE_OBJECT DeviceObject = NULL;
255 GUID FilterGuid;
256 PZZWSTR SymbolicLinkList = NULL, LinkList;
257 SIZE_T TotalLength;
258
259 _SEH2_TRY
260 {
261 RtlCopyMemory(&StackList, DeviceList, sizeof(PLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA));
262
263 ProbeForRead(StackList.FilterGuid, sizeof(GUID), sizeof(UCHAR));
264 RtlCopyMemory(&FilterGuid, StackList.FilterGuid, sizeof(GUID));
265
266 if (StackList.Buffer != NULL && StackList.BufferSize != 0)
267 {
268 ProbeForWrite(StackList.Buffer, StackList.BufferSize, sizeof(UCHAR));
269 }
270 }
271 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
272 {
273 _SEH2_YIELD(return _SEH2_GetExceptionCode());
274 }
275 _SEH2_END;
276
277 Status = IopCaptureUnicodeString(&DeviceInstance, &StackList.DeviceInstance);
278 if (NT_SUCCESS(Status))
279 {
280 /* Get the device object */
281 DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
282 if (DeviceInstance.Buffer != NULL)
283 {
284 ExFreePool(DeviceInstance.Buffer);
285 }
286 }
287
288 Status = IoGetDeviceInterfaces(&FilterGuid, DeviceObject, StackList.Flags, &SymbolicLinkList);
289 ObDereferenceObject(DeviceObject);
290
291 if (!NT_SUCCESS(Status))
292 {
293 /* failed */
294 return Status;
295 }
296
297 LinkList = SymbolicLinkList;
298 while (*SymbolicLinkList != UNICODE_NULL)
299 {
300 SymbolicLinkList += wcslen(SymbolicLinkList) + (sizeof(UNICODE_NULL) / sizeof(WCHAR));
301 }
302 TotalLength = ((SymbolicLinkList - LinkList + 1) * sizeof(WCHAR));
303
304 _SEH2_TRY
305 {
306 if (StackList.Buffer != NULL &&
307 StackList.BufferSize >= TotalLength)
308 {
309 // We've already probed the buffer for writing above.
310 RtlCopyMemory(StackList.Buffer, LinkList, TotalLength);
311 }
312
313 DeviceList->BufferSize = TotalLength;
314 }
315 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
316 {
317 ExFreePool(LinkList);
318 _SEH2_YIELD(return _SEH2_GetExceptionCode());
319 }
320 _SEH2_END;
321
322 ExFreePool(LinkList);
323 return STATUS_SUCCESS;
324 }
325
326 static NTSTATUS
327 IopGetDeviceProperty(PPLUGPLAY_CONTROL_PROPERTY_DATA PropertyData)
328 {
329 PDEVICE_OBJECT DeviceObject = NULL;
330 PDEVICE_NODE DeviceNode;
331 UNICODE_STRING DeviceInstance;
332 ULONG BufferSize;
333 ULONG Property;
334 DEVICE_REGISTRY_PROPERTY DeviceProperty;
335 PVOID Buffer;
336 NTSTATUS Status;
337
338 DPRINT("IopGetDeviceProperty() called\n");
339 DPRINT("Device name: %wZ\n", &PropertyData->DeviceInstance);
340
341 Status = IopCaptureUnicodeString(&DeviceInstance, &PropertyData->DeviceInstance);
342 if (!NT_SUCCESS(Status))
343 {
344 return Status;
345 }
346
347 _SEH2_TRY
348 {
349 Property = PropertyData->Property;
350 BufferSize = PropertyData->BufferSize;
351 ProbeForWrite(PropertyData->Buffer,
352 BufferSize,
353 sizeof(UCHAR));
354 }
355 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
356 {
357 if (DeviceInstance.Buffer != NULL)
358 {
359 ExFreePool(DeviceInstance.Buffer);
360 }
361 _SEH2_YIELD(return _SEH2_GetExceptionCode());
362 }
363 _SEH2_END;
364
365 /* Get the device object */
366 DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
367 if (DeviceInstance.Buffer != NULL)
368 {
369 ExFreePool(DeviceInstance.Buffer);
370 }
371 if (DeviceObject == NULL)
372 {
373 return STATUS_NO_SUCH_DEVICE;
374 }
375
376 Buffer = ExAllocatePool(NonPagedPool, BufferSize);
377 if (Buffer == NULL)
378 {
379 ObDereferenceObject(DeviceObject);
380 return STATUS_INSUFFICIENT_RESOURCES;
381 }
382
383
384 DeviceNode = ((PEXTENDED_DEVOBJ_EXTENSION)DeviceObject->DeviceObjectExtension)->DeviceNode;
385
386 if (Property == PNP_PROPERTY_POWER_DATA)
387 {
388 if (BufferSize < sizeof(CM_POWER_DATA))
389 {
390 BufferSize = 0;
391 Status = STATUS_BUFFER_TOO_SMALL;
392 }
393 else
394 {
395 DEVICE_CAPABILITIES DeviceCapabilities;
396 PCM_POWER_DATA PowerData;
397 IO_STACK_LOCATION Stack;
398 IO_STATUS_BLOCK IoStatusBlock;
399
400 PowerData = (PCM_POWER_DATA)Buffer;
401 RtlZeroMemory(PowerData, sizeof(CM_POWER_DATA));
402 PowerData->PD_Size = sizeof(CM_POWER_DATA);
403
404 RtlZeroMemory(&DeviceCapabilities, sizeof(DEVICE_CAPABILITIES));
405 DeviceCapabilities.Size = sizeof(DEVICE_CAPABILITIES);
406 DeviceCapabilities.Version = 1;
407 DeviceCapabilities.Address = -1;
408 DeviceCapabilities.UINumber = -1;
409
410 Stack.Parameters.DeviceCapabilities.Capabilities = &DeviceCapabilities;
411
412 Status = IopInitiatePnpIrp(DeviceObject,
413 &IoStatusBlock,
414 IRP_MN_QUERY_CAPABILITIES,
415 &Stack);
416 if (NT_SUCCESS(Status))
417 {
418 DPRINT("Got device capabiliities\n");
419
420 PowerData->PD_MostRecentPowerState = PowerDeviceD0; // FIXME
421 if (DeviceCapabilities.DeviceD1)
422 PowerData->PD_Capabilities |= PDCAP_D1_SUPPORTED;
423 if (DeviceCapabilities.DeviceD2)
424 PowerData->PD_Capabilities |= PDCAP_D2_SUPPORTED;
425 if (DeviceCapabilities.WakeFromD0)
426 PowerData->PD_Capabilities |= PDCAP_WAKE_FROM_D0_SUPPORTED;
427 if (DeviceCapabilities.WakeFromD1)
428 PowerData->PD_Capabilities |= PDCAP_WAKE_FROM_D1_SUPPORTED;
429 if (DeviceCapabilities.WakeFromD2)
430 PowerData->PD_Capabilities |= PDCAP_WAKE_FROM_D2_SUPPORTED;
431 if (DeviceCapabilities.WakeFromD3)
432 PowerData->PD_Capabilities |= PDCAP_WAKE_FROM_D3_SUPPORTED;
433 if (DeviceCapabilities.WarmEjectSupported)
434 PowerData->PD_Capabilities |= PDCAP_WARM_EJECT_SUPPORTED;
435 PowerData->PD_D1Latency = DeviceCapabilities.D1Latency;
436 PowerData->PD_D2Latency = DeviceCapabilities.D2Latency;
437 PowerData->PD_D3Latency = DeviceCapabilities.D3Latency;
438 RtlCopyMemory(&PowerData->PD_PowerStateMapping,
439 &DeviceCapabilities.DeviceState,
440 sizeof(DeviceCapabilities.DeviceState));
441 PowerData->PD_DeepestSystemWake = DeviceCapabilities.SystemWake;
442 }
443 else
444 {
445 DPRINT("IRP_MN_QUERY_CAPABILITIES failed (Status 0x%08lx)\n", Status);
446
447 PowerData->PD_Capabilities = PDCAP_D0_SUPPORTED | PDCAP_D3_SUPPORTED;
448 PowerData->PD_MostRecentPowerState = PowerDeviceD0;
449 }
450 }
451 }
452 else if (Property == PNP_PROPERTY_REMOVAL_POLICY_OVERRIDE)
453 {
454 }
455 else if (Property == PNP_PROPERTY_REMOVAL_POLICY_HARDWARE_DEFAULT)
456 {
457 if (BufferSize < sizeof(DeviceNode->HardwareRemovalPolicy))
458 {
459 BufferSize = 0;
460 Status = STATUS_BUFFER_TOO_SMALL;
461 }
462 else
463 {
464 BufferSize = sizeof(DeviceNode->HardwareRemovalPolicy);
465 RtlCopyMemory(Buffer,
466 &DeviceNode->HardwareRemovalPolicy,
467 BufferSize);
468 }
469 }
470 else
471 {
472 switch (Property)
473 {
474 case PNP_PROPERTY_UI_NUMBER:
475 DeviceProperty = DevicePropertyUINumber;
476 break;
477
478 case PNP_PROPERTY_PHYSICAL_DEVICE_OBJECT_NAME:
479 DeviceProperty = DevicePropertyPhysicalDeviceObjectName;
480 break;
481
482 case PNP_PROPERTY_BUSTYPEGUID:
483 DeviceProperty = DevicePropertyBusTypeGuid;
484 break;
485
486 case PNP_PROPERTY_LEGACYBUSTYPE:
487 DeviceProperty = DevicePropertyLegacyBusType;
488 break;
489
490 case PNP_PROPERTY_BUSNUMBER:
491 DeviceProperty = DevicePropertyBusNumber;
492 break;
493
494 case PNP_PROPERTY_REMOVAL_POLICY:
495 DeviceProperty = DevicePropertyRemovalPolicy;
496 break;
497
498 case PNP_PROPERTY_ADDRESS:
499 DeviceProperty = DevicePropertyAddress;
500 break;
501
502 case PNP_PROPERTY_ENUMERATOR_NAME:
503 DeviceProperty = DevicePropertyEnumeratorName;
504 break;
505
506 case PNP_PROPERTY_INSTALL_STATE:
507 DeviceProperty = DevicePropertyInstallState;
508 break;
509
510 #if (WINVER >= _WIN32_WINNT_WS03)
511 case PNP_PROPERTY_LOCATION_PATHS:
512 break;
513 #endif
514
515 #if (WINVER >= _WIN32_WINNT_WIN7)
516 case PNP_PROPERTY_CONTAINERID:
517 DeviceProperty = DevicePropertyContainerID;
518 break;
519 #endif
520
521 default:
522 BufferSize = 0;
523 Status = STATUS_INVALID_PARAMETER;
524 break;
525 }
526
527 if (Status == STATUS_SUCCESS)
528 {
529 Status = IoGetDeviceProperty(DeviceObject,
530 DeviceProperty,
531 BufferSize,
532 Buffer,
533 &BufferSize);
534 }
535 }
536
537 ObDereferenceObject(DeviceObject);
538
539 if (NT_SUCCESS(Status))
540 {
541 _SEH2_TRY
542 {
543 RtlCopyMemory(PropertyData->Buffer, Buffer, BufferSize);
544 PropertyData->BufferSize = BufferSize;
545 }
546 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
547 {
548 Status = _SEH2_GetExceptionCode();
549 }
550 _SEH2_END;
551 }
552
553 ExFreePool(Buffer);
554 return Status;
555 }
556
557
558 static NTSTATUS
559 IopGetRelatedDevice(PPLUGPLAY_CONTROL_RELATED_DEVICE_DATA RelatedDeviceData)
560 {
561 UNICODE_STRING RootDeviceName;
562 PDEVICE_OBJECT DeviceObject = NULL;
563 PDEVICE_NODE DeviceNode = NULL;
564 PDEVICE_NODE RelatedDeviceNode;
565 UNICODE_STRING TargetDeviceInstance;
566 NTSTATUS Status = STATUS_SUCCESS;
567 ULONG Relation = 0;
568 ULONG MaximumLength = 0;
569
570 DPRINT("IopGetRelatedDevice() called\n");
571 DPRINT("Device name: %wZ\n", &RelatedDeviceData->TargetDeviceInstance);
572
573 Status = IopCaptureUnicodeString(&TargetDeviceInstance, &RelatedDeviceData->TargetDeviceInstance);
574 if (!NT_SUCCESS(Status))
575 {
576 return Status;
577 }
578
579 _SEH2_TRY
580 {
581 Relation = RelatedDeviceData->Relation;
582 MaximumLength = RelatedDeviceData->RelatedDeviceInstanceLength;
583 ProbeForWrite(RelatedDeviceData->RelatedDeviceInstance,
584 MaximumLength,
585 sizeof(WCHAR));
586 }
587 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
588 {
589 if (TargetDeviceInstance.Buffer != NULL)
590 {
591 ExFreePool(TargetDeviceInstance.Buffer);
592 }
593 _SEH2_YIELD(return _SEH2_GetExceptionCode());
594 }
595 _SEH2_END;
596
597 RtlInitUnicodeString(&RootDeviceName,
598 L"HTREE\\ROOT\\0");
599 if (RtlEqualUnicodeString(&TargetDeviceInstance,
600 &RootDeviceName,
601 TRUE))
602 {
603 DeviceNode = IopRootDeviceNode;
604 if (TargetDeviceInstance.Buffer != NULL)
605 {
606 ExFreePool(TargetDeviceInstance.Buffer);
607 }
608 }
609 else
610 {
611 /* Get the device object */
612 DeviceObject = IopGetDeviceObjectFromDeviceInstance(&TargetDeviceInstance);
613 if (TargetDeviceInstance.Buffer != NULL)
614 {
615 ExFreePool(TargetDeviceInstance.Buffer);
616 }
617 if (DeviceObject == NULL)
618 return STATUS_NO_SUCH_DEVICE;
619
620 DeviceNode = ((PEXTENDED_DEVOBJ_EXTENSION)DeviceObject->DeviceObjectExtension)->DeviceNode;
621 }
622
623 switch (Relation)
624 {
625 case PNP_GET_PARENT_DEVICE:
626 RelatedDeviceNode = DeviceNode->Parent;
627 break;
628
629 case PNP_GET_CHILD_DEVICE:
630 RelatedDeviceNode = DeviceNode->Child;
631 break;
632
633 case PNP_GET_SIBLING_DEVICE:
634 RelatedDeviceNode = DeviceNode->Sibling;
635 break;
636
637 default:
638 if (DeviceObject != NULL)
639 {
640 ObDereferenceObject(DeviceObject);
641 }
642
643 return STATUS_INVALID_PARAMETER;
644 }
645
646 if (RelatedDeviceNode == NULL)
647 {
648 if (DeviceObject)
649 {
650 ObDereferenceObject(DeviceObject);
651 }
652
653 return STATUS_NO_SUCH_DEVICE;
654 }
655
656 if (RelatedDeviceNode->InstancePath.Length > MaximumLength)
657 {
658 if (DeviceObject)
659 {
660 ObDereferenceObject(DeviceObject);
661 }
662
663 return STATUS_BUFFER_TOO_SMALL;
664 }
665
666 /* Copy related device instance name */
667 _SEH2_TRY
668 {
669 RtlCopyMemory(RelatedDeviceData->RelatedDeviceInstance,
670 RelatedDeviceNode->InstancePath.Buffer,
671 RelatedDeviceNode->InstancePath.Length);
672 RelatedDeviceData->RelatedDeviceInstanceLength = RelatedDeviceNode->InstancePath.Length;
673 }
674 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
675 {
676 Status = _SEH2_GetExceptionCode();
677 }
678 _SEH2_END;
679
680 if (DeviceObject != NULL)
681 {
682 ObDereferenceObject(DeviceObject);
683 }
684
685 DPRINT("IopGetRelatedDevice() done\n");
686
687 return Status;
688 }
689
690 static ULONG
691 IopGetDeviceNodeStatus(PDEVICE_NODE DeviceNode)
692 {
693 ULONG Output = 0;
694
695 if (DeviceNode->Parent == IopRootDeviceNode)
696 Output |= DN_ROOT_ENUMERATED;
697
698 if (DeviceNode->Flags & DNF_ADDED)
699 Output |= DN_DRIVER_LOADED;
700
701 /* FIXME: DN_ENUM_LOADED */
702
703 if (DeviceNode->Flags & DNF_STARTED)
704 Output |= DN_STARTED;
705
706 /* FIXME: Manual */
707
708 if (!(DeviceNode->Flags & DNF_PROCESSED))
709 Output |= DN_NEED_TO_ENUM;
710
711 /* DN_NOT_FIRST_TIME is 9x only */
712
713 /* FIXME: DN_HARDWARE_ENUM */
714
715 /* DN_LIAR and DN_HAS_MARK are 9x only */
716
717 if (DeviceNode->Problem != 0)
718 Output |= DN_HAS_PROBLEM;
719
720 /* FIXME: DN_FILTERED */
721
722 if (DeviceNode->Flags & DNF_LEGACY_DRIVER)
723 Output |= DN_LEGACY_DRIVER;
724
725 if (DeviceNode->UserFlags & DNUF_DONT_SHOW_IN_UI)
726 Output |= DN_NO_SHOW_IN_DM;
727
728 if (!(DeviceNode->UserFlags & DNUF_NOT_DISABLEABLE))
729 Output |= DN_DISABLEABLE;
730
731 /* FIXME: Implement the rest */
732
733 Output |= DN_NT_ENUMERATOR | DN_NT_DRIVER;
734
735 return Output;
736 }
737
738 static NTSTATUS
739 IopDeviceStatus(PPLUGPLAY_CONTROL_STATUS_DATA StatusData)
740 {
741 PDEVICE_OBJECT DeviceObject;
742 PDEVICE_NODE DeviceNode;
743 ULONG Operation = 0;
744 ULONG DeviceStatus = 0;
745 ULONG DeviceProblem = 0;
746 UNICODE_STRING DeviceInstance;
747 NTSTATUS Status;
748
749 DPRINT("IopDeviceStatus() called\n");
750
751 Status = IopCaptureUnicodeString(&DeviceInstance, &StatusData->DeviceInstance);
752 if (!NT_SUCCESS(Status))
753 {
754 return Status;
755 }
756
757 DPRINT("Device name: '%wZ'\n", &DeviceInstance);
758
759 _SEH2_TRY
760 {
761 Operation = StatusData->Operation;
762 if (Operation == PNP_SET_DEVICE_STATUS)
763 {
764 DeviceStatus = StatusData->DeviceStatus;
765 DeviceProblem = StatusData->DeviceProblem;
766 }
767 }
768 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
769 {
770 if (DeviceInstance.Buffer != NULL)
771 {
772 ExFreePool(DeviceInstance.Buffer);
773 }
774 _SEH2_YIELD(return _SEH2_GetExceptionCode());
775 }
776 _SEH2_END;
777
778 /* Get the device object */
779 DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
780 if (DeviceInstance.Buffer != NULL)
781 {
782 ExFreePool(DeviceInstance.Buffer);
783 }
784 if (DeviceObject == NULL)
785 {
786 return STATUS_NO_SUCH_DEVICE;
787 }
788
789 DeviceNode = IopGetDeviceNode(DeviceObject);
790
791 switch (Operation)
792 {
793 case PNP_GET_DEVICE_STATUS:
794 DPRINT("Get status data\n");
795 DeviceStatus = IopGetDeviceNodeStatus(DeviceNode);
796 DeviceProblem = DeviceNode->Problem;
797 break;
798
799 case PNP_SET_DEVICE_STATUS:
800 DPRINT1("Set status data is NOT SUPPORTED\n");
801 break;
802
803 case PNP_CLEAR_DEVICE_STATUS:
804 DPRINT1("FIXME: Clear status data!\n");
805 break;
806 }
807
808 ObDereferenceObject(DeviceObject);
809
810 if (Operation == PNP_GET_DEVICE_STATUS)
811 {
812 _SEH2_TRY
813 {
814 StatusData->DeviceStatus = DeviceStatus;
815 StatusData->DeviceProblem = DeviceProblem;
816 }
817 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
818 {
819 Status = _SEH2_GetExceptionCode();
820 }
821 _SEH2_END;
822 }
823
824 return Status;
825 }
826
827 static
828 NTSTATUS
829 IopGetDeviceRelations(PPLUGPLAY_CONTROL_DEVICE_RELATIONS_DATA RelationsData)
830 {
831 UNICODE_STRING DeviceInstance;
832 PDEVICE_OBJECT DeviceObject = NULL;
833 IO_STACK_LOCATION Stack;
834 IO_STATUS_BLOCK IoStatusBlock;
835 PDEVICE_RELATIONS DeviceRelations = NULL;
836 PDEVICE_OBJECT ChildDeviceObject;
837 PDEVICE_NODE ChildDeviceNode;
838 ULONG i;
839 ULONG Relations;
840 ULONG BufferSize, RequiredSize;
841 ULONG BufferLeft;
842 PWCHAR Buffer, Ptr;
843 NTSTATUS Status = STATUS_SUCCESS;
844
845 DPRINT("IopGetDeviceRelations() called\n");
846 DPRINT("Device name: %wZ\n", &RelationsData->DeviceInstance);
847 DPRINT("Relations: %lu\n", RelationsData->Relations);
848 DPRINT("BufferSize: %lu\n", RelationsData->BufferSize);
849 DPRINT("Buffer: %p\n", RelationsData->Buffer);
850
851 _SEH2_TRY
852 {
853 Relations = RelationsData->Relations;
854 BufferSize = RelationsData->BufferSize;
855 Buffer = RelationsData->Buffer;
856
857 ProbeForWrite(Buffer, BufferSize, sizeof(CHAR));
858 }
859 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
860 {
861 _SEH2_YIELD(return _SEH2_GetExceptionCode());
862 }
863 _SEH2_END;
864
865 Status = IopCaptureUnicodeString(&DeviceInstance, &RelationsData->DeviceInstance);
866 if (!NT_SUCCESS(Status))
867 {
868 DPRINT1("IopCaptureUnicodeString() failed (Status 0x%08lx)\n", Status);
869 return Status;
870 }
871
872 /* Get the device object */
873 DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
874 if (DeviceObject == NULL)
875 {
876 DPRINT1("IopGetDeviceObjectFromDeviceInstance() returned NULL\n");
877 Status = STATUS_NO_SUCH_DEVICE;
878 goto done;
879 }
880
881 switch (Relations)
882 {
883 case PNP_EJECT_RELATIONS:
884 Stack.Parameters.QueryDeviceRelations.Type = EjectionRelations;
885 break;
886
887 case PNP_REMOVAL_RELATIONS:
888 Stack.Parameters.QueryDeviceRelations.Type = RemovalRelations;
889 break;
890
891 case PNP_POWER_RELATIONS:
892 Stack.Parameters.QueryDeviceRelations.Type = PowerRelations;
893 break;
894
895 case PNP_BUS_RELATIONS:
896 Stack.Parameters.QueryDeviceRelations.Type = BusRelations;
897 break;
898
899 default:
900 Status = STATUS_INVALID_PARAMETER;
901 goto done;
902 }
903
904 Status = IopInitiatePnpIrp(DeviceObject,
905 &IoStatusBlock,
906 IRP_MN_QUERY_DEVICE_RELATIONS,
907 &Stack);
908 if (!NT_SUCCESS(Status))
909 {
910 DPRINT1("IopInitiatePnpIrp() failed (Status 0x%08lx)\n", Status);
911 goto done;
912 }
913
914 DeviceRelations = (PDEVICE_RELATIONS)IoStatusBlock.Information;
915
916 DPRINT("Found %d device relations\n", DeviceRelations->Count);
917
918 _SEH2_TRY
919 {
920 RequiredSize = 0;
921 BufferLeft = BufferSize;
922 Ptr = Buffer;
923
924 for (i = 0; i < DeviceRelations->Count; i++)
925 {
926 ChildDeviceObject = DeviceRelations->Objects[i];
927
928 ChildDeviceNode = IopGetDeviceNode(ChildDeviceObject);
929 if (ChildDeviceNode)
930 {
931 DPRINT("Device instance: %wZ\n", &ChildDeviceNode->InstancePath);
932 DPRINT("RequiredSize: %hu\n", ChildDeviceNode->InstancePath.Length + sizeof(WCHAR));
933
934 if (Ptr != NULL)
935 {
936 if (BufferLeft < ChildDeviceNode->InstancePath.Length + 2 * sizeof(WCHAR))
937 {
938 Status = STATUS_BUFFER_TOO_SMALL;
939 break;
940 }
941
942 RtlCopyMemory(Ptr,
943 ChildDeviceNode->InstancePath.Buffer,
944 ChildDeviceNode->InstancePath.Length);
945 Ptr = (PWCHAR)((ULONG_PTR)Ptr + ChildDeviceNode->InstancePath.Length);
946 *Ptr = UNICODE_NULL;
947 Ptr = (PWCHAR)((ULONG_PTR)Ptr + sizeof(WCHAR));
948
949 BufferLeft -= (ChildDeviceNode->InstancePath.Length + sizeof(WCHAR));
950 }
951
952 RequiredSize += (ChildDeviceNode->InstancePath.Length + sizeof(WCHAR));
953 }
954 }
955
956 if (Ptr != NULL && BufferLeft >= sizeof(WCHAR))
957 *Ptr = UNICODE_NULL;
958
959 if (RequiredSize > 0)
960 RequiredSize += sizeof(WCHAR);
961
962 DPRINT("BufferSize: %lu RequiredSize: %lu\n", RelationsData->BufferSize, RequiredSize);
963
964 RelationsData->BufferSize = RequiredSize;
965 }
966 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
967 {
968 Status = _SEH2_GetExceptionCode();
969 }
970 _SEH2_END;
971
972 done:
973 if (DeviceRelations != NULL)
974 ExFreePool(DeviceRelations);
975
976 if (DeviceObject != NULL)
977 ObDereferenceObject(DeviceObject);
978
979 if (DeviceInstance.Buffer != NULL)
980 ExFreePool(DeviceInstance.Buffer);
981
982 return Status;
983 }
984
985 static NTSTATUS
986 IopGetDeviceDepth(PPLUGPLAY_CONTROL_DEPTH_DATA DepthData)
987 {
988 PDEVICE_OBJECT DeviceObject;
989 PDEVICE_NODE DeviceNode;
990 UNICODE_STRING DeviceInstance;
991 NTSTATUS Status = STATUS_SUCCESS;
992
993 DPRINT("IopGetDeviceDepth() called\n");
994 DPRINT("Device name: %wZ\n", &DepthData->DeviceInstance);
995
996 Status = IopCaptureUnicodeString(&DeviceInstance, &DepthData->DeviceInstance);
997 if (!NT_SUCCESS(Status))
998 {
999 return Status;
1000 }
1001
1002 /* Get the device object */
1003 DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
1004 if (DeviceInstance.Buffer != NULL)
1005 {
1006 ExFreePool(DeviceInstance.Buffer);
1007 }
1008 if (DeviceObject == NULL)
1009 {
1010 return STATUS_NO_SUCH_DEVICE;
1011 }
1012
1013 DeviceNode = IopGetDeviceNode(DeviceObject);
1014
1015 _SEH2_TRY
1016 {
1017 DepthData->Depth = DeviceNode->Level;
1018 }
1019 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1020 {
1021 Status = _SEH2_GetExceptionCode();
1022 }
1023 _SEH2_END;
1024
1025 ObDereferenceObject(DeviceObject);
1026
1027 return Status;
1028 }
1029
1030
1031 static NTSTATUS
1032 IopResetDevice(PPLUGPLAY_CONTROL_RESET_DEVICE_DATA ResetDeviceData)
1033 {
1034 PDEVICE_OBJECT DeviceObject;
1035 PDEVICE_NODE DeviceNode;
1036 NTSTATUS Status = STATUS_SUCCESS;
1037 UNICODE_STRING DeviceInstance;
1038
1039 Status = IopCaptureUnicodeString(&DeviceInstance, &ResetDeviceData->DeviceInstance);
1040 if (!NT_SUCCESS(Status))
1041 {
1042 return Status;
1043 }
1044
1045 DPRINT("IopResetDevice(%wZ)\n", &DeviceInstance);
1046
1047 /* Get the device object */
1048 DeviceObject = IopGetDeviceObjectFromDeviceInstance(&DeviceInstance);
1049 if (DeviceInstance.Buffer != NULL)
1050 {
1051 ExFreePool(DeviceInstance.Buffer);
1052 }
1053 if (DeviceObject == NULL)
1054 {
1055 return STATUS_NO_SUCH_DEVICE;
1056 }
1057
1058 /* Get the device node */
1059 DeviceNode = IopGetDeviceNode(DeviceObject);
1060
1061 ASSERT(DeviceNode->Flags & DNF_ENUMERATED);
1062 ASSERT(DeviceNode->Flags & DNF_PROCESSED);
1063
1064 /* Check if there's already a driver loaded for this device */
1065 if (DeviceNode->Flags & DNF_ADDED)
1066 {
1067 #if 0
1068 /* Remove the device node */
1069 Status = IopRemoveDevice(DeviceNode);
1070 if (NT_SUCCESS(Status))
1071 {
1072 /* Invalidate device relations for the parent to reenumerate the device */
1073 DPRINT1("A new driver will be loaded for '%wZ' (FDO above removed)\n", &DeviceNode->InstancePath);
1074 Status = IoSynchronousInvalidateDeviceRelations(DeviceNode->Parent->PhysicalDeviceObject, BusRelations);
1075 }
1076 else
1077 #endif
1078 {
1079 /* A driver has already been loaded for this device */
1080 DPRINT1("A reboot is required for the current driver for '%wZ' to be replaced\n", &DeviceNode->InstancePath);
1081 DeviceNode->Problem = CM_PROB_NEED_RESTART;
1082 }
1083 }
1084 else
1085 {
1086 /* FIXME: What if the device really is disabled? */
1087 DeviceNode->Flags &= ~DNF_DISABLED;
1088 DeviceNode->Problem = 0;
1089
1090 /* Load service data from the registry */
1091 Status = IopActionConfigureChildServices(DeviceNode, DeviceNode->Parent);
1092
1093 if (NT_SUCCESS(Status))
1094 {
1095 /* Start the service and begin PnP initialization of the device again */
1096 DPRINT1("A new driver will be loaded for '%wZ' (no FDO above)\n", &DeviceNode->InstancePath);
1097 Status = IopActionInitChildServices(DeviceNode, DeviceNode->Parent);
1098 }
1099 }
1100
1101 ObDereferenceObject(DeviceObject);
1102
1103 return Status;
1104 }
1105
1106 /* PUBLIC FUNCTIONS **********************************************************/
1107
1108 /*
1109 * Plug and Play event structure used by NtGetPlugPlayEvent.
1110 *
1111 * EventGuid
1112 * Can be one of the following values:
1113 * GUID_HWPROFILE_QUERY_CHANGE
1114 * GUID_HWPROFILE_CHANGE_CANCELLED
1115 * GUID_HWPROFILE_CHANGE_COMPLETE
1116 * GUID_TARGET_DEVICE_QUERY_REMOVE
1117 * GUID_TARGET_DEVICE_REMOVE_CANCELLED
1118 * GUID_TARGET_DEVICE_REMOVE_COMPLETE
1119 * GUID_PNP_CUSTOM_NOTIFICATION
1120 * GUID_PNP_POWER_NOTIFICATION
1121 * GUID_DEVICE_* (see above)
1122 *
1123 * EventCategory
1124 * Type of the event that happened.
1125 *
1126 * Result
1127 * ?
1128 *
1129 * Flags
1130 * ?
1131 *
1132 * TotalSize
1133 * Size of the event block including the device IDs and other
1134 * per category specific fields.
1135 */
1136
1137 /*
1138 * NtGetPlugPlayEvent
1139 *
1140 * Returns one Plug & Play event from a global queue.
1141 *
1142 * Parameters
1143 * Reserved1
1144 * Reserved2
1145 * Always set to zero.
1146 *
1147 * Buffer
1148 * The buffer that will be filled with the event information on
1149 * successful return from the function.
1150 *
1151 * BufferSize
1152 * Size of the buffer pointed by the Buffer parameter. If the
1153 * buffer size is not large enough to hold the whole event
1154 * information, error STATUS_BUFFER_TOO_SMALL is returned and
1155 * the buffer remains untouched.
1156 *
1157 * Return Values
1158 * STATUS_PRIVILEGE_NOT_HELD
1159 * STATUS_BUFFER_TOO_SMALL
1160 * STATUS_SUCCESS
1161 *
1162 * Remarks
1163 * This function isn't multi-thread safe!
1164 *
1165 * @implemented
1166 */
1167 NTSTATUS
1168 NTAPI
1169 NtGetPlugPlayEvent(IN ULONG Reserved1,
1170 IN ULONG Reserved2,
1171 OUT PPLUGPLAY_EVENT_BLOCK Buffer,
1172 IN ULONG BufferSize)
1173 {
1174 PPNP_EVENT_ENTRY Entry;
1175 NTSTATUS Status;
1176
1177 DPRINT("NtGetPlugPlayEvent() called\n");
1178
1179 /* Function can only be called from user-mode */
1180 if (KeGetPreviousMode() == KernelMode)
1181 {
1182 DPRINT1("NtGetPlugPlayEvent cannot be called from kernel mode!\n");
1183 return STATUS_ACCESS_DENIED;
1184 }
1185
1186 /* Check for Tcb privilege */
1187 if (!SeSinglePrivilegeCheck(SeTcbPrivilege,
1188 UserMode))
1189 {
1190 DPRINT1("NtGetPlugPlayEvent: Caller does not hold the SeTcbPrivilege privilege!\n");
1191 return STATUS_PRIVILEGE_NOT_HELD;
1192 }
1193
1194 /* Wait for a PnP event */
1195 DPRINT("Waiting for pnp notification event\n");
1196 Status = KeWaitForSingleObject(&IopPnpNotifyEvent,
1197 UserRequest,
1198 UserMode,
1199 FALSE,
1200 NULL);
1201 if (!NT_SUCCESS(Status) || Status == STATUS_USER_APC)
1202 {
1203 DPRINT("KeWaitForSingleObject() failed (Status %lx)\n", Status);
1204 ASSERT(Status == STATUS_USER_APC);
1205 return Status;
1206 }
1207
1208 /* Get entry from the tail of the queue */
1209 Entry = CONTAINING_RECORD(IopPnpEventQueueHead.Blink,
1210 PNP_EVENT_ENTRY,
1211 ListEntry);
1212
1213 /* Check the buffer size */
1214 if (BufferSize < Entry->Event.TotalSize)
1215 {
1216 DPRINT1("Buffer is too small for the pnp-event\n");
1217 return STATUS_BUFFER_TOO_SMALL;
1218 }
1219
1220 /* Copy event data to the user buffer */
1221 _SEH2_TRY
1222 {
1223 ProbeForWrite(Buffer,
1224 Entry->Event.TotalSize,
1225 sizeof(UCHAR));
1226 RtlCopyMemory(Buffer,
1227 &Entry->Event,
1228 Entry->Event.TotalSize);
1229 }
1230 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1231 {
1232 _SEH2_YIELD(return _SEH2_GetExceptionCode());
1233 }
1234 _SEH2_END;
1235
1236 DPRINT("NtGetPlugPlayEvent() done\n");
1237
1238 return STATUS_SUCCESS;
1239 }
1240
1241 /*
1242 * NtPlugPlayControl
1243 *
1244 * A function for doing various Plug & Play operations from user mode.
1245 *
1246 * Parameters
1247 * PlugPlayControlClass
1248 * 0x00 Reenumerate device tree
1249 *
1250 * Buffer points to UNICODE_STRING decribing the instance
1251 * path (like "HTREE\ROOT\0" or "Root\ACPI_HAL\0000"). For
1252 * more information about instance paths see !devnode command
1253 * in kernel debugger or look at "Inside Windows 2000" book,
1254 * chapter "Driver Loading, Initialization, and Installation".
1255 *
1256 * 0x01 Register new device
1257 * 0x02 Deregister device
1258 * 0x03 Initialize device
1259 * 0x04 Start device
1260 * 0x06 Query and remove device
1261 * 0x07 User response
1262 *
1263 * Called after processing the message from NtGetPlugPlayEvent.
1264 *
1265 * 0x08 Generate legacy device
1266 * 0x09 Get interface device list
1267 * 0x0A Get property data
1268 * 0x0B Device class association (Registration)
1269 * 0x0C Get related device
1270 * 0x0D Get device interface alias
1271 * 0x0E Get/set/clear device status
1272 * 0x0F Get device depth
1273 * 0x10 Query device relations
1274 * 0x11 Query target device relation
1275 * 0x12 Query conflict list
1276 * 0x13 Retrieve dock data
1277 * 0x14 Reset device
1278 * 0x15 Halt device
1279 * 0x16 Get blocked driver data
1280 *
1281 * Buffer
1282 * The buffer contains information that is specific to each control
1283 * code. The buffer is read-only.
1284 *
1285 * BufferSize
1286 * Size of the buffer pointed by the Buffer parameter. If the
1287 * buffer size specifies incorrect value for specified control
1288 * code, error ??? is returned.
1289 *
1290 * Return Values
1291 * STATUS_PRIVILEGE_NOT_HELD
1292 * STATUS_SUCCESS
1293 * ...
1294 *
1295 * @unimplemented
1296 */
1297 NTSTATUS
1298 NTAPI
1299 NtPlugPlayControl(IN PLUGPLAY_CONTROL_CLASS PlugPlayControlClass,
1300 IN OUT PVOID Buffer,
1301 IN ULONG BufferLength)
1302 {
1303 DPRINT("NtPlugPlayControl(%d %p %lu) called\n",
1304 PlugPlayControlClass, Buffer, BufferLength);
1305
1306 /* Function can only be called from user-mode */
1307 if (KeGetPreviousMode() == KernelMode)
1308 {
1309 DPRINT1("NtGetPlugPlayEvent cannot be called from kernel mode!\n");
1310 return STATUS_ACCESS_DENIED;
1311 }
1312
1313 /* Check for Tcb privilege */
1314 if (!SeSinglePrivilegeCheck(SeTcbPrivilege,
1315 UserMode))
1316 {
1317 DPRINT1("NtGetPlugPlayEvent: Caller does not hold the SeTcbPrivilege privilege!\n");
1318 return STATUS_PRIVILEGE_NOT_HELD;
1319 }
1320
1321 /* Probe the buffer */
1322 _SEH2_TRY
1323 {
1324 ProbeForWrite(Buffer,
1325 BufferLength,
1326 sizeof(ULONG));
1327 }
1328 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1329 {
1330 _SEH2_YIELD(return _SEH2_GetExceptionCode());
1331 }
1332 _SEH2_END;
1333
1334 switch (PlugPlayControlClass)
1335 {
1336 case PlugPlayControlEnumerateDevice:
1337 if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_ENUMERATE_DEVICE_DATA))
1338 return STATUS_INVALID_PARAMETER;
1339 return IopPnpEnumerateDevice((PPLUGPLAY_CONTROL_ENUMERATE_DEVICE_DATA)Buffer);
1340
1341 // case PlugPlayControlRegisterNewDevice:
1342 // case PlugPlayControlDeregisterDevice:
1343 // case PlugPlayControlInitializeDevice:
1344 // case PlugPlayControlStartDevice:
1345 // case PlugPlayControlUnlockDevice:
1346 // case PlugPlayControlQueryAndRemoveDevice:
1347
1348 case PlugPlayControlUserResponse:
1349 if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_USER_RESPONSE_DATA))
1350 return STATUS_INVALID_PARAMETER;
1351 return IopRemovePlugPlayEvent();
1352
1353 // case PlugPlayControlGenerateLegacyDevice:
1354
1355 case PlugPlayControlGetInterfaceDeviceList:
1356 if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA))
1357 return STATUS_INVALID_PARAMETER;
1358 return IopGetInterfaceDeviceList((PPLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA)Buffer);
1359
1360 case PlugPlayControlProperty:
1361 if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_PROPERTY_DATA))
1362 return STATUS_INVALID_PARAMETER;
1363 return IopGetDeviceProperty((PPLUGPLAY_CONTROL_PROPERTY_DATA)Buffer);
1364
1365 // case PlugPlayControlDeviceClassAssociation:
1366
1367 case PlugPlayControlGetRelatedDevice:
1368 if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_RELATED_DEVICE_DATA))
1369 return STATUS_INVALID_PARAMETER;
1370 return IopGetRelatedDevice((PPLUGPLAY_CONTROL_RELATED_DEVICE_DATA)Buffer);
1371
1372 // case PlugPlayControlGetInterfaceDeviceAlias:
1373
1374 case PlugPlayControlDeviceStatus:
1375 if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_STATUS_DATA))
1376 return STATUS_INVALID_PARAMETER;
1377 return IopDeviceStatus((PPLUGPLAY_CONTROL_STATUS_DATA)Buffer);
1378
1379 case PlugPlayControlGetDeviceDepth:
1380 if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_DEPTH_DATA))
1381 return STATUS_INVALID_PARAMETER;
1382 return IopGetDeviceDepth((PPLUGPLAY_CONTROL_DEPTH_DATA)Buffer);
1383
1384 case PlugPlayControlQueryDeviceRelations:
1385 if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_DEVICE_RELATIONS_DATA))
1386 return STATUS_INVALID_PARAMETER;
1387 return IopGetDeviceRelations((PPLUGPLAY_CONTROL_DEVICE_RELATIONS_DATA)Buffer);
1388
1389 // case PlugPlayControlTargetDeviceRelation:
1390 // case PlugPlayControlQueryConflictList:
1391 // case PlugPlayControlRetrieveDock:
1392
1393 case PlugPlayControlResetDevice:
1394 if (!Buffer || BufferLength < sizeof(PLUGPLAY_CONTROL_RESET_DEVICE_DATA))
1395 return STATUS_INVALID_PARAMETER;
1396 return IopResetDevice((PPLUGPLAY_CONTROL_RESET_DEVICE_DATA)Buffer);
1397
1398 // case PlugPlayControlHaltDevice:
1399 // case PlugPlayControlGetBlockedDriverList:
1400
1401 default:
1402 return STATUS_NOT_IMPLEMENTED;
1403 }
1404
1405 return STATUS_NOT_IMPLEMENTED;
1406 }