ReactOS 0.4.16-dev-1172-g2041f3c
rpcserver.c
Go to the documentation of this file.
1/*
2 * ReactOS kernel
3 * Copyright (C) 2005 ReactOS Team
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19/*
20 * COPYRIGHT: See COPYING in the top level directory
21 * PROJECT: ReactOS kernel
22 * FILE: base/services/umpnpmgr/rpcserver.c
23 * PURPOSE: RPC server
24 * PROGRAMMER: Eric Kohl (eric.kohl@reactos.org)
25 * Hervé Poussineau (hpoussin@reactos.org)
26 * Colin Finck (colin@reactos.org)
27 */
28
29/* INCLUDES *****************************************************************/
30
31#include "precomp.h"
32
33#define NDEBUG
34#include <debug.h>
35
36
37/* GLOBALS ******************************************************************/
38
39static WCHAR szRootDeviceInstanceID[] = L"HTREE\\ROOT\\0";
41
44
45/* FUNCTIONS *****************************************************************/
46
49{
51 BOOLEAN RegisteredProtSeq = FALSE;
52
53 UNREFERENCED_PARAMETER(lpParameter);
54
55 DPRINT("RpcServerThread() called\n");
56
59
60#if 0
61 /* 2k/XP/2k3-compatible protocol sequence/endpoint */
63 20,
64 L"\\pipe\\ntsvcs",
65 NULL); // Security descriptor
66 if (Status == RPC_S_OK)
67 RegisteredProtSeq = TRUE;
68 else
69 DPRINT1("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
70#endif
71
72 /* Vista/7-compatible protocol sequence/endpoint */
74 20,
75 L"\\pipe\\plugplay",
76 NULL); // Security descriptor
77 if (Status == RPC_S_OK)
78 RegisteredProtSeq = TRUE;
79 else
80 DPRINT1("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
81
82 /* Make sure there's a usable endpoint */
83 if (RegisteredProtSeq == FALSE)
84 return 0;
85
86 Status = RpcServerRegisterIf(pnp_v1_0_s_ifspec,
87 NULL,
88 NULL);
89 if (Status != RPC_S_OK)
90 {
91 DPRINT1("RpcServerRegisterIf() failed (Status %lx)\n", Status);
92 return 0;
93 }
94
96 20,
97 FALSE);
98 if (Status != RPC_S_OK)
99 {
100 DPRINT1("RpcServerListen() failed (Status %lx)\n", Status);
101 return 0;
102 }
103
104 /* ROS HACK (this should never happen...) */
105 DPRINT1("*** Other devices won't be installed correctly. If something\n");
106 DPRINT1("*** doesn't work, try to reboot to get a new chance.\n");
107
108 DPRINT("RpcServerThread() done\n");
109
110 return 0;
111}
112
113
115{
117}
118
119
121{
123}
124
125
126static CONFIGRET WINAPI
128{
129 switch (Status)
130 {
133
135 return CR_INVALID_DATA;
136
138 return CR_NO_SUCH_DEVINST;
139
141 return CR_ACCESS_DENIED;
142
144 return CR_BUFFER_SMALL;
145
147 return CR_NO_SUCH_VALUE;
148
149 default:
150 return CR_FAILURE;
151 }
152}
153
154
155static VOID
156SplitDeviceInstanceID(IN LPWSTR pszDeviceInstanceID,
157 OUT LPWSTR pszEnumerator,
158 OUT LPWSTR pszDevice,
159 OUT LPWSTR pszInstance)
160{
161 WCHAR szLocalDeviceInstanceID[MAX_DEVICE_ID_LEN];
162 LPWSTR lpEnumerator = NULL;
163 LPWSTR lpDevice = NULL;
164 LPWSTR lpInstance = NULL;
165 LPWSTR ptr;
166
167 wcscpy(szLocalDeviceInstanceID, pszDeviceInstanceID);
168
169 *pszEnumerator = 0;
170 *pszDevice = 0;
171 *pszInstance = 0;
172
173 lpEnumerator = szLocalDeviceInstanceID;
174
175 ptr = wcschr(lpEnumerator, L'\\');
176 if (ptr != NULL)
177 {
178 *ptr = 0;
179 lpDevice = ++ptr;
180
181 ptr = wcschr(lpDevice, L'\\');
182 if (ptr != NULL)
183 {
184 *ptr = 0;
185 lpInstance = ++ptr;
186 }
187 }
188
189 if (lpEnumerator != NULL)
190 wcscpy(pszEnumerator, lpEnumerator);
191
192 if (lpDevice != NULL)
193 wcscpy(pszDevice, lpDevice);
194
195 if (lpInstance != NULL)
196 wcscpy(pszInstance, lpInstance);
197}
198
199
200static
203 _In_ LPWSTR pszDeviceID,
204 _In_ DWORD ulStatus,
205 _In_ DWORD ulProblem)
206{
207 PLUGPLAY_CONTROL_STATUS_DATA PlugPlayData;
210
211 DPRINT1("ClearDeviceStatus(%S 0x%lx 0x%lx)\n",
212 pszDeviceID, ulStatus, ulProblem);
213
215 pszDeviceID);
216 PlugPlayData.Operation = PNP_CLEAR_DEVICE_STATUS;
217 PlugPlayData.DeviceStatus = ulStatus;
218 PlugPlayData.DeviceProblem = ulProblem;
219
221 (PVOID)&PlugPlayData,
223 if (!NT_SUCCESS(Status))
225
226 return ret;
227}
228
229
230static
233 _In_ LPWSTR pszDeviceID,
234 _Out_ DWORD *pulStatus,
235 _Out_ DWORD *pulProblem)
236{
237 PLUGPLAY_CONTROL_STATUS_DATA PlugPlayData;
240
241 DPRINT("GetDeviceStatus(%S %p %p)\n",
242 pszDeviceID, pulStatus, pulProblem);
243
245 pszDeviceID);
246 PlugPlayData.Operation = PNP_GET_DEVICE_STATUS;
247
249 (PVOID)&PlugPlayData,
251 if (NT_SUCCESS(Status))
252 {
253 *pulStatus = PlugPlayData.DeviceStatus;
254 *pulProblem = PlugPlayData.DeviceProblem;
255 }
256 else
257 {
259 }
260
261 return ret;
262}
263
264
265static
268 _In_ LPWSTR pszDeviceID,
269 _In_ DWORD ulStatus,
270 _In_ DWORD ulProblem)
271{
272 PLUGPLAY_CONTROL_STATUS_DATA PlugPlayData;
275
276 DPRINT1("SetDeviceStatus(%S 0x%lx 0x%lx)\n",
277 pszDeviceID, ulStatus, ulProblem);
278
280 pszDeviceID);
281 PlugPlayData.Operation = PNP_SET_DEVICE_STATUS;
282 PlugPlayData.DeviceStatus = ulStatus;
283 PlugPlayData.DeviceProblem = ulProblem;
284
286 (PVOID)&PlugPlayData,
288 if (!NT_SUCCESS(Status))
290
291 return ret;
292}
293
294
295static
298 _In_ LPWSTR pszDeviceInstance,
299 _Inout_opt_ PPNP_VETO_TYPE pVetoType,
300 _Inout_opt_ LPWSTR pszVetoName,
301 _In_ DWORD ulNameLength)
302{
306
307 DPRINT1("DisableDeviceInstance(%S %p %p %lu)\n",
308 pszDeviceInstance, pVetoType, pszVetoName, ulNameLength);
309
310 RtlInitUnicodeString(&QueryRemoveData.DeviceInstance,
311 pszDeviceInstance);
312
313 QueryRemoveData.Flags = 0;
314 QueryRemoveData.VetoType = 0;
315 QueryRemoveData.VetoName = pszVetoName;
316 QueryRemoveData.NameLength = ulNameLength;
317
319 &QueryRemoveData,
322 {
324 }
326 {
327 if (pVetoType != NULL)
328 *pVetoType = QueryRemoveData.VetoType;
329
331 }
332 else if (!NT_SUCCESS(Status))
333 {
335 }
336
337 return ret;
338}
339
340
341static
342BOOL
344 _In_ PWSTR pszDeviceInstanceID)
345{
346 INT nPartLength[3] = {0, 0, 0};
347 INT nLength = 0, nParts = 0;
348 PWCHAR p;
349
350 DPRINT("IsValidDeviceInstanceID(%S)\n",
351 pszDeviceInstanceID);
352
353 if (pszDeviceInstanceID == NULL)
354 {
355 DPRINT("Device instance ID is NULL!\n");
356 return FALSE;
357 }
358
359 p = pszDeviceInstanceID;
360 while (*p != UNICODE_NULL)
361 {
362 if (*p == L'\\')
363 {
364 nParts++;
365 if (nParts >= 3)
366 {
367 DPRINT("Too many separators: %d\n", nParts);
368 return FALSE;
369 }
370 }
371 else
372 {
373 nPartLength[nParts]++;
374 }
375
376 nLength++;
378 {
379 DPRINT("Too long: %d\n", nLength);
380 return FALSE;
381 }
382
383 p++;
384 }
385
386 if (nParts != 2)
387 {
388 DPRINT("Invalid number of separtors: %d\n", nParts);
389 return FALSE;
390 }
391
392 if ((nPartLength[0] == 0) ||
393 (nPartLength[1] == 0) ||
394 (nPartLength[2] == 0))
395 {
396 DPRINT("Invalid part lengths: %d %d %d\n",
397 nPartLength[0], nPartLength[1], nPartLength[2]);
398 return FALSE;
399 }
400
401 DPRINT("Valid device instance ID!\n");
402
403 return TRUE;
404}
405
406
407static
408BOOL
410 _In_ PWSTR pszDeviceInstanceID)
411{
412 if (_wcsicmp(pszDeviceInstanceID, szRootDeviceInstanceID) == 0)
413 return TRUE;
414
415 return FALSE;
416}
417
418
419static
420BOOL
422 _In_ LPWSTR pszDeviceInstanceID)
423{
424 DWORD ulStatus, ulProblem;
425
426 return (GetDeviceStatus(pszDeviceInstanceID, &ulStatus, &ulProblem) == CR_SUCCESS);
427}
428
429
430static
433 _In_ LPCWSTR pszDeviceID,
434 _In_ DWORD ulLogConfType,
435 _Out_ PHKEY phKey)
436{
437 WCHAR szKeyName[MAX_PATH];
438 PCWSTR pszSubKeyName;
439 HKEY hInstanceKey;
440 DWORD dwError;
441
442 /* Build the full device instance key name */
443 wcscpy(szKeyName, L"System\\CurrentControlSet\\Enum\\");
444 wcscat(szKeyName, pszDeviceID);
445
446 /* Open the device instance key */
448 szKeyName,
449 0,
451 &hInstanceKey);
452 if (dwError != ERROR_SUCCESS)
453 return CR_INVALID_DEVINST;
454
455 switch (ulLogConfType)
456 {
457 case BOOT_LOG_CONF:
458 case BASIC_LOG_CONF:
459 pszSubKeyName = L"LogConf";
460 break;
461
462 case ALLOC_LOG_CONF:
464 pszSubKeyName = L"Control";
465 break;
466
467 default:
468 DPRINT1("Unsupported configuration type!\n");
469 return CR_FAILURE;
470 }
471
472 /* Create or open the LogConf key */
473 dwError = RegCreateKeyExW(hInstanceKey,
474 pszSubKeyName,
475 0,
476 NULL,
479 NULL,
480 phKey,
481 NULL);
482
483 /* Close the device instance key */
484 RegCloseKey(hInstanceKey);
485
486 if (dwError != ERROR_SUCCESS)
487 return CR_REGISTRY_ERROR;
488
489 return CR_SUCCESS;
490}
491
492
493static
496 _In_ HKEY hKey,
497 _In_ ULONG ulLogConfType,
498 _Out_ PULONG pulRegDataType,
499 _Out_ PULONG pulDataSize,
500 _Out_ LPBYTE *ppBuffer,
501 _In_ ULONG ulValueNameBufferSize,
502 _Out_opt_ LPWSTR pszValueNameBuffer)
503{
504 LPCWSTR pszValueName;
505
506 switch (ulLogConfType)
507 {
508 case BOOT_LOG_CONF:
509 pszValueName = L"BootConfig";
510 *pulRegDataType = REG_RESOURCE_LIST;
511 break;
512
513 case ALLOC_LOG_CONF:
514 pszValueName = L"AllocConfig";
515 *pulRegDataType = REG_RESOURCE_LIST;
516 break;
517
518 case FORCED_LOG_CONF:
519 pszValueName = L"ForcedConfig";
520 *pulRegDataType = REG_RESOURCE_LIST;
521 break;
522
524 pszValueName = L"FilteredConfigVector";
525 *pulRegDataType = REG_RESOURCE_REQUIREMENTS_LIST;
526 break;
527
528 case BASIC_LOG_CONF:
529 pszValueName = L"BasicConfigVector";
530 *pulRegDataType = REG_RESOURCE_REQUIREMENTS_LIST;
531 break;
532
534 pszValueName = L"OverrideConfigVector";
535 *pulRegDataType = REG_RESOURCE_REQUIREMENTS_LIST;
536 break;
537
538 default:
539 DPRINT1("Unsupported configuration type!\n");
540 return CR_FAILURE;
541 }
542
543 /* Return the selected configuration value name */
544 if ((ulValueNameBufferSize > 0) && (pszValueNameBuffer != NULL) &&
545 (wcslen(pszValueName) + 1 <= ulValueNameBufferSize))
546 wcscpy(pszValueNameBuffer, pszValueName);
547
548 /* Get the configuration data size */
550 pszValueName,
551 NULL,
552 NULL,
553 NULL,
554 pulDataSize) != ERROR_SUCCESS)
555 {
556 return CR_INVALID_LOG_CONF;
557 }
558
559 /* Allocate the buffer */
560 *ppBuffer = HeapAlloc(GetProcessHeap(), 0, *pulDataSize);
561 if (*ppBuffer == NULL)
562 {
563 return CR_OUT_OF_MEMORY;
564 }
565
566 /* Retrieve the configuration data */
568 pszValueName,
569 NULL,
570 NULL,
571 (LPBYTE)*ppBuffer,
572 pulDataSize) != ERROR_SUCCESS)
573 {
574 return CR_INVALID_LOG_CONF;
575 }
576
577 return CR_SUCCESS;
578}
579
580
581static
585{
586 PBYTE pNext = NULL;
587 ULONG ulLastIndex = 0;
588
589 if (pDescriptor == NULL)
590 return NULL;
591
592 /* Skip the full resource descriptor */
593 pNext = (LPBYTE)pDescriptor + sizeof(CM_FULL_RESOURCE_DESCRIPTOR);
594
595 /* Skip the partial resource descriptors */
596 pNext += (pDescriptor->PartialResourceList.Count - 1) *
598
599 /* Skip the device specific data, if present */
600 if (pDescriptor->PartialResourceList.Count > 0)
601 {
602 ulLastIndex = pDescriptor->PartialResourceList.Count - 1;
603
604 if (pDescriptor->PartialResourceList.PartialDescriptors[ulLastIndex].Type ==
606 {
607 pNext += pDescriptor->PartialResourceList.PartialDescriptors[ulLastIndex].
608 u.DeviceSpecificData.DataSize;
609 }
610 }
611
612 return (PCM_FULL_RESOURCE_DESCRIPTOR)pNext;
613}
614
615
616static
617BOOL
620{
622 HANDLE hToken;
623 PSID pInteractiveSid = NULL;
624 BOOL bInteractive = FALSE;
625 RPC_STATUS RpcStatus;
626
627 DPRINT("IsCallerInteractive(%p)\n", hBinding);
628
629 /* Allocate an interactive user sid */
631 1,
633 0, 0, 0, 0, 0, 0, 0,
634 &pInteractiveSid))
635 {
636 DPRINT1("AllocateAndInitializeSid failed\n");
637 return FALSE;
638 }
639
640 /* Impersonate the client */
641 RpcStatus = RpcImpersonateClient(hBinding);
642 if (RpcStatus != RPC_S_OK)
643 {
644 DPRINT1("RpcImpersonateClient failed (Status 0x%08lx)\n", RpcStatus);
645 goto done;
646 }
647
648 /* Open the thread token and check for interactive user membership */
650 {
651 CheckTokenMembership(hToken, pInteractiveSid, &bInteractive);
652 CloseHandle(hToken);
653 }
654
655 /* Revert the impersonation */
657
658done:
659 if (pInteractiveSid)
660 FreeSid(pInteractiveSid);
661
662 return bInteractive;
663}
664
665
666VOID
669 PNP_NOTIFY_HANDLE pHandle)
670{
671 DPRINT1("PNP_NOTIFY_HANDLE_rundown(%p)\n", pHandle);
672}
673
674
675/* PUBLIC FUNCTIONS **********************************************************/
676
677/* Function 0 */
678DWORD
679WINAPI
682{
684 return CR_SUCCESS;
685}
686
687
688/* Function 1 */
689DWORD
690WINAPI
693{
695 return CR_SUCCESS;
696}
697
698
699/* Function 2 */
700DWORD
701WINAPI
704 WORD *pVersion)
705{
707
708 DPRINT("PNP_GetVersion(%p %p)\n",
709 hBinding, pVersion);
710
711 *pVersion = CONFIGMG_VERSION;
712
713 return CR_SUCCESS;
714}
715
716
717/* Function 3 */
718DWORD
719WINAPI
722 DWORD *pulState,
723 DWORD ulFlags)
724{
726
727 DPRINT("PNP_GetGlobalState(%p %p 0x%08lx)\n",
728 hBinding, pulState, ulFlags);
729
730 if (ulFlags != 0)
731 return CR_INVALID_FLAG;
732
734
735 if (g_ShuttingDown)
737
738 return CR_SUCCESS;
739}
740
741
742/* Function 4 */
743DWORD
744WINAPI
747{
749
750 DPRINT("PNP_InitDetection(%p)\n",
751 hBinding);
752
753 return CR_SUCCESS;
754}
755
756
757/* Function 5 */
758DWORD
759WINAPI
762 BOOL Admin,
764{
767
769
770 DPRINT("PNP_ReportLogOn(%p %u, %u)\n",
771 hBinding, Admin, ProcessId);
772
773 /* Fail, if the caller is not an interactive user */
775 goto cleanup;
776
777 /* Get the users token */
779
780 if (!hProcess)
781 {
782 DPRINT1("OpenProcess failed with error %u\n", GetLastError());
783 goto cleanup;
784 }
785
786 if (hUserToken)
787 {
790 }
791
793 {
794 DPRINT1("OpenProcessToken failed with error %u\n", GetLastError());
795 goto cleanup;
796 }
797
798 /* Trigger the installer thread */
799 if (hInstallEvent)
801
803
804cleanup:
805 if (hProcess)
807
808 return ReturnValue;
809}
810
811
812/* Function 6 */
813DWORD
814WINAPI
817 LPWSTR pDeviceID,
818 DWORD ulFlags)
819{
821 HKEY hDeviceKey = NULL;
822
824 UNREFERENCED_PARAMETER(ulFlags);
825
826 DPRINT("PNP_ValidateDeviceInstance(%p %S 0x%08lx)\n",
827 hBinding, pDeviceID, ulFlags);
828
829 if (!IsValidDeviceInstanceID(pDeviceID))
830 return CR_INVALID_DEVINST;
831
833 pDeviceID,
834 0,
835 KEY_READ,
836 &hDeviceKey))
837 {
838 DPRINT("Could not open the Device Key!\n");
840 goto Done;
841 }
842
843 /* FIXME: add more tests */
844
845Done:
846 if (hDeviceKey != NULL)
847 RegCloseKey(hDeviceKey);
848
849 DPRINT("PNP_ValidateDeviceInstance() done (returns %lx)\n", ret);
850
851 return ret;
852}
853
854
855/* Function 7 */
856DWORD
857WINAPI
860 LPWSTR pDeviceID,
861 PNP_RPC_STRING_LEN ulLength)
862{
864
866
867 DPRINT("PNP_GetRootDeviceInstance(%p %S %lu)\n",
868 hBinding, pDeviceID, ulLength);
869
870 if (!pDeviceID)
871 {
873 goto Done;
874 }
875
876 if (ulLength < lstrlenW(szRootDeviceInstanceID) + 1)
877 {
879 goto Done;
880 }
881
882 lstrcpyW(pDeviceID,
884
885Done:
886 DPRINT("PNP_GetRootDeviceInstance() done (returns %lx)\n", ret);
887
888 return ret;
889}
890
891
892/* Function 8 */
893DWORD
894WINAPI
897 DWORD ulRelationship,
898 LPWSTR pDeviceID,
899 LPWSTR pRelatedDeviceId,
900 PNP_RPC_STRING_LEN *pulLength,
901 DWORD ulFlags)
902{
906
908 UNREFERENCED_PARAMETER(ulFlags);
909
910 DPRINT("PNP_GetRelatedDeviceInstance(%p %lu %S %p %p 0x%lx)\n",
911 hBinding, ulRelationship, pDeviceID, pRelatedDeviceId,
912 pulLength, ulFlags);
913
914 if (!IsValidDeviceInstanceID(pDeviceID))
915 return CR_INVALID_DEVINST;
916
917 if (ulRelationship == PNP_GET_PARENT_DEVICE_INSTANCE)
918 {
919 /* The root device does not have a parent */
920 if (IsRootDeviceInstanceID(pDeviceID))
921 return CR_NO_SUCH_DEVINST;
922
923 /* Return the root device for non existing devices */
924 if (!IsPresentDeviceInstanceID(pDeviceID))
925 {
926 if ((wcslen(szRootDeviceInstanceID) + 1) > *pulLength)
927 {
928 *pulLength = wcslen(szRootDeviceInstanceID) + 1;
929 return CR_BUFFER_SMALL;
930 }
931
932 wcscpy(pRelatedDeviceId, szRootDeviceInstanceID);
933 *pulLength = wcslen(szRootDeviceInstanceID) + 1;
934 return CR_SUCCESS;
935 }
936 }
937 else if (ulRelationship == PNP_GET_SIBLING_DEVICE_INSTANCE)
938 {
939 /* The root device does not have siblings */
940 if (IsRootDeviceInstanceID(pDeviceID))
941 return CR_NO_SUCH_DEVINST;
942 }
943
945 pDeviceID);
946
947 PlugPlayData.Relation = ulRelationship;
948
949 PlugPlayData.RelatedDeviceInstanceLength = *pulLength;
950 PlugPlayData.RelatedDeviceInstance = pRelatedDeviceId;
951
953 (PVOID)&PlugPlayData,
955 if (!NT_SUCCESS(Status))
956 {
958 }
959
960 DPRINT("PNP_GetRelatedDeviceInstance() done (returns %lx)\n", ret);
961 if (ret == CR_SUCCESS)
962 {
963 DPRINT("RelatedDevice: %wZ\n", &PlugPlayData.RelatedDeviceInstance);
964 }
965
966 return ret;
967}
968
969
970/* Function 9 */
971DWORD
972WINAPI
975 DWORD ulBranch,
976 DWORD ulIndex,
978 PNP_RPC_STRING_LEN ulLength,
979 PNP_RPC_STRING_LEN *pulRequiredLen,
980 DWORD ulFlags)
981{
983 HKEY hKey;
984 DWORD dwError;
985
987 UNREFERENCED_PARAMETER(ulFlags);
988
989 DPRINT("PNP_EnumerateSubKeys(%p %lu %lu %p %lu %p 0x%08lx)\n",
990 hBinding, ulBranch, ulIndex, Buffer, ulLength,
991 pulRequiredLen, ulFlags);
992
993 switch (ulBranch)
994 {
995 case PNP_ENUMERATOR_SUBKEYS:
996 hKey = hEnumKey;
997 break;
998
999 case PNP_CLASS_SUBKEYS:
1000 hKey = hClassKey;
1001 break;
1002
1003 default:
1004 return CR_FAILURE;
1005 }
1006
1007 *pulRequiredLen = ulLength;
1008 dwError = RegEnumKeyExW(hKey,
1009 ulIndex,
1010 Buffer,
1011 pulRequiredLen,
1012 NULL,
1013 NULL,
1014 NULL,
1015 NULL);
1016 if (dwError != ERROR_SUCCESS)
1017 {
1019 }
1020 else
1021 {
1022 (*pulRequiredLen)++;
1023 }
1024
1025 DPRINT("PNP_EnumerateSubKeys() done (returns %lx)\n", ret);
1026
1027 return ret;
1028}
1029
1030
1031static
1034 _In_ PWSTR pszDevice,
1035 _In_ DWORD ulFlags,
1036 _Inout_ PWSTR pszBuffer,
1037 _Inout_ PDWORD pulLength)
1038{
1042
1044 pszDevice);
1045
1047 {
1048 PlugPlayData.Relations = 3;
1049 }
1050 else if (ulFlags & CM_GETIDLIST_FILTER_POWERRELATIONS)
1051 {
1052 PlugPlayData.Relations = 2;
1053 }
1054 else if (ulFlags & CM_GETIDLIST_FILTER_REMOVALRELATIONS)
1055 {
1056 PlugPlayData.Relations = 1;
1057 }
1058 else if (ulFlags & CM_GETIDLIST_FILTER_EJECTRELATIONS)
1059 {
1060 PlugPlayData.Relations = 0;
1061 }
1062
1063 PlugPlayData.BufferSize = *pulLength * sizeof(WCHAR);
1064 PlugPlayData.Buffer = pszBuffer;
1065
1067 (PVOID)&PlugPlayData,
1069 if (NT_SUCCESS(Status))
1070 {
1071 *pulLength = PlugPlayData.BufferSize / sizeof(WCHAR);
1072 }
1073 else
1074 {
1076 }
1077
1078 return ret;
1079}
1080
1081
1082static
1085 _In_ PWSTR pszService,
1086 _Inout_ PWSTR pszBuffer,
1087 _Inout_ PDWORD pulLength)
1088{
1089 WCHAR szPathBuffer[512];
1090 WCHAR szName[16];
1091 HKEY hServicesKey = NULL, hServiceKey = NULL, hEnumKey = NULL;
1092 DWORD dwValues, dwSize, dwIndex, dwUsedLength, dwPathLength;
1093 DWORD dwError;
1094 PWSTR pPtr;
1096
1097 /* Open the device key */
1099 L"System\\CurrentControlSet\\Services",
1100 0,
1101 KEY_READ,
1102 &hServicesKey);
1103 if (dwError != ERROR_SUCCESS)
1104 {
1105 DPRINT("Failed to open the services key (Error %lu)\n", dwError);
1106 return CR_REGISTRY_ERROR;
1107 }
1108
1109 dwError = RegOpenKeyExW(hServicesKey,
1110 pszService,
1111 0,
1112 KEY_READ,
1113 &hServiceKey);
1114 if (dwError != ERROR_SUCCESS)
1115 {
1116 DPRINT("Failed to open the service key (Error %lu)\n", dwError);
1118 goto Done;
1119 }
1120
1121 dwError = RegOpenKeyExW(hServiceKey,
1122 L"Enum",
1123 0,
1124 KEY_READ,
1125 &hEnumKey);
1126 if (dwError != ERROR_SUCCESS)
1127 {
1128 DPRINT("Failed to open the service enum key (Error %lu)\n", dwError);
1130 goto Done;
1131 }
1132
1133 /* Retrieve the number of device instances */
1134 dwSize = sizeof(DWORD);
1135 dwError = RegQueryValueExW(hEnumKey,
1136 L"Count",
1137 NULL,
1138 NULL,
1139 (LPBYTE)&dwValues,
1140 &dwSize);
1141 if (dwError != ERROR_SUCCESS)
1142 {
1143 DPRINT("RegQueryValueExW failed (Error %lu)\n", dwError);
1144 dwValues = 1;
1145 }
1146
1147 DPRINT("dwValues %lu\n", dwValues);
1148
1149 dwUsedLength = 0;
1150 pPtr = pszBuffer;
1151
1152 for (dwIndex = 0; dwIndex < dwValues; dwIndex++)
1153 {
1154 wsprintf(szName, L"%lu", dwIndex);
1155
1156 dwSize = sizeof(szPathBuffer);
1157 dwError = RegQueryValueExW(hEnumKey,
1158 szName,
1159 NULL,
1160 NULL,
1161 (LPBYTE)szPathBuffer,
1162 &dwSize);
1163 if (dwError != ERROR_SUCCESS)
1164 break;
1165
1166 DPRINT("Path: %S\n", szPathBuffer);
1167
1168 dwPathLength = wcslen(szPathBuffer) + 1;
1169 if (dwUsedLength + dwPathLength + 1 > *pulLength)
1170 {
1172 break;
1173 }
1174
1175 wcscpy(pPtr, szPathBuffer);
1176 dwUsedLength += dwPathLength;
1177 pPtr += dwPathLength;
1178
1179 *pPtr = UNICODE_NULL;
1180 }
1181
1182Done:
1183 if (hEnumKey != NULL)
1185
1186 if (hServiceKey != NULL)
1187 RegCloseKey(hServiceKey);
1188
1189 if (hServicesKey != NULL)
1191
1192 if (ret == CR_SUCCESS)
1193 *pulLength = dwUsedLength + 1;
1194 else
1195 *pulLength = 0;
1196
1197 return ret;
1198}
1199
1200
1201static
1204 _In_ PWSTR pszDevice,
1205 _Inout_ PWSTR pszBuffer,
1206 _Inout_ PDWORD pulLength)
1207{
1208 WCHAR szInstanceBuffer[MAX_DEVICE_ID_LEN];
1209 WCHAR szPathBuffer[512];
1210 HKEY hDeviceKey;
1211 DWORD dwInstanceLength, dwPathLength, dwUsedLength;
1212 DWORD dwIndex, dwError;
1213 PWSTR pPtr;
1215
1216 /* Open the device key */
1217 dwError = RegOpenKeyExW(hEnumKey,
1218 pszDevice,
1219 0,
1221 &hDeviceKey);
1222 if (dwError != ERROR_SUCCESS)
1223 {
1224 DPRINT("Failed to open the device key (Error %lu)\n", dwError);
1225 return CR_REGISTRY_ERROR;
1226 }
1227
1228 dwUsedLength = 0;
1229 pPtr = pszBuffer;
1230
1231 for (dwIndex = 0; ; dwIndex++)
1232 {
1233 dwInstanceLength = MAX_DEVICE_ID_LEN;
1234 dwError = RegEnumKeyExW(hDeviceKey,
1235 dwIndex,
1236 szInstanceBuffer,
1237 &dwInstanceLength,
1238 NULL,
1239 NULL,
1240 NULL,
1241 NULL);
1242 if (dwError != ERROR_SUCCESS)
1243 break;
1244
1245 wsprintf(szPathBuffer, L"%s\\%s", pszDevice, szInstanceBuffer);
1246 DPRINT("Path: %S\n", szPathBuffer);
1247
1248 dwPathLength = wcslen(szPathBuffer) + 1;
1249 if (dwUsedLength + dwPathLength + 1 > *pulLength)
1250 {
1252 break;
1253 }
1254
1255 wcscpy(pPtr, szPathBuffer);
1256 dwUsedLength += dwPathLength;
1257 pPtr += dwPathLength;
1258
1259 *pPtr = UNICODE_NULL;
1260 }
1261
1262 RegCloseKey(hDeviceKey);
1263
1264 if (ret == CR_SUCCESS)
1265 *pulLength = dwUsedLength + 1;
1266 else
1267 *pulLength = 0;
1268
1269 return ret;
1270}
1271
1272
1275 _In_ PWSTR pszEnumerator,
1276 _Inout_ PWSTR pszBuffer,
1277 _Inout_ PDWORD pulLength)
1278{
1279 WCHAR szDeviceBuffer[MAX_DEVICE_ID_LEN];
1280 WCHAR szPathBuffer[512];
1281 HKEY hEnumeratorKey;
1282 PWSTR pPtr;
1283 DWORD dwIndex, dwDeviceLength, dwUsedLength, dwRemainingLength, dwPathLength;
1284 DWORD dwError;
1286
1287 /* Open the enumerator key */
1288 dwError = RegOpenKeyExW(hEnumKey,
1289 pszEnumerator,
1290 0,
1292 &hEnumeratorKey);
1293 if (dwError != ERROR_SUCCESS)
1294 {
1295 DPRINT("Failed to open the enumerator key (Error %lu)\n", dwError);
1296 return CR_REGISTRY_ERROR;
1297 }
1298
1299 dwUsedLength = 0;
1300 dwRemainingLength = *pulLength;
1301 pPtr = pszBuffer;
1302
1303 for (dwIndex = 0; ; dwIndex++)
1304 {
1305 dwDeviceLength = MAX_DEVICE_ID_LEN;
1306 dwError = RegEnumKeyExW(hEnumeratorKey,
1307 dwIndex,
1308 szDeviceBuffer,
1309 &dwDeviceLength,
1310 NULL,
1311 NULL,
1312 NULL,
1313 NULL);
1314 if (dwError != ERROR_SUCCESS)
1315 break;
1316
1317 wsprintf(szPathBuffer, L"%s\\%s", pszEnumerator, szDeviceBuffer);
1318 DPRINT("Path: %S\n", szPathBuffer);
1319
1320 dwPathLength = dwRemainingLength;
1321 ret = GetDeviceInstanceList(szPathBuffer,
1322 pPtr,
1323 &dwPathLength);
1324 if (ret != CR_SUCCESS)
1325 break;
1326
1327 dwUsedLength += dwPathLength - 1;
1328 dwRemainingLength -= dwPathLength - 1;
1329 pPtr += dwPathLength - 1;
1330 }
1331
1332 RegCloseKey(hEnumeratorKey);
1333
1334 if (ret == CR_SUCCESS)
1335 *pulLength = dwUsedLength + 1;
1336 else
1337 *pulLength = 0;
1338
1339 return ret;
1340}
1341
1342
1343static
1346 _Inout_ PWSTR pszBuffer,
1347 _Inout_ PDWORD pulLength)
1348{
1349 WCHAR szEnumeratorBuffer[MAX_DEVICE_ID_LEN];
1350 PWSTR pPtr;
1351 DWORD dwIndex, dwEnumeratorLength, dwUsedLength, dwRemainingLength, dwPathLength;
1352 DWORD dwError;
1354
1355 dwUsedLength = 0;
1356 dwRemainingLength = *pulLength;
1357 pPtr = pszBuffer;
1358
1359 for (dwIndex = 0; ; dwIndex++)
1360 {
1361 dwEnumeratorLength = MAX_DEVICE_ID_LEN;
1362 dwError = RegEnumKeyExW(hEnumKey,
1363 dwIndex,
1364 szEnumeratorBuffer,
1365 &dwEnumeratorLength,
1366 NULL, NULL, NULL, NULL);
1367 if (dwError != ERROR_SUCCESS)
1368 break;
1369
1370 dwPathLength = dwRemainingLength;
1371 ret = GetEnumeratorInstanceList(szEnumeratorBuffer,
1372 pPtr,
1373 &dwPathLength);
1374 if (ret != CR_SUCCESS)
1375 break;
1376
1377 dwUsedLength += dwPathLength - 1;
1378 dwRemainingLength -= dwPathLength - 1;
1379 pPtr += dwPathLength - 1;
1380 }
1381
1382 if (ret == CR_SUCCESS)
1383 *pulLength = dwUsedLength + 1;
1384 else
1385 *pulLength = 0;
1386
1387 return ret;
1388}
1389
1390
1391/* Function 10 */
1392DWORD
1393WINAPI
1396 LPWSTR pszFilter,
1397 LPWSTR Buffer,
1398 PNP_RPC_STRING_LEN *pulLength,
1399 DWORD ulFlags)
1400{
1401 WCHAR szEnumerator[MAX_DEVICE_ID_LEN];
1402 WCHAR szDevice[MAX_DEVICE_ID_LEN];
1403 WCHAR szInstance[MAX_DEVICE_ID_LEN];
1405
1406 DPRINT("PNP_GetDeviceList(%p %S %p %p 0x%08lx)\n",
1407 hBinding, pszFilter, Buffer, pulLength, ulFlags);
1408
1409 if (ulFlags & ~CM_GETIDLIST_FILTER_BITS)
1410 return CR_INVALID_FLAG;
1411
1412 if (pulLength == NULL)
1413 return CR_INVALID_POINTER;
1414
1415 if ((ulFlags != CM_GETIDLIST_FILTER_NONE) &&
1416 (pszFilter == NULL))
1417 return CR_INVALID_POINTER;
1418
1419 if (ulFlags &
1424 {
1425 ret = GetRelationsInstanceList(pszFilter,
1426 ulFlags,
1427 Buffer,
1428 pulLength);
1429 }
1430 else if (ulFlags & CM_GETIDLIST_FILTER_SERVICE)
1431 {
1432 ret = GetServiceInstanceList(pszFilter,
1433 Buffer,
1434 pulLength);
1435 }
1436 else if (ulFlags & CM_GETIDLIST_FILTER_ENUMERATOR)
1437 {
1438 SplitDeviceInstanceID(pszFilter,
1439 szEnumerator,
1440 szDevice,
1441 szInstance);
1442
1443 if (*szEnumerator != UNICODE_NULL && *szDevice != UNICODE_NULL)
1444 {
1445 ret = GetDeviceInstanceList(pszFilter,
1446 Buffer,
1447 pulLength);
1448 }
1449 else
1450 {
1451 ret = GetEnumeratorInstanceList(pszFilter,
1452 Buffer,
1453 pulLength);
1454 }
1455 }
1456 else /* CM_GETIDLIST_FILTER_NONE */
1457 {
1459 pulLength);
1460 }
1461
1462 return ret;
1463}
1464
1465
1466static
1469 _In_ PWSTR pszDevice,
1470 _In_ DWORD ulFlags,
1471 _Inout_ PDWORD pulLength)
1472{
1476
1478 pszDevice);
1479
1481 {
1482 PlugPlayData.Relations = 3;
1483 }
1484 else if (ulFlags & CM_GETIDLIST_FILTER_POWERRELATIONS)
1485 {
1486 PlugPlayData.Relations = 2;
1487 }
1488 else if (ulFlags & CM_GETIDLIST_FILTER_REMOVALRELATIONS)
1489 {
1490 PlugPlayData.Relations = 1;
1491 }
1492 else if (ulFlags & CM_GETIDLIST_FILTER_EJECTRELATIONS)
1493 {
1494 PlugPlayData.Relations = 0;
1495 }
1496
1497 PlugPlayData.BufferSize = 0;
1498 PlugPlayData.Buffer = NULL;
1499
1501 (PVOID)&PlugPlayData,
1503 if (NT_SUCCESS(Status))
1504 {
1505 *pulLength = PlugPlayData.BufferSize / sizeof(WCHAR);
1506 }
1507 else
1508 {
1510 }
1511
1512 return ret;
1513}
1514
1515
1516static
1519 _In_ PWSTR pszService,
1520 _Out_ PDWORD pulLength)
1521{
1522 HKEY hServicesKey = NULL, hServiceKey = NULL, hEnumKey = NULL;
1523 DWORD dwValues, dwMaxValueLength, dwSize;
1524 DWORD dwError;
1526
1527 /* Open the device key */
1529 L"System\\CurrentControlSet\\Services",
1530 0,
1531 KEY_READ,
1532 &hServicesKey);
1533 if (dwError != ERROR_SUCCESS)
1534 {
1535 DPRINT("Failed to open the services key (Error %lu)\n", dwError);
1536 return CR_REGISTRY_ERROR;
1537 }
1538
1539 dwError = RegOpenKeyExW(hServicesKey,
1540 pszService,
1541 0,
1542 KEY_READ,
1543 &hServiceKey);
1544 if (dwError != ERROR_SUCCESS)
1545 {
1546 DPRINT("Failed to open the service key (Error %lu)\n", dwError);
1548 goto Done;
1549 }
1550
1551 dwError = RegOpenKeyExW(hServiceKey,
1552 L"Enum",
1553 0,
1554 KEY_READ,
1555 &hEnumKey);
1556 if (dwError != ERROR_SUCCESS)
1557 {
1558 DPRINT("Failed to open the service enum key (Error %lu)\n", dwError);
1560 goto Done;
1561 }
1562
1563 /* Retrieve the number of device instances */
1564 dwSize = sizeof(DWORD);
1565 dwError = RegQueryValueExW(hEnumKey,
1566 L"Count",
1567 NULL,
1568 NULL,
1569 (LPBYTE)&dwValues,
1570 &dwSize);
1571 if (dwError != ERROR_SUCCESS)
1572 {
1573 DPRINT("RegQueryValueExW failed (Error %lu)\n", dwError);
1574 dwValues = 1;
1575 }
1576
1577 /* Retrieve the maximum instance name length */
1578 dwError = RegQueryInfoKeyW(hEnumKey,
1579 NULL,
1580 NULL,
1581 NULL,
1582 NULL,
1583 NULL,
1584 NULL,
1585 NULL,
1586 NULL,
1587 &dwMaxValueLength,
1588 NULL,
1589 NULL);
1590 if (dwError != ERROR_SUCCESS)
1591 {
1592 DPRINT("RegQueryInfoKeyW failed (Error %lu)\n", dwError);
1593 dwMaxValueLength = MAX_DEVICE_ID_LEN;
1594 }
1595
1596 DPRINT("dwValues %lu dwMaxValueLength %lu\n", dwValues, dwMaxValueLength / sizeof(WCHAR));
1597
1598 /* Return the largest possible buffer size */
1599 *pulLength = dwValues * dwMaxValueLength / sizeof(WCHAR) + 2;
1600
1601Done:
1602 if (hEnumKey != NULL)
1604
1605 if (hServiceKey != NULL)
1606 RegCloseKey(hServiceKey);
1607
1608 if (hServicesKey != NULL)
1610
1611 return ret;
1612}
1613
1614
1615static
1618 _In_ LPCWSTR pszDevice,
1619 _Out_ PULONG pulLength)
1620{
1621 HKEY hDeviceKey;
1622 DWORD dwSubKeys, dwMaxSubKeyLength;
1623 DWORD dwError;
1624
1625 /* Open the device key */
1626 dwError = RegOpenKeyExW(hEnumKey,
1627 pszDevice,
1628 0,
1629 KEY_READ,
1630 &hDeviceKey);
1631 if (dwError != ERROR_SUCCESS)
1632 {
1633 DPRINT("Failed to open the device key (Error %lu)\n", dwError);
1634 return CR_REGISTRY_ERROR;
1635 }
1636
1637 /* Retrieve the number of device instances and the maximum name length */
1638 dwError = RegQueryInfoKeyW(hDeviceKey,
1639 NULL,
1640 NULL,
1641 NULL,
1642 &dwSubKeys,
1643 &dwMaxSubKeyLength,
1644 NULL,
1645 NULL,
1646 NULL,
1647 NULL,
1648 NULL,
1649 NULL);
1650 if (dwError != ERROR_SUCCESS)
1651 {
1652 DPRINT("RegQueryInfoKeyW failed (Error %lu)\n", dwError);
1653 dwSubKeys = 0;
1654 dwMaxSubKeyLength = 0;
1655 }
1656
1657 /* Close the device key */
1658 RegCloseKey(hDeviceKey);
1659
1660 /* Return the largest possible buffer size */
1661 *pulLength = dwSubKeys * (wcslen(pszDevice) + 1 + dwMaxSubKeyLength + 1);
1662
1663 return CR_SUCCESS;
1664}
1665
1666
1667static
1670 _In_ LPCWSTR pszEnumerator,
1671 _Out_ PULONG pulLength)
1672{
1673 WCHAR szDeviceBuffer[MAX_DEVICE_ID_LEN];
1674 WCHAR szPathBuffer[512];
1675 HKEY hEnumeratorKey;
1676 DWORD dwIndex, dwDeviceLength, dwBufferLength;
1677 DWORD dwError;
1679
1680 *pulLength = 0;
1681
1682 /* Open the enumerator key */
1683 dwError = RegOpenKeyExW(hEnumKey,
1684 pszEnumerator,
1685 0,
1687 &hEnumeratorKey);
1688 if (dwError != ERROR_SUCCESS)
1689 {
1690 DPRINT("Failed to open the enumerator key (Error %lu)\n", dwError);
1691 return CR_REGISTRY_ERROR;
1692 }
1693
1694 for (dwIndex = 0; ; dwIndex++)
1695 {
1696 dwDeviceLength = MAX_DEVICE_ID_LEN;
1697 dwError = RegEnumKeyExW(hEnumeratorKey,
1698 dwIndex,
1699 szDeviceBuffer,
1700 &dwDeviceLength,
1701 NULL,
1702 NULL,
1703 NULL,
1704 NULL);
1705 if (dwError != ERROR_SUCCESS)
1706 break;
1707
1708 wsprintf(szPathBuffer, L"%s\\%s", pszEnumerator, szDeviceBuffer);
1709 DPRINT("Path: %S\n", szPathBuffer);
1710
1711 ret = GetDeviceInstanceListSize(szPathBuffer, &dwBufferLength);
1712 if (ret != CR_SUCCESS)
1713 {
1714 *pulLength = 0;
1715 break;
1716 }
1717
1718 *pulLength += dwBufferLength;
1719 }
1720
1721 /* Close the enumerator key */
1722 RegCloseKey(hEnumeratorKey);
1723
1724 return ret;
1725}
1726
1727
1728static
1731 _Out_ PULONG pulLength)
1732{
1733 WCHAR szEnumeratorBuffer[MAX_DEVICE_ID_LEN];
1734 DWORD dwIndex, dwEnumeratorLength, dwBufferLength;
1735 DWORD dwError;
1737
1738 for (dwIndex = 0; ; dwIndex++)
1739 {
1740 dwEnumeratorLength = MAX_DEVICE_ID_LEN;
1741 dwError = RegEnumKeyExW(hEnumKey,
1742 dwIndex,
1743 szEnumeratorBuffer,
1744 &dwEnumeratorLength,
1745 NULL, NULL, NULL, NULL);
1746 if (dwError != ERROR_SUCCESS)
1747 break;
1748
1749 /* Get the size of all device instances for the enumerator */
1750 ret = GetEnumeratorInstanceListSize(szEnumeratorBuffer,
1751 &dwBufferLength);
1752 if (ret != CR_SUCCESS)
1753 break;
1754
1755 *pulLength += dwBufferLength;
1756 }
1757
1758 return ret;
1759}
1760
1761
1762/* Function 11 */
1763DWORD
1764WINAPI
1767 LPWSTR pszFilter,
1768 PNP_RPC_BUFFER_SIZE *pulLength,
1769 DWORD ulFlags)
1770{
1771 WCHAR szEnumerator[MAX_DEVICE_ID_LEN];
1772 WCHAR szDevice[MAX_DEVICE_ID_LEN];
1773 WCHAR szInstance[MAX_DEVICE_ID_LEN];
1775
1776 DPRINT("PNP_GetDeviceListSize(%p %S %p 0x%08lx)\n",
1777 hBinding, pszFilter, pulLength, ulFlags);
1778
1779 if (ulFlags & ~CM_GETIDLIST_FILTER_BITS)
1780 return CR_INVALID_FLAG;
1781
1782 if (pulLength == NULL)
1783 return CR_INVALID_POINTER;
1784
1785 if ((ulFlags != CM_GETIDLIST_FILTER_NONE) &&
1786 (pszFilter == NULL))
1787 return CR_INVALID_POINTER;
1788
1789 *pulLength = 0;
1790
1791 if (ulFlags &
1796 {
1798 ulFlags,
1799 pulLength);
1800 }
1801 else if (ulFlags & CM_GETIDLIST_FILTER_SERVICE)
1802 {
1803 ret = GetServiceInstanceListSize(pszFilter,
1804 pulLength);
1805 }
1806 else if (ulFlags & CM_GETIDLIST_FILTER_ENUMERATOR)
1807 {
1808 SplitDeviceInstanceID(pszFilter,
1809 szEnumerator,
1810 szDevice,
1811 szInstance);
1812
1813 if (*szEnumerator != UNICODE_NULL && *szDevice != UNICODE_NULL)
1814 {
1815 ret = GetDeviceInstanceListSize(pszFilter,
1816 pulLength);
1817 }
1818 else
1819 {
1821 pulLength);
1822 }
1823 }
1824 else /* CM_GETIDLIST_FILTER_NONE */
1825 {
1826 ret = GetAllInstanceListSize(pulLength);
1827 }
1828
1829 /* Add one character for the terminating double UNICODE_NULL */
1830 if (ret == CR_SUCCESS)
1831 (*pulLength) += 1;
1832
1833 return ret;
1834}
1835
1836
1837/* Function 12 */
1838DWORD
1839WINAPI
1842 LPWSTR pszDeviceID,
1843 DWORD *pulDepth,
1844 DWORD ulFlags)
1845{
1846 PLUGPLAY_CONTROL_DEPTH_DATA PlugPlayData;
1849
1851 UNREFERENCED_PARAMETER(ulFlags);
1852
1853 DPRINT("PNP_GetDepth(%p %S %p 0x%08lx)\n",
1854 hBinding, pszDeviceID, pulDepth, ulFlags);
1855
1856 if (!IsValidDeviceInstanceID(pszDeviceID))
1857 return CR_INVALID_DEVINST;
1858
1860 pszDeviceID);
1861
1863 (PVOID)&PlugPlayData,
1865 if (NT_SUCCESS(Status))
1866 {
1867 *pulDepth = PlugPlayData.Depth;
1868 }
1869 else
1870 {
1872 }
1873
1874 DPRINT("PNP_GetDepth() done (returns %lx)\n", ret);
1875
1876 return ret;
1877}
1878
1879
1880/* Function 13 */
1881DWORD
1882WINAPI
1885 LPWSTR pDeviceID,
1886 DWORD ulProperty,
1887 DWORD *pulRegDataType,
1888 BYTE *Buffer,
1889 PNP_PROP_SIZE *pulTransferLen,
1890 PNP_PROP_SIZE *pulLength,
1891 DWORD ulFlags)
1892{
1893 PLUGPLAY_CONTROL_PROPERTY_DATA PlugPlayData;
1895 LPWSTR lpValueName = NULL;
1896 HKEY hKey = NULL;
1897 LONG lError;
1899
1901
1902 DPRINT("PNP_GetDeviceRegProp(%p %S %lu %p %p %p %p 0x%08lx)\n",
1903 hBinding, pDeviceID, ulProperty, pulRegDataType, Buffer,
1904 pulTransferLen, pulLength, ulFlags);
1905
1906 if (pulTransferLen == NULL || pulLength == NULL)
1907 {
1909 goto done;
1910 }
1911
1912 if (ulFlags != 0)
1913 {
1915 goto done;
1916 }
1917
1918 /* Check pDeviceID */
1919 if (!IsValidDeviceInstanceID(pDeviceID))
1920 {
1922 goto done;
1923 }
1924
1925 if (*pulLength < *pulTransferLen)
1926 *pulLength = *pulTransferLen;
1927
1928 *pulTransferLen = 0;
1929
1930 switch (ulProperty)
1931 {
1932 case CM_DRP_DEVICEDESC:
1933 lpValueName = L"DeviceDesc";
1934 break;
1935
1936 case CM_DRP_HARDWAREID:
1937 lpValueName = L"HardwareID";
1938 break;
1939
1941 lpValueName = L"CompatibleIDs";
1942 break;
1943
1944 case CM_DRP_SERVICE:
1945 lpValueName = L"Service";
1946 break;
1947
1948 case CM_DRP_CLASS:
1949 lpValueName = L"Class";
1950 break;
1951
1952 case CM_DRP_CLASSGUID:
1953 lpValueName = L"ClassGUID";
1954 break;
1955
1956 case CM_DRP_DRIVER:
1957 lpValueName = L"Driver";
1958 break;
1959
1960 case CM_DRP_CONFIGFLAGS:
1961 lpValueName = L"ConfigFlags";
1962 break;
1963
1964 case CM_DRP_MFG:
1965 lpValueName = L"Mfg";
1966 break;
1967
1969 lpValueName = L"FriendlyName";
1970 break;
1971
1973 lpValueName = L"LocationInformation";
1974 break;
1975
1978 *pulRegDataType = REG_SZ;
1979 break;
1980
1982 lpValueName = L"Capabilities";
1983 break;
1984
1985 case CM_DRP_UI_NUMBER:
1986 PlugPlayData.Property = PNP_PROPERTY_UI_NUMBER;
1987 break;
1988
1990 lpValueName = L"UpperFilters";
1991 break;
1992
1994 lpValueName = L"LowerFilters";
1995 break;
1996
1997 case CM_DRP_BUSTYPEGUID:
1998 PlugPlayData.Property = PNP_PROPERTY_BUSTYPEGUID;
1999 *pulRegDataType = REG_BINARY;
2000 break;
2001
2003 PlugPlayData.Property = PNP_PROPERTY_LEGACYBUSTYPE;
2004 *pulRegDataType = REG_DWORD;
2005 break;
2006
2007 case CM_DRP_BUSNUMBER:
2008 PlugPlayData.Property = PNP_PROPERTY_BUSNUMBER;
2009 *pulRegDataType = REG_DWORD;
2010 break;
2011
2014 *pulRegDataType = REG_SZ;
2015 break;
2016
2017 case CM_DRP_SECURITY:
2018 lpValueName = L"Security";
2019 break;
2020
2021 case CM_DRP_DEVTYPE:
2022 lpValueName = L"DeviceType";
2023 break;
2024
2025 case CM_DRP_EXCLUSIVE:
2026 lpValueName = L"Exclusive";
2027 break;
2028
2030 lpValueName = L"DeviceCharacteristics";
2031 break;
2032
2033 case CM_DRP_ADDRESS:
2034 PlugPlayData.Property = PNP_PROPERTY_ADDRESS;
2035 *pulRegDataType = REG_DWORD;
2036 break;
2037
2039 lpValueName = L"UINumberDescFormat";
2040 break;
2041
2043 PlugPlayData.Property = PNP_PROPERTY_POWER_DATA;
2044 *pulRegDataType = REG_BINARY;
2045 break;
2046
2049 *pulRegDataType = REG_DWORD;
2050 break;
2051
2054 *pulRegDataType = REG_DWORD;
2055 break;
2056
2058 lpValueName = L"RemovalPolicy";
2059 *pulRegDataType = REG_DWORD;
2060 break;
2061
2063 PlugPlayData.Property = PNP_PROPERTY_INSTALL_STATE;
2064 *pulRegDataType = REG_DWORD;
2065 break;
2066
2067#if (WINVER >= _WIN32_WINNT_WS03)
2070 *pulRegDataType = REG_MULTI_SZ;
2071 break;
2072#endif
2073
2074#if (WINVER >= _WIN32_WINNT_WIN7)
2076 PlugPlayData.Property = PNP_PROPERTY_CONTAINERID;
2077 *pulRegDataType = REG_SZ;
2078 break;
2079#endif
2080
2081 default:
2083 goto done;
2084 }
2085
2086 DPRINT("Value name: %S\n", lpValueName);
2087
2088 if (lpValueName)
2089 {
2090 /* Retrieve information from the Registry */
2091 lError = RegOpenKeyExW(hEnumKey,
2092 pDeviceID,
2093 0,
2095 &hKey);
2096 if (lError != ERROR_SUCCESS)
2097 {
2098 hKey = NULL;
2099 *pulLength = 0;
2101 goto done;
2102 }
2103
2104 lError = RegQueryValueExW(hKey,
2105 lpValueName,
2106 NULL,
2107 pulRegDataType,
2108 Buffer,
2109 pulLength);
2110 if (lError != ERROR_SUCCESS)
2111 {
2112 if (lError == ERROR_MORE_DATA)
2113 {
2115 }
2116 else
2117 {
2118 *pulLength = 0;
2120 }
2121 }
2122 }
2123 else
2124 {
2125 /* Retrieve information from the Device Node */
2127 pDeviceID);
2128 PlugPlayData.Buffer = Buffer;
2129 PlugPlayData.BufferSize = *pulLength;
2130
2132 (PVOID)&PlugPlayData,
2134 if (NT_SUCCESS(Status))
2135 {
2136 *pulLength = PlugPlayData.BufferSize;
2137 }
2138 else
2139 {
2141 }
2142 }
2143
2144done:
2145 if (pulTransferLen)
2146 *pulTransferLen = (ret == CR_SUCCESS) ? *pulLength : 0;
2147
2148 if (hKey != NULL)
2150
2151 DPRINT("PNP_GetDeviceRegProp() done (returns %lx)\n", ret);
2152
2153 return ret;
2154}
2155
2156
2157/* Function 14 */
2158DWORD
2159WINAPI
2162 LPWSTR pDeviceId,
2163 DWORD ulProperty,
2164 DWORD ulDataType,
2165 BYTE *Buffer,
2166 PNP_PROP_SIZE ulLength,
2167 DWORD ulFlags)
2168{
2170 LPWSTR lpValueName = NULL;
2171 HKEY hKey = 0;
2172
2174 UNREFERENCED_PARAMETER(ulFlags);
2175
2176 DPRINT("PNP_SetDeviceRegProp(%p %S %lu %lu %p %lu 0x%08lx)\n",
2177 hBinding, pDeviceId, ulProperty, ulDataType, Buffer,
2178 ulLength, ulFlags);
2179
2180 if (!IsValidDeviceInstanceID(pDeviceId))
2181 return CR_INVALID_DEVINST;
2182
2183 switch (ulProperty)
2184 {
2185 case CM_DRP_DEVICEDESC:
2186 lpValueName = L"DeviceDesc";
2187 break;
2188
2189 case CM_DRP_HARDWAREID:
2190 lpValueName = L"HardwareID";
2191 break;
2192
2194 lpValueName = L"CompatibleIDs";
2195 break;
2196
2197 case CM_DRP_SERVICE:
2198 lpValueName = L"Service";
2199 break;
2200
2201 case CM_DRP_CLASS:
2202 lpValueName = L"Class";
2203 break;
2204
2205 case CM_DRP_CLASSGUID:
2206 lpValueName = L"ClassGUID";
2207 break;
2208
2209 case CM_DRP_DRIVER:
2210 lpValueName = L"Driver";
2211 break;
2212
2213 case CM_DRP_CONFIGFLAGS:
2214 lpValueName = L"ConfigFlags";
2215 break;
2216
2217 case CM_DRP_MFG:
2218 lpValueName = L"Mfg";
2219 break;
2220
2222 lpValueName = L"FriendlyName";
2223 break;
2224
2226 lpValueName = L"LocationInformation";
2227 break;
2228
2230 lpValueName = L"UpperFilters";
2231 break;
2232
2234 lpValueName = L"LowerFilters";
2235 break;
2236
2237 case CM_DRP_SECURITY:
2238 lpValueName = L"Security";
2239 break;
2240
2241 case CM_DRP_DEVTYPE:
2242 lpValueName = L"DeviceType";
2243 break;
2244
2245 case CM_DRP_EXCLUSIVE:
2246 lpValueName = L"Exclusive";
2247 break;
2248
2250 lpValueName = L"DeviceCharacteristics";
2251 break;
2252
2254 lpValueName = L"UINumberDescFormat";
2255 break;
2256
2258 lpValueName = L"RemovalPolicy";
2259 break;
2260
2261 default:
2262 return CR_INVALID_PROPERTY;
2263 }
2264
2265 DPRINT("Value name: %S\n", lpValueName);
2266
2268 pDeviceId,
2269 0,
2271 &hKey))
2272 return CR_INVALID_DEVNODE;
2273
2274 if (ulLength == 0)
2275 {
2277 lpValueName))
2279 }
2280 else
2281 {
2282 if (RegSetValueExW(hKey,
2283 lpValueName,
2284 0,
2285 ulDataType,
2286 Buffer,
2287 ulLength))
2289 }
2290
2292
2293 DPRINT("PNP_SetDeviceRegProp() done (returns %lx)\n", ret);
2294
2295 return ret;
2296}
2297
2298
2299/* Function 15 */
2300DWORD
2301WINAPI
2304 LPWSTR pDeviceId,
2305 LPWSTR pszClassInstance,
2306 PNP_RPC_STRING_LEN ulLength)
2307{
2308 WCHAR szClassGuid[40];
2309 WCHAR szClassInstance[5];
2310 HKEY hDeviceClassKey = NULL;
2311 HKEY hClassInstanceKey;
2312 ULONG ulTransferLength, ulDataLength;
2313 DWORD dwDataType, dwDisposition, i;
2314 DWORD dwError;
2316
2317 DPRINT("PNP_GetClassInstance(%p %S %p %lu)\n",
2318 hBinding, pDeviceId, pszClassInstance, ulLength);
2319
2320 if (!IsValidDeviceInstanceID(pDeviceId))
2321 return CR_INVALID_DEVINST;
2322
2323 ulTransferLength = ulLength;
2325 pDeviceId,
2327 &dwDataType,
2328 (BYTE *)pszClassInstance,
2329 &ulTransferLength,
2330 &ulLength,
2331 0);
2332 if (ret == CR_SUCCESS)
2333 return ret;
2334
2335 ulTransferLength = sizeof(szClassGuid);
2336 ulDataLength = sizeof(szClassGuid);
2338 pDeviceId,
2340 &dwDataType,
2341 (BYTE *)szClassGuid,
2342 &ulTransferLength,
2343 &ulDataLength,
2344 0);
2345 if (ret != CR_SUCCESS)
2346 {
2347 DPRINT1("PNP_GetDeviceRegProp() failed (Error %lu)\n", ret);
2348 goto done;
2349 }
2350
2351 dwError = RegOpenKeyExW(hClassKey,
2352 szClassGuid,
2353 0,
2354 KEY_READ,
2355 &hDeviceClassKey);
2356 if (dwError != ERROR_SUCCESS)
2357 {
2358 DPRINT1("RegOpenKeyExW() failed (Error %lu)\n", dwError);
2359 ret = CR_FAILURE;
2360 goto done;
2361 }
2362
2363 for (i = 0; i < 10000; i++)
2364 {
2365 wsprintf(szClassInstance, L"%04lu", i);
2366
2367 dwError = RegCreateKeyExW(hDeviceClassKey,
2368 szClassInstance,
2369 0,
2370 NULL,
2373 NULL,
2374 &hClassInstanceKey,
2375 &dwDisposition);
2376 if (dwError == ERROR_SUCCESS)
2377 {
2378 RegCloseKey(hClassInstanceKey);
2379
2380 if (dwDisposition == REG_CREATED_NEW_KEY)
2381 {
2382 wsprintf(pszClassInstance,
2383 L"%s\\%s",
2384 szClassGuid,
2385 szClassInstance);
2386
2387 ulDataLength = (wcslen(pszClassInstance) + 1) * sizeof(WCHAR);
2389 pDeviceId,
2391 REG_SZ,
2392 (BYTE *)pszClassInstance,
2393 ulDataLength,
2394 0);
2395 if (ret != CR_SUCCESS)
2396 {
2397 DPRINT1("PNP_SetDeviceRegProp() failed (Error %lu)\n", ret);
2398 RegDeleteKeyW(hDeviceClassKey,
2399 szClassInstance);
2400 }
2401
2402 break;
2403 }
2404 }
2405 }
2406
2407done:
2408 if (hDeviceClassKey != NULL)
2409 RegCloseKey(hDeviceClassKey);
2410
2411 return ret;
2412}
2413
2414
2415/* Function 16 */
2416DWORD
2417WINAPI
2420 LPWSTR pszSubKey,
2421 DWORD samDesired,
2422 DWORD ulFlags)
2423{
2424 HKEY hDeviceKey = NULL, hParametersKey = NULL;
2425 DWORD dwError;
2427
2429 UNREFERENCED_PARAMETER(samDesired);
2430
2431 DPRINT("PNP_CreateKey(%p %S 0x%lx 0x%08lx)\n",
2432 hBinding, pszSubKey, samDesired, ulFlags);
2433
2434 if (ulFlags != 0)
2435 return CR_INVALID_FLAG;
2436
2437 if (!IsValidDeviceInstanceID(pszSubKey))
2438 return CR_INVALID_DEVINST;
2439
2440 dwError = RegOpenKeyExW(hEnumKey,
2441 pszSubKey,
2442 0,
2443 KEY_WRITE,
2444 &hDeviceKey);
2445 if (dwError != ERROR_SUCCESS)
2446 {
2448 goto done;
2449 }
2450
2451 dwError = RegCreateKeyExW(hDeviceKey,
2452 L"Device Parameters",
2453 0,
2454 NULL,
2457 NULL,
2458 &hParametersKey,
2459 NULL);
2460 if (dwError != ERROR_SUCCESS)
2461 {
2463 goto done;
2464 }
2465
2466 /* FIXME: Set key security */
2467
2468done:
2469 if (hParametersKey != NULL)
2470 RegCloseKey(hParametersKey);
2471
2472 if (hDeviceKey != NULL)
2473 RegCloseKey(hDeviceKey);
2474
2475 return ret;
2476}
2477
2478
2479/* Function 17 */
2480DWORD
2481WINAPI
2484 LPWSTR pszDeviceID,
2485 LPWSTR pszParentKey,
2486 LPWSTR pszChildKey,
2487 DWORD ulFlags)
2488{
2491}
2492
2493
2494/* Function 18 */
2495DWORD
2496WINAPI
2499 DWORD *pulClassCount,
2500 DWORD ulFlags)
2501{
2502 HKEY hKey;
2503 DWORD dwError;
2504
2506 UNREFERENCED_PARAMETER(ulFlags);
2507
2508 DPRINT("PNP_GetClassCount(%p %p 0x%08lx)\n",
2509 hBinding, pulClassCount, ulFlags);
2510
2513 0,
2515 &hKey);
2516 if (dwError != ERROR_SUCCESS)
2517 return CR_INVALID_DATA;
2518
2519 dwError = RegQueryInfoKeyW(hKey,
2520 NULL,
2521 NULL,
2522 NULL,
2523 pulClassCount,
2524 NULL,
2525 NULL,
2526 NULL,
2527 NULL,
2528 NULL,
2529 NULL,
2530 NULL);
2532 if (dwError != ERROR_SUCCESS)
2533 return CR_INVALID_DATA;
2534
2535 return CR_SUCCESS;
2536}
2537
2538
2539/* Function 19 */
2540DWORD
2541WINAPI
2544 LPWSTR pszClassGuid,
2545 LPWSTR Buffer,
2546 PNP_RPC_STRING_LEN *pulLength,
2547 DWORD ulFlags)
2548{
2549 WCHAR szKeyName[MAX_PATH];
2551 HKEY hKey;
2552 DWORD dwSize;
2553
2555 UNREFERENCED_PARAMETER(ulFlags);
2556
2557 DPRINT("PNP_GetClassName(%p %S %p %p 0x%08lx)\n",
2558 hBinding, pszClassGuid, Buffer, pulLength, ulFlags);
2559
2560 lstrcpyW(szKeyName, L"System\\CurrentControlSet\\Control\\Class\\");
2561 if (lstrlenW(pszClassGuid) + 1 < sizeof(szKeyName)/sizeof(WCHAR)-(lstrlenW(szKeyName) * sizeof(WCHAR)))
2562 lstrcatW(szKeyName, pszClassGuid);
2563 else
2564 return CR_INVALID_DATA;
2565
2567 szKeyName,
2568 0,
2570 &hKey))
2571 return CR_REGISTRY_ERROR;
2572
2573 dwSize = *pulLength * sizeof(WCHAR);
2575 L"Class",
2576 NULL,
2577 NULL,
2578 (LPBYTE)Buffer,
2579 &dwSize))
2580 {
2581 *pulLength = 0;
2583 }
2584 else
2585 {
2586 *pulLength = dwSize / sizeof(WCHAR);
2587 }
2588
2590
2591 DPRINT("PNP_GetClassName() done (returns %lx)\n", ret);
2592
2593 return ret;
2594}
2595
2596
2597/* Function 20 */
2598DWORD
2599WINAPI
2602 LPWSTR pszClassGuid,
2603 DWORD ulFlags)
2604{
2606
2608
2609 DPRINT("PNP_DeleteClassKey(%p %S 0x%08lx)\n",
2610 hBinding, pszClassGuid, ulFlags);
2611
2612 if (ulFlags & CM_DELETE_CLASS_SUBKEYS)
2613 {
2614 if (SHDeleteKeyW(hClassKey, pszClassGuid) != ERROR_SUCCESS)
2616 }
2617 else
2618 {
2619 if (RegDeleteKeyW(hClassKey, pszClassGuid) != ERROR_SUCCESS)
2621 }
2622
2623 DPRINT("PNP_DeleteClassKey() done (returns %lx)\n", ret);
2624
2625 return ret;
2626}
2627
2628
2629/* Function 21 */
2630DWORD
2631WINAPI
2634 LPWSTR pszInterfaceDevice,
2635 GUID *AliasInterfaceGuid,
2636 LPWSTR pszAliasInterfaceDevice,
2637 PNP_RPC_STRING_LEN *pulLength,
2638 PNP_RPC_STRING_LEN *pulTransferLen,
2639 DWORD ulFlags)
2640{
2643}
2644
2645
2646/* Function 22 */
2647DWORD
2648WINAPI
2652 LPWSTR pszDeviceID,
2653 BYTE *Buffer,
2654 PNP_RPC_BUFFER_SIZE *pulLength,
2655 DWORD ulFlags)
2656{
2660
2662
2663 DPRINT("PNP_GetInterfaceDeviceList(%p %p %S %p %p 0x%08lx)\n",
2664 hBinding, InterfaceGuid, pszDeviceID, Buffer, pulLength, ulFlags);
2665
2666 if (!IsValidDeviceInstanceID(pszDeviceID))
2667 return CR_INVALID_DEVINST;
2668
2670 pszDeviceID);
2671
2672 PlugPlayData.Flags = ulFlags;
2673 PlugPlayData.FilterGuid = InterfaceGuid;
2674 PlugPlayData.Buffer = Buffer;
2675 PlugPlayData.BufferSize = *pulLength;
2676
2678 (PVOID)&PlugPlayData,
2680 if (NT_SUCCESS(Status))
2681 {
2682 *pulLength = PlugPlayData.BufferSize;
2683 }
2684 else
2685 {
2687 }
2688
2689 DPRINT("PNP_GetInterfaceDeviceList() done (returns %lx)\n", ret);
2690 return ret;
2691}
2692
2693
2694/* Function 23 */
2695DWORD
2696WINAPI
2699 PNP_RPC_BUFFER_SIZE *pulLen,
2701 LPWSTR pszDeviceID,
2702 DWORD ulFlags)
2703{
2707
2709
2710 DPRINT("PNP_GetInterfaceDeviceListSize(%p %p %p %S 0x%08lx)\n",
2711 hBinding, pulLen, InterfaceGuid, pszDeviceID, ulFlags);
2712
2713 if (!IsValidDeviceInstanceID(pszDeviceID))
2714 return CR_INVALID_DEVINST;
2715
2717 pszDeviceID);
2718
2719 PlugPlayData.FilterGuid = InterfaceGuid;
2720 PlugPlayData.Buffer = NULL;
2721 PlugPlayData.BufferSize = 0;
2722 PlugPlayData.Flags = ulFlags;
2723
2725 (PVOID)&PlugPlayData,
2727 if (NT_SUCCESS(Status))
2728 {
2729 *pulLen = PlugPlayData.BufferSize;
2730 }
2731 else
2732 {
2734 }
2735
2736 DPRINT("PNP_GetInterfaceDeviceListSize() done (returns %lx)\n", ret);
2737 return ret;
2738}
2739
2740
2741/* Function 24 */
2742DWORD
2743WINAPI
2746 LPWSTR pszDeviceID,
2748 LPWSTR pszReference,
2749 LPWSTR pszSymLink,
2750 PNP_RPC_STRING_LEN *pulLength,
2751 PNP_RPC_STRING_LEN *pulTransferLen,
2752 DWORD ulFlags)
2753{
2756}
2757
2758
2759/* Function 25 */
2760DWORD
2761WINAPI
2764 LPWSTR pszInterfaceDevice,
2765 DWORD ulFlags)
2766{
2769}
2770
2771
2772/* Function 26 */
2773DWORD
2774WINAPI
2777 LPWSTR pszClassGuid,
2778 DWORD ulProperty,
2779 DWORD *pulRegDataType,
2780 BYTE *Buffer,
2781 PNP_RPC_STRING_LEN *pulTransferLen,
2782 PNP_RPC_STRING_LEN *pulLength,
2783 DWORD ulFlags)
2784{
2786 LPWSTR lpValueName = NULL;
2787 HKEY hInstKey = NULL;
2788 HKEY hPropKey = NULL;
2789 LONG lError;
2790
2792
2793 DPRINT("PNP_GetClassRegProp(%p %S %lu %p %p %p %p 0x%08lx)\n",
2794 hBinding, pszClassGuid, ulProperty, pulRegDataType,
2795 Buffer, pulTransferLen, pulLength, ulFlags);
2796
2797 if (pulTransferLen == NULL || pulLength == NULL)
2798 {
2800 goto done;
2801 }
2802
2803 if (ulFlags != 0)
2804 {
2806 goto done;
2807 }
2808
2809 if (*pulLength < *pulTransferLen)
2810 *pulLength = *pulTransferLen;
2811
2812 *pulTransferLen = 0;
2813
2814 switch (ulProperty)
2815 {
2816 case CM_CRP_SECURITY:
2817 lpValueName = L"Security";
2818 break;
2819
2820 case CM_CRP_DEVTYPE:
2821 lpValueName = L"DeviceType";
2822 break;
2823
2824 case CM_CRP_EXCLUSIVE:
2825 lpValueName = L"Exclusive";
2826 break;
2827
2829 lpValueName = L"DeviceCharacteristics";
2830 break;
2831
2832 default:
2834 goto done;
2835 }
2836
2837 DPRINT("Value name: %S\n", lpValueName);
2838
2839 lError = RegOpenKeyExW(hClassKey,
2840 pszClassGuid,
2841 0,
2842 KEY_READ,
2843 &hInstKey);
2844 if (lError != ERROR_SUCCESS)
2845 {
2846 *pulLength = 0;
2848 goto done;
2849 }
2850
2851 lError = RegOpenKeyExW(hInstKey,
2852 L"Properties",
2853 0,
2854 KEY_READ,
2855 &hPropKey);
2856 if (lError != ERROR_SUCCESS)
2857 {
2858 *pulLength = 0;
2860 goto done;
2861 }
2862
2863 lError = RegQueryValueExW(hPropKey,
2864 lpValueName,
2865 NULL,
2866 pulRegDataType,
2867 Buffer,
2868 pulLength);
2869 if (lError != ERROR_SUCCESS)
2870 {
2871 if (lError == ERROR_MORE_DATA)
2872 {
2874 }
2875 else
2876 {
2877 *pulLength = 0;
2879 }
2880 }
2881
2882done:
2883 if (ret == CR_SUCCESS)
2884 *pulTransferLen = *pulLength;
2885
2886 if (hPropKey != NULL)
2887 RegCloseKey(hPropKey);
2888
2889 if (hInstKey != NULL)
2890 RegCloseKey(hInstKey);
2891
2892 DPRINT("PNP_GetClassRegProp() done (returns %lx)\n", ret);
2893
2894 return ret;
2895}
2896
2897
2898/* Function 27 */
2899DWORD
2900WINAPI
2903 LPWSTR pszClassGuid,
2904 DWORD ulProperty,
2905 DWORD ulDataType,
2906 BYTE *Buffer,
2907 PNP_PROP_SIZE ulLength,
2908 DWORD ulFlags)
2909{
2911 LPWSTR lpValueName = NULL;
2912 HKEY hInstKey = 0;
2913 HKEY hPropKey = 0;
2914 LONG lError;
2915
2917
2918 DPRINT("PNP_SetClassRegProp(%p %S %lu %lu %p %lu 0x%08lx)\n",
2919 hBinding, pszClassGuid, ulProperty, ulDataType,
2920 Buffer, ulLength, ulFlags);
2921
2922 if (ulFlags != 0)
2923 return CR_INVALID_FLAG;
2924
2925 switch (ulProperty)
2926 {
2927 case CM_CRP_SECURITY:
2928 lpValueName = L"Security";
2929 break;
2930
2931 case CM_CRP_DEVTYPE:
2932 lpValueName = L"DeviceType";
2933 break;
2934
2935 case CM_CRP_EXCLUSIVE:
2936 lpValueName = L"Exclusive";
2937 break;
2938
2940 lpValueName = L"DeviceCharacteristics";
2941 break;
2942
2943 default:
2944 return CR_INVALID_PROPERTY;
2945 }
2946
2947 lError = RegOpenKeyExW(hClassKey,
2948 pszClassGuid,
2949 0,
2950 KEY_WRITE,
2951 &hInstKey);
2952 if (lError != ERROR_SUCCESS)
2953 {
2955 goto done;
2956 }
2957
2958 /* FIXME: Set security descriptor */
2959 lError = RegCreateKeyExW(hInstKey,
2960 L"Properties",
2961 0,
2962 NULL,
2965 NULL,
2966 &hPropKey,
2967 NULL);
2968 if (lError != ERROR_SUCCESS)
2969 {
2971 goto done;
2972 }
2973
2974 if (ulLength == 0)
2975 {
2976 if (RegDeleteValueW(hPropKey,
2977 lpValueName))
2979 }
2980 else
2981 {
2982 if (RegSetValueExW(hPropKey,
2983 lpValueName,
2984 0,
2985 ulDataType,
2986 Buffer,
2987 ulLength))
2989 }
2990
2991done:
2992 if (hPropKey != NULL)
2993 RegCloseKey(hPropKey);
2994
2995 if (hInstKey != NULL)
2996 RegCloseKey(hInstKey);
2997
2998 return ret;
2999}
3000
3001
3002static
3005 _In_ LPWSTR pszDeviceID,
3006 _In_ BOOL bPhantomDevice)
3007{
3008 WCHAR szEnumerator[MAX_DEVICE_ID_LEN];
3009 WCHAR szDevice[MAX_DEVICE_ID_LEN];
3010 WCHAR szInstance[MAX_DEVICE_ID_LEN];
3011 HKEY hKeyEnumerator;
3012 HKEY hKeyDevice;
3013 HKEY hKeyInstance;
3014 HKEY hKeyControl;
3015 LONG lError;
3016
3017 /* Split the instance ID */
3018 SplitDeviceInstanceID(pszDeviceID,
3019 szEnumerator,
3020 szDevice,
3021 szInstance);
3022
3023 /* Open or create the enumerator key */
3024 lError = RegCreateKeyExW(hEnumKey,
3025 szEnumerator,
3026 0,
3027 NULL,
3030 NULL,
3031 &hKeyEnumerator,
3032 NULL);
3033 if (lError != ERROR_SUCCESS)
3034 {
3035 return CR_REGISTRY_ERROR;
3036 }
3037
3038 /* Open or create the device key */
3039 lError = RegCreateKeyExW(hKeyEnumerator,
3040 szDevice,
3041 0,
3042 NULL,
3045 NULL,
3046 &hKeyDevice,
3047 NULL);
3048
3049 /* Close the enumerator key */
3050 RegCloseKey(hKeyEnumerator);
3051
3052 if (lError != ERROR_SUCCESS)
3053 {
3054 return CR_REGISTRY_ERROR;
3055 }
3056
3057 /* Try to open the instance key and fail if it exists */
3058 lError = RegOpenKeyExW(hKeyDevice,
3059 szInstance,
3060 0,
3062 &hKeyInstance);
3063 if (lError == ERROR_SUCCESS)
3064 {
3065 DPRINT1("Instance %S already exists!\n", szInstance);
3066 RegCloseKey(hKeyInstance);
3067 RegCloseKey(hKeyDevice);
3069 }
3070
3071 /* Create a new instance key */
3072 lError = RegCreateKeyExW(hKeyDevice,
3073 szInstance,
3074 0,
3075 NULL,
3078 NULL,
3079 &hKeyInstance,
3080 NULL);
3081
3082 /* Close the device key */
3083 RegCloseKey(hKeyDevice);
3084
3085 if (lError != ERROR_SUCCESS)
3086 {
3087 return CR_REGISTRY_ERROR;
3088 }
3089
3090 if (bPhantomDevice)
3091 {
3092 DWORD dwPhantomValue = 1;
3093 RegSetValueExW(hKeyInstance,
3094 L"Phantom",
3095 0,
3096 REG_DWORD,
3097 (PBYTE)&dwPhantomValue,
3098 sizeof(dwPhantomValue));
3099 }
3100
3101 /* Create the 'Control' sub key */
3102 lError = RegCreateKeyExW(hKeyInstance,
3103 L"Control",
3104 0,
3105 NULL,
3108 NULL,
3109 &hKeyControl,
3110 NULL);
3111 if (lError == ERROR_SUCCESS)
3112 {
3113 RegCloseKey(hKeyControl);
3114 }
3115
3116 RegCloseKey(hKeyInstance);
3117
3118 return (lError == ERROR_SUCCESS) ? CR_SUCCESS : CR_REGISTRY_ERROR;
3119}
3120
3121
3122static
3125 _Inout_ LPWSTR pszDeviceID,
3126 _In_ PNP_RPC_STRING_LEN ulLength)
3127{
3128 WCHAR szGeneratedInstance[MAX_DEVICE_ID_LEN];
3129 HKEY hKey;
3130 DWORD dwInstanceNumber;
3131 DWORD dwError = ERROR_SUCCESS;
3133
3134 /* Fail, if the device name contains backslashes */
3135 if (wcschr(pszDeviceID, L'\\') != NULL)
3136 return CR_INVALID_DEVICE_ID;
3137
3138 /* Generated ID is: Root<Device ID><Instance number> */
3139 dwInstanceNumber = 0;
3140 while (dwError == ERROR_SUCCESS)
3141 {
3142 if (dwInstanceNumber >= 10000)
3143 return CR_FAILURE;
3144
3145 swprintf(szGeneratedInstance, L"Root\\%ls\\%04lu",
3146 pszDeviceID, dwInstanceNumber);
3147
3148 /* Try to open the enum key of the device instance */
3149 dwError = RegOpenKeyEx(hEnumKey, szGeneratedInstance, 0, KEY_QUERY_VALUE, &hKey);
3150 if (dwError == ERROR_SUCCESS)
3151 {
3153 dwInstanceNumber++;
3154 }
3155 }
3156
3157 /* pszDeviceID is an out parameter too for generated IDs */
3158 if (wcslen(szGeneratedInstance) > ulLength)
3159 {
3161 }
3162 else
3163 {
3164 wcscpy(pszDeviceID, szGeneratedInstance);
3165 }
3166
3167 return ret;
3168}
3169
3170
3171/* Function 28 */
3172DWORD
3173WINAPI
3176 LPWSTR pszDeviceID,
3177 LPWSTR pszParentDeviceID,
3178 PNP_RPC_STRING_LEN ulLength,
3179 DWORD ulFlags)
3180{
3182 HKEY hKey = NULL;
3183 DWORD dwSize, dwPhantom;
3186
3187 DPRINT("PNP_CreateDevInst(%p %S %S %lu 0x%08lx)\n",
3188 hBinding, pszParentDeviceID, pszDeviceID, ulLength, ulFlags);
3189
3190 if (ulFlags & ~CM_CREATE_DEVNODE_BITS)
3191 return CR_INVALID_FLAG;
3192
3193 if (pszDeviceID == NULL || pszParentDeviceID == NULL)
3194 return CR_INVALID_POINTER;
3195
3196 /* Fail, if the parent device is not the root device */
3197 if (!IsRootDeviceInstanceID(pszParentDeviceID))
3198 return CR_INVALID_DEVINST;
3199
3200 if (ulFlags & CM_CREATE_DEVNODE_GENERATE_ID)
3201 {
3202 ret = GenerateDeviceID(pszDeviceID,
3203 ulLength);
3204 if (ret != CR_SUCCESS)
3205 return ret;
3206 }
3207
3208 /* Try to open the device instance key */
3209 RegOpenKeyEx(hEnumKey, pszDeviceID, 0, KEY_READ | KEY_WRITE, &hKey);
3210
3211 if (ulFlags & CM_CREATE_DEVNODE_PHANTOM)
3212 {
3213 /* Fail, if the device already exists */
3214 if (hKey != NULL)
3215 {
3217 goto done;
3218 }
3219
3220 /* Create the phantom device instance */
3221 ret = CreateDeviceInstance(pszDeviceID, TRUE);
3222 }
3223 else
3224 {
3225 /* Fail, if the device exists and is present */
3226 if ((hKey != NULL) && (IsPresentDeviceInstanceID(pszDeviceID)))
3227 {
3229 goto done;
3230 }
3231
3232 /* If it does not already exist ... */
3233 if (hKey == NULL)
3234 {
3235 /* Create the device instance */
3236 ret = CreateDeviceInstance(pszDeviceID, FALSE);
3237
3238 /* Open the device instance key */
3239 RegOpenKeyEx(hEnumKey, pszDeviceID, 0, KEY_READ | KEY_WRITE, &hKey);
3240 }
3241
3242 /* Create a device node for the device */
3243 RtlInitUnicodeString(&ControlData.DeviceInstance, pszDeviceID);
3245 &ControlData,
3246 sizeof(ControlData));
3247 if (!NT_SUCCESS(Status))
3248 {
3249 ret = CR_FAILURE;
3250 goto done;
3251 }
3252
3253 /* If the device is a phantom device, turn it into a normal device */
3254 if (hKey != NULL)
3255 {
3256 dwPhantom = 0;
3257 dwSize = sizeof(DWORD);
3258 RegQueryValueEx(hKey, L"Phantom", NULL, NULL, (PBYTE)&dwPhantom, &dwSize);
3259
3260 if (dwPhantom != 0)
3261 RegDeleteValue(hKey, L"Phantom");
3262 }
3263 }
3264
3265done:
3266 if (hKey)
3268
3269 DPRINT("PNP_CreateDevInst() done (returns %lx)\n", ret);
3270
3271 return ret;
3272}
3273
3274
3275static CONFIGRET
3277 _In_ LPWSTR pszDeviceInstance,
3278 _In_ DWORD ulMinorAction)
3279{
3281 HKEY hDeviceKey = NULL;
3282 DWORD dwDisableCount, dwSize;
3283 DWORD ulStatus, ulProblem;
3284 DWORD dwError;
3287
3288 DPRINT1("SetupDeviceInstance(%S 0x%08lx)\n",
3289 pszDeviceInstance, ulMinorAction);
3290
3291 if (IsRootDeviceInstanceID(pszDeviceInstance))
3292 return CR_INVALID_DEVINST;
3293
3294 if (ulMinorAction & ~CM_SETUP_BITS)
3295 return CR_INVALID_FLAG;
3296
3297 if ((ulMinorAction == CM_SETUP_DOWNLOAD) ||
3298 (ulMinorAction == CM_SETUP_WRITE_LOG_CONFS))
3299 return CR_SUCCESS;
3300
3301 dwError = RegOpenKeyExW(hEnumKey,
3302 pszDeviceInstance,
3303 0,
3304 KEY_READ,
3305 &hDeviceKey);
3306 if (dwError != ERROR_SUCCESS)
3307 return CR_INVALID_DEVNODE;
3308
3309 dwSize = sizeof(dwDisableCount);
3310 dwError = RegQueryValueExW(hDeviceKey,
3311 L"DisableCount",
3312 NULL,
3313 NULL,
3314 (LPBYTE)&dwDisableCount,
3315 &dwSize);
3316 if ((dwError == ERROR_SUCCESS) &&
3317 (dwDisableCount > 0))
3318 {
3319 goto done;
3320 }
3321
3322 GetDeviceStatus(pszDeviceInstance,
3323 &ulStatus,
3324 &ulProblem);
3325
3326 if (ulStatus & DN_STARTED)
3327 {
3328 goto done;
3329 }
3330
3331 if (ulStatus & DN_HAS_PROBLEM)
3332 {
3333 ret = ClearDeviceStatus(pszDeviceInstance,
3335 ulProblem);
3336 }
3337
3338 if (ret != CR_SUCCESS)
3339 goto done;
3340
3341 /* Start the device */
3343 pszDeviceInstance);
3345 &ControlData,
3347 if (!NT_SUCCESS(Status))
3349
3350done:
3351 if (hDeviceKey != NULL)
3352 RegCloseKey(hDeviceKey);
3353
3354 return ret;
3355}
3356
3357
3358static CONFIGRET
3360 _In_ LPWSTR pszDeviceInstance)
3361{
3365
3366 DPRINT("Enable device instance %S\n", pszDeviceInstance);
3367
3368 RtlInitUnicodeString(&ControlData.DeviceInstance, pszDeviceInstance);
3369 Status = NtPlugPlayControl(PlugPlayControlStartDevice, &ControlData, sizeof(ControlData));
3370 if (!NT_SUCCESS(Status))
3372
3373 return ret;
3374}
3375
3376
3377static CONFIGRET
3379 _In_ LPWSTR pszDeviceInstance,
3380 _In_ ULONG ulMinorAction)
3381{
3382 PLUGPLAY_CONTROL_ENUMERATE_DEVICE_DATA EnumerateDeviceData;
3385
3386 DPRINT1("ReenumerateDeviceInstance(%S 0x%08lx)\n",
3387 pszDeviceInstance, ulMinorAction);
3388
3389 if (ulMinorAction & ~CM_REENUMERATE_BITS)
3390 return CR_INVALID_FLAG;
3391
3392 if (ulMinorAction & CM_REENUMERATE_RETRY_INSTALLATION)
3393 {
3394 DPRINT1("CM_REENUMERATE_RETRY_INSTALLATION not implemented!\n");
3395 }
3396
3397 RtlInitUnicodeString(&EnumerateDeviceData.DeviceInstance,
3398 pszDeviceInstance);
3399 EnumerateDeviceData.Flags = 0;
3400
3402 &EnumerateDeviceData,
3404 if (!NT_SUCCESS(Status))
3406
3407 return ret;
3408}
3409
3410
3411/* Function 29 */
3412DWORD
3413WINAPI
3416 DWORD ulMajorAction,
3417 DWORD ulMinorAction,
3418 LPWSTR pszDeviceInstance1,
3419 LPWSTR pszDeviceInstance2)
3420{
3422
3424
3425 DPRINT("PNP_DeviceInstanceAction(%p %lu 0x%08lx %S %S)\n",
3426 hBinding, ulMajorAction, ulMinorAction,
3427 pszDeviceInstance1, pszDeviceInstance2);
3428
3429 switch (ulMajorAction)
3430 {
3431 case PNP_DEVINST_SETUP:
3432 ret = SetupDeviceInstance(pszDeviceInstance1,
3433 ulMinorAction);
3434 break;
3435
3436 case PNP_DEVINST_ENABLE:
3437 ret = EnableDeviceInstance(pszDeviceInstance1);
3438 break;
3439
3440 case PNP_DEVINST_REENUMERATE:
3441 ret = ReenumerateDeviceInstance(pszDeviceInstance1,
3442 ulMinorAction);
3443 break;
3444
3445 default:
3446 DPRINT1("Unknown device action %lu: not implemented\n", ulMajorAction);
3448 }
3449
3450 DPRINT("PNP_DeviceInstanceAction() done (returns %lx)\n", ret);
3451
3452 return ret;
3453}
3454
3455
3456/* Function 30 */
3457DWORD
3458WINAPI
3461 LPWSTR pDeviceID,
3462 DWORD *pulStatus,
3463 DWORD *pulProblem,
3464 DWORD ulFlags)
3465{
3466 DWORD ulDataType, ulTransferLength, ulLength;
3467 DWORD ulCapabilities, ulConfigFlags;
3468 CONFIGRET ret;
3469
3471 UNREFERENCED_PARAMETER(ulFlags);
3472
3473 DPRINT("PNP_GetDeviceStatus(%p %S %p %p 0x%08lx)\n",
3474 hBinding, pDeviceID, pulStatus, pulProblem, ulFlags);
3475
3476 if (ulFlags != 0)
3477 return CR_INVALID_FLAG;
3478
3479 if ((pulStatus == NULL) || (pulProblem == NULL))
3480 return CR_INVALID_POINTER;
3481
3482 if (!IsValidDeviceInstanceID(pDeviceID))
3483 return CR_INVALID_DEVINST;
3484
3485 ret = GetDeviceStatus(pDeviceID, pulStatus, pulProblem);
3486 if (ret != CR_SUCCESS)
3487 return ret;
3488
3489 /* Check for DN_REMOVABLE */
3490 ulTransferLength = sizeof(ulCapabilities);
3491 ulLength = sizeof(ulCapabilities);
3493 pDeviceID,
3495 &ulDataType,
3496 (PBYTE)&ulCapabilities,
3497 &ulTransferLength,
3498 &ulLength,
3499 0);
3500 if (ret != CR_SUCCESS)
3501 ulCapabilities = 0;
3502
3503 if (ulCapabilities & CM_DEVCAP_REMOVABLE)
3504 *pulStatus |= DN_REMOVABLE;
3505
3506 /* Check for DN_MANUAL */
3507 ulTransferLength = sizeof(ulConfigFlags);
3508 ulLength = sizeof(ulConfigFlags);
3510 pDeviceID,
3512 &ulDataType,
3513 (PBYTE)&ulConfigFlags,
3514 &ulTransferLength,
3515 &ulLength,
3516 0);
3517 if (ret != CR_SUCCESS)
3518 ulConfigFlags = 0;
3519
3520 if (ulConfigFlags & CONFIGFLAG_MANUAL_INSTALL)
3521 *pulStatus |= DN_MANUAL;
3522
3523 /* Check for failed install */
3524 if (((*pulStatus & DN_HAS_PROBLEM) == 0) && (ulConfigFlags & CONFIGFLAG_FAILEDINSTALL))
3525 {
3526 *pulStatus |= DN_HAS_PROBLEM;
3527 *pulProblem = CM_PROB_FAILED_INSTALL;
3528 }
3529
3530 return CR_SUCCESS;
3531}
3532
3533
3534/* Function 31 */
3535DWORD
3536WINAPI
3539 LPWSTR pDeviceID,
3540 DWORD ulProblem,
3541 DWORD ulFlags)
3542{
3543 ULONG ulOldStatus, ulOldProblem;
3545
3547
3548 DPRINT1("PNP_SetDeviceProblem(%p %S %lu 0x%08lx)\n",
3549 hBinding, pDeviceID, ulProblem, ulFlags);
3550
3551 if (ulFlags & ~CM_SET_DEVNODE_PROBLEM_BITS)
3552 return CR_INVALID_FLAG;
3553
3554 if (!IsValidDeviceInstanceID(pDeviceID))
3555 return CR_INVALID_DEVINST;
3556
3557 ret = GetDeviceStatus(pDeviceID,
3558 &ulOldStatus,
3559 &ulOldProblem);
3560 if (ret != CR_SUCCESS)
3561 return ret;
3562
3563 if (((ulFlags & CM_SET_DEVNODE_PROBLEM_OVERRIDE) == 0) &&
3564 (ulOldProblem != 0) &&
3565 (ulOldProblem != ulProblem))
3566 {
3567 return CR_FAILURE;
3568 }
3569
3570 if (ulProblem == 0)
3571 {
3572 ret = ClearDeviceStatus(pDeviceID,
3574 ulOldProblem);
3575 }
3576 else
3577 {
3578 ret = SetDeviceStatus(pDeviceID,
3580 ulProblem);
3581 }
3582
3583 return ret;
3584}
3585
3586
3587/* Function 32 */
3588DWORD
3589WINAPI
3592 LPWSTR pDeviceID,
3593 PPNP_VETO_TYPE pVetoType,
3594 LPWSTR pszVetoName,
3595 DWORD ulNameLength,
3596 DWORD ulFlags)
3597{
3599
3600 DPRINT1("PNP_DisableDevInst(%p %S %p %p %lu 0x%08lx)\n",
3601 hBinding, pDeviceID, pVetoType, pszVetoName, ulNameLength, ulFlags);
3602
3603 if (ulFlags & ~CM_DISABLE_BITS)
3604 return CR_INVALID_FLAG;
3605
3606 if (!IsValidDeviceInstanceID(pDeviceID) ||
3607 IsRootDeviceInstanceID(pDeviceID))
3608 return CR_INVALID_DEVINST;
3609
3610 return DisableDeviceInstance(pDeviceID,
3611 pVetoType,
3612 pszVetoName,
3613 ulNameLength);
3614}
3615
3616
3617/* Function 33 */
3618DWORD
3619WINAPI
3622 LPWSTR pDeviceID,
3623 DWORD ulFlags)
3624{
3627}
3628
3629
3630static BOOL
3632 LPWSTR lpDeviceId)
3633{
3634 LPWSTR lpPtr;
3636
3637 lpPtr = lpDeviceIdList;
3638 while (*lpPtr != 0)
3639 {
3640 dwLength = wcslen(lpPtr);
3641 if (0 == _wcsicmp(lpPtr, lpDeviceId))
3642 return TRUE;
3643
3644 lpPtr += (dwLength + 1);
3645 }
3646
3647 return FALSE;
3648}
3649
3650
3651static VOID
3652AppendDeviceId(LPWSTR lpDeviceIdList,
3653 LPDWORD lpDeviceIdListSize,
3654 LPWSTR lpDeviceId)
3655{
3656 DWORD dwLen;
3657 DWORD dwPos;
3658
3659 dwLen = wcslen(lpDeviceId);
3660 dwPos = (*lpDeviceIdListSize / sizeof(WCHAR)) - 1;
3661
3662 wcscpy(&lpDeviceIdList[dwPos], lpDeviceId);
3663
3664 dwPos += (dwLen + 1);
3665
3666 lpDeviceIdList[dwPos] = 0;
3667
3668 *lpDeviceIdListSize = dwPos * sizeof(WCHAR);
3669}
3670
3671
3672/* Function 34 */
3673DWORD
3674WINAPI
3677 LPWSTR pszDeviceID,
3678 LPWSTR pszID,
3679 DWORD ulFlags)
3680{
3682 HKEY hDeviceKey;
3683 LPWSTR pszSubKey;
3684 DWORD dwDeviceIdListSize;
3685 DWORD dwNewDeviceIdSize;
3686 WCHAR * pszDeviceIdList = NULL;
3687
3689
3690 DPRINT("PNP_AddID(%p %S %S 0x%08lx)\n",
3691 hBinding, pszDeviceID, pszID, ulFlags);
3692
3694 pszDeviceID,
3695 0,
3697 &hDeviceKey) != ERROR_SUCCESS)
3698 {
3699 DPRINT("Failed to open the device key!\n");
3700 return CR_INVALID_DEVNODE;
3701 }
3702
3703 pszSubKey = (ulFlags & CM_ADD_ID_COMPATIBLE) ? L"CompatibleIDs" : L"HardwareID";
3704
3705 if (RegQueryValueExW(hDeviceKey,
3706 pszSubKey,
3707 NULL,
3708 NULL,
3709 NULL,
3710 &dwDeviceIdListSize) != ERROR_SUCCESS)
3711 {
3712 DPRINT("Failed to query the desired ID string!\n");
3714 goto Done;
3715 }
3716
3717 dwNewDeviceIdSize = lstrlenW(pszDeviceID);
3718 if (!dwNewDeviceIdSize)
3719 {
3721 goto Done;
3722 }
3723
3724 dwDeviceIdListSize += (dwNewDeviceIdSize + 2) * sizeof(WCHAR);
3725
3726 pszDeviceIdList = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwDeviceIdListSize);
3727 if (!pszDeviceIdList)
3728 {
3729 DPRINT("Failed to allocate memory for the desired ID string!\n");
3731 goto Done;
3732 }
3733
3734 if (RegQueryValueExW(hDeviceKey,
3735 pszSubKey,
3736 NULL,
3737 NULL,
3738 (LPBYTE)pszDeviceIdList,
3739 &dwDeviceIdListSize) != ERROR_SUCCESS)
3740 {
3741 DPRINT("Failed to query the desired ID string!\n");
3743 goto Done;
3744 }
3745
3746 /* Check whether the device ID is already in use */
3747 if (CheckForDeviceId(pszDeviceIdList, pszDeviceID))
3748 {
3749 DPRINT("Device ID was found in the ID string!\n");
3750 ret = CR_SUCCESS;
3751 goto Done;
3752 }
3753
3754 /* Append the Device ID */
3755 AppendDeviceId(pszDeviceIdList, &dwDeviceIdListSize, pszID);
3756
3757 if (RegSetValueExW(hDeviceKey,
3758 pszSubKey,
3759 0,
3761 (LPBYTE)pszDeviceIdList,
3762 dwDeviceIdListSize) != ERROR_SUCCESS)
3763 {
3764 DPRINT("Failed to set the desired ID string!\n");
3766 }
3767
3768Done:
3769 RegCloseKey(hDeviceKey);
3770 if (pszDeviceIdList)
3771 HeapFree(GetProcessHeap(), 0, pszDeviceIdList);
3772
3773 DPRINT("PNP_AddID() done (returns %lx)\n", ret);
3774
3775 return ret;
3776}
3777
3778
3779/* Function 35 */
3780DWORD
3781WINAPI
3784 LPWSTR pszDeviceID,
3785 DWORD ulFlags)
3786{
3787 DPRINT("PNP_RegisterDriver(%p %S 0x%lx)\n",
3788 hBinding, pszDeviceID, ulFlags);
3789
3790 if (ulFlags & ~CM_REGISTER_DEVICE_DRIVER_BITS)
3791 return CR_INVALID_FLAG;
3792
3793 if (!IsValidDeviceInstanceID(pszDeviceID))
3794 return CR_INVALID_DEVINST;
3795
3796 SetDeviceStatus(pszDeviceID, 0, 0);
3797
3798 return CR_SUCCESS;
3799}
3800
3801
3802/* Function 36 */
3803DWORD
3804WINAPI
3807 LPWSTR pszDeviceID,
3808 PPNP_VETO_TYPE pVetoType,
3809 LPWSTR pszVetoName,
3810 DWORD ulNameLength,
3811 DWORD ulFlags)
3812{
3816
3817 DPRINT1("PNP_QueryRemove(%p %S %p %p %lu 0x%lx)\n",
3818 hBinding, pszDeviceID, pVetoType, pszVetoName,
3819 ulNameLength, ulFlags);
3820
3821 if (ulFlags & ~CM_REMOVE_BITS)
3822 return CR_INVALID_FLAG;
3823
3824 if (!IsValidDeviceInstanceID(pszDeviceID) ||
3825 IsRootDeviceInstanceID(pszDeviceID))
3826 return CR_INVALID_DEVINST;
3827
3828 if (pVetoType != NULL)
3829 *pVetoType = PNP_VetoTypeUnknown;
3830
3831 if (pszVetoName != NULL && ulNameLength > 0)
3832 *pszVetoName = UNICODE_NULL;
3833
3834 RtlZeroMemory(&PlugPlayData, sizeof(PlugPlayData));
3836 pszDeviceID);
3837 PlugPlayData.VetoName = pszVetoName;
3838 PlugPlayData.NameLength = ulNameLength;
3839// PlugPlayData.Flags =
3840
3842 &PlugPlayData,
3843 sizeof(PlugPlayData));
3844 if (!NT_SUCCESS(Status))
3846
3847 return ret;
3848}
3849
3850
3851/* Function 37 */
3852DWORD
3853WINAPI
3856 LPWSTR pszDeviceID,
3857 PPNP_VETO_TYPE pVetoType,
3858 LPWSTR pszVetoName,
3859 DWORD ulNameLength,
3860 DWORD ulFlags)
3861{
3865
3866 DPRINT1("PNP_RequestDeviceEject(%p %S %p %p %lu 0x%lx)\n",
3867 hBinding, pszDeviceID, pVetoType, pszVetoName,
3868 ulNameLength, ulFlags);
3869
3870 if (ulFlags != 0)
3871 return CR_INVALID_FLAG;
3872
3873 if (!IsValidDeviceInstanceID(pszDeviceID))
3874 return CR_INVALID_DEVINST;
3875
3876 if (pVetoType != NULL)
3877 *pVetoType = PNP_VetoTypeUnknown;
3878
3879 if (pszVetoName != NULL && ulNameLength > 0)
3880 *pszVetoName = UNICODE_NULL;
3881
3882 RtlZeroMemory(&PlugPlayData, sizeof(PlugPlayData));
3884 pszDeviceID);
3885 PlugPlayData.VetoName = pszVetoName;
3886 PlugPlayData.NameLength = ulNameLength;
3887// PlugPlayData.Flags =
3888
3890 &PlugPlayData,
3891 sizeof(PlugPlayData));
3892 if (!NT_SUCCESS(Status))
3894
3895 return ret;
3896}
3897
3898
3899/* Function 38 */
3901WINAPI
3904 BOOL *Present)
3905{
3906 HKEY hKey;
3907 DWORD dwType;
3908 DWORD dwValue;
3909 DWORD dwSize;
3911
3913
3914 DPRINT1("PNP_IsDockStationPresent(%p %p)\n",
3915 hBinding, Present);
3916
3917 *Present = FALSE;
3918
3920 L"CurrentDockInfo",
3921 0,
3922 KEY_READ,
3923 &hKey) != ERROR_SUCCESS)
3924 return CR_REGISTRY_ERROR;
3925
3926 dwSize = sizeof(DWORD);
3928 L"DockingState",
3929 NULL,
3930 &dwType,
3931 (LPBYTE)&dwValue,
3932 &dwSize) != ERROR_SUCCESS)
3934
3936
3937 if (ret == CR_SUCCESS)
3938 {
3939 if (dwType != REG_DWORD || dwSize != sizeof(DWORD))
3940 {
3942 }
3943 else if (dwValue != 0)
3944 {
3945 *Present = TRUE;
3946 }
3947 }
3948
3949 DPRINT1("PNP_IsDockStationPresent() done (returns %lx)\n", ret);
3950
3951 return ret;
3952}
3953
3954
3955/* Function 39 */
3956DWORD
3957WINAPI
3960{
3961 WCHAR szDockDeviceInstance[MAX_DEVICE_ID_LEN];
3964
3965 DPRINT("PNP_RequestEjectPC(%p)\n", hBinding);
3966
3967 /* Retrieve the dock device */
3968 DockData.DeviceInstanceLength = ARRAYSIZE(szDockDeviceInstance);
3969 DockData.DeviceInstance = szDockDeviceInstance;
3970
3972 &DockData,
3973 sizeof(DockData));
3974 if (!NT_SUCCESS(Status))
3975 return NtStatusToCrError(Status);
3976
3977 /* Eject the dock device */
3979 szDockDeviceInstance,
3980 NULL,
3981 NULL,
3982 0,
3983 0);
3984}
3985
3986
3987/* Function 40 */
3988DWORD
3989WINAPI
3992 DWORD ulAction,
3993 LPWSTR pDeviceID,
3994 DWORD ulConfig,
3995 DWORD *pulValue,
3996 PPNP_VETO_TYPE pVetoType,
3997 LPWSTR pszVetoName,
3998 DWORD ulNameLength,
3999 DWORD ulFlags)
4000{
4002 WCHAR szKeyName[MAX_PATH];
4003 HKEY hKey;
4004 HKEY hDeviceKey;
4005 DWORD dwSize;
4006
4008
4009 DPRINT("PNP_HwProfFlags() called\n");
4010
4011 if (!IsValidDeviceInstanceID(pDeviceID))
4012 return CR_INVALID_DEVINST;
4013
4014 if (ulConfig == 0)
4015 {
4016 wcscpy(szKeyName,
4017 L"System\\CurrentControlSet\\HardwareProfiles\\Current\\System\\CurrentControlSet\\Enum");
4018 }
4019 else
4020 {
4021 swprintf(szKeyName,
4022 L"System\\CurrentControlSet\\HardwareProfiles\\%04lu\\System\\CurrentControlSet\\Enum",
4023 ulConfig);
4024 }
4025
4027 szKeyName,
4028 0,
4030 &hKey) != ERROR_SUCCESS)
4031 return CR_REGISTRY_ERROR;
4032
4033 if (ulAction == PNP_GET_HWPROFFLAGS)
4034 {
4035 if (RegOpenKeyExW(hKey,
4036 pDeviceID,
4037 0,
4039 &hDeviceKey) != ERROR_SUCCESS)
4040 {
4041 *pulValue = 0;
4042 }
4043 else
4044 {
4045 dwSize = sizeof(DWORD);
4046 if (RegQueryValueExW(hDeviceKey,
4047 L"CSConfigFlags",
4048 NULL,
4049 NULL,
4050 (LPBYTE)pulValue,
4051 &dwSize) != ERROR_SUCCESS)
4052 {
4053 *pulValue = 0;
4054 }
4055
4056 RegCloseKey(hDeviceKey);
4057 }
4058 }
4059 else if (ulAction == PNP_SET_HWPROFFLAGS)
4060 {
4061 /* FIXME: not implemented yet */
4063 }
4064
4066
4067 return ret;
4068}
4069
4070
4071/* Function 41 */
4072DWORD
4073WINAPI
4076 DWORD ulIndex,
4077 HWPROFILEINFO *pHWProfileInfo,
4078 DWORD ulProfileInfoSize,
4079 DWORD ulFlags)
4080{
4081 WCHAR szProfileName[5];
4082 HKEY hKeyConfig = NULL;
4083 HKEY hKeyProfiles = NULL;
4084 HKEY hKeyProfile = NULL;
4085 DWORD dwDisposition;
4086 DWORD dwSize;
4087 LONG lError;
4089
4091
4092 DPRINT("PNP_GetHwProfInfo() called\n");
4093
4094 if (ulProfileInfoSize == 0)
4095 {
4097 goto done;
4098 }
4099
4100 if (ulFlags != 0)
4101 {
4103 goto done;
4104 }
4105
4106 /* Initialize the profile information */
4107 pHWProfileInfo->HWPI_ulHWProfile = 0;
4108 pHWProfileInfo->HWPI_szFriendlyName[0] = 0;
4109 pHWProfileInfo->HWPI_dwFlags = 0;
4110
4111 /* Open the 'IDConfigDB' key */
4113 L"System\\CurrentControlSet\\Control\\IDConfigDB",
4114 0,
4115 NULL,
4118 NULL,
4119 &hKeyConfig,
4120 &dwDisposition);
4121 if (lError != ERROR_SUCCESS)
4122 {
4124 goto done;
4125 }
4126
4127 /* Open the 'Hardware Profiles' subkey */
4128 lError = RegCreateKeyExW(hKeyConfig,
4129 L"Hardware Profiles",
4130 0,
4131 NULL,
4134 NULL,
4135 &hKeyProfiles,
4136 &dwDisposition);
4137 if (lError != ERROR_SUCCESS)
4138 {
4140 goto done;
4141 }
4142
4143 if (ulIndex == (ULONG)-1)
4144 {
4145 dwSize = sizeof(ULONG);
4146 lError = RegQueryValueExW(hKeyConfig,
4147 L"CurrentConfig",
4148 NULL,
4149 NULL,
4150 (LPBYTE)&pHWProfileInfo->HWPI_ulHWProfile,
4151 &dwSize);
4152 if (lError != ERROR_SUCCESS)
4153 {
4154 pHWProfileInfo->HWPI_ulHWProfile = 0;
4156 goto done;
4157 }
4158 }
4159 else
4160 {
4161 /* FIXME: not implemented yet */
4163 goto done;
4164 }
4165
4166 swprintf(szProfileName, L"%04lu", pHWProfileInfo->HWPI_ulHWProfile);
4167
4168 lError = RegOpenKeyExW(hKeyProfiles,
4169 szProfileName,
4170 0,
4172 &hKeyProfile);
4173 if (lError != ERROR_SUCCESS)
4174 {
4176 goto done;
4177 }
4178
4179 dwSize = sizeof(pHWProfileInfo->HWPI_szFriendlyName);
4180 lError = RegQueryValueExW(hKeyProfile,
4181 L"FriendlyName",
4182 NULL,
4183 NULL,
4184 (LPBYTE)&pHWProfileInfo->HWPI_szFriendlyName,
4185 &dwSize);
4186 if (lError != ERROR_SUCCESS)
4187 {
4189 goto done;
4190 }
4191
4192done:
4193 if (hKeyProfile != NULL)
4194 RegCloseKey(hKeyProfile);
4195
4196 if (hKeyProfiles != NULL)
4197 RegCloseKey(hKeyProfiles);
4198
4199 if (hKeyConfig != NULL)
4200 RegCloseKey(hKeyConfig);
4201
4202 return ret;
4203}
4204
4205
4206/* Function 42 */
4207DWORD
4208WINAPI
4211 LPWSTR pDeviceID,
4212 DWORD ulPriority,
4213 DWORD *pulLogConfTag,
4214 DWORD ulFlags)
4215{
4216 HKEY hConfigKey = NULL;
4217 DWORD RegDataType = 0;
4218 ULONG ulDataSize = 0, ulNewSize = 0;
4219 PBYTE pDataBuffer = NULL;
4220 WCHAR szValueNameBuffer[LOGCONF_NAME_BUFFER_SIZE];
4222
4223 DPRINT("PNP_AddEmptyLogConf(%p %S %lu %p 0x%08lx)\n",
4224 hBinding, pDeviceID, ulPriority, pulLogConfTag, ulFlags);
4225
4226 if (pulLogConfTag == NULL)
4227 return CR_INVALID_POINTER;
4228
4229 *pulLogConfTag = 0;
4230
4231 if (ulFlags & ~(LOG_CONF_BITS | PRIORITY_BIT))
4232 return CR_INVALID_FLAG;
4233
4234 if (!IsValidDeviceInstanceID(pDeviceID) || IsRootDeviceInstanceID(pDeviceID))
4235 return CR_INVALID_DEVNODE;
4236
4237 ret = OpenConfigurationKey(pDeviceID,
4238 ulFlags & LOG_CONF_BITS,
4239 &hConfigKey);
4240 if (ret != CR_SUCCESS)
4241 {
4242 DPRINT1("OpenConfigurationKey() failed (Error %lu)\n", ret);
4244 goto done;
4245 }
4246
4247 ret = GetConfigurationData(hConfigKey,
4248 ulFlags & LOG_CONF_BITS,
4249 &RegDataType,
4250 &ulDataSize,
4251 &pDataBuffer,
4253 szValueNameBuffer);
4254
4255 if (ret != CR_SUCCESS || ulDataSize == 0)
4256 {
4257 ret = CR_SUCCESS;
4258
4259 if (RegDataType == REG_RESOURCE_LIST)
4260 {
4261 PCM_RESOURCE_LIST pResourceList = NULL;
4263
4264 /* Allocate a buffer for the new configuration */
4265 ulDataSize = sizeof(CM_RESOURCE_LIST) - sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
4266 pDataBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ulDataSize);
4267 if (pDataBuffer == NULL)
4268 {
4270 goto done;
4271 }
4272
4273 pResourceList = (PCM_RESOURCE_LIST)pDataBuffer;
4274 pResourceList->Count = 1;
4275
4276 pResource = (PCM_FULL_RESOURCE_DESCRIPTOR)&pResourceList->List[0];
4278 pResource->BusNumber = 0;
4279 pResource->PartialResourceList.Version = 1;
4280 pResource->PartialResourceList.Revision = 1;
4281 pResource->PartialResourceList.Count = 0;
4282 }
4283 else if (RegDataType == REG_RESOURCE_REQUIREMENTS_LIST)
4284 {
4285 PIO_RESOURCE_REQUIREMENTS_LIST pRequirementsList = NULL;
4286 PIO_RESOURCE_LIST pResourceList = NULL;
4287
4288 ulDataSize = sizeof(IO_RESOURCE_REQUIREMENTS_LIST);
4289 pDataBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ulDataSize);
4290 if (pDataBuffer == NULL)
4291 {
4293 goto done;
4294 }
4295
4296 pRequirementsList = (PIO_RESOURCE_REQUIREMENTS_LIST)pDataBuffer;
4297 pRequirementsList->ListSize = ulDataSize;
4298 pRequirementsList->InterfaceType = InterfaceTypeUndefined;
4299 pRequirementsList->BusNumber = 0;
4300 pRequirementsList->SlotNumber = 0;
4301 pRequirementsList->AlternativeLists = 1;
4302
4303 pResourceList = (PIO_RESOURCE_LIST)&pRequirementsList->List[0];
4304 pResourceList->Version = 1;
4305 pResourceList->Revision = 1;
4306 pResourceList->Count = 1;
4307
4308 pResourceList->Descriptors[0].Option = IO_RESOURCE_PREFERRED;
4309 pResourceList->Descriptors[0].Type = CmResourceTypeConfigData;
4310 pResourceList->Descriptors[0].u.ConfigData.Priority = ulPriority;
4311 }
4312 else
4313 {
4314 ret = CR_FAILURE;
4315 goto done;
4316 }
4317 }
4318 else
4319 {
4320 if (RegDataType == REG_RESOURCE_LIST)
4321 {
4322 PCM_RESOURCE_LIST pResourceList = NULL;
4324 ULONG ulIndex;
4325
4326 /* Reallocate a larger buffer in order to add the new configuration */
4327 ulNewSize = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) - sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
4328 pDataBuffer = HeapReAlloc(GetProcessHeap(),
4329 0,
4330 pDataBuffer,
4331 ulDataSize + ulNewSize);
4332 if (pDataBuffer == NULL)
4333 {
4335 goto done;
4336 }
4337
4338 pResourceList = (PCM_RESOURCE_LIST)pDataBuffer;
4339
4340 /* Get a pointer to the new (uninitialized) resource descriptor */
4341 pResource = (PCM_FULL_RESOURCE_DESCRIPTOR)&pResourceList->List[0];
4342 for (ulIndex = 0; ulIndex < pResourceList->Count; ulIndex++)
4343 pResource = NextResourceDescriptor(pResource);
4344
4345 /* Initialize the new resource descriptor */
4346 pResourceList->Count++;
4348 pResource->BusNumber = 0;
4349 pResource->PartialResourceList.Version = 1;
4350 pResource->PartialResourceList.Revision = 1;
4351 pResource->PartialResourceList.Count = 0;
4352
4353 *pulLogConfTag = ulIndex;
4354 }
4355 else if (RegDataType == REG_RESOURCE_REQUIREMENTS_LIST)
4356 {
4357 /* FIXME */
4358 }
4359 else
4360 {
4361 ret = CR_FAILURE;
4362 goto done;
4363 }
4364 }
4365
4366 /* Store the configuration */
4367 if (RegSetValueEx(hConfigKey,
4368 szValueNameBuffer,
4369 0,
4370 RegDataType,
4371 pDataBuffer,
4372 ulDataSize + ulNewSize) != ERROR_SUCCESS)
4373 {
4375 goto done;
4376 }
4377
4378done:
4379 if (pDataBuffer != NULL)
4380 HeapFree(GetProcessHeap(), 0, pDataBuffer);
4381
4382 if (hConfigKey != NULL)
4383 RegCloseKey(hConfigKey);
4384
4385 DPRINT("PNP_AddEmptyLogConf() returns %lu\n", ret);
4386
4387 return ret;
4388}
4389
4390
4391/* Function 43 */
4392DWORD
4393WINAPI
4396 LPWSTR pDeviceID,
4397 DWORD ulLogConfType,
4398 DWORD ulLogConfTag,
4399 DWORD ulFlags)
4400{
4401 HKEY hConfigKey = NULL;
4402 DWORD RegDataType = 0;
4403 ULONG ulDataSize = 0;
4404 LPBYTE pDataBuffer = NULL;
4405 WCHAR szValueNameBuffer[LOGCONF_NAME_BUFFER_SIZE];
4407
4408 DPRINT("PNP_FreeLogConf(%p %S %lu %lu 0x%08lx)\n",
4409 hBinding, pDeviceID, ulLogConfType, ulLogConfTag, ulFlags);
4410
4411 if (ulFlags != 0)
4412 return CR_INVALID_FLAG;
4413
4414 if (!IsValidDeviceInstanceID(pDeviceID))
4415 return CR_INVALID_DEVNODE;
4416
4417 ret = OpenConfigurationKey(pDeviceID,
4418 ulLogConfType,
4419 &hConfigKey);
4420 if (ret != CR_SUCCESS)
4421 {
4422 DPRINT1("OpenConfigurationKey() failed (Error %lu)\n", ret);
4424 goto done;
4425 }
4426
4427 ret = GetConfigurationData(hConfigKey,
4428 ulLogConfType,
4429 &RegDataType,
4430 &ulDataSize,
4431 &pDataBuffer,
4433 szValueNameBuffer);
4434 if (ret != CR_SUCCESS)
4435 {
4437 goto done;
4438 }
4439
4440 if (RegDataType == REG_RESOURCE_LIST)
4441 {
4442 if (((PCM_RESOURCE_LIST)pDataBuffer)->Count <= 1)
4443 {
4444 /* Delete the key if there is only one or no configuration in the key */
4445 DPRINT("Delete value %S\n", szValueNameBuffer);
4446 RegDeleteValue(hConfigKey, szValueNameBuffer);
4447 }
4448 else
4449 {
4450 /* FIXME */
4451 }
4452 }
4453 else if (RegDataType == REG_RESOURCE_REQUIREMENTS_LIST)
4454 {
4455 if (((PIO_RESOURCE_REQUIREMENTS_LIST)pDataBuffer)->AlternativeLists <= 1)
4456 {
4457 /* Delete the key if there is only one or no configuration in the key */
4458 DPRINT("Delete value %S\n", szValueNameBuffer);
4459 RegDeleteValue(hConfigKey, szValueNameBuffer);
4460 }
4461 else
4462 {
4463 /* FIXME */
4464 }
4465 }
4466 else
4467 {
4468 ret = CR_FAILURE;
4469 goto done;
4470 }
4471
4472done:
4473 if (pDataBuffer != NULL)
4474 HeapFree(GetProcessHeap(), 0, pDataBuffer);
4475
4476 if (hConfigKey != NULL)
4477 RegCloseKey(hConfigKey);
4478
4479 DPRINT("PNP_FreeLogConf() returns %lu\n", ret);
4480
4481 return ret;
4482}
4483
4484
4485/* Function 44 */
4486DWORD
4487WINAPI
4490 LPWSTR pDeviceID,
4491 DWORD ulLogConfType,
4492 DWORD *pulLogConfTag,
4493 DWORD ulFlags)
4494{
4495 HKEY hConfigKey = NULL;
4496 DWORD RegDataType = 0;
4497 ULONG ulDataSize = 0;
4498 LPBYTE lpData = NULL;
4500
4501 DPRINT("PNP_GetFirstLogConf(%p %S %lu %p 0x%08lx)\n",
4502 hBinding, pDeviceID, ulLogConfType, pulLogConfTag, ulFlags);
4503
4504 if (pulLogConfTag == NULL)
4505 return CR_INVALID_POINTER;
4506
4507 *pulLogConfTag = (DWORD)0;
4508
4509 if (ulFlags & ~LOG_CONF_BITS)
4510 return CR_INVALID_FLAG;
4511
4512 if (!IsValidDeviceInstanceID(pDeviceID))
4513 return CR_INVALID_DEVINST;
4514
4515 ret = OpenConfigurationKey(pDeviceID,
4516 ulLogConfType,
4517 &hConfigKey);
4518 if (ret != CR_SUCCESS)
4519 {
4520 DPRINT1("OpenConfigurationKey() failed (Error %lu)\n", ret);
4522 goto done;
4523 }
4524
4525 ret = GetConfigurationData(hConfigKey,
4526 ulLogConfType,
4527 &RegDataType,
4528 &ulDataSize,
4529 &lpData,
4530 0,
4531 NULL);
4532 if (ret != CR_SUCCESS)
4533 {
4534 DPRINT1("GetConfigurationData() failed (Error %lu)\n", ret);
4536 goto done;
4537 }
4538
4539 DPRINT1("Data size %lu\n", ulDataSize);
4540 if (ulDataSize == 0 || lpData == NULL)
4541 {
4542 DPRINT1("No config data available!\n");
4544 goto done;
4545 }
4546
4547 /* Get the first tag */
4548 if (RegDataType == REG_RESOURCE_LIST)
4549 {
4550 DPRINT("REG_RESOURCE_LIST->Count %lu\n", ((PCM_RESOURCE_LIST)lpData)->Count);
4551
4552 /* Fail, if we do not have any resource */
4553 if (((PCM_RESOURCE_LIST)lpData)->Count == 0)
4554 {
4555 DPRINT1("No resource descriptors!\n");
4557 goto done;
4558 }
4559 }
4560 else if (RegDataType == REG_RESOURCE_REQUIREMENTS_LIST)
4561 {
4562 DPRINT("REG_RESOURCE_REQUIREMENTS_LIST->AlternativeLists %lu\n",
4563 ((PIO_RESOURCE_REQUIREMENTS_LIST)lpData)->AlternativeLists);
4564
4565 /* Fail, if we do not have any requirements */
4566 if (((PIO_RESOURCE_REQUIREMENTS_LIST)lpData)->AlternativeLists == 0)
4567 {
4569 goto done;
4570 }
4571 }
4572
4573done:
4574 if (lpData != NULL)
4575 HeapFree(GetProcessHeap(), 0, lpData);
4576
4577 if (hConfigKey != NULL)
4578 RegCloseKey(hConfigKey);
4579
4580 DPRINT("PNP_GetFirstLogConf() returns %lu\n", ret);
4581
4582 return ret;
4583}
4584
4585
4586/* Function 45 */
4587DWORD
4588WINAPI
4591 LPWSTR pDeviceID,
4592 DWORD ulLogConfType,
4593 DWORD ulCurrentTag,
4594 DWORD *pulNextTag,
4595 DWORD ulFlags)
4596{
4597 HKEY hConfigKey = NULL;
4598 DWORD RegDataType = 0;
4599 ULONG ulDataSize = 0;
4600 LPBYTE lpData = NULL;
4602
4603 DPRINT("PNP_GetNextLogConf(%p %S %lu %ul %p 0x%08lx)\n",
4604 hBinding, pDeviceID, ulLogConfType, ulCurrentTag, pulNextTag, ulFlags);
4605
4606 if (pulNextTag == NULL)
4607 return CR_INVALID_POINTER;
4608
4609 *pulNextTag = (DWORD)0;
4610
4611 if (ulFlags != 0)
4612 return CR_INVALID_FLAG;
4613
4614 if (!IsValidDeviceInstanceID(pDeviceID))
4615 return CR_INVALID_DEVINST;
4616
4617 ret = OpenConfigurationKey(pDeviceID,
4618 ulLogConfType,
4619 &hConfigKey);
4620 if (ret != CR_SUCCESS)
4621 {
4622 DPRINT1("OpenConfigurationKey() failed (Error %lu)\n", ret);
4624 goto done;
4625 }
4626
4627 ret = GetConfigurationData(hConfigKey,
4628 ulLogConfType,
4629 &RegDataType,
4630 &ulDataSize,
4631 &lpData,
4632 0,
4633 NULL);
4634 if (ret != CR_SUCCESS)
4635 {
4636 DPRINT1("GetConfigurationData() failed (Error %lu)\n", ret);
4638 goto done;
4639 }
4640
4641 DPRINT("Data size %lu\n", ulDataSize);
4642
4643 if (ulDataSize == 0 || lpData == NULL)
4644 {
4645 DPRINT1("No config data available!\n");
4647 goto done;
4648 }
4649
4650 /* Check if the next entry is available */
4651 if (RegDataType == REG_RESOURCE_LIST)
4652 {
4653 DPRINT("REG_RESOURCE_LIST->Count %lu\n", ((PCM_RESOURCE_LIST)lpData)->Count);
4654
4655 /* Fail, if we are beyond the end of the list */
4656 if (ulCurrentTag >= ((PCM_RESOURCE_LIST)lpData)->Count)
4657 {
4659 goto done;
4660 }
4661
4662 /* Indicate that we reached the end of the list */
4663 if (ulCurrentTag == ((PCM_RESOURCE_LIST)lpData)->Count - 1)
4664 {
4666 goto done;
4667 }
4668 }
4669 else if (RegDataType == REG_RESOURCE_REQUIREMENTS_LIST)
4670 {
4671 DPRINT("REG_RESOURCE_REQUIREMENTS_LIST->AlternativeLists %lu\n",
4672 ((PIO_RESOURCE_REQUIREMENTS_LIST)lpData)->AlternativeLists);
4673
4674 /* Fail, if we are beyond the end of the list */
4675 if (ulCurrentTag >= ((PIO_RESOURCE_REQUIREMENTS_LIST)lpData)->AlternativeLists)
4676 {
4678 goto done;
4679 }
4680
4681 /* Indicate that we reached the end of the list */
4682 if (ulCurrentTag == ((PIO_RESOURCE_REQUIREMENTS_LIST)lpData)->AlternativeLists - 1)
4683 {
4685 goto done;
4686 }
4687 }
4688
4689 /* Return the next tag value */
4690 *pulNextTag = ulCurrentTag + 1;
4691
4692done:
4693 if (lpData != NULL)
4694 HeapFree(GetProcessHeap(), 0, lpData);
4695
4696 if (hConfigKey != NULL)
4697 RegCloseKey(hConfigKey);
4698
4699 DPRINT("PNP_GetNextLogConf() returns %lu\n", ret);
4700
4701 return ret;
4702}
4703
4704
4705/* Function 46 */
4706DWORD
4707WINAPI
4710 LPWSTR pDeviceID,
4711 DWORD ulType,
4712 DWORD ulTag,
4713 DWORD *pPriority,
4714 DWORD ulFlags)
4715{
4718}
4719
4720
4721/* Function 47 */
4722DWORD
4723WINAPI
4726 LPWSTR pDeviceID,
4727 DWORD ulLogConfTag,
4728 DWORD ulLogConfType,
4729 RESOURCEID ResourceID,
4730 DWORD *pulResourceTag,
4731 BYTE *ResourceData,
4732 PNP_RPC_BUFFER_SIZE ResourceLen,
4733 DWORD ulFlags)
4734{
4737}
4738
4739
4740/* Function 48 */
4741DWORD
4742WINAPI
4745 LPWSTR pDeviceID,
4746 DWORD ulLogConfTag,
4747 DWORD ulLogConfType,
4748 RESOURCEID ResourceID,
4749 DWORD ulResourceTag,
4750 DWORD *pulPreviousResType,
4751 DWORD *pulPreviousResTag,
4752 DWORD ulFlags)
4753{
4756}
4757
4758
4759/* Function 49 */
4760DWORD
4761WINAPI
4764 LPWSTR pDeviceID,
4765 DWORD ulLogConfTag,
4766 DWORD ulLogConfType,
4767 RESOURCEID ResourceID,
4768 DWORD ulResourceTag,
4769 DWORD *pulNextResType,
4770 DWORD *pulNextResTag,
4771 DWORD ulFlags)
4772{
4773 HKEY hConfigKey = NULL;
4774 DWORD RegDataType = 0;
4775 ULONG ulDataSize = 0;
4776 LPBYTE lpData = NULL;
4778
4779 DPRINT1("PNP_GetNextResDes(%p %S 0x%lx %lu %lu %ul %p %p 0x%08lx)\n",
4780 hBinding, pDeviceID, ulLogConfTag, ulLogConfType, ResourceID,
4781 ulResourceTag, pulNextResType, pulNextResTag, ulFlags);
4782
4783 if (pulNextResType == NULL)
4784 return CR_INVALID_POINTER;
4785
4786 *pulNextResType = 0;
4787
4788 if (ulFlags != 0)
4789 return CR_INVALID_FLAG;
4790
4791 if (!IsValidDeviceInstanceID(pDeviceID))
4792 return CR_INVALID_DEVINST;
4793
4794 ret = OpenConfigurationKey(pDeviceID,
4795 ulLogConfType,
4796 &hConfigKey);
4797 if (ret != CR_SUCCESS)
4798 {
4799 DPRINT1("OpenConfigurationKey() failed (Error %lu)\n", ret);
4801 goto done;
4802 }
4803
4804 ret = GetConfigurationData(hConfigKey,
4805 ulLogConfType,
4806 &RegDataType,
4807 &ulDataSize,
4808 &lpData,
4809 0,
4810 NULL);
4811 if (ret != CR_SUCCESS)
4812 {
4813 DPRINT1("GetConfigurationData() failed (Error %lu)\n", ret);
4815 goto done;
4816 }
4817
4818 DPRINT1("Data size %lu\n", ulDataSize);
4819
4820 if (ulDataSize == 0 || lpData == NULL)
4821 {
4822 DPRINT1("No config data available!\n");
4824 goto done;
4825 }
4826
4827 /* Get the next resource descriptor */
4828 if (RegDataType == REG_RESOURCE_LIST)
4829 {
4830 DPRINT1("FIXME: REG_RESOURCE_LIST\n");
4831 /* FIXME */
4833 goto done;
4834 }
4835 else if (RegDataType == REG_RESOURCE_REQUIREMENTS_LIST)
4836 {
4837 DPRINT1("FIXME: REG_RESOURCE_REQUIREMENTS_LIST\n");
4838 /* FIXME */
4840 goto done;
4841 }
4842
4843done:
4844 if (lpData != NULL)
4845 HeapFree(GetProcessHeap(), 0, lpData);
4846
4847 if (hConfigKey != NULL)
4848 RegCloseKey(hConfigKey);
4849
4850 DPRINT1("PNP_GetNextResDes() returns %lu\n", ret);
4851
4852 return ret;
4853}
4854
4855
4856/* Function 50 */
4857DWORD
4858WINAPI
4861 LPWSTR pDeviceID,
4862 DWORD ulLogConfTag,
4863 DWORD ulLogConfType,
4864 RESOURCEID ResourceID,
4865 DWORD ulResourceTag,
4866 BYTE *Buffer,
4867 PNP_RPC_BUFFER_SIZE BufferLen,
4868 DWORD ulFlags)
4869{
4872}
4873
4874
4875/* Function 51 */
4876DWORD
4877WINAPI
4880 LPWSTR pDeviceID,
4881 DWORD ulLogConfTag,
4882 DWORD ulLogConfType,
4883 RESOURCEID ResourceID,
4884 DWORD ulResourceTag,
4885 DWORD *pulSize,
4886 DWORD ulFlags)
4887{
4890}
4891
4892
4893/* Function 52 */
4894DWORD
4895WINAPI
4898 LPWSTR pDeviceID,
4899 DWORD ulLogConfTag,
4900 DWORD ulLogConfType,
4901 RESOURCEID CurrentResourceID,
4902 RESOURCEID NewResourceID,
4903 DWORD ulResourceTag,
4904 BYTE *ResourceData,
4905 PNP_RPC_BUFFER_SIZE ResourceLen,
4906 DWORD ulFlags)
4907{
4910}
4911
4912
4913/* Function 53 */
4914DWORD
4915WINAPI
4918 LPWSTR pDeviceID,
4919 RESOURCEID ResourceID,
4920 BYTE *ResourceData,
4921 PNP_RPC_BUFFER_SIZE ResourceLen,
4922 BOOL *pbConflictDetected,
4923 DWORD ulFlags)
4924{
4925 DPRINT("PNP_DetectResourceConflict()\n");
4926
4927 if (pbConflictDetected != NULL)
4928 *pbConflictDetected = FALSE;
4929
4931}
4932
4933
4934/* Function 54 */
4935DWORD
4936WINAPI
4939 LPWSTR pDeviceID,
4940 RESOURCEID ResourceID,
4941 BYTE *ResourceData,
4942 PNP_RPC_BUFFER_SIZE ResourceLen,
4943 BYTE *Buffer,
4944 PNP_RPC_BUFFER_SIZE BufferLen,
4945 DWORD ulFlags)
4946{
4949}
4950
4951
4952/* Function 55 */
4953DWORD
4954WINAPI
4957 DWORD ulHardwareProfile,
4958 DWORD ulFlags)
4959{
4961}
4962
4963
4964/* Function 56 */
4965DWORD
4966WINAPI
4969 BYTE *pData,
4970 DWORD DataLen,
4971 LPWSTR pDeviceID,
4972 RESOURCEID ResourceID,
4973 DWORD ulFlags)
4974{
4976}
4977
4978
4979/* Function 57 */
4980DWORD
4981WINAPI
4984 DWORD *pulSize,
4985 LPWSTR pDeviceID,
4986 RESOURCEID ResourceID,
4987 DWORD ulFlags)
4988{
4989 if (pulSize != NULL)
4990 *pulSize = 0;
4991
4993}
4994
4995
4996/* Function 58 */
4998WINAPI
5001 DWORD ulFlags)
5002{
5004}
5005
5006
5007/* Function 59 */
5008DWORD
5009WINAPI
5012 DWORD_PTR hRecipient,
5013 LPWSTR pszName,
5014 BYTE *pNotificationFilter,
5015 DWORD ulNotificationFilterSize,
5016 DWORD ulFlags,
5017 PNP_NOTIFY_HANDLE *pNotifyHandle,
5018 DWORD ulProcessId,
5019 DWORD *pulUnknown9)
5020{
5021 PDEV_BROADCAST_DEVICEINTERFACE_W pBroadcastDeviceInterface;
5022 PDEV_BROADCAST_HANDLE pBroadcastDeviceHandle;
5023 PNOTIFY_ENTRY pNotifyData = NULL;
5025
5026 DPRINT1("PNP_RegisterNotification(%p %p '%S' %p %lu 0x%lx %p %lx %p)\n",
5027 hBinding, hRecipient, pszName, pNotificationFilter,
5028 ulNotificationFilterSize, ulFlags, pNotifyHandle, ulProcessId, pulUnknown9);
5029
5030 if (pNotifyHandle == NULL)
5031 return CR_INVALID_POINTER;
5032
5033 *pNotifyHandle = NULL;
5034
5035 if (pNotificationFilter == NULL ||
5036 pulUnknown9 == NULL)
5037 return CR_INVALID_POINTER;
5038
5039 if (ulFlags & ~0x7)
5040 return CR_INVALID_FLAG;
5041
5042 if ((ulNotificationFilterSize < sizeof(DEV_BROADCAST_HDR)) ||
5043 (((PDEV_BROADCAST_HDR)pNotificationFilter)->dbch_size < sizeof(DEV_BROADCAST_HDR)))
5044 return CR_INVALID_DATA;
5045
5046 if (((PDEV_BROADCAST_HDR)pNotificationFilter)->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE)
5047 {
5048 DPRINT1("DBT_DEVTYP_DEVICEINTERFACE\n");
5049 pBroadcastDeviceInterface = (PDEV_BROADCAST_DEVICEINTERFACE_W)pNotificationFilter;
5050
5051 if ((ulNotificationFilterSize < sizeof(DEV_BROADCAST_DEVICEINTERFACE_W)) ||
5052 (pBroadcastDeviceInterface->dbcc_size < sizeof(DEV_BROADCAST_DEVICEINTERFACE_W)))
5053 return CR_INVALID_DATA;
5054
5056 if (pNotifyData == NULL)
5057 {
5059 goto done;
5060 }
5061
5062 pNotifyData->dwType = CLASS_NOTIFICATION;
5063
5064 if (pszName != NULL)
5065 {
5066 pNotifyData->pszName = RtlAllocateHeap(GetProcessHeap(),
5068 (wcslen(pszName) + 1) * sizeof(WCHAR));
5069 if (pNotifyData->pszName == NULL)
5070 {
5072 goto done;
5073 }
5074
5075 wcscpy(pNotifyData->pszName, pszName);
5076 }
5077
5078 if ((ulFlags & DEVICE_NOTIFY_SERVICE_HANDLE) == DEVICE_NOTIFY_WINDOW_HANDLE)
5079 {
5080 pNotifyData->hRecipient = hRecipient;
5081 }
5082 else
5083 {
5084 DPRINT("Validate service: %S\n", pszName);
5086 pszName,
5087 (SERVICE_STATUS_HANDLE *)&pNotifyData->hRecipient) != ERROR_SUCCESS)
5088 {
5089 DPRINT1("I_ScValidatePnpService failed!\n");
5091 goto done;
5092 }
5093
5094 DPRINT("Service status handle: %p\n", pNotifyData->hRecipient);
5095 }
5096
5097 pNotifyData->ulFlags = ulFlags;
5098
5099 if ((ulFlags & DEVICE_NOTIFY_ALL_INTERFACE_CLASSES) == 0)
5100 {
5101 CopyMemory(&pNotifyData->ClassGuid,
5102 &pBroadcastDeviceInterface->dbcc_classguid,
5103 sizeof(GUID));
5104 }
5105
5106 /* Add the entry to the notification list */
5110
5111 DPRINT("pNotifyData: %p\n", pNotifyData);
5112 *pNotifyHandle = (PNP_NOTIFY_HANDLE)pNotifyData;
5113 }
5114 else if (((PDEV_BROADCAST_HDR)pNotificationFilter)->dbch_devicetype == DBT_DEVTYP_HANDLE)
5115 {
5116 DPRINT1("DBT_DEVTYP_HANDLE\n");
5117 pBroadcastDeviceHandle = (PDEV_BROADCAST_HANDLE)pNotificationFilter;
5118
5119 if ((ulNotificationFilterSize < sizeof(DEV_BROADCAST_HANDLE)) ||
5120 (pBroadcastDeviceHandle->dbch_size < sizeof(DEV_BROADCAST_HANDLE)))
5121 {
5123 goto done;
5124 }
5125
5126 if (ulFlags & DEVICE_NOTIFY_ALL_INTERFACE_CLASSES)
5127 {
5129 goto done;
5130 }
5131
5132 /* FIXME */
5133 }
5134 else
5135 {
5136 DPRINT1("Invalid device type %lu\n", ((PDEV_BROADCAST_HDR)pNotificationFilter)->dbch_devicetype);
5138 }
5139
5140done:
5141 if (ret != CR_SUCCESS)
5142 {
5143 if (pNotifyData)
5144 {
5145 if (pNotifyData->pszName)
5146 RtlFreeHeap(GetProcessHeap(), 0, pNotifyData->pszName);
5147
5148 RtlFreeHeap(GetProcessHeap(), 0, pNotifyData);
5149 }
5150 }
5151
5152 return ret;
5153}
5154
5155
5156/* Function 60 */
5157DWORD
5158WINAPI
5161 PNP_NOTIFY_HANDLE *pNotifyHandle)
5162{
5164
5165 DPRINT1("PNP_UnregisterNotification(%p %p)\n",
5166 hBinding, pNotifyHandle);
5167
5168 pEntry = (PNOTIFY_ENTRY)*pNotifyHandle;
5169 if (pEntry == NULL)
5170 return CR_INVALID_DATA;
5171
5173 RemoveEntryList(&pEntry->ListEntry);
5175
5176 if (pEntry->pszName)
5177 RtlFreeHeap(RtlGetProcessHeap(), 0, pEntry->pszName);
5178 RtlFreeHeap(RtlGetProcessHeap(), 0, pEntry);
5179 *pNotifyHandle = NULL;
5180
5181 return CR_SUCCESS;
5182}
5183
5184
5185/* Function 61 */
5186DWORD
5187WINAPI
5190 LPWSTR pDeviceID,
5191 LPWSTR CustomPropName,
5192 DWORD *pulRegDataType,
5193 BYTE *Buffer,
5194 PNP_RPC_STRING_LEN *pulTransferLen,
5195 PNP_RPC_STRING_LEN *pulLength,
5196 DWORD ulFlags)
5197{
5198 HKEY hDeviceKey = NULL;
5199 HKEY hParamKey = NULL;
5200 LONG lError;
5202
5204
5205 DPRINT("PNP_GetCustomDevProp() called\n");
5206
5207 if (pulTransferLen == NULL || pulLength == NULL)
5208 {
5210 goto done;
5211 }
5212
5213 if (ulFlags & ~CM_CUSTOMDEVPROP_BITS)
5214 {
5216 goto done;
5217 }
5218
5219 if (!IsValidDeviceInstanceID(pDeviceID))
5220 return CR_INVALID_DEVINST;
5221
5222 if (*pulLength < *pulTransferLen)
5223 *pulLength = *pulTransferLen;
5224
5225 *pulTransferLen = 0;
5226
5227 lError = RegOpenKeyExW(hEnumKey,
5228 pDeviceID,
5229 0,
5230 KEY_READ,
5231 &hDeviceKey);
5232 if (lError != ERROR_SUCCESS)
5233 {
5235 goto done;
5236 }
5237
5238 lError = RegOpenKeyExW(hDeviceKey,
5239 L"Device Parameters",
5240 0,
5241 KEY_READ,
5242 &hParamKey);
5243 if (lError != ERROR_SUCCESS)
5244 {
5246 goto done;
5247 }
5248
5249 lError = RegQueryValueExW(hParamKey,
5250 CustomPropName,
5251 NULL,
5252 pulRegDataType,
5253 Buffer,
5254 pulLength);
5255 if (lError != ERROR_SUCCESS)
5256 {
5257 if (lError == ERROR_MORE_DATA)
5258 {
5260 }
5261 else
5262 {
5263 *pulLength = 0;
5265 }
5266 }
5267
5268done:
5269 if (ret == CR_SUCCESS)
5270 *pulTransferLen = *pulLength;
5271
5272 if (hParamKey != NULL)
5273 RegCloseKey(hParamKey);
5274
5275 if (hDeviceKey != NULL)
5276 RegCloseKey(hDeviceKey);
5277
5278 DPRINT("PNP_GetCustomDevProp() done (returns %lx)\n", ret);
5279
5280 return ret;
5281}
5282
5283
5284/* Function 62 */
5285DWORD
5286WINAPI
5289 WORD *pwVersion)
5290{
5292
5293 *pwVersion = WINVER;
5294 return CR_SUCCESS;
5295}
5296
5297
5298/* Function 63 */
5299DWORD
5300WINAPI
5303 BYTE *Buffer,
5304 PNP_RPC_BUFFER_SIZE *pulTransferLen,
5305 PNP_RPC_BUFFER_SIZE *pulLength,
5306 DWORD ulFlags)
5307{
5310}
5311
5312
5313/* Function 64 */
5314DWORD
5315WINAPI
5318 DWORD *pulSSDIFlags,
5319 DWORD ulFlags)
5320{
5322
5323 DPRINT1("PNP_GetServerSideDeviceInstallFlags(%p %p %lu)\n",
5324 hBinding, pulSSDIFlags, ulFlags);
5325
5326 if (pulSSDIFlags == NULL)
5327 return CR_INVALID_POINTER;
5328
5329 if (ulFlags != 0)
5330 return CR_INVALID_FLAG;
5331
5332 /* FIXME */
5333 *pulSSDIFlags = 0;
5334
5335 return CR_SUCCESS;
5336}
5337
5338
5339/* Function 65 */
5340DWORD
5341WINAPI
5346 LPWSTR PropertyCultureName,
5347 PNP_PROP_COUNT *PropertyCount,
5348 PNP_PROP_COUNT *TransferLen,
5349 DEVPROPKEY *PropertyKeys,
5350 DWORD Flags)
5351{
5354}
5355
5356
5357/* Function 66 */
5358DWORD
5359WINAPI
5364 LPWSTR PropertyCultureName,
5365 const DEVPROPKEY *PropertyKey,
5367 PNP_PROP_SIZE *PropertySize,
5368 PNP_PROP_SIZE *TransferLen,
5370 DWORD Flags)
5371{
5374}
5375
5376
5377/* Function 67 */
5378DWORD
5379WINAPI
5384 LPWSTR PropertyCultureName,
5385 const DEVPROPKEY *PropertyKey,
5387 PNP_PROP_SIZE PropertySize,
5389 DWORD Flags)
5390{
5393}
5394
5395
5396/* Function 68 */
5397DWORD
5398WINAPI
5401{
5404}
5405
5406
5407/* Function 69 */
5408DWORD
5409WINAPI
5412{
5415}
5416
5417
5418/* Function 70 */
5419DWORD
5420WINAPI
5423{
5426}
5427
5428
5429/* Function 71 */
5430DWORD
5431WINAPI
5434{
5437}
5438
5439
5440/* Function 72 */
5441DWORD
5442WINAPI
5445{
5448}
5449
5450
5451/* Function 73 */
5452DWORD
5453WINAPI
5456 LPWSTR pszFilter,
5457 DWORD ulFlags)
5458{
5461}
5462
5463
5464/* Function 74 */
5465DWORD
5466WINAPI
5469{
5472}
static SERVICE_STATUS_HANDLE(WINAPI *pRegisterServiceCtrlHandlerExA)(LPCSTR
unsigned char BOOLEAN
UINT32 void void ** ReturnValue
Definition: acevents.h:216
LONG NTSTATUS
Definition: precomp.h:26
#define DPRINT1
Definition: precomp.h:8
HANDLE hInstallEvent
Definition: install.c:40
HANDLE hUserToken
Definition: install.c:39
#define LOGCONF_NAME_BUFFER_SIZE
Definition: precomp.h:38
@ CLASS_NOTIFICATION
Definition: precomp.h:48
struct NOTIFY_ENTRY * PNOTIFY_ENTRY
HKEY hEnumKey
Definition: umpnpmgr.c:44
BOOL g_ShuttingDown
Definition: umpnpmgr.c:47
HKEY hClassKey
Definition: umpnpmgr.c:45
DWORD WINAPI PNP_RegisterServiceNotification(handle_t hBinding)
Definition: rpcserver.c:5443
DWORD WINAPI PNP_GetVersion(handle_t hBinding, WORD *pVersion)
Definition: rpcserver.c:702
DWORD WINAPI PNP_GetInterfaceDeviceList(handle_t hBinding, GUID *InterfaceGuid, LPWSTR pszDeviceID, BYTE *Buffer, PNP_RPC_BUFFER_SIZE *pulLength, DWORD ulFlags)
Definition: rpcserver.c:2649
DWORD WINAPI PNP_SetHwProf(handle_t hBinding, DWORD ulHardwareProfile, DWORD ulFlags)
Definition: rpcserver.c:4955
DWORD WINAPI PNP_UnregisterNotification(handle_t hBinding, PNP_NOTIFY_HANDLE *pNotifyHandle)
Definition: rpcserver.c:5159
static CONFIGRET GetDeviceInstanceListSize(_In_ LPCWSTR pszDevice, _Out_ PULONG pulLength)
Definition: rpcserver.c:1617
DWORD WINAPI PNP_InstallDevInst(handle_t hBinding)
Definition: rpcserver.c:5399
DWORD WINAPI PNP_DriverStoreDeleteDriverPackage(handle_t hBinding)
Definition: rpcserver.c:5432
static CONFIGRET GetServiceInstanceListSize(_In_ PWSTR pszService, _Out_ PDWORD pulLength)
Definition: rpcserver.c:1518
DWORD WINAPI PNP_QueryResConfList(handle_t hBinding, LPWSTR pDeviceID, RESOURCEID ResourceID, BYTE *ResourceData, PNP_RPC_BUFFER_SIZE ResourceLen, BYTE *Buffer, PNP_RPC_BUFFER_SIZE BufferLen, DWORD ulFlags)
Definition: rpcserver.c:4937
DWORD WINAPI PNP_Connect(handle_t hBinding)
Definition: rpcserver.c:691
DWORD WINAPI PNP_GetRelatedDeviceInstance(handle_t hBinding, DWORD ulRelationship, LPWSTR pDeviceID, LPWSTR pRelatedDeviceId, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
Definition: rpcserver.c:895
DWORD WINAPI PNP_EnumerateSubKeys(handle_t hBinding, DWORD ulBranch, DWORD ulIndex, LPWSTR Buffer, PNP_RPC_STRING_LEN ulLength, PNP_RPC_STRING_LEN *pulRequiredLen, DWORD ulFlags)
Definition: rpcserver.c:973
DWORD WINAPI PNP_SetActiveService(handle_t hBinding, LPWSTR pszFilter, DWORD ulFlags)
Definition: rpcserver.c:5454
LUID LoadDriverPrivilege
Definition: rpcserver.c:40
DWORD WINAPI PNP_UnregisterDeviceClassAssociation(handle_t hBinding, LPWSTR pszInterfaceDevice, DWORD ulFlags)
Definition: rpcserver.c:2762
DWORD WINAPI PNP_DetectResourceConflict(handle_t hBinding, LPWSTR pDeviceID, RESOURCEID ResourceID, BYTE *ResourceData, PNP_RPC_BUFFER_SIZE ResourceLen, BOOL *pbConflictDetected, DWORD ulFlags)
Definition: rpcserver.c:4916
static CONFIGRET WINAPI NtStatusToCrError(NTSTATUS Status)
Definition: rpcserver.c:127
DWORD WINAPI PNP_GetDeviceListSize(handle_t hBinding, LPWSTR pszFilter, PNP_RPC_BUFFER_SIZE *pulLength, DWORD ulFlags)
Definition: rpcserver.c:1765
DWORD WINAPI PNP_InitDetection(handle_t hBinding)
Definition: rpcserver.c:745
DWORD WINAPI PNP_AddEmptyLogConf(handle_t hBinding, LPWSTR pDeviceID, DWORD ulPriority, DWORD *pulLogConfTag, DWORD ulFlags)
Definition: rpcserver.c:4209
DWORD WINAPI PNP_ApplyPowerSettings(handle_t hBinding)
Definition: rpcserver.c:5410
DWORD WINAPI PNP_GetClassCount(handle_t hBinding, DWORD *pulClassCount, DWORD ulFlags)
Definition: rpcserver.c:2497
DWORD WINAPI PNP_GetClassRegProp(handle_t hBinding, LPWSTR pszClassGuid, DWORD ulProperty, DWORD *pulRegDataType, BYTE *Buffer, PNP_RPC_STRING_LEN *pulTransferLen, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
Definition: rpcserver.c:2775
DWORD WINAPI PNP_GetServerSideDeviceInstallFlags(handle_t hBinding, DWORD *pulSSDIFlags, DWORD ulFlags)
Definition: rpcserver.c:5316
DWORD WINAPI PNP_FreeLogConf(handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfType, DWORD ulLogConfTag, DWORD ulFlags)
Definition: rpcserver.c:4394
LIST_ENTRY NotificationListHead
Definition: rpcserver.c:42
DWORD WINAPI PNP_GetDeviceRegProp(handle_t hBinding, LPWSTR pDeviceID, DWORD ulProperty, DWORD *pulRegDataType, BYTE *Buffer, PNP_PROP_SIZE *pulTransferLen, PNP_PROP_SIZE *pulLength, DWORD ulFlags)
Definition: rpcserver.c:1883
DWORD WINAPI PNP_GetBlockedDriverInfo(handle_t hBinding, BYTE *Buffer, PNP_RPC_BUFFER_SIZE *pulTransferLen, PNP_RPC_BUFFER_SIZE *pulLength, DWORD ulFlags)
Definition: rpcserver.c:5301
DWORD WINAPI PNP_GetInterfaceDeviceListSize(handle_t hBinding, PNP_RPC_BUFFER_SIZE *pulLen, GUID *InterfaceGuid, LPWSTR pszDeviceID, DWORD ulFlags)
Definition: rpcserver.c:2697
static WCHAR szRootDeviceInstanceID[]
Definition: rpcserver.c:39
DWORD WINAPI PNP_UninstallDevInst(handle_t hBinding, LPWSTR pDeviceID, DWORD ulFlags)
Definition: rpcserver.c:3620
static VOID AppendDeviceId(LPWSTR lpDeviceIdList, LPDWORD lpDeviceIdListSize, LPWSTR lpDeviceId)
Definition: rpcserver.c:3652
DWORD WINAPI PNP_GetDeviceStatus(handle_t hBinding, LPWSTR pDeviceID, DWORD *pulStatus, DWORD *pulProblem, DWORD ulFlags)
Definition: rpcserver.c:3459
DWORD WINAPI PNP_GetClassInstance(handle_t hBinding, LPWSTR pDeviceId, LPWSTR pszClassInstance, PNP_RPC_STRING_LEN ulLength)
Definition: rpcserver.c:2302
static BOOL CheckForDeviceId(LPWSTR lpDeviceIdList, LPWSTR lpDeviceId)
Definition: rpcserver.c:3631
DWORD WINAPI PNP_DeviceInstanceAction(handle_t hBinding, DWORD ulMajorAction, DWORD ulMinorAction, LPWSTR pszDeviceInstance1, LPWSTR pszDeviceInstance2)
Definition: rpcserver.c:3414
static CONFIGRET GetAllInstanceListSize(_Out_ PULONG pulLength)
Definition: rpcserver.c:1730
VOID __RPC_USER PNP_NOTIFY_HANDLE_rundown(PNP_NOTIFY_HANDLE pHandle)
Definition: rpcserver.c:668
DWORD WINAPI PNP_RegisterDriver(handle_t hBinding, LPWSTR pszDeviceID, DWORD ulFlags)
Definition: rpcserver.c:3782
static CONFIGRET GenerateDeviceID(_Inout_ LPWSTR pszDeviceID, _In_ PNP_RPC_STRING_LEN ulLength)
Definition: rpcserver.c:3124
DWORD WINAPI PNP_GetDepth(handle_t hBinding, LPWSTR pszDeviceID, DWORD *pulDepth, DWORD ulFlags)
Definition: rpcserver.c:1840
DWORD WINAPI PNP_HwProfFlags(handle_t hBinding, DWORD ulAction, LPWSTR pDeviceID, DWORD ulConfig, DWORD *pulValue, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, DWORD ulNameLength, DWORD ulFlags)
Definition: rpcserver.c:3990
static CONFIGRET SetDeviceStatus(_In_ LPWSTR pszDeviceID, _In_ DWORD ulStatus, _In_ DWORD ulProblem)
Definition: rpcserver.c:267
DWORD WINAPI PNP_DisableDevInst(handle_t hBinding, LPWSTR pDeviceID, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, DWORD ulNameLength, DWORD ulFlags)
Definition: rpcserver.c:3590
static CONFIGRET OpenConfigurationKey(_In_ LPCWSTR pszDeviceID, _In_ DWORD ulLogConfType, _Out_ PHKEY phKey)
Definition: rpcserver.c:432
DWORD WINAPI PNP_GetClassName(handle_t hBinding, LPWSTR pszClassGuid, LPWSTR Buffer, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
Definition: rpcserver.c:2542
RTL_RESOURCE NotificationListLock
Definition: rpcserver.c:43
DWORD WINAPI PNP_RequestDeviceEject(handle_t hBinding, LPWSTR pszDeviceID, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, DWORD ulNameLength, DWORD ulFlags)
Definition: rpcserver.c:3854
DWORD WINAPI PNP_GetObjectProp(handle_t hBinding, LPWSTR ObjectName, DWORD ObjectType, LPWSTR PropertyCultureName, const DEVPROPKEY *PropertyKey, DEVPROPTYPE *PropertyType, PNP_PROP_SIZE *PropertySize, PNP_PROP_SIZE *TransferLen, BYTE *PropertyBuffer, DWORD Flags)
Definition: rpcserver.c:5360
DWORD WINAPI PNP_GetLogConfPriority(handle_t hBinding, LPWSTR pDeviceID, DWORD ulType, DWORD ulTag, DWORD *pPriority, DWORD ulFlags)
Definition: rpcserver.c:4708
static CONFIGRET SetupDeviceInstance(_In_ LPWSTR pszDeviceInstance, _In_ DWORD ulMinorAction)
Definition: rpcserver.c:3276
DWORD WINAPI PNP_GetObjectPropKeys(handle_t hBinding, LPWSTR ObjectName, DWORD ObjectType, LPWSTR PropertyCultureName, PNP_PROP_COUNT *PropertyCount, PNP_PROP_COUNT *TransferLen, DEVPROPKEY *PropertyKeys, DWORD Flags)
Definition: rpcserver.c:5342
DWORD WINAPI PNP_GetInterfaceDeviceAlias(handle_t hBinding, LPWSTR pszInterfaceDevice, GUID *AliasInterfaceGuid, LPWSTR pszAliasInterfaceDevice, PNP_RPC_STRING_LEN *pulLength, PNP_RPC_STRING_LEN *pulTransferLen, DWORD ulFlags)
Definition: rpcserver.c:2632
static PCM_FULL_RESOURCE_DESCRIPTOR NextResourceDescriptor(_In_ PCM_FULL_RESOURCE_DESCRIPTOR pDescriptor)
Definition: rpcserver.c:583
static CONFIGRET GetDeviceStatus(_In_ LPWSTR pszDeviceID, _Out_ DWORD *pulStatus, _Out_ DWORD *pulProblem)
Definition: rpcserver.c:232
DWORD WINAPI RpcServerThread(LPVOID lpParameter)
Definition: rpcserver.c:48
static CONFIGRET GetDeviceInstanceList(_In_ PWSTR pszDevice, _Inout_ PWSTR pszBuffer, _Inout_ PDWORD pulLength)
Definition: rpcserver.c:1203
CONFIGRET GetEnumeratorInstanceList(_In_ PWSTR pszEnumerator, _Inout_ PWSTR pszBuffer, _Inout_ PDWORD pulLength)
Definition: rpcserver.c:1274
static CONFIGRET ClearDeviceStatus(_In_ LPWSTR pszDeviceID, _In_ DWORD ulStatus, _In_ DWORD ulProblem)
Definition: rpcserver.c:202
DWORD WINAPI PNP_RequestEjectPC(handle_t hBinding)
Definition: rpcserver.c:3958
DWORD WINAPI PNP_DeleteServiceDevices(handle_t hBinding)
Definition: rpcserver.c:5467
DWORD WINAPI PNP_CreateDevInst(handle_t hBinding, LPWSTR pszDeviceID, LPWSTR pszParentDeviceID, PNP_RPC_STRING_LEN ulLength, DWORD ulFlags)
Definition: rpcserver.c:3174
static CONFIGRET GetRelationsInstanceList(_In_ PWSTR pszDevice, _In_ DWORD ulFlags, _Inout_ PWSTR pszBuffer, _Inout_ PDWORD pulLength)
Definition: rpcserver.c:1033
DWORD WINAPI PNP_SetDeviceRegProp(handle_t hBinding, LPWSTR pDeviceId, DWORD ulProperty, DWORD ulDataType, BYTE *Buffer, PNP_PROP_SIZE ulLength, DWORD ulFlags)
Definition: rpcserver.c:2160
static CONFIGRET GetAllInstanceList(_Inout_ PWSTR pszBuffer, _Inout_ PDWORD pulLength)
Definition: rpcserver.c:1345
DWORD WINAPI PNP_AddID(handle_t hBinding, LPWSTR pszDeviceID, LPWSTR pszID, DWORD ulFlags)
Definition: rpcserver.c:3675
DWORD WINAPI PNP_QueryRemove(handle_t hBinding, LPWSTR pszDeviceID, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, DWORD ulNameLength, DWORD ulFlags)
Definition: rpcserver.c:3805
DWORD WINAPI PNP_GetFirstLogConf(handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfType, DWORD *pulLogConfTag, DWORD ulFlags)
Definition: rpcserver.c:4488
static BOOL IsPresentDeviceInstanceID(_In_ LPWSTR pszDeviceInstanceID)
Definition: rpcserver.c:421
DWORD WINAPI PNP_SetClassRegProp(handle_t hBinding, LPWSTR pszClassGuid, DWORD ulProperty, DWORD ulDataType, BYTE *Buffer, PNP_PROP_SIZE ulLength, DWORD ulFlags)
Definition: rpcserver.c:2901
static VOID SplitDeviceInstanceID(IN LPWSTR pszDeviceInstanceID, OUT LPWSTR pszEnumerator, OUT LPWSTR pszDevice, OUT LPWSTR pszInstance)
Definition: rpcserver.c:156
DWORD WINAPI PNP_GetNextLogConf(handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfType, DWORD ulCurrentTag, DWORD *pulNextTag, DWORD ulFlags)
Definition: rpcserver.c:4589
DWORD WINAPI PNP_GetGlobalState(handle_t hBinding, DWORD *pulState, DWORD ulFlags)
Definition: rpcserver.c:720
CONFIGRET WINAPI PNP_IsDockStationPresent(handle_t hBinding, BOOL *Present)
Definition: rpcserver.c:3902
DWORD WINAPI PNP_RegisterNotification(handle_t hBinding, DWORD_PTR hRecipient, LPWSTR pszName, BYTE *pNotificationFilter, DWORD ulNotificationFilterSize, DWORD ulFlags, PNP_NOTIFY_HANDLE *pNotifyHandle, DWORD ulProcessId, DWORD *pulUnknown9)
Definition: rpcserver.c:5010
DWORD WINAPI PNP_GetHwProfInfo(handle_t hBinding, DWORD ulIndex, HWPROFILEINFO *pHWProfileInfo, DWORD ulProfileInfoSize, DWORD ulFlags)
Definition: rpcserver.c:4074
DWORD WINAPI PNP_FreeResDes(handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfTag, DWORD ulLogConfType, RESOURCEID ResourceID, DWORD ulResourceTag, DWORD *pulPreviousResType, DWORD *pulPreviousResTag, DWORD ulFlags)
Definition: rpcserver.c:4743
DWORD WINAPI PNP_AddResDes(handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfTag, DWORD ulLogConfType, RESOURCEID ResourceID, DWORD *pulResourceTag, BYTE *ResourceData, PNP_RPC_BUFFER_SIZE ResourceLen, DWORD ulFlags)
Definition: rpcserver.c:4724
DWORD WINAPI PNP_SetDeviceProblem(handle_t hBinding, LPWSTR pDeviceID, DWORD ulProblem, DWORD ulFlags)
Definition: rpcserver.c:3537
CONFIGRET WINAPI PNP_RunDetection(handle_t hBinding, DWORD ulFlags)
Definition: rpcserver.c:4999
static CONFIGRET ReenumerateDeviceInstance(_In_ LPWSTR pszDeviceInstance, _In_ ULONG ulMinorAction)
Definition: rpcserver.c:3378
static CONFIGRET GetServiceInstanceList(_In_ PWSTR pszService, _Inout_ PWSTR pszBuffer, _Inout_ PDWORD pulLength)
Definition: rpcserver.c:1084
DWORD WINAPI PNP_CreateKey(handle_t hBinding, LPWSTR pszSubKey, DWORD samDesired, DWORD ulFlags)
Definition: rpcserver.c:2418
DWORD WINAPI PNP_GetResDesDataSize(handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfTag, DWORD ulLogConfType, RESOURCEID ResourceID, DWORD ulResourceTag, DWORD *pulSize, DWORD ulFlags)
Definition: rpcserver.c:4878
DWORD WINAPI PNP_GetRootDeviceInstance(handle_t hBinding, LPWSTR pDeviceID, PNP_RPC_STRING_LEN ulLength)
Definition: rpcserver.c:858
DWORD WINAPI PNP_GetDeviceList(handle_t hBinding, LPWSTR pszFilter, LPWSTR Buffer, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
Definition: rpcserver.c:1394
DWORD WINAPI PNP_SetObjectProp(handle_t hBinding, LPWSTR ObjectName, DWORD ObjectType, LPWSTR PropertyCultureName, const DEVPROPKEY *PropertyKey, DEVPROPTYPE PropertyType, PNP_PROP_SIZE PropertySize, BYTE *PropertyBuffer, DWORD Flags)
Definition: rpcserver.c:5380
static BOOL IsCallerInteractive(_In_ handle_t hBinding)
Definition: rpcserver.c:618
static CONFIGRET GetRelationsInstanceListSize(_In_ PWSTR pszDevice, _In_ DWORD ulFlags, _Inout_ PDWORD pulLength)
Definition: rpcserver.c:1468
static CONFIGRET EnableDeviceInstance(_In_ LPWSTR pszDeviceInstance)
Definition: rpcserver.c:3359
DWORD WINAPI PNP_GetCustomDevProp(handle_t hBinding, LPWSTR pDeviceID, LPWSTR CustomPropName, DWORD *pulRegDataType, BYTE *Buffer, PNP_RPC_STRING_LEN *pulTransferLen, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
Definition: rpcserver.c:5188
DWORD WINAPI PNP_DeleteRegistryKey(handle_t hBinding, LPWSTR pszDeviceID, LPWSTR pszParentKey, LPWSTR pszChildKey, DWORD ulFlags)
Definition: rpcserver.c:2482
DWORD WINAPI PNP_Disconnect(handle_t hBinding)
Definition: rpcserver.c:680
DWORD WINAPI PNP_QueryArbitratorFreeData(handle_t hBinding, BYTE *pData, DWORD DataLen, LPWSTR pDeviceID, RESOURCEID ResourceID, DWORD ulFlags)
Definition: rpcserver.c:4967
static CONFIGRET DisableDeviceInstance(_In_ LPWSTR pszDeviceInstance, _Inout_opt_ PPNP_VETO_TYPE pVetoType, _Inout_opt_ LPWSTR pszVetoName, _In_ DWORD ulNameLength)
Definition: rpcserver.c:297
DWORD WINAPI PNP_ReportLogOn(handle_t hBinding, BOOL Admin, DWORD ProcessId)
Definition: rpcserver.c:760
static BOOL IsRootDeviceInstanceID(_In_ PWSTR pszDeviceInstanceID)
Definition: rpcserver.c:409
DWORD WINAPI PNP_GetNextResDes(handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfTag, DWORD ulLogConfType, RESOURCEID ResourceID, DWORD ulResourceTag, DWORD *pulNextResType, DWORD *pulNextResTag, DWORD ulFlags)
Definition: rpcserver.c:4762
DWORD WINAPI PNP_GetResDesData(handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfTag, DWORD ulLogConfType, RESOURCEID ResourceID, DWORD ulResourceTag, BYTE *Buffer, PNP_RPC_BUFFER_SIZE BufferLen, DWORD ulFlags)
Definition: rpcserver.c:4859
static CONFIGRET GetConfigurationData(_In_ HKEY hKey, _In_ ULONG ulLogConfType, _Out_ PULONG pulRegDataType, _Out_ PULONG pulDataSize, _Out_ LPBYTE *ppBuffer, _In_ ULONG ulValueNameBufferSize, _Out_opt_ LPWSTR pszValueNameBuffer)
Definition: rpcserver.c:495
DWORD WINAPI PNP_ValidateDeviceInstance(handle_t hBinding, LPWSTR pDeviceID, DWORD ulFlags)
Definition: rpcserver.c:815
DWORD WINAPI PNP_ModifyResDes(handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfTag, DWORD ulLogConfType, RESOURCEID CurrentResourceID, RESOURCEID NewResourceID, DWORD ulResourceTag, BYTE *ResourceData, PNP_RPC_BUFFER_SIZE ResourceLen, DWORD ulFlags)
Definition: rpcserver.c:4896
DWORD WINAPI PNP_QueryArbitratorFreeSize(handle_t hBinding, DWORD *pulSize, LPWSTR pDeviceID, RESOURCEID ResourceID, DWORD ulFlags)
Definition: rpcserver.c:4982
static CONFIGRET GetEnumeratorInstanceListSize(_In_ LPCWSTR pszEnumerator, _Out_ PULONG pulLength)
Definition: rpcserver.c:1669
DWORD WINAPI PNP_DriverStoreAddDriverPackage(handle_t hBinding)
Definition: rpcserver.c:5421
DWORD WINAPI PNP_DeleteClassKey(handle_t hBinding, LPWSTR pszClassGuid, DWORD ulFlags)
Definition: rpcserver.c:2600
static BOOL IsValidDeviceInstanceID(_In_ PWSTR pszDeviceInstanceID)
Definition: rpcserver.c:343
DWORD WINAPI PNP_GetVersionInternal(handle_t hBinding, WORD *pwVersion)
Definition: rpcserver.c:5287
static CONFIGRET CreateDeviceInstance(_In_ LPWSTR pszDeviceID, _In_ BOOL bPhantomDevice)
Definition: rpcserver.c:3004
DWORD WINAPI PNP_RegisterDeviceClassAssociation(handle_t hBinding, LPWSTR pszDeviceID, GUID *InterfaceGuid, LPWSTR pszReference, LPWSTR pszSymLink, PNP_RPC_STRING_LEN *pulLength, PNP_RPC_STRING_LEN *pulTransferLen, DWORD ulFlags)
Definition: rpcserver.c:2744
static HANDLE hServicesKey
Definition: devinst.c:21
static SID_IDENTIFIER_AUTHORITY NtAuthority
Definition: security.c:40
#define UNIMPLEMENTED
Definition: ntoskrnl.c:15
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:616
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:634
#define RegCloseKey(hKey)
Definition: registry.h:49
@ PNP_VetoTypeUnknown
Definition: cfg.h:180
#define DN_REMOVABLE
Definition: cfg.h:132
#define DN_HAS_PROBLEM
Definition: cfg.h:128
#define DN_STARTED
Definition: cfg.h:121
#define DN_MANUAL
Definition: cfg.h:122
#define CM_PROB_FAILED_INSTALL
Definition: cfg.h:58
enum _PNP_VETO_TYPE * PPNP_VETO_TYPE
#define CM_DRP_BUSNUMBER
Definition: cfgmgr32.h:703
#define CM_REGISTER_DEVICE_DRIVER_BITS
Definition: cfgmgr32.h:798
#define CM_DRP_LOCATION_INFORMATION
Definition: cfgmgr32.h:689
#define CM_DRP_CONFIGFLAGS
Definition: cfgmgr32.h:686
#define CR_INVALID_PROPERTY
Definition: cfgmgr32.h:899
#define FILTERED_LOG_CONF
Definition: cfgmgr32.h:597
#define CM_SETUP_DOWNLOAD
Definition: cfgmgr32.h:821
#define CM_CUSTOMDEVPROP_BITS
Definition: cfgmgr32.h:836
#define CR_INVALID_DATA
Definition: cfgmgr32.h:877
#define CM_DRP_REMOVAL_POLICY
Definition: cfgmgr32.h:719
#define CM_DRP_ENUMERATOR_NAME
Definition: cfgmgr32.h:704
#define CM_ADD_ID_COMPATIBLE
Definition: cfgmgr32.h:615
#define BASIC_LOG_CONF
Definition: cfgmgr32.h:596
#define CM_DRP_REMOVAL_POLICY_HW_DEFAULT
Definition: cfgmgr32.h:720
#define CR_INVALID_DEVICE_ID
Definition: cfgmgr32.h:876
#define CM_DRP_BUSTYPEGUID
Definition: cfgmgr32.h:701
#define CR_NO_MORE_LOG_CONF
Definition: cfgmgr32.h:859
#define CR_OUT_OF_MEMORY
Definition: cfgmgr32.h:844
#define CR_INVALID_LOG_CONF
Definition: cfgmgr32.h:850
#define CM_GETIDLIST_FILTER_BITS
Definition: cfgmgr32.h:669
#define CM_DRP_LOWERFILTERS
Definition: cfgmgr32.h:697
#define CM_DRP_SECURITY
Definition: cfgmgr32.h:705
#define CM_SET_DEVNODE_PROBLEM_BITS
Definition: cfgmgr32.h:808
#define CM_CRP_DEVTYPE
Definition: cfgmgr32.h:710
#define CM_DRP_MFG
Definition: cfgmgr32.h:687
#define CM_DRP_EXCLUSIVE
Definition: cfgmgr32.h:711
#define CM_DRP_DRIVER
Definition: cfgmgr32.h:685
#define CR_NO_SUCH_DEVINST
Definition: cfgmgr32.h:858
#define CM_GETIDLIST_FILTER_REMOVALRELATIONS
Definition: cfgmgr32.h:658
#define CM_SETUP_BITS
Definition: cfgmgr32.h:828
#define CM_DRP_LOCATION_PATHS
Definition: cfgmgr32.h:725
#define CM_DRP_REMOVAL_POLICY_OVERRIDE
Definition: cfgmgr32.h:721
#define CM_DRP_CAPABILITIES
Definition: cfgmgr32.h:691
#define CM_DRP_UPPERFILTERS
Definition: cfgmgr32.h:693
#define CR_FAILURE
Definition: cfgmgr32.h:865
#define CM_SETUP_WRITE_LOG_CONFS
Definition: cfgmgr32.h:822
#define CM_DRP_CLASSGUID
Definition: cfgmgr32.h:684
#define CONFIGMG_VERSION
Definition: cfgmgr32.h:64
#define CM_DRP_COMPATIBLEIDS
Definition: cfgmgr32.h:678
ULONG RESOURCEID
Definition: cfgmgr32.h:96
#define CR_INVALID_DEVINST
Definition: cfgmgr32.h:848
#define CM_DRP_DEVICEDESC
Definition: cfgmgr32.h:676
#define LOG_CONF_BITS
Definition: cfgmgr32.h:603
#define CM_REENUMERATE_BITS
Definition: cfgmgr32.h:793
#define CM_DRP_CLASS
Definition: cfgmgr32.h:683
#define CM_GETIDLIST_FILTER_EJECTRELATIONS
Definition: cfgmgr32.h:657
#define CM_REENUMERATE_RETRY_INSTALLATION
Definition: cfgmgr32.h:790
#define CM_CRP_SECURITY
Definition: cfgmgr32.h:706
#define PRIORITY_BIT
Definition: cfgmgr32.h:607
#define CR_ACCESS_DENIED
Definition: cfgmgr32.h:897
#define BOOT_LOG_CONF
Definition: cfgmgr32.h:599
#define CM_DRP_LEGACYBUSTYPE
Definition: cfgmgr32.h:702
#define CM_DRP_PHYSICAL_DEVICE_OBJECT_NAME
Definition: cfgmgr32.h:690
#define CR_INVALID_FLAG
Definition: cfgmgr32.h:846
#define CM_SET_DEVNODE_PROBLEM_OVERRIDE
Definition: cfgmgr32.h:807
#define CM_DRP_DEVTYPE
Definition: cfgmgr32.h:709
#define CM_DELETE_CLASS_SUBKEYS
Definition: cfgmgr32.h:635
#define CM_GLOBAL_STATE_SERVICES_AVAILABLE
Definition: cfgmgr32.h:910
#define CM_GETIDLIST_FILTER_ENUMERATOR
Definition: cfgmgr32.h:655
#define CR_ALREADY_SUCH_DEVINST
Definition: cfgmgr32.h:862
#define CM_GLOBAL_STATE_CAN_DO_UI
Definition: cfgmgr32.h:908
#define CM_GETIDLIST_FILTER_BUSRELATIONS
Definition: cfgmgr32.h:660
#define CM_DRP_FRIENDLYNAME
Definition: cfgmgr32.h:688
#define CM_DRP_INSTALL_STATE
Definition: cfgmgr32.h:722
#define CM_DRP_UI_NUMBER
Definition: cfgmgr32.h:692
#define OVERRIDE_LOG_CONF
Definition: cfgmgr32.h:601
#define ALLOC_LOG_CONF
Definition: cfgmgr32.h:598
#define CM_DRP_CHARACTERISTICS
Definition: cfgmgr32.h:713
#define CR_NO_SUCH_DEVNODE
Definition: cfgmgr32.h:857
#define CM_CRP_EXCLUSIVE
Definition: cfgmgr32.h:712
#define CM_CREATE_DEVNODE_BITS
Definition: cfgmgr32.h:624
#define CM_DRP_BASE_CONTAINERID
Definition: cfgmgr32.h:728
#define CR_BUFFER_SMALL
Definition: cfgmgr32.h:872
#define CM_GETIDLIST_FILTER_POWERRELATIONS
Definition: cfgmgr32.h:659
#define FORCED_LOG_CONF
Definition: cfgmgr32.h:600
#define CR_CALL_NOT_IMPLEMENTED
Definition: cfgmgr32.h:898
#define CM_DEVCAP_REMOVABLE
Definition: cfgmgr32.h:737
#define CM_CREATE_DEVNODE_GENERATE_ID
Definition: cfgmgr32.h:622
RETURN_TYPE CONFIGRET
Definition: cfgmgr32.h:74
#define CM_DRP_UI_NUMBER_DESC_FORMAT
Definition: cfgmgr32.h:716
#define CR_INVALID_POINTER
Definition: cfgmgr32.h:845
#define CM_GETIDLIST_FILTER_SERVICE
Definition: cfgmgr32.h:656
#define CR_SUCCESS
Definition: cfgmgr32.h:842
#define CM_DRP_ADDRESS
Definition: cfgmgr32.h:715
#define CR_NO_SUCH_VALUE
Definition: cfgmgr32.h:883
#define CM_CRP_CHARACTERISTICS
Definition: cfgmgr32.h:714
#define CM_CREATE_DEVNODE_PHANTOM
Definition: cfgmgr32.h:621
#define CM_GLOBAL_STATE_SHUTTING_DOWN
Definition: cfgmgr32.h:911
#define CM_REMOVE_BITS
Definition: cfgmgr32.h:780
#define CM_GETIDLIST_FILTER_NONE
Definition: cfgmgr32.h:654
#define CM_DRP_DEVICE_POWER_DATA
Definition: cfgmgr32.h:718
#define CM_DRP_HARDWAREID
Definition: cfgmgr32.h:677
#define CR_NO_SUCH_REGISTRY_KEY
Definition: cfgmgr32.h:892
#define CM_DISABLE_BITS
Definition: cfgmgr32.h:652
#define CM_DRP_SERVICE
Definition: cfgmgr32.h:680
#define CR_INVALID_DEVNODE
Definition: cfgmgr32.h:847
#define CR_REGISTRY_ERROR
Definition: cfgmgr32.h:875
#define CR_REMOVE_VETOED
Definition: cfgmgr32.h:869
Definition: bufpool.h:45
wcscat
wcscpy
handle_t hBinding
Definition: ctx_c.c:54
#define STATUS_NOT_IMPLEMENTED
Definition: d3dkmdt.h:42
#define DBT_DEVTYP_HANDLE
Definition: dbt.h:25
struct _DEV_BROADCAST_DEVICEINTERFACE_W DEV_BROADCAST_DEVICEINTERFACE_W
struct _DEV_BROADCAST_HANDLE DEV_BROADCAST_HANDLE
#define DBT_DEVTYP_DEVICEINTERFACE
Definition: dbt.h:24
struct _DEV_BROADCAST_HANDLE * PDEV_BROADCAST_HANDLE
struct _DEV_BROADCAST_DEVICEINTERFACE_W * PDEV_BROADCAST_DEVICEINTERFACE_W
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define ERROR_SUCCESS
Definition: deptool.c:10
#define MAX_DEVICE_ID_LEN
Definition: devaction.c:40
ULONG DEVPROPTYPE
Definition: devpropdef.h:24
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
LONG WINAPI RegCreateKeyExW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ DWORD Reserved, _In_opt_ LPWSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_opt_ LPDWORD lpdwDisposition)
Definition: reg.c:1096
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
LONG WINAPI RegEnumKeyExW(_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPWSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPWSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)
Definition: reg.c:2504
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
Definition: reg.c:4882
LONG WINAPI RegDeleteKeyW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey)
Definition: reg.c:1239
LONG WINAPI RegDeleteValueW(HKEY hKey, LPCWSTR lpValueName)
Definition: reg.c:2330
LONG WINAPI RegQueryInfoKeyW(HKEY hKey, LPWSTR lpClass, LPDWORD lpcClass, LPDWORD lpReserved, LPDWORD lpcSubKeys, LPDWORD lpcMaxSubKeyLen, LPDWORD lpcMaxClassLen, LPDWORD lpcValues, LPDWORD lpcMaxValueNameLen, LPDWORD lpcMaxValueLen, LPDWORD lpcbSecurityDescriptor, PFILETIME lpftLastWriteTime)
Definition: reg.c:3662
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4103
BOOL WINAPI CheckTokenMembership(IN HANDLE ExistingTokenHandle, IN PSID SidToCheck, OUT PBOOL IsMember)
Definition: token.c:21
BOOL WINAPI OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle)
Definition: security.c:294
BOOL WINAPI AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount, DWORD nSubAuthority0, DWORD nSubAuthority1, DWORD nSubAuthority2, DWORD nSubAuthority3, DWORD nSubAuthority4, DWORD nSubAuthority5, DWORD nSubAuthority6, DWORD nSubAuthority7, PSID *pSid)
Definition: security.c:674
BOOL WINAPI OpenThreadToken(HANDLE ThreadHandle, DWORD DesiredAccess, BOOL OpenAsSelf, HANDLE *TokenHandle)
Definition: security.c:336
PVOID WINAPI FreeSid(PSID pSid)
Definition: security.c:698
#define CloseHandle
Definition: compat.h:739
#define wcschr
Definition: compat.h:17
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
#define HeapReAlloc
Definition: compat.h:734
#define ERROR_NO_MORE_ITEMS
Definition: compat.h:105
#define MAX_PATH
Definition: compat.h:34
#define HeapFree(x, y, z)
Definition: compat.h:735
#define lstrcpyW
Definition: compat.h:749
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
#define lstrlenW
Definition: compat.h:750
static DWORD DWORD * dwLength
Definition: fusion.c:86
static void cleanup(void)
Definition: main.c:1335
HANDLE WINAPI OpenProcess(IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwProcessId)
Definition: proc.c:1227
DWORD WINAPI SHDeleteKeyW(HKEY hKey, LPCWSTR lpszSubKey)
Definition: reg.c:1546
#define swprintf
Definition: precomp.h:40
#define RemoveEntryList(Entry)
Definition: env_spec_w32.h:986
#define InsertTailList(ListHead, Entry)
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
IN PLARGE_INTEGER IN PLARGE_INTEGER PEPROCESS ProcessId
Definition: fatprocs.h:2712
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
_In_ WDFDEVICE _In_ PWDF_DEVICE_INTERFACE_PROPERTY_DATA _In_ ULONG _Out_ PVOID _Out_ PULONG _Out_ PDEVPROPTYPE PropertyType
FxAutoRegKey hKey
PLIST_ENTRY pEntry
Definition: fxioqueue.cpp:4484
Status
Definition: gdiplustypes.h:25
GLfloat GLfloat p
Definition: glext.h:8902
GLenum GLsizei len
Definition: glext.h:6722
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
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 * u
Definition: glfuncs.h:240
struct _CM_FULL_RESOURCE_DESCRIPTOR CM_FULL_RESOURCE_DESCRIPTOR
struct _CM_FULL_RESOURCE_DESCRIPTOR * PCM_FULL_RESOURCE_DESCRIPTOR
struct _CM_RESOURCE_LIST CM_RESOURCE_LIST
#define CmResourceTypeConfigData
Definition: hwresource.cpp:130
struct _CM_RESOURCE_LIST * PCM_RESOURCE_LIST
#define CmResourceTypeDeviceSpecific
Definition: hwresource.cpp:127
@ InterfaceTypeUndefined
Definition: hwresource.cpp:136
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define REG_SZ
Definition: layer.c:22
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:71
#define for
Definition: utility.h:88
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
static PVOID ptr
Definition: dispmode.c:27
#define SE_LOAD_DRIVER_PRIVILEGE
Definition: security.c:664
ObjectType
Definition: metafile.c:81
#define PNP_PROPERTY_UI_NUMBER
Definition: cmtypes.h:34
#define PNP_SET_DEVICE_STATUS
Definition: cmtypes.h:60
#define PNP_PROPERTY_REMOVAL_POLICY
Definition: cmtypes.h:40
#define PNP_PROPERTY_POWER_DATA
Definition: cmtypes.h:39
#define PNP_PROPERTY_ENUMERATOR_NAME
Definition: cmtypes.h:43
#define PNP_PROPERTY_PHYSICAL_DEVICE_OBJECT_NAME
Definition: cmtypes.h:35
@ PlugPlayControlEnumerateDevice
Definition: cmtypes.h:209
@ PlugPlayControlProperty
Definition: cmtypes.h:219
@ PlugPlayControlQueryDeviceRelations
Definition: cmtypes.h:225
@ PlugPlayControlGetRelatedDevice
Definition: cmtypes.h:221
@ PlugPlayControlDeviceStatus
Definition: cmtypes.h:223
@ PlugPlayControlQueryAndRemoveDevice
Definition: cmtypes.h:215
@ PlugPlayControlGetDeviceDepth
Definition: cmtypes.h:224
@ PlugPlayControlInitializeDevice
Definition: cmtypes.h:212
@ PlugPlayControlGetInterfaceDeviceList
Definition: cmtypes.h:218
@ PlugPlayControlStartDevice
Definition: cmtypes.h:213
@ PlugPlayControlRetrieveDock
Definition: cmtypes.h:228
#define PNP_PROPERTY_INSTALL_STATE
Definition: cmtypes.h:45
#define PNP_PROPERTY_LOCATION_PATHS
Definition: cmtypes.h:46
#define PNP_PROPERTY_REMOVAL_POLICY_HARDWARE_DEFAULT
Definition: cmtypes.h:44
#define PNP_CLEAR_DEVICE_STATUS
Definition: cmtypes.h:61
#define PNP_PROPERTY_LEGACYBUSTYPE
Definition: cmtypes.h:37
#define PNP_GET_DEVICE_STATUS
Definition: cmtypes.h:59
#define PNP_PROPERTY_BUSTYPEGUID
Definition: cmtypes.h:36
#define PNP_PROPERTY_ADDRESS
Definition: cmtypes.h:42
#define PNP_PROPERTY_BUSNUMBER
Definition: cmtypes.h:38
#define PNP_PROPERTY_CONTAINERID
Definition: cmtypes.h:47
NTSYSAPI VOID NTAPI RtlInitializeResource(_In_ PRTL_RESOURCE Resource)
NTSYSAPI BOOLEAN NTAPI RtlAcquireResourceExclusive(_In_ PRTL_RESOURCE Resource, _In_ BOOLEAN Wait)
NTSYSAPI VOID NTAPI RtlReleaseResource(_In_ PRTL_RESOURCE Resource)
#define _Out_opt_
Definition: no_sal2.h:214
#define _Inout_
Definition: no_sal2.h:162
#define _Inout_opt_
Definition: no_sal2.h:216
#define _Out_
Definition: no_sal2.h:160
#define _In_
Definition: no_sal2.h:158
int Count
Definition: noreturn.cpp:7
#define REG_BINARY
Definition: nt_native.h:1496
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
#define KEY_READ
Definition: nt_native.h:1023
#define PROCESS_ALL_ACCESS
Definition: nt_native.h:1324
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define KEY_CREATE_SUB_KEY
Definition: nt_native.h:1018
#define REG_OPTION_NON_VOLATILE
Definition: nt_native.h:1057
#define REG_CREATED_NEW_KEY
Definition: nt_native.h:1084
#define REG_RESOURCE_LIST
Definition: nt_native.h:1502
#define KEY_QUERY_VALUE
Definition: nt_native.h:1016
#define REG_MULTI_SZ
Definition: nt_native.h:1501
#define KEY_ENUMERATE_SUB_KEYS
Definition: nt_native.h:1019
#define REG_RESOURCE_REQUIREMENTS_LIST
Definition: nt_native.h:1504
#define KEY_WRITE
Definition: nt_native.h:1031
#define DWORD
Definition: nt_native.h:44
#define KEY_SET_VALUE
Definition: nt_native.h:1017
#define UNICODE_NULL
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:329
#define STATUS_PLUGPLAY_QUERY_VETOED
Definition: ntstatus.h:219
#define L(x)
Definition: ntvdm.h:50
BYTE * PBYTE
Definition: pedump.c:66
DWORD * PDWORD
Definition: pedump.c:68
long LONG
Definition: pedump.c:60
NTSTATUS NTAPI NtPlugPlayControl(IN PLUGPLAY_CONTROL_CLASS PlugPlayControlClass, IN OUT PVOID Buffer, IN ULONG BufferLength)
Definition: plugplay.c:1494
unsigned long PNP_PROP_COUNT
Definition: pnp.idl:32
unsigned long PNP_RPC_BUFFER_SIZE
Definition: pnp.idl:34
void * PNP_NOTIFY_HANDLE
Definition: pnp.idl:7
unsigned long PNP_RPC_STRING_LEN
Definition: pnp.idl:33
unsigned long PNP_PROP_SIZE
Definition: pnp.idl:31
static const WCHAR szName[]
Definition: powrprof.c:45
#define CONFIGFLAG_MANUAL_INSTALL
Definition: regstr.h:392
#define CONFIGFLAG_FAILEDINSTALL
Definition: regstr.h:396
#define REGSTR_PATH_CLASS
Definition: regstr.h:42
RPC_STATUS WINAPI RpcRevertToSelf(void)
Definition: rpc_binding.c:1463
RPC_STATUS WINAPI RpcImpersonateClient(RPC_BINDING_HANDLE BindingHandle)
Definition: rpc_binding.c:1056
RPC_STATUS WINAPI RpcServerListen(UINT MinimumCallThreads, UINT MaxCalls, UINT DontWait)
Definition: rpc_server.c:1520
RPC_STATUS WINAPI RpcServerRegisterIf(RPC_IF_HANDLE IfSpec, UUID *MgrTypeUuid, RPC_MGR_EPV *MgrEpv)
Definition: rpc_server.c:1116
RPC_STATUS WINAPI RpcServerUseProtseqEpW(RPC_WSTR Protseq, UINT MaxCalls, RPC_WSTR Endpoint, LPVOID SecurityDescriptor)
Definition: rpc_server.c:927
#define RPC_S_OK
Definition: rpcnterr.h:22
DWORD WINAPI I_ScValidatePnpService(_In_ LPCWSTR pszMachineName, _In_ LPCWSTR pszServiceName, _Out_ SERVICE_STATUS_HANDLE *phServiceStatus)
Definition: scm.c:1948
#define REG_DWORD
Definition: sdbapi.c:596
_Check_return_ _CRTIMP int __cdecl _wcsicmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
#define midl_user_free
Definition: rpc.h:41
#define __RPC_FAR
Definition: rpc.h:52
long RPC_STATUS
Definition: rpc.h:48
#define __RPC_USER
Definition: rpc.h:61
#define midl_user_allocate
Definition: rpc.h:40
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
#define DPRINT
Definition: sndvol32.h:73
ULONG HWPI_ulHWProfile
Definition: cfgmgr32.h:554
CHAR HWPI_szFriendlyName[MAX_PROFILE_LEN]
Definition: cfgmgr32.h:555
DWORD HWPI_dwFlags
Definition: cfgmgr32.h:556
Definition: precomp.h:54
NOTIFICATION_TYPE dwType
Definition: precomp.h:56
PWSTR pszName
Definition: precomp.h:57
DWORD ulFlags
Definition: precomp.h:59
LIST_ENTRY ListEntry
Definition: precomp.h:55
DWORD_PTR hRecipient
Definition: precomp.h:58
GUID ClassGuid
Definition: precomp.h:60
CM_PARTIAL_RESOURCE_LIST PartialResourceList
Definition: hwresource.cpp:160
CM_FULL_RESOURCE_DESCRIPTOR List[1]
Definition: hwresource.cpp:165
union _IO_RESOURCE_DESCRIPTOR::@2140 u
struct _IO_RESOURCE_DESCRIPTOR::@2140::@2148 ConfigData
IO_RESOURCE_DESCRIPTOR Descriptors[1]
Definition: iotypes.h:2737
INTERFACE_TYPE InterfaceType
Definition: iotypes.h:2742
IO_RESOURCE_LIST List[1]
Definition: iotypes.h:2747
Definition: typedefs.h:120
UNICODE_STRING DeviceInstance
Definition: cmtypes.h:525
UNICODE_STRING DeviceInstance
Definition: cmtypes.h:534
UNICODE_STRING DeviceInstance
Definition: cmtypes.h:507
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733
#define WINVER
Definition: targetver.h:11
TW_UINT32 TW_UINT16 TW_UINT16 TW_MEMREF pData
Definition: twain.h:1830
uint16_t * PWSTR
Definition: typedefs.h:56
uint32_t * PULONG
Definition: typedefs.h:59
const uint16_t * PCWSTR
Definition: typedefs.h:57
uint32_t DWORD_PTR
Definition: typedefs.h:65
unsigned char * LPBYTE
Definition: typedefs.h:53
ULONG_PTR SIZE_T
Definition: typedefs.h:80
uint32_t * LPDWORD
Definition: typedefs.h:59
int32_t INT
Definition: typedefs.h:58
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define IN
Definition: typedefs.h:39
uint16_t * PWCHAR
Definition: typedefs.h:56
uint32_t ULONG
Definition: typedefs.h:59
#define OUT
Definition: typedefs.h:40
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define STATUS_NO_SUCH_DEVICE
Definition: udferr_usr.h:136
#define STATUS_OBJECT_NAME_NOT_FOUND
Definition: udferr_usr.h:149
_In_z_ PCWSTR _In_ ULONG ulType
Definition: ntuser.h:43
int ret
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ ULONG _Out_ PVOID PropertyBuffer
Definition: wdfdevice.h:4437
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
HANDLE WINAPI GetCurrentThread(void)
Definition: proc.c:1148
#define CopyMemory
Definition: winbase.h:1742
_In_ DWORD nLength
Definition: wincon.h:473
_In_ ULONG _In_ ULONG ulTag
Definition: winddi.h:3942
_Check_return_ _Out_ PULONG pulSize
Definition: winddi.h:2120
#define WINAPI
Definition: msvc.h:6
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
#define HKEY_CURRENT_CONFIG
Definition: winreg.h:15
#define RegOpenKeyEx
Definition: winreg.h:520
#define RegSetValueEx
Definition: winreg.h:533
#define RegQueryValueEx
Definition: winreg.h:524
#define RegDeleteValue
Definition: winreg.h:508
#define wsprintf
Definition: winuser.h:5893
static const GUID InterfaceGuid
Definition: wlanapi.c:25
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
_In_ PVOID _Out_opt_ PULONG_PTR _Outptr_opt_ PCUNICODE_STRING * ObjectName
Definition: cmfuncs.h:64
_In_ CONST DEVPROPKEY * PropertyKey
Definition: iofuncs.h:2414
struct _IO_RESOURCE_LIST * PIO_RESOURCE_LIST
#define IO_RESOURCE_PREFERRED
struct _IO_RESOURCE_REQUIREMENTS_LIST * PIO_RESOURCE_REQUIREMENTS_LIST
struct _IO_RESOURCE_REQUIREMENTS_LIST IO_RESOURCE_REQUIREMENTS_LIST
#define TOKEN_DUPLICATE
Definition: setypes.h:926
#define SECURITY_INTERACTIVE_RID
Definition: setypes.h:559
#define TOKEN_QUERY
Definition: setypes.h:928
#define SECURITY_NT_AUTHORITY
Definition: setypes.h:554
#define TOKEN_ASSIGN_PRIMARY
Definition: setypes.h:925
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
unsigned char BYTE
Definition: xxhash.c:193