ReactOS  0.4.15-dev-1389-g828d5fa
plugplay.c
Go to the documentation of this file.
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 typedef struct _PNP_EVENT_ENTRY
16 {
20 
21 
22 /* GLOBALS *******************************************************************/
23 
26 
27 /* FUNCTIONS *****************************************************************/
28 
29 CODE_SEG("INIT")
32 {
34 
37  FALSE);
38 
39  return STATUS_SUCCESS;
40 }
41 
44  PUNICODE_STRING DeviceIds)
45 {
46  PPNP_EVENT_ENTRY EventEntry;
48  ULONG TotalSize;
50 
51  ASSERT(DeviceIds);
52 
53  /* Allocate a big enough buffer */
54  Copy.Length = 0;
55  Copy.MaximumLength = DeviceIds->Length + sizeof(UNICODE_NULL);
56  TotalSize =
58  Copy.MaximumLength;
59 
60  EventEntry = ExAllocatePool(NonPagedPool,
61  TotalSize + FIELD_OFFSET(PNP_EVENT_ENTRY, Event));
62  if (!EventEntry)
64  RtlZeroMemory(EventEntry, TotalSize + FIELD_OFFSET(PNP_EVENT_ENTRY, Event));
65 
66  /* Fill the buffer with the event GUID */
67  RtlCopyMemory(&EventEntry->Event.EventGuid,
68  Guid,
69  sizeof(GUID));
71  EventEntry->Event.TotalSize = TotalSize;
72 
73  /* Fill the device id */
74  Copy.Buffer = EventEntry->Event.TargetDevice.DeviceIds;
76  if (!NT_SUCCESS(Status))
77  {
78  ExFreePool(EventEntry);
79  return Status;
80  }
81 
83  &EventEntry->ListEntry);
85  0,
86  FALSE);
87 
88  return STATUS_SUCCESS;
89 }
90 
91 
92 static PDEVICE_OBJECT
94 {
96  PDEVICE_NODE ChildNode;
97 
98  if (RtlEqualUnicodeString(&Node->InstancePath,
100  {
101  ObReferenceObject(Node->PhysicalDeviceObject);
102  return Node->PhysicalDeviceObject;
103  }
104 
105  /* Traversal of all children nodes */
106  for (ChildNode = Node->Child;
107  ChildNode != NULL;
108  ChildNode = ChildNode->Sibling)
109  {
111  if (DeviceObject != NULL)
112  {
113  return DeviceObject;
114  }
115  }
116 
117  return NULL;
118 }
119 
120 
123 {
124  if (IopRootDeviceNode == NULL)
125  return NULL;
126 
127  if (DeviceInstance == NULL ||
128  DeviceInstance->Length == 0)
129  {
131  {
134  }
135  else
136  return NULL;
137  }
138 
140 }
141 
142 static NTSTATUS
144 {
146  volatile UNICODE_STRING Name;
147 
148  Name.Buffer = NULL;
149  _SEH2_TRY
150  {
151  Name.Length = SrcName->Length;
152  Name.MaximumLength = SrcName->MaximumLength;
153  if (Name.Length > Name.MaximumLength)
154  {
156  _SEH2_LEAVE;
157  }
158 
159  if (Name.MaximumLength)
160  {
161  ProbeForRead(SrcName->Buffer,
162  Name.MaximumLength,
163  sizeof(WCHAR));
164  Name.Buffer = ExAllocatePool(NonPagedPool, Name.MaximumLength);
165  if (Name.Buffer == NULL)
166  {
168  _SEH2_LEAVE;
169  }
170 
171  memcpy(Name.Buffer, SrcName->Buffer, Name.MaximumLength);
172  }
173 
174  *DstName = Name;
175  }
177  {
178  if (Name.Buffer)
179  {
180  ExFreePool(Name.Buffer);
181  }
183  }
184  _SEH2_END;
185 
186  return Status;
187 }
188 
189 static NTSTATUS
191 {
195 
197  if (!NT_SUCCESS(Status))
198  {
199  return Status;
200  }
201 
202  DPRINT("IopPnpEnumerateDevice(%wZ)\n", &DeviceInstance);
203 
204  /* Get the device object */
206  if (DeviceInstance.Buffer != NULL)
207  {
209  }
210  if (DeviceObject == NULL)
211  {
212  return STATUS_NO_SUCH_DEVICE;
213  }
214 
216 
218 
219  return Status;
220 }
221 
222 
223 /*
224  * Remove the current PnP event from the tail of the event queue
225  * and signal IopPnpNotifyEvent if there is yet another event in the queue.
226  */
227 static
228 NTSTATUS
231 {
232  /* Remove a pnp event entry from the tail of the queue */
234  {
236  }
237 
238  /* Signal the next pnp event in the queue */
240  {
242  0,
243  FALSE);
244  }
245 
246  return STATUS_SUCCESS;
247 }
248 
249 
250 static NTSTATUS
252 {
257  GUID FilterGuid;
258  PZZWSTR SymbolicLinkList = NULL, LinkList;
260 
261  _SEH2_TRY
262  {
264 
265  ProbeForRead(StackList.FilterGuid, sizeof(GUID), sizeof(UCHAR));
266  RtlCopyMemory(&FilterGuid, StackList.FilterGuid, sizeof(GUID));
267 
268  if (StackList.Buffer != NULL && StackList.BufferSize != 0)
269  {
270  ProbeForWrite(StackList.Buffer, StackList.BufferSize, sizeof(UCHAR));
271  }
272  }
274  {
276  }
277  _SEH2_END;
278 
280  if (NT_SUCCESS(Status))
281  {
282  /* Get the device object */
284  if (DeviceInstance.Buffer != NULL)
285  {
287  }
288  }
289 
290  Status = IoGetDeviceInterfaces(&FilterGuid, DeviceObject, StackList.Flags, &SymbolicLinkList);
292 
293  if (!NT_SUCCESS(Status))
294  {
295  /* failed */
296  return Status;
297  }
298 
299  LinkList = SymbolicLinkList;
300  while (*SymbolicLinkList != UNICODE_NULL)
301  {
302  SymbolicLinkList += wcslen(SymbolicLinkList) + (sizeof(UNICODE_NULL) / sizeof(WCHAR));
303  }
304  TotalLength = ((SymbolicLinkList - LinkList + 1) * sizeof(WCHAR));
305 
306  _SEH2_TRY
307  {
308  if (StackList.Buffer != NULL &&
309  StackList.BufferSize >= TotalLength)
310  {
311  // We've already probed the buffer for writing above.
312  RtlCopyMemory(StackList.Buffer, LinkList, TotalLength);
313  }
314 
315  DeviceList->BufferSize = TotalLength;
316  }
318  {
319  ExFreePool(LinkList);
321  }
322  _SEH2_END;
323 
324  ExFreePool(LinkList);
325  return STATUS_SUCCESS;
326 }
327 
328 static NTSTATUS
330 {
335  ULONG Property;
337  PVOID Buffer;
339 
340  DPRINT("IopGetDeviceProperty() called\n");
341  DPRINT("Device name: %wZ\n", &PropertyData->DeviceInstance);
342 
344  if (!NT_SUCCESS(Status))
345  {
346  return Status;
347  }
348 
349  _SEH2_TRY
350  {
351  Property = PropertyData->Property;
352  BufferSize = PropertyData->BufferSize;
353  ProbeForWrite(PropertyData->Buffer,
354  BufferSize,
355  sizeof(UCHAR));
356  }
358  {
359  if (DeviceInstance.Buffer != NULL)
360  {
362  }
364  }
365  _SEH2_END;
366 
367  /* Get the device object */
369  if (DeviceInstance.Buffer != NULL)
370  {
372  }
373  if (DeviceObject == NULL)
374  {
375  return STATUS_NO_SUCH_DEVICE;
376  }
377 
379  if (Buffer == NULL)
380  {
383  }
384 
385 
386  DeviceNode = ((PEXTENDED_DEVOBJ_EXTENSION)DeviceObject->DeviceObjectExtension)->DeviceNode;
387 
389  {
390  if (BufferSize < sizeof(CM_POWER_DATA))
391  {
392  BufferSize = 0;
394  }
395  else
396  {
398  PCM_POWER_DATA PowerData;
401 
402  PowerData = (PCM_POWER_DATA)Buffer;
403  RtlZeroMemory(PowerData, sizeof(CM_POWER_DATA));
404  PowerData->PD_Size = sizeof(CM_POWER_DATA);
405 
408  DeviceCapabilities.Version = 1;
409  DeviceCapabilities.Address = -1;
410  DeviceCapabilities.UINumber = -1;
411 
412  Stack.Parameters.DeviceCapabilities.Capabilities = &DeviceCapabilities;
413 
415  &IoStatusBlock,
417  &Stack);
418  if (NT_SUCCESS(Status))
419  {
420  DPRINT("Got device capabiliities\n");
421 
422  PowerData->PD_MostRecentPowerState = PowerDeviceD0; // FIXME
423  if (DeviceCapabilities.DeviceD1)
424  PowerData->PD_Capabilities |= PDCAP_D1_SUPPORTED;
425  if (DeviceCapabilities.DeviceD2)
426  PowerData->PD_Capabilities |= PDCAP_D2_SUPPORTED;
427  if (DeviceCapabilities.WakeFromD0)
429  if (DeviceCapabilities.WakeFromD1)
431  if (DeviceCapabilities.WakeFromD2)
433  if (DeviceCapabilities.WakeFromD3)
435  if (DeviceCapabilities.WarmEjectSupported)
437  PowerData->PD_D1Latency = DeviceCapabilities.D1Latency;
438  PowerData->PD_D2Latency = DeviceCapabilities.D2Latency;
439  PowerData->PD_D3Latency = DeviceCapabilities.D3Latency;
441  &DeviceCapabilities.DeviceState,
442  sizeof(DeviceCapabilities.DeviceState));
443  PowerData->PD_DeepestSystemWake = DeviceCapabilities.SystemWake;
444  }
445  else
446  {
447  DPRINT("IRP_MN_QUERY_CAPABILITIES failed (Status 0x%08lx)\n", Status);
448 
451  }
452  }
453  }
455  {
456  }
458  {
459  if (BufferSize < sizeof(DeviceNode->HardwareRemovalPolicy))
460  {
461  BufferSize = 0;
463  }
464  else
465  {
466  BufferSize = sizeof(DeviceNode->HardwareRemovalPolicy);
468  &DeviceNode->HardwareRemovalPolicy,
469  BufferSize);
470  }
471  }
472  else
473  {
474  switch (Property)
475  {
478  break;
479 
482  break;
483 
486  break;
487 
490  break;
491 
494  break;
495 
498  break;
499 
502  break;
503 
506  break;
507 
510  break;
511 
512 #if (WINVER >= _WIN32_WINNT_WS03)
514  break;
515 #endif
516 
517 #if (WINVER >= _WIN32_WINNT_WIN7)
520  break;
521 #endif
522 
523  default:
524  BufferSize = 0;
526  break;
527  }
528 
529  if (Status == STATUS_SUCCESS)
530  {
533  BufferSize,
534  Buffer,
535  &BufferSize);
536  }
537  }
538 
540 
541  if (NT_SUCCESS(Status))
542  {
543  _SEH2_TRY
544  {
546  PropertyData->BufferSize = BufferSize;
547  }
549  {
551  }
552  _SEH2_END;
553  }
554 
556  return Status;
557 }
558 
559 
560 static NTSTATUS
562 {
563  UNICODE_STRING RootDeviceName;
566  PDEVICE_NODE RelatedDeviceNode;
567  UNICODE_STRING TargetDeviceInstance;
569  ULONG Relation = 0;
570  ULONG MaximumLength = 0;
571 
572  DPRINT("IopGetRelatedDevice() called\n");
573  DPRINT("Device name: %wZ\n", &RelatedDeviceData->TargetDeviceInstance);
574 
575  Status = IopCaptureUnicodeString(&TargetDeviceInstance, &RelatedDeviceData->TargetDeviceInstance);
576  if (!NT_SUCCESS(Status))
577  {
578  return Status;
579  }
580 
581  _SEH2_TRY
582  {
583  Relation = RelatedDeviceData->Relation;
584  MaximumLength = RelatedDeviceData->RelatedDeviceInstanceLength;
585  ProbeForWrite(RelatedDeviceData->RelatedDeviceInstance,
587  sizeof(WCHAR));
588  }
590  {
591  if (TargetDeviceInstance.Buffer != NULL)
592  {
593  ExFreePool(TargetDeviceInstance.Buffer);
594  }
596  }
597  _SEH2_END;
598 
599  RtlInitUnicodeString(&RootDeviceName,
600  L"HTREE\\ROOT\\0");
601  if (RtlEqualUnicodeString(&TargetDeviceInstance,
602  &RootDeviceName,
603  TRUE))
604  {
606  if (TargetDeviceInstance.Buffer != NULL)
607  {
608  ExFreePool(TargetDeviceInstance.Buffer);
609  }
610  }
611  else
612  {
613  /* Get the device object */
614  DeviceObject = IopGetDeviceObjectFromDeviceInstance(&TargetDeviceInstance);
615  if (TargetDeviceInstance.Buffer != NULL)
616  {
617  ExFreePool(TargetDeviceInstance.Buffer);
618  }
619  if (DeviceObject == NULL)
620  return STATUS_NO_SUCH_DEVICE;
621 
622  DeviceNode = ((PEXTENDED_DEVOBJ_EXTENSION)DeviceObject->DeviceObjectExtension)->DeviceNode;
623  }
624 
625  switch (Relation)
626  {
628  RelatedDeviceNode = DeviceNode->Parent;
629  break;
630 
632  RelatedDeviceNode = DeviceNode->Child;
633  break;
634 
636  RelatedDeviceNode = DeviceNode->Sibling;
637  break;
638 
639  default:
640  if (DeviceObject != NULL)
641  {
643  }
644 
646  }
647 
648  if (RelatedDeviceNode == NULL)
649  {
650  if (DeviceObject)
651  {
653  }
654 
655  return STATUS_NO_SUCH_DEVICE;
656  }
657 
658  if (RelatedDeviceNode->InstancePath.Length > MaximumLength)
659  {
660  if (DeviceObject)
661  {
663  }
664 
666  }
667 
668  /* Copy related device instance name */
669  _SEH2_TRY
670  {
671  RtlCopyMemory(RelatedDeviceData->RelatedDeviceInstance,
672  RelatedDeviceNode->InstancePath.Buffer,
673  RelatedDeviceNode->InstancePath.Length);
674  RelatedDeviceData->RelatedDeviceInstanceLength = RelatedDeviceNode->InstancePath.Length;
675  }
677  {
679  }
680  _SEH2_END;
681 
682  if (DeviceObject != NULL)
683  {
685  }
686 
687  DPRINT("IopGetRelatedDevice() done\n");
688 
689  return Status;
690 }
691 
692 static ULONG
694 {
695  ULONG Output = 0;
696 
697  if (DeviceNode->Parent == IopRootDeviceNode)
699 
700  if (DeviceNode->Flags & DNF_ADDED)
702 
703  /* FIXME: DN_ENUM_LOADED */
704 
705  if (DeviceNode->Flags & DNF_STARTED)
706  Output |= DN_STARTED;
707 
708  /* FIXME: Manual */
709 
710  if (!(DeviceNode->Flags & DNF_PROCESSED))
712 
713  /* DN_NOT_FIRST_TIME is 9x only */
714 
715  /* FIXME: DN_HARDWARE_ENUM */
716 
717  /* DN_LIAR and DN_HAS_MARK are 9x only */
718 
719  if (DeviceNode->Problem != 0)
721 
722  /* FIXME: DN_FILTERED */
723 
724  if (DeviceNode->Flags & DNF_LEGACY_DRIVER)
726 
727  if (DeviceNode->UserFlags & DNUF_DONT_SHOW_IN_UI)
729 
730  if (!(DeviceNode->UserFlags & DNUF_NOT_DISABLEABLE))
732 
733  /* FIXME: Implement the rest */
734 
736 
737  return Output;
738 }
739 
740 static NTSTATUS
742 {
745  ULONG Operation = 0;
746  ULONG DeviceStatus = 0;
747  ULONG DeviceProblem = 0;
750 
751  DPRINT("IopDeviceStatus() called\n");
752 
754  if (!NT_SUCCESS(Status))
755  {
756  return Status;
757  }
758 
759  DPRINT("Device name: '%wZ'\n", &DeviceInstance);
760 
761  _SEH2_TRY
762  {
763  Operation = StatusData->Operation;
765  {
766  DeviceStatus = StatusData->DeviceStatus;
767  DeviceProblem = StatusData->DeviceProblem;
768  }
769  }
771  {
772  if (DeviceInstance.Buffer != NULL)
773  {
775  }
777  }
778  _SEH2_END;
779 
780  /* Get the device object */
782  if (DeviceInstance.Buffer != NULL)
783  {
785  }
786  if (DeviceObject == NULL)
787  {
788  return STATUS_NO_SUCH_DEVICE;
789  }
790 
792 
793  switch (Operation)
794  {
796  DPRINT("Get status data\n");
797  DeviceStatus = IopGetDeviceNodeStatus(DeviceNode);
798  DeviceProblem = DeviceNode->Problem;
799  break;
800 
802  DPRINT1("Set status data is NOT SUPPORTED\n");
803  break;
804 
806  DPRINT1("FIXME: Clear status data!\n");
807  break;
808  }
809 
811 
813  {
814  _SEH2_TRY
815  {
816  StatusData->DeviceStatus = DeviceStatus;
817  StatusData->DeviceProblem = DeviceProblem;
818  }
820  {
822  }
823  _SEH2_END;
824  }
825 
826  return Status;
827 }
828 
829 static
830 NTSTATUS
832 {
837  PDEVICE_RELATIONS DeviceRelations = NULL;
838  PDEVICE_OBJECT ChildDeviceObject;
839  PDEVICE_NODE ChildDeviceNode;
840  ULONG i;
841  ULONG Relations;
843  ULONG BufferLeft;
844  PWCHAR Buffer, Ptr;
846 
847  DPRINT("IopGetDeviceRelations() called\n");
848  DPRINT("Device name: %wZ\n", &RelationsData->DeviceInstance);
849  DPRINT("Relations: %lu\n", RelationsData->Relations);
850  DPRINT("BufferSize: %lu\n", RelationsData->BufferSize);
851  DPRINT("Buffer: %p\n", RelationsData->Buffer);
852 
853  _SEH2_TRY
854  {
855  Relations = RelationsData->Relations;
856  BufferSize = RelationsData->BufferSize;
857  Buffer = RelationsData->Buffer;
858 
859  ProbeForWrite(Buffer, BufferSize, sizeof(CHAR));
860  }
862  {
864  }
865  _SEH2_END;
866 
868  if (!NT_SUCCESS(Status))
869  {
870  DPRINT1("IopCaptureUnicodeString() failed (Status 0x%08lx)\n", Status);
871  return Status;
872  }
873 
874  /* Get the device object */
876  if (DeviceObject == NULL)
877  {
878  DPRINT1("IopGetDeviceObjectFromDeviceInstance() returned NULL\n");
880  goto done;
881  }
882 
883  switch (Relations)
884  {
885  case PNP_EJECT_RELATIONS:
886  Stack.Parameters.QueryDeviceRelations.Type = EjectionRelations;
887  break;
888 
890  Stack.Parameters.QueryDeviceRelations.Type = RemovalRelations;
891  break;
892 
893  case PNP_POWER_RELATIONS:
894  Stack.Parameters.QueryDeviceRelations.Type = PowerRelations;
895  break;
896 
897  case PNP_BUS_RELATIONS:
898  Stack.Parameters.QueryDeviceRelations.Type = BusRelations;
899  break;
900 
901  default:
903  goto done;
904  }
905 
907  &IoStatusBlock,
909  &Stack);
910  if (!NT_SUCCESS(Status))
911  {
912  DPRINT1("IopInitiatePnpIrp() failed (Status 0x%08lx)\n", Status);
913  goto done;
914  }
915 
916  DeviceRelations = (PDEVICE_RELATIONS)IoStatusBlock.Information;
917 
918  DPRINT("Found %d device relations\n", DeviceRelations->Count);
919 
920  _SEH2_TRY
921  {
922  RequiredSize = 0;
923  BufferLeft = BufferSize;
924  Ptr = Buffer;
925 
926  for (i = 0; i < DeviceRelations->Count; i++)
927  {
928  ChildDeviceObject = DeviceRelations->Objects[i];
929 
930  ChildDeviceNode = IopGetDeviceNode(ChildDeviceObject);
931  if (ChildDeviceNode)
932  {
933  DPRINT("Device instance: %wZ\n", &ChildDeviceNode->InstancePath);
934  DPRINT("RequiredSize: %hu\n", ChildDeviceNode->InstancePath.Length + sizeof(WCHAR));
935 
936  if (Ptr != NULL)
937  {
938  if (BufferLeft < ChildDeviceNode->InstancePath.Length + 2 * sizeof(WCHAR))
939  {
941  break;
942  }
943 
945  ChildDeviceNode->InstancePath.Buffer,
946  ChildDeviceNode->InstancePath.Length);
947  Ptr = (PWCHAR)((ULONG_PTR)Ptr + ChildDeviceNode->InstancePath.Length);
948  *Ptr = UNICODE_NULL;
949  Ptr = (PWCHAR)((ULONG_PTR)Ptr + sizeof(WCHAR));
950 
951  BufferLeft -= (ChildDeviceNode->InstancePath.Length + sizeof(WCHAR));
952  }
953 
954  RequiredSize += (ChildDeviceNode->InstancePath.Length + sizeof(WCHAR));
955  }
956  }
957 
958  if (Ptr != NULL && BufferLeft >= sizeof(WCHAR))
959  *Ptr = UNICODE_NULL;
960 
961  if (RequiredSize > 0)
962  RequiredSize += sizeof(WCHAR);
963 
964  DPRINT("BufferSize: %lu RequiredSize: %lu\n", RelationsData->BufferSize, RequiredSize);
965 
966  RelationsData->BufferSize = RequiredSize;
967  }
969  {
971  }
972  _SEH2_END;
973 
974 done:
975  if (DeviceRelations != NULL)
976  ExFreePool(DeviceRelations);
977 
978  if (DeviceObject != NULL)
980 
981  if (DeviceInstance.Buffer != NULL)
983 
984  return Status;
985 }
986 
987 static NTSTATUS
989 {
994 
995  DPRINT("IopGetDeviceDepth() called\n");
996  DPRINT("Device name: %wZ\n", &DepthData->DeviceInstance);
997 
999  if (!NT_SUCCESS(Status))
1000  {
1001  return Status;
1002  }
1003 
1004  /* Get the device object */
1006  if (DeviceInstance.Buffer != NULL)
1007  {
1009  }
1010  if (DeviceObject == NULL)
1011  {
1012  return STATUS_NO_SUCH_DEVICE;
1013  }
1014 
1016 
1017  _SEH2_TRY
1018  {
1019  DepthData->Depth = DeviceNode->Level;
1020  }
1022  {
1024  }
1025  _SEH2_END;
1026 
1028 
1029  return Status;
1030 }
1031 
1032 
1033 static NTSTATUS
1035 {
1037  NTSTATUS Status;
1039 
1041  if (!NT_SUCCESS(Status))
1042  {
1043  return Status;
1044  }
1045 
1046  DPRINT("IopResetDevice(%wZ)\n", &DeviceInstance);
1047 
1048  /* Get the device object */
1050  if (DeviceInstance.Buffer != NULL)
1051  {
1053  }
1054  if (DeviceObject == NULL)
1055  {
1056  return STATUS_NO_SUCH_DEVICE;
1057  }
1058 
1060 
1062 
1063  return Status;
1064 }
1065 
1066 /* PUBLIC FUNCTIONS **********************************************************/
1067 
1068 /*
1069  * Plug and Play event structure used by NtGetPlugPlayEvent.
1070  *
1071  * EventGuid
1072  * Can be one of the following values:
1073  * GUID_HWPROFILE_QUERY_CHANGE
1074  * GUID_HWPROFILE_CHANGE_CANCELLED
1075  * GUID_HWPROFILE_CHANGE_COMPLETE
1076  * GUID_TARGET_DEVICE_QUERY_REMOVE
1077  * GUID_TARGET_DEVICE_REMOVE_CANCELLED
1078  * GUID_TARGET_DEVICE_REMOVE_COMPLETE
1079  * GUID_PNP_CUSTOM_NOTIFICATION
1080  * GUID_PNP_POWER_NOTIFICATION
1081  * GUID_DEVICE_* (see above)
1082  *
1083  * EventCategory
1084  * Type of the event that happened.
1085  *
1086  * Result
1087  * ?
1088  *
1089  * Flags
1090  * ?
1091  *
1092  * TotalSize
1093  * Size of the event block including the device IDs and other
1094  * per category specific fields.
1095  */
1096 
1097 /*
1098  * NtGetPlugPlayEvent
1099  *
1100  * Returns one Plug & Play event from a global queue.
1101  *
1102  * Parameters
1103  * Reserved1
1104  * Reserved2
1105  * Always set to zero.
1106  *
1107  * Buffer
1108  * The buffer that will be filled with the event information on
1109  * successful return from the function.
1110  *
1111  * BufferSize
1112  * Size of the buffer pointed by the Buffer parameter. If the
1113  * buffer size is not large enough to hold the whole event
1114  * information, error STATUS_BUFFER_TOO_SMALL is returned and
1115  * the buffer remains untouched.
1116  *
1117  * Return Values
1118  * STATUS_PRIVILEGE_NOT_HELD
1119  * STATUS_BUFFER_TOO_SMALL
1120  * STATUS_SUCCESS
1121  *
1122  * Remarks
1123  * This function isn't multi-thread safe!
1124  *
1125  * @implemented
1126  */
1127 NTSTATUS
1128 NTAPI
1130  IN ULONG Reserved2,
1133 {
1135  NTSTATUS Status;
1136 
1137  DPRINT("NtGetPlugPlayEvent() called\n");
1138 
1139  /* Function can only be called from user-mode */
1140  if (KeGetPreviousMode() == KernelMode)
1141  {
1142  DPRINT1("NtGetPlugPlayEvent cannot be called from kernel mode!\n");
1143  return STATUS_ACCESS_DENIED;
1144  }
1145 
1146  /* Check for Tcb privilege */
1148  UserMode))
1149  {
1150  DPRINT1("NtGetPlugPlayEvent: Caller does not hold the SeTcbPrivilege privilege!\n");
1152  }
1153 
1154  /* Wait for a PnP event */
1155  DPRINT("Waiting for pnp notification event\n");
1157  UserRequest,
1158  UserMode,
1159  FALSE,
1160  NULL);
1162  {
1163  DPRINT("KeWaitForSingleObject() failed (Status %lx)\n", Status);
1165  return Status;
1166  }
1167 
1168  /* Get entry from the tail of the queue */
1171  ListEntry);
1172 
1173  /* Check the buffer size */
1174  if (BufferSize < Entry->Event.TotalSize)
1175  {
1176  DPRINT1("Buffer is too small for the pnp-event\n");
1177  return STATUS_BUFFER_TOO_SMALL;
1178  }
1179 
1180  /* Copy event data to the user buffer */
1181  _SEH2_TRY
1182  {
1184  Entry->Event.TotalSize,
1185  sizeof(UCHAR));
1187  &Entry->Event,
1188  Entry->Event.TotalSize);
1189  }
1191  {
1193  }
1194  _SEH2_END;
1195 
1196  DPRINT("NtGetPlugPlayEvent() done\n");
1197 
1198  return STATUS_SUCCESS;
1199 }
1200 
1201 /*
1202  * NtPlugPlayControl
1203  *
1204  * A function for doing various Plug & Play operations from user mode.
1205  *
1206  * Parameters
1207  * PlugPlayControlClass
1208  * 0x00 Reenumerate device tree
1209  *
1210  * Buffer points to UNICODE_STRING decribing the instance
1211  * path (like "HTREE\ROOT\0" or "Root\ACPI_HAL\0000"). For
1212  * more information about instance paths see !devnode command
1213  * in kernel debugger or look at "Inside Windows 2000" book,
1214  * chapter "Driver Loading, Initialization, and Installation".
1215  *
1216  * 0x01 Register new device
1217  * 0x02 Deregister device
1218  * 0x03 Initialize device
1219  * 0x04 Start device
1220  * 0x06 Query and remove device
1221  * 0x07 User response
1222  *
1223  * Called after processing the message from NtGetPlugPlayEvent.
1224  *
1225  * 0x08 Generate legacy device
1226  * 0x09 Get interface device list
1227  * 0x0A Get property data
1228  * 0x0B Device class association (Registration)
1229  * 0x0C Get related device
1230  * 0x0D Get device interface alias
1231  * 0x0E Get/set/clear device status
1232  * 0x0F Get device depth
1233  * 0x10 Query device relations
1234  * 0x11 Query target device relation
1235  * 0x12 Query conflict list
1236  * 0x13 Retrieve dock data
1237  * 0x14 Reset device
1238  * 0x15 Halt device
1239  * 0x16 Get blocked driver data
1240  *
1241  * Buffer
1242  * The buffer contains information that is specific to each control
1243  * code. The buffer is read-only.
1244  *
1245  * BufferSize
1246  * Size of the buffer pointed by the Buffer parameter. If the
1247  * buffer size specifies incorrect value for specified control
1248  * code, error ??? is returned.
1249  *
1250  * Return Values
1251  * STATUS_PRIVILEGE_NOT_HELD
1252  * STATUS_SUCCESS
1253  * ...
1254  *
1255  * @unimplemented
1256  */
1257 NTSTATUS
1258 NTAPI
1260  IN OUT PVOID Buffer,
1262 {
1263  DPRINT("NtPlugPlayControl(%d %p %lu) called\n",
1264  PlugPlayControlClass, Buffer, BufferLength);
1265 
1266  /* Function can only be called from user-mode */
1267  if (KeGetPreviousMode() == KernelMode)
1268  {
1269  DPRINT1("NtGetPlugPlayEvent cannot be called from kernel mode!\n");
1270  return STATUS_ACCESS_DENIED;
1271  }
1272 
1273  /* Check for Tcb privilege */
1275  UserMode))
1276  {
1277  DPRINT1("NtGetPlugPlayEvent: Caller does not hold the SeTcbPrivilege privilege!\n");
1279  }
1280 
1281  /* Probe the buffer */
1282  _SEH2_TRY
1283  {
1285  BufferLength,
1286  sizeof(ULONG));
1287  }
1289  {
1291  }
1292  _SEH2_END;
1293 
1294  switch (PlugPlayControlClass)
1295  {
1298  return STATUS_INVALID_PARAMETER;
1300 
1301 // case PlugPlayControlRegisterNewDevice:
1302 // case PlugPlayControlDeregisterDevice:
1303 // case PlugPlayControlInitializeDevice:
1304 // case PlugPlayControlStartDevice:
1305 // case PlugPlayControlUnlockDevice:
1306 // case PlugPlayControlQueryAndRemoveDevice:
1307 
1310  return STATUS_INVALID_PARAMETER;
1312 
1313 // case PlugPlayControlGenerateLegacyDevice:
1314 
1317  return STATUS_INVALID_PARAMETER;
1319 
1322  return STATUS_INVALID_PARAMETER;
1324 
1325 // case PlugPlayControlDeviceClassAssociation:
1326 
1329  return STATUS_INVALID_PARAMETER;
1331 
1332 // case PlugPlayControlGetInterfaceDeviceAlias:
1333 
1336  return STATUS_INVALID_PARAMETER;
1338 
1341  return STATUS_INVALID_PARAMETER;
1343 
1346  return STATUS_INVALID_PARAMETER;
1348 
1349 // case PlugPlayControlTargetDeviceRelation:
1350 // case PlugPlayControlQueryConflictList:
1351 // case PlugPlayControlRetrieveDock:
1352 
1355  return STATUS_INVALID_PARAMETER;
1357 
1358 // case PlugPlayControlHaltDevice:
1359 // case PlugPlayControlGetBlockedDriverList:
1360 
1361  default:
1362  return STATUS_NOT_IMPLEMENTED;
1363  }
1364 
1365  return STATUS_NOT_IMPLEMENTED;
1366 }
DEVICE_REGISTRY_PROPERTY
Definition: iotypes.h:1177
static ULONG IopGetDeviceNodeStatus(PDEVICE_NODE DeviceNode)
Definition: plugplay.c:693
#define PNP_PROPERTY_POWER_DATA
Definition: cmtypes.h:39
#define IN
Definition: typedefs.h:39
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG BufferLength
Definition: wdfdevice.h:3767
#define PNP_REMOVAL_RELATIONS
Definition: cmtypes.h:67
#define STATUS_PRIVILEGE_NOT_HELD
Definition: DriverTester.h:9
#define PDCAP_WARM_EJECT_SUPPORTED
Definition: advprop.cpp:44
PDEVICE_OBJECT PhysicalDeviceObject
Definition: iotypes.h:839
PDEVICE_NODE IopRootDeviceNode
Definition: devnode.c:18
#define DNF_PROCESSED
Definition: iotypes.h:167
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
_In_opt_ PDEVICE_OBJECT _In_ ULONG _Outptr_result_nullonfailure_ _At_ * SymbolicLinkList(return==0, __drv_allocatesMem(Mem))) PZZWSTR *SymbolicLinkList
struct _Entry Entry
Definition: kefuncs.h:627
USHORT MaximumLength
Definition: env_spec_w32.h:370
_Must_inspect_result_ __drv_aliasesMem PDEVICE_OBJECT _In_ PDEVICE_OBJECT TargetDevice
Definition: iofuncs.h:688
static NTSTATUS IopGetRelatedDevice(PPLUGPLAY_CONTROL_RELATED_DEVICE_DATA RelatedDeviceData)
Definition: plugplay.c:561
static NTSTATUS IopResetDevice(PPLUGPLAY_CONTROL_RESET_DEVICE_DATA ResetDeviceData)
Definition: plugplay.c:1034
#define DNUF_NOT_DISABLEABLE
Definition: iotypes.h:204
#define PDCAP_D1_SUPPORTED
Definition: advprop.cpp:37
#define PNP_POWER_RELATIONS
Definition: cmtypes.h:68
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
#define DN_ROOT_ENUMERATED
Definition: cfg.h:118
#define TRUE
Definition: types.h:120
Definition: plugplay.c:15
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
struct _LIST_ENTRY * Blink
Definition: typedefs.h:122
FORCEINLINE VOID InsertHeadList(_Inout_ PLIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
Definition: rtlfuncs.h:201
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY DeviceProperty
Definition: wdfdevice.h:3767
PDEVICE_OBJECT Objects[1]
Definition: iotypes.h:2143
#define PNP_GET_SIBLING_DEVICE
Definition: cmtypes.h:54
char CHAR
Definition: xmlstorage.h:175
FORCEINLINE PLIST_ENTRY RemoveTailList(_Inout_ PLIST_ENTRY ListHead)
Definition: rtlfuncs.h:154
_Must_inspect_result_ _In_ PFSRTL_PER_STREAM_CONTEXT Ptr
Definition: fsrtlfuncs.h:898
#define KeGetPreviousMode()
Definition: ketypes.h:1107
LONG NTSTATUS
Definition: precomp.h:26
#define DN_NEED_TO_ENUM
Definition: cfg.h:123
#define DN_DRIVER_LOADED
Definition: cfg.h:119
#define DN_DISABLEABLE
Definition: cfg.h:131
PLUGPLAY_EVENT_BLOCK Event
Definition: plugplay.c:18
NTSTATUS NTAPI IoGetDeviceInterfaces(IN CONST GUID *InterfaceClassGuid, IN PDEVICE_OBJECT PhysicalDeviceObject OPTIONAL, IN ULONG Flags, OUT PWSTR *SymbolicLinkList)
Definition: deviface.c:454
BOOLEAN NTAPI SeSinglePrivilegeCheck(IN LUID PrivilegeValue, IN KPROCESSOR_MODE PreviousMode)
Definition: priv.c:520
#define PNP_SET_DEVICE_STATUS
Definition: cmtypes.h:60
#define PNP_GET_PARENT_DEVICE
Definition: cmtypes.h:52
DEVICE_CAPABILITIES
Definition: iotypes.h:948
struct _EXTENDED_DEVOBJ_EXTENSION * PEXTENDED_DEVOBJ_EXTENSION
#define PNP_BUS_RELATIONS
Definition: cmtypes.h:69
PDEVICE_LIST DeviceList
Definition: utils.c:27
static LIST_ENTRY IopPnpEventQueueHead
Definition: plugplay.c:24
uint16_t * PWCHAR
Definition: typedefs.h:56
struct _PNP_EVENT_ENTRY PNP_EVENT_ENTRY
UNICODE_STRING DeviceInstance
Definition: cmtypes.h:513
_In_ WDFDEVICE _In_ PWDF_DEVICE_INTERFACE_PROPERTY_DATA PropertyData
static NTSTATUS IopGetDeviceRelations(PPLUGPLAY_CONTROL_DEVICE_RELATIONS_DATA RelationsData)
Definition: plugplay.c:831
_NullNull_terminated_ WCHAR * PZZWSTR
Definition: ntbasedef.h:421
_In_ ULONG TotalLength
Definition: usbdlib.h:158
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
static PDEVICE_OBJECT IopTraverseDeviceNode(PDEVICE_NODE Node, PUNICODE_STRING DeviceInstance)
Definition: plugplay.c:93
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
static NTSTATUS IopRemovePlugPlayEvent(_In_ PPLUGPLAY_CONTROL_USER_RESPONSE_DATA ResponseData)
Definition: plugplay.c:229
enum _PLUGPLAY_CONTROL_CLASS PLUGPLAY_CONTROL_CLASS
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
NTSTATUS IopQueueTargetDeviceEvent(const GUID *Guid, PUNICODE_STRING DeviceIds)
Definition: plugplay.c:43
_SEH2_TRY
Definition: create.c:4226
uint32_t ULONG_PTR
Definition: typedefs.h:65
static NTSTATUS IopGetDeviceProperty(PPLUGPLAY_CONTROL_PROPERTY_DATA PropertyData)
Definition: plugplay.c:329
_In_ WDFREQUEST _In_ PIO_STACK_LOCATION Stack
Definition: wdfrequest.h:636
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
return STATUS_NOT_IMPLEMENTED
PLUGPLAY_EVENT_CATEGORY EventCategory
Definition: cmtypes.h:406
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define FALSE
Definition: types.h:117
#define UNICODE_NULL
#define DNUF_DONT_SHOW_IN_UI
Definition: iotypes.h:203
NTSTATUS NTAPI NtGetPlugPlayEvent(IN ULONG Reserved1, IN ULONG Reserved2, OUT PPLUGPLAY_EVENT_BLOCK Buffer, IN ULONG BufferSize)
Definition: plugplay.c:1129
#define PDCAP_D2_SUPPORTED
Definition: advprop.cpp:38
ULONG PD_D2Latency
Definition: advprop.cpp:52
static NTSTATUS IopPnpEnumerateDevice(PPLUGPLAY_CONTROL_ENUMERATE_DEVICE_DATA DeviceData)
Definition: plugplay.c:190
struct NameRec_ * Name
Definition: cdprocs.h:459
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
struct _DEVICE_RELATIONS * PDEVICE_RELATIONS
PDEVICE_OBJECT IopGetDeviceObjectFromDeviceInstance(PUNICODE_STRING DeviceInstance)
Definition: plugplay.c:122
#define PNP_PROPERTY_BUSTYPEGUID
Definition: cmtypes.h:36
#define DeviceCapabilities
Definition: wingdi.h:4448
NTSTATUS NTAPI IoGetDeviceProperty(IN PDEVICE_OBJECT DeviceObject, IN DEVICE_REGISTRY_PROPERTY DeviceProperty, IN ULONG BufferLength, OUT PVOID PropertyBuffer, OUT PULONG ResultLength)
Definition: pnpmgr.c:2096
#define PNP_PROPERTY_REMOVAL_POLICY_HARDWARE_DEFAULT
Definition: cmtypes.h:44
void DPRINT(...)
Definition: polytest.cpp:61
Definition: bufpool.h:45
#define DN_NO_SHOW_IN_DM
Definition: cfg.h:148
#define PDCAP_D3_SUPPORTED
Definition: advprop.cpp:39
static KEVENT IopPnpNotifyEvent
Definition: plugplay.c:25
Definition: bcd.h:202
NTSTATUS IopInitPlugPlayEvents(VOID)
Definition: plugplay.c:31
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
#define PNP_PROPERTY_ADDRESS
Definition: cmtypes.h:42
#define DNF_STARTED
Definition: iotypes.h:168
ULONG PD_D3Latency
Definition: advprop.cpp:53
Status
Definition: gdiplustypes.h:24
#define PNP_PROPERTY_LOCATION_PATHS
Definition: cmtypes.h:46
#define PNP_PROPERTY_ENUMERATOR_NAME
Definition: cmtypes.h:43
_In_ WDFDMATRANSACTION _In_ size_t MaximumLength
#define _SEH2_YIELD(STMT_)
Definition: pseh2_64.h:8
#define ASSERT(a)
Definition: mode.c:45
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define PNP_GET_DEVICE_STATUS
Definition: cmtypes.h:59
#define STATUS_NO_SUCH_DEVICE
Definition: udferr_usr.h:136
_Must_inspect_result_ _In_ WDFOBJECT _In_ CONST GUID * Guid
Definition: wdfobject.h:760
#define PNP_PROPERTY_REMOVAL_POLICY
Definition: cmtypes.h:40
struct _PNP_EVENT_ENTRY * PPNP_EVENT_ENTRY
static NTSTATUS IopDeviceStatus(PPLUGPLAY_CONTROL_STATUS_DATA StatusData)
Definition: plugplay.c:741
#define ObDereferenceObject
Definition: obfuncs.h:203
#define DN_HAS_PROBLEM
Definition: cfg.h:128
#define DN_NT_DRIVER
Definition: cfg.h:142
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
CODE_SEG("INIT")
Definition: fsrtlpc.c:19
#define DN_NT_ENUMERATOR
Definition: cfg.h:141
Definition: Node.h:9
#define PNP_PROPERTY_UI_NUMBER
Definition: cmtypes.h:34
#define PNP_PROPERTY_REMOVAL_POLICY_OVERRIDE
Definition: cmtypes.h:41
unsigned char UCHAR
Definition: xmlstorage.h:181
#define PNP_CLEAR_DEVICE_STATUS
Definition: cmtypes.h:61
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
static const WCHAR L[]
Definition: oid.c:1250
Definition: arc.h:85
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
#define PNP_PROPERTY_PHYSICAL_DEVICE_OBJECT_NAME
Definition: cmtypes.h:35
static NTSTATUS IopCaptureUnicodeString(PUNICODE_STRING DstName, PUNICODE_STRING SrcName)
Definition: plugplay.c:143
#define DNF_LEGACY_DRIVER
Definition: iotypes.h:181
_In_ PNDIS_STRING DeviceInstance
Definition: ndis.h:5202
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
Definition: typedefs.h:119
#define PNP_GET_CHILD_DEVICE
Definition: cmtypes.h:53
static NTSTATUS IopGetDeviceDepth(PPLUGPLAY_CONTROL_DEPTH_DATA DepthData)
Definition: plugplay.c:988
UNICODE_STRING InstancePath
Definition: iotypes.h:842
NTSTATUS PiPerformSyncDeviceAction(_In_ PDEVICE_OBJECT DeviceObject, _In_ DEVICE_ACTION Action)
Perfom a device operation synchronously via PiQueueDeviceAction.
Definition: devaction.c:2533
const LUID SeTcbPrivilege
Definition: priv.c:24
#define PDCAP_WAKE_FROM_D1_SUPPORTED
Definition: advprop.cpp:41
#define STATUS_USER_APC
Definition: ntstatus.h:78
#define _In_
Definition: no_sal2.h:158
_In_ DWORD Property
Definition: setupapi.h:1545
ULONG_PTR SIZE_T
Definition: typedefs.h:80
VOID Copy(PVOID Src, PVOID Dst, ULONG NumBytes)
Definition: mmixer.c:126
SYSTEM_POWER_STATE PD_DeepestSystemWake
Definition: advprop.cpp:55
_SEH2_END
Definition: create.c:4400
NTSTATUS NTAPI NtPlugPlayControl(IN PLUGPLAY_CONTROL_CLASS PlugPlayControlClass, IN OUT PVOID Buffer, IN ULONG BufferLength)
Definition: plugplay.c:1259
LIST_ENTRY ListEntry
Definition: plugplay.c:17
ULONG PD_D1Latency
Definition: advprop.cpp:51
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
struct CM_Power_Data_s CM_POWER_DATA
struct CM_Power_Data_s * PCM_POWER_DATA
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
#define PNP_PROPERTY_LEGACYBUSTYPE
Definition: cmtypes.h:37
#define NULL
Definition: types.h:112
#define IRP_MN_QUERY_DEVICE_RELATIONS
struct _DEVICE_NODE * Sibling
Definition: iotypes.h:823
Definition: bcd.h:201
DEVICE_POWER_STATE PD_PowerStateMapping[PowerSystemMaximum]
Definition: advprop.cpp:54
#define DPRINT1
Definition: precomp.h:8
#define PNP_EJECT_RELATIONS
Definition: cmtypes.h:66
#define DN_LEGACY_DRIVER
Definition: cfg.h:155
#define PNP_PROPERTY_INSTALL_STATE
Definition: cmtypes.h:45
#define DN_STARTED
Definition: cfg.h:121
#define OUT
Definition: typedefs.h:40
#define ObReferenceObject
Definition: obfuncs.h:204
unsigned int ULONG
Definition: retypes.h:1
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define PDCAP_WAKE_FROM_D0_SUPPORTED
Definition: advprop.cpp:40
_In_ FLT_SET_CONTEXT_OPERATION Operation
Definition: fltkernel.h:1468
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define PNP_PROPERTY_BUSNUMBER
Definition: cmtypes.h:38
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
DEVICE_POWER_STATE PD_MostRecentPowerState
Definition: advprop.cpp:49
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ ULONG _Out_ PVOID _Out_ PULONG RequiredSize
Definition: wdfdevice.h:4431
#define STATUS_SUCCESS
Definition: shellext.h:65
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
#define _SEH2_LEAVE
Definition: filesup.c:20
#define PDCAP_WAKE_FROM_D2_SUPPORTED
Definition: advprop.cpp:42
#define PNP_PROPERTY_CONTAINERID
Definition: cmtypes.h:47
struct _PLUGPLAY_EVENT_BLOCK::@2354::@2357 TargetDevice
#define DNF_ADDED
Definition: iotypes.h:179
NTSTATUS NTAPI IopInitiatePnpIrp(IN PDEVICE_OBJECT DeviceObject, IN PIO_STATUS_BLOCK IoStatusBlock, IN UCHAR MinorFunction, IN PIO_STACK_LOCATION Stack)
NTSYSAPI BOOLEAN NTAPI RtlEqualUnicodeString(PUNICODE_STRING String1, PUNICODE_STRING String2, BOOLEAN CaseInSensitive)
static NTSTATUS IopGetInterfaceDeviceList(PPLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA DeviceList)
Definition: plugplay.c:251
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
UNICODE_STRING DeviceInstance
Definition: cmtypes.h:522
#define PDCAP_WAKE_FROM_D3_SUPPORTED
Definition: advprop.cpp:43
base of all file and directory entries
Definition: entries.h:82
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
ULONG PD_Capabilities
Definition: advprop.cpp:50
PDEVICE_NODE FASTCALL IopGetDeviceNode(IN PDEVICE_OBJECT DeviceObject)
#define BufferSize
Definition: mmc.h:75
_In_ WDFMEMORY _Out_opt_ size_t * BufferSize
Definition: wdfmemory.h:251
#define PDCAP_D0_SUPPORTED
Definition: advprop.cpp:36
#define IRP_MN_QUERY_CAPABILITIES
Definition: dlist.c:348