ReactOS 0.4.16-dev-1170-ge326b06
cfgmgr.c
Go to the documentation of this file.
1/*
2 * Configuration manager functions
3 *
4 * Copyright 2000 James Hatheway
5 * Copyright 2005, 2006 Eric Kohl
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22#include "setupapi_private.h"
23
24#include <dbt.h>
25#include <pnp_c.h>
26#include <winsvc.h>
27#include <winsvc_undoc.h>
28
29#include <pseh/pseh2.h>
30
31#include "rpc_private.h"
32
33/* Registry key and value names */
34static const WCHAR BackslashOpenBrace[] = {'\\', '{', 0};
35static const WCHAR CloseBrace[] = {'}', 0};
36static const WCHAR Class[] = {'C','l','a','s','s',0};
37
38static const WCHAR ControlClass[] = {'S','y','s','t','e','m','\\',
39 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
40 'C','o','n','t','r','o','l','\\',
41 'C','l','a','s','s',0};
42
43static const WCHAR DeviceClasses[] = {'S','y','s','t','e','m','\\',
44 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
45 'C','o','n','t','r','o','l','\\',
46 'D','e','v','i','c','e','C','l','a','s','s','e','s',0};
47
48typedef struct _MACHINE_INFO
49{
55
56
57typedef struct _LOG_CONF_INFO
58{
64
65#define LOG_CONF_MAGIC 0x464E434C /* "LCNF" */
66
67typedef struct _RES_DES_INFO
68{
76
77#define RES_DES_MAGIC 0x53445352 /* "RSDS" */
78
79typedef struct _NOTIFY_DATA
80{
84
85#define NOTIFY_MAGIC 0x44556677
86
87
88typedef struct _INTERNAL_RANGE
89{
95
97{
102
103#define RANGE_LIST_MAGIC 0x33445566
104
105typedef struct _CONFLICT_DATA
106{
110
111#define CONFLICT_MAGIC 0x11225588
112
113
114/* FUNCTIONS ****************************************************************/
115
116static
117BOOL
121{
122 LPWSTR lpString;
123
124 if (UuidToStringW(Guid, &lpString) != RPC_S_OK)
125 return FALSE;
126
127 lstrcpyW(&String[1], lpString);
128
129 String[0] = '{';
130 String[MAX_GUID_STRING_LEN - 2] = '}';
132
133 RpcStringFreeW(&lpString);
134
135 return TRUE;
136}
137
138
139static
143{
144 return CR_FAILURE;
145}
146
147
148static
149ULONG
151 _In_ ULONG ulProperty)
152{
153 switch (ulProperty)
154 {
156 case CM_DRP_SERVICE:
157 case CM_DRP_CLASS:
158 case CM_DRP_CLASSGUID:
159 case CM_DRP_DRIVER:
160 case CM_DRP_MFG:
167 return REG_SZ;
168
173 return REG_MULTI_SZ;
174
177 case CM_DRP_UI_NUMBER:
179 case CM_DRP_BUSNUMBER:
180 case CM_DRP_DEVTYPE:
181 case CM_DRP_EXCLUSIVE:
183 case CM_DRP_ADDRESS:
188 return REG_DWORD;
189
191 case CM_DRP_SECURITY:
193 default:
194 return REG_BINARY;
195 }
196
197 return REG_NONE;
198}
199
200
201static
202VOID
204 _In_ PWSTR pszDeviceInstanceId,
205 _Out_ PWSTR pszDeviceId,
206 _Out_ PWSTR pszInstanceId)
207{
208 PWCHAR ptr;
209
210 wcscpy(pszDeviceId, pszDeviceInstanceId);
211
212 ptr = wcschr(pszDeviceId, L'\\');
213 if (ptr != NULL)
214 {
215 *ptr = UNICODE_NULL;
216 ptr++;
217
218 wcscpy(pszInstanceId, ptr);
219 }
220 else
221 {
222 *pszInstanceId = UNICODE_NULL;
223 }
224}
225
226
227static
231 _In_ PWSTR pszDeviceInst,
232 _Out_ PWSTR pszKeyPath,
233 _Out_ PWSTR pszInstancePath,
234 _In_ ULONG ulHardwareProfile,
235 _In_ ULONG ulFlags)
236{
237 PWSTR pszBuffer = NULL;
238 ULONG ulType = 0;
239 ULONG ulTransferLength, ulLength;
241
242 TRACE("GetDeviceInstanceKeyPath()\n");
243
244 /* Allocate a buffer for the device id */
245 pszBuffer = MyMalloc(300 * sizeof(WCHAR));
246 if (pszBuffer == NULL)
247 {
248 ERR("MyMalloc() failed\n");
249 return CR_OUT_OF_MEMORY;
250 }
251
252 if (ulFlags & CM_REGISTRY_SOFTWARE)
253 {
254 /* Software Key Path */
255
256 ulTransferLength = 300 * sizeof(WCHAR);
257 ulLength = 300 * sizeof(WCHAR);
258
260 {
262 pszDeviceInst,
264 &ulType,
265 (PVOID)pszBuffer,
266 &ulTransferLength,
267 &ulLength,
268 0);
269 }
271 {
273 }
275
276 if (ret != CR_SUCCESS)
277 {
279 {
281 pszDeviceInst,
282 (PVOID)pszBuffer,
283 300);
284 }
286 {
288 }
290
291 if (ret != CR_SUCCESS)
292 {
293 goto done;
294 }
295 }
296
297 TRACE("szBuffer: %S\n", pszBuffer);
298
299 SplitDeviceInstanceId(pszBuffer,
300 pszBuffer,
301 pszInstancePath);
302
303 TRACE("szBuffer: %S\n", pszBuffer);
304
305 if (ulFlags & CM_REGISTRY_CONFIG)
306 {
307 if (ulHardwareProfile == 0)
308 {
309 wsprintfW(pszKeyPath,
310 L"%s\\%s\\%s\\%s",
311 L"System\\CurrentControlSet\\Hardware Profiles",
312 L"Current",
313 L"System\\CurrentControlSet\\Control\\Class",
314 pszBuffer);
315 }
316 else
317 {
318 wsprintfW(pszKeyPath,
319 L"%s\\%04lu\\%s\\%s",
320 L"System\\CurrentControlSet\\Hardware Profiles",
321 ulHardwareProfile,
322 L"System\\CurrentControlSet\\Control\\Class",
323 pszBuffer);
324 }
325 }
326 else
327 {
328 wsprintfW(pszKeyPath,
329 L"%s\\%s",
330 L"System\\CurrentControlSet\\Control\\Class",
331 pszBuffer);
332 }
333 }
334 else
335 {
336 /* Hardware Key Path */
337
338 if (ulFlags & CM_REGISTRY_CONFIG)
339 {
340 SplitDeviceInstanceId(pszDeviceInst,
341 pszBuffer,
342 pszInstancePath);
343
344 if (ulHardwareProfile == 0)
345 {
346 wsprintfW(pszKeyPath,
347 L"%s\\%s\\%s\\%s",
348 L"System\\CurrentControlSet\\Hardware Profiles",
349 L"Current",
350 L"System\\CurrentControlSet\\Enum",
351 pszBuffer);
352 }
353 else
354 {
355 wsprintfW(pszKeyPath,
356 L"%s\\%04lu\\%s\\%s",
357 L"System\\CurrentControlSet\\Hardware Profiles",
358 ulHardwareProfile,
359 L"System\\CurrentControlSet\\Enum",
360 pszBuffer);
361 }
362 }
363 else if (ulFlags & CM_REGISTRY_USER)
364 {
365 wsprintfW(pszKeyPath,
366 L"%s\\%s",
367 L"System\\CurrentControlSet\\Enum",
368 pszDeviceInst);
369
370 wcscpy(pszInstancePath,
371 L"Device Parameters");
372 }
373 else
374 {
375 SplitDeviceInstanceId(pszDeviceInst,
376 pszBuffer,
377 pszInstancePath);
378
379 wsprintfW(pszKeyPath,
380 L"%s\\%s",
381 L"System\\CurrentControlSet\\Enum",
382 pszBuffer);
383 }
384 }
385
386done:
387 if (pszBuffer != NULL)
388 MyFree(pszBuffer);
389
390 return ret;
391}
392
393
394BOOL
397{
398 BOOL bValid = TRUE;
399
400 if (pRangeList == NULL)
401 return FALSE;
402
404 {
405 if (pRangeList->ulMagic != RANGE_LIST_MAGIC)
406 bValid = FALSE;
407 }
409 {
410 bValid = FALSE;
411 }
412 _SEH2_END;
413
414 return bValid;
415}
416
417
418BOOL
420 _In_opt_ PLOG_CONF_INFO pLogConfInfo)
421{
422 BOOL bValid = TRUE;
423
424 if (pLogConfInfo == NULL)
425 return FALSE;
426
428 {
429 if (pLogConfInfo->ulMagic != LOG_CONF_MAGIC)
430 bValid = FALSE;
431 }
433 {
434 bValid = FALSE;
435 }
436 _SEH2_END;
437
438 return bValid;
439}
440
441
442BOOL
444 _In_opt_ PRES_DES_INFO pResDesInfo)
445{
446 BOOL bValid = TRUE;
447
448 if (pResDesInfo == NULL)
449 return FALSE;
450
452 {
453 if (pResDesInfo->ulMagic != RES_DES_MAGIC)
454 bValid = FALSE;
455 }
457 {
458 bValid = FALSE;
459 }
460 _SEH2_END;
461
462 return bValid;
463}
464
465
466BOOL
468 _In_opt_ PCONFLICT_DATA pConflictData)
469{
470 BOOL bValid = TRUE;
471
472 if (pConflictData == NULL)
473 return FALSE;
474
476 {
477 if (pConflictData->ulMagic != CONFLICT_MAGIC)
478 bValid = FALSE;
479 }
481 {
482 bValid = FALSE;
483 }
484 _SEH2_END;
485
486 return bValid;
487}
488
489
490/***********************************************************************
491 * CMP_GetBlockedDriverInfo [SETUPAPI.@]
492 */
494WINAPI
496 _Out_opt_ LPWSTR pszNames,
497 _Inout_ PULONG pulLength,
498 _In_ ULONG ulFlags,
499 _In_opt_ HMACHINE hMachine)
500{
502 ULONG ulTransferLength;
504
505 TRACE("CMP_GetBlockedDriverInfo(%p %p %lx %p)\n",
506 pszNames, pulLength, ulFlags, hMachine);
507
508 if (hMachine != NULL)
509 {
510 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
511 if (BindingHandle == NULL)
512 return CR_FAILURE;
513 }
514 else
515 {
517 return CR_FAILURE;
518 }
519
520 ulTransferLength = *pulLength;
521
523 {
525 (PBYTE)pszNames,
526 &ulTransferLength,
527 pulLength,
528 ulFlags);
529 }
531 {
533 }
535
536 return ret;
537}
538
539
540/***********************************************************************
541 * CMP_GetServerSideDeviceInstallFlags [SETUPAPI.@]
542 */
544WINAPI
546 _Out_ PULONG pulSSDIFlags,
547 _In_ ULONG ulFlags,
548 _In_opt_ HMACHINE hMachine)
549{
552
553 TRACE("CMP_GetServerSideDeviceInstallFlags(%p %lx %p)\n",
554 pulSSDIFlags, ulFlags, hMachine);
555
556 if (pulSSDIFlags == NULL)
557 return CR_INVALID_POINTER;
558
559 if (ulFlags != 0)
560 return CR_INVALID_FLAG;
561
562 if (hMachine != NULL)
563 {
564 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
565 if (BindingHandle == NULL)
566 return CR_FAILURE;
567 }
568 else
569 {
571 return CR_FAILURE;
572 }
573
575 {
577 pulSSDIFlags,
578 ulFlags);
579 }
581 {
583 }
585
586 return ret;
587}
588
589
590/***********************************************************************
591 * CMP_Init_Detection [SETUPAPI.@]
592 */
594WINAPI
596 _In_ ULONG ulMagic)
597{
600
601 TRACE("CMP_Init_Detection(%lu)\n", ulMagic);
602
603 if (ulMagic != CMP_MAGIC)
604 return CR_INVALID_DATA;
605
607 return CR_FAILURE;
608
610 {
612 }
614 {
616 }
618
619 return ret;
620}
621
622
623/***********************************************************************
624 * CMP_RegisterNotification [SETUPAPI.@]
625 */
627WINAPI
629 _In_ HANDLE hRecipient,
630 _In_ LPVOID lpvNotificationFilter,
631 _In_ ULONG ulFlags,
632 _Out_ PHDEVNOTIFY phDevNotify)
633{
635 PNOTIFY_DATA pNotifyData;
636 WCHAR szNameBuffer[256];
637 INT nLength;
638 DWORD ulUnknown9 = 0;
639 DWORD dwError;
641
642 FIXME("CMP_RegisterNotification(%p %p %lu %p)\n",
643 hRecipient, lpvNotificationFilter, ulFlags, phDevNotify);
644
645 if ((hRecipient == NULL) ||
646 (lpvNotificationFilter == NULL) ||
647 (phDevNotify == NULL))
648 return CR_INVALID_POINTER;
649
650 if (ulFlags & ~0x7)
651 return CR_INVALID_FLAG;
652
653 if (((PDEV_BROADCAST_HDR)lpvNotificationFilter)->dbch_size < sizeof(DEV_BROADCAST_HDR))
654 return CR_INVALID_DATA;
655
657 return CR_FAILURE;
658
659 pNotifyData = HeapAlloc(GetProcessHeap(),
661 sizeof(NOTIFY_DATA));
662 if (pNotifyData == NULL)
663 return CR_OUT_OF_MEMORY;
664
665 pNotifyData->ulMagic = NOTIFY_MAGIC;
666 pNotifyData->hNotifyHandle = NULL;
667
668 ZeroMemory(szNameBuffer, sizeof(szNameBuffer));
669
670 if ((ulFlags & DEVICE_NOTIFY_SERVICE_HANDLE) == DEVICE_NOTIFY_WINDOW_HANDLE)
671 {
672 FIXME("Register a window\n");
673
674 nLength = GetWindowTextW((HWND)hRecipient,
675 szNameBuffer,
676 ARRAYSIZE(szNameBuffer));
677 if (nLength == 0)
678 {
679 szNameBuffer[0] = UNICODE_NULL;
680 }
681
682 FIXME("Register window: %S\n", szNameBuffer);
683 }
684 else if ((ulFlags & DEVICE_NOTIFY_SERVICE_HANDLE) == DEVICE_NOTIFY_SERVICE_HANDLE)
685 {
686 FIXME("Register a service\n");
687
688 dwError = I_ScPnPGetServiceName((SERVICE_STATUS_HANDLE)hRecipient,
689 szNameBuffer,
690 ARRAYSIZE(szNameBuffer));
691 if (dwError != ERROR_SUCCESS)
692 {
693 HeapFree(GetProcessHeap(), 0, pNotifyData);
694 return CR_INVALID_DATA;
695 }
696
697 FIXME("Register service: %S\n", szNameBuffer);
698 }
699
701 {
703 (DWORD_PTR)hRecipient,
704 szNameBuffer,
705 (BYTE*)lpvNotificationFilter,
706 ((DEV_BROADCAST_HDR*)lpvNotificationFilter)->dbch_size,
707 ulFlags,
708 &pNotifyData->hNotifyHandle,
710 &ulUnknown9); /* ??? */
711 }
713 {
715 }
717
718 if (ret == CR_SUCCESS)
719 {
720 TRACE("hNotifyHandle: %p\n", pNotifyData->hNotifyHandle);
721 *phDevNotify = (HDEVNOTIFY)pNotifyData;
722 }
723 else
724 {
725 HeapFree(GetProcessHeap(), 0, pNotifyData);
726
727 *phDevNotify = (HDEVNOTIFY)NULL;
728 }
729
730 return ret;
731}
732
733
734/***********************************************************************
735 * CMP_Report_LogOn [SETUPAPI.@]
736 */
738WINAPI
740 _In_ DWORD dwMagic,
741 _In_ DWORD dwProcessId)
742{
745 BOOL bAdmin;
746 DWORD i;
747
748 TRACE("CMP_Report_LogOn(%lu %lu)\n", dwMagic, dwProcessId);
749
750 if (dwMagic != CMP_MAGIC)
751 return CR_INVALID_DATA;
752
754 return CR_FAILURE;
755
756 bAdmin = pSetupIsUserAdmin();
757
758 for (i = 0; i < 30; i++)
759 {
761 {
763 bAdmin,
764 dwProcessId);
765 }
767 {
769 }
771
772 if (ret == CR_SUCCESS)
773 break;
774
775 Sleep(5000);
776 }
777
778 return ret;
779}
780
781
782/***********************************************************************
783 * CMP_UnregisterNotification [SETUPAPI.@]
784 */
786WINAPI
788 _In_ HDEVNOTIFY hDevNotify)
789{
791 PNOTIFY_DATA pNotifyData;
793
794 TRACE("CMP_UnregisterNotification(%p)\n", hDevNotify);
795
796 pNotifyData = (PNOTIFY_DATA)hDevNotify;
797
798 if ((pNotifyData == NULL) ||
799 (pNotifyData->ulMagic != NOTIFY_MAGIC))
800 return CR_INVALID_POINTER;
801
803 return CR_FAILURE;
804
806 {
808 &pNotifyData->hNotifyHandle);
809 }
811 {
813 }
815
816 if (ret == CR_SUCCESS)
817 {
818 pNotifyData->hNotifyHandle = NULL;
819 HeapFree(GetProcessHeap(), 0, pNotifyData);
820 }
821
822 return ret;
823}
824
825
826/***********************************************************************
827 * CMP_WaitNoPendingInstallEvents [SETUPAPI.@]
828 */
829DWORD
830WINAPI
833{
835 DWORD ret;
836
837 TRACE("CMP_WaitNoPendingInstallEvents(%lu)\n", dwTimeout);
838
839 hEvent = OpenEventW(SYNCHRONIZE, FALSE, L"Global\\PnP_No_Pending_Install_Events");
840 if (hEvent == NULL)
841 return WAIT_FAILED;
842
845 return ret;
846}
847
848
849/***********************************************************************
850 * CMP_WaitServicesAvailable [SETUPAPI.@]
851 */
853WINAPI
855 _In_opt_ HMACHINE hMachine)
856{
860
861 TRACE("CMP_WaitServicesAvailable(%p)\n", hMachine);
862
863 if (hMachine != NULL)
864 {
865 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
866 if (BindingHandle == NULL)
867 return CR_FAILURE;
868 }
869 else
870 {
872 return CR_FAILURE;
873 }
874
876 {
878 }
880 {
882 }
884
885 return ret;
886}
887
888
889/***********************************************************************
890 * CM_Add_Empty_Log_Conf [SETUPAPI.@]
891 */
893WINAPI
895 _Out_ PLOG_CONF plcLogConf,
896 _In_ DEVINST dnDevInst,
898 _In_ ULONG ulFlags)
899{
900 TRACE("CM_Add_Empty_Log_Conf(%p %p %lu %lx)\n",
901 plcLogConf, dnDevInst, Priority, ulFlags);
902
903 return CM_Add_Empty_Log_Conf_Ex(plcLogConf, dnDevInst, Priority,
904 ulFlags, NULL);
905}
906
907
908/***********************************************************************
909 * CM_Add_Empty_Log_Conf_Ex [SETUPAPI.@]
910 */
912WINAPI
914 _Out_ PLOG_CONF plcLogConf,
915 _In_ DEVINST dnDevInst,
917 _In_ ULONG ulFlags,
918 _In_opt_ HMACHINE hMachine)
919{
921 HSTRING_TABLE StringTable = NULL;
922 ULONG ulLogConfTag = 0;
923 LPWSTR lpDevInst;
924 PLOG_CONF_INFO pLogConfInfo;
926
927 FIXME("CM_Add_Empty_Log_Conf_Ex(%p %p %lu %lx %p)\n",
928 plcLogConf, dnDevInst, Priority, ulFlags, hMachine);
929
930 if (!pSetupIsUserAdmin())
931 return CR_ACCESS_DENIED;
932
933 if (plcLogConf == NULL)
934 return CR_INVALID_POINTER;
935
936 if (dnDevInst == 0)
937 return CR_INVALID_DEVINST;
938
939 if (Priority > 0xFFFF)
940 return CR_INVALID_PRIORITY;
941
942 if (ulFlags & ~(LOG_CONF_BITS | PRIORITY_BIT))
943 return CR_INVALID_FLAG;
944
945 if (hMachine != NULL)
946 {
947 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
948 if (BindingHandle == NULL)
949 return CR_FAILURE;
950
951 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
952 if (StringTable == 0)
953 return CR_FAILURE;
954 }
955 else
956 {
957 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
958 return CR_FAILURE;
959 }
960
961 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
962 if (lpDevInst == NULL)
963 return CR_INVALID_DEVNODE;
964
966 {
968 &ulLogConfTag, ulFlags);
969 }
971 {
973 }
975
976 if (ret == CR_SUCCESS)
977 {
978 pLogConfInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(LOG_CONF_INFO));
979 if (pLogConfInfo == NULL)
980 {
982 }
983 else
984 {
985 pLogConfInfo->ulMagic = LOG_CONF_MAGIC;
986 pLogConfInfo->dnDevInst = dnDevInst;
987 pLogConfInfo->ulType = ulFlags;
988 pLogConfInfo->ulTag = ulLogConfTag;
989
990 *plcLogConf = (LOG_CONF)pLogConfInfo;
991
992 ret = CR_SUCCESS;
993 }
994 }
995
996 return ret;
997}
998
999
1000/***********************************************************************
1001 * CM_Add_IDA [SETUPAPI.@]
1002 */
1004WINAPI
1006 _In_ DEVINST dnDevInst,
1007 _In_ PSTR pszID,
1008 _In_ ULONG ulFlags)
1009{
1010 TRACE("CM_Add_IDA(%p %s %lx)\n",
1011 dnDevInst, debugstr_a(pszID), ulFlags);
1012
1013 return CM_Add_ID_ExA(dnDevInst, pszID, ulFlags, NULL);
1014}
1015
1016
1017/***********************************************************************
1018 * CM_Add_IDW [SETUPAPI.@]
1019 */
1021WINAPI
1023 _In_ DEVINST dnDevInst,
1024 _In_ PWSTR pszID,
1025 _In_ ULONG ulFlags)
1026{
1027 TRACE("CM_Add_IDW(%p %s %lx)\n",
1028 dnDevInst, debugstr_w(pszID), ulFlags);
1029
1030 return CM_Add_ID_ExW(dnDevInst, pszID, ulFlags, NULL);
1031}
1032
1033
1034/***********************************************************************
1035 * CM_Add_ID_ExA [SETUPAPI.@]
1036 */
1038WINAPI
1040 _In_ DEVINST dnDevInst,
1041 _In_ PSTR pszID,
1042 _In_ ULONG ulFlags,
1043 _In_opt_ HMACHINE hMachine)
1044{
1045 PWSTR pszIDW;
1046 CONFIGRET ret;
1047
1048 TRACE("CM_Add_ID_ExA(%p %s %lx %p)\n",
1049 dnDevInst, debugstr_a(pszID), ulFlags, hMachine);
1050
1051 if (pSetupCaptureAndConvertAnsiArg(pszID, &pszIDW))
1052 return CR_INVALID_DATA;
1053
1054 ret = CM_Add_ID_ExW(dnDevInst, pszIDW, ulFlags, hMachine);
1055
1056 MyFree(pszIDW);
1057
1058 return ret;
1059}
1060
1061
1062/***********************************************************************
1063 * CM_Add_ID_ExW [SETUPAPI.@]
1064 */
1066WINAPI
1068 _In_ DEVINST dnDevInst,
1069 _In_ PWSTR pszID,
1070 _In_ ULONG ulFlags,
1071 _In_opt_ HMACHINE hMachine)
1072{
1074 HSTRING_TABLE StringTable = NULL;
1075 LPWSTR lpDevInst;
1076 CONFIGRET ret;
1077
1078 TRACE("CM_Add_ID_ExW(%p %s %lx %p)\n",
1079 dnDevInst, debugstr_w(pszID), ulFlags, hMachine);
1080
1081 if (!pSetupIsUserAdmin())
1082 return CR_ACCESS_DENIED;
1083
1084 if (dnDevInst == 0)
1085 return CR_INVALID_DEVINST;
1086
1087 if (pszID == NULL)
1088 return CR_INVALID_POINTER;
1089
1090 if (ulFlags & ~CM_ADD_ID_BITS)
1091 return CR_INVALID_FLAG;
1092
1093 if (hMachine != NULL)
1094 {
1095 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1096 if (BindingHandle == NULL)
1097 return CR_FAILURE;
1098
1099 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1100 if (StringTable == 0)
1101 return CR_FAILURE;
1102 }
1103 else
1104 {
1105 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
1106 return CR_FAILURE;
1107 }
1108
1109 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
1110 if (lpDevInst == NULL)
1111 return CR_INVALID_DEVNODE;
1112
1114 {
1116 lpDevInst,
1117 pszID,
1118 ulFlags);
1119 }
1121 {
1123 }
1125
1126 return ret;
1127}
1128
1129
1130/***********************************************************************
1131 * CM_Add_Range [SETUPAPI.@]
1132 */
1134WINAPI
1136 _In_ DWORDLONG ullStartValue,
1137 _In_ DWORDLONG ullEndValue,
1138 _In_ RANGE_LIST rlh,
1139 _In_ ULONG ulFlags)
1140{
1141 PINTERNAL_RANGE_LIST pRangeList;
1142 PINTERNAL_RANGE pRange;
1144
1145 FIXME("CM_Add_Range(%I64u %I64u %p %lx)\n",
1146 ullStartValue, ullEndValue, rlh, ulFlags);
1147
1148 pRangeList = (PINTERNAL_RANGE_LIST)rlh;
1149
1150 if (!IsValidRangeList(pRangeList))
1151 return CR_INVALID_RANGE_LIST;
1152
1153 if (ulFlags & ~CM_ADD_RANGE_BITS)
1154 return CR_INVALID_FLAG;
1155
1156 if (ullEndValue < ullStartValue)
1157 return CR_INVALID_RANGE;
1158
1159 /* Lock the range list */
1160 WaitForSingleObject(pRangeList->hMutex, INFINITE);
1161
1162 /* Allocate the new range */
1163 pRange = HeapAlloc(GetProcessHeap(), 0, sizeof(INTERNAL_RANGE));
1164 if (pRange == NULL)
1165 {
1167 goto done;
1168 }
1169
1170 pRange->pRangeList = pRangeList;
1171 pRange->ullStart = ullStartValue;
1172 pRange->ullEnd = ullEndValue;
1173
1174 /* Insert the range */
1175 if (IsListEmpty(&pRangeList->ListHead))
1176 {
1177 InsertTailList(&pRangeList->ListHead, &pRange->ListEntry);
1178 }
1179 else
1180 {
1181 HeapFree(GetProcessHeap(), 0, pRange);
1183 }
1184
1185done:
1186 /* Unlock the range list */
1187 ReleaseMutex(pRangeList->hMutex);
1188
1189 return ret;
1190}
1191
1192
1193/***********************************************************************
1194 * CM_Add_Res_Des [SETUPAPI.@]
1195 */
1197WINAPI
1199 _Out_opt_ PRES_DES prdResDes,
1200 _In_ LOG_CONF lcLogConf,
1201 _In_ RESOURCEID ResourceID,
1202 _In_reads_bytes_(ResourceLen) PCVOID ResourceData,
1203 _In_ ULONG ResourceLen,
1204 _In_ ULONG ulFlags)
1205{
1206 TRACE("CM_Add_Res_Des(%p %p %lu %p %lu %lx)\n",
1207 prdResDes, lcLogConf, ResourceID, ResourceData, ResourceLen, ulFlags);
1208
1209 return CM_Add_Res_Des_Ex(prdResDes, lcLogConf, ResourceID, ResourceData,
1210 ResourceLen, ulFlags, NULL);
1211}
1212
1213
1214/***********************************************************************
1215 * CM_Add_Res_Des_Ex [SETUPAPI.@]
1216 */
1218WINAPI
1220 _Out_opt_ PRES_DES prdResDes,
1221 _In_ LOG_CONF lcLogConf,
1222 _In_ RESOURCEID ResourceID,
1223 _In_reads_bytes_(ResourceLen) PCVOID ResourceData,
1224 _In_ ULONG ResourceLen,
1225 _In_ ULONG ulFlags,
1226 _In_opt_ HMACHINE hMachine)
1227{
1228 FIXME("CM_Add_Res_Des_Ex(%p %p %lu %p %lu %lx %p)\n",
1229 prdResDes, lcLogConf, ResourceID,
1230 ResourceData, ResourceLen, ulFlags, hMachine);
1231
1233}
1234
1235
1236/***********************************************************************
1237 * CM_Connect_MachineA [SETUPAPI.@]
1238 */
1240WINAPI
1242 _In_opt_ PCSTR UNCServerName,
1243 _Out_ PHMACHINE phMachine)
1244{
1245 PWSTR pServerNameW;
1246 CONFIGRET ret;
1247
1248 TRACE("CM_Connect_MachineA(%s %p)\n",
1249 debugstr_a(UNCServerName), phMachine);
1250
1251 if (UNCServerName == NULL || *UNCServerName == 0)
1252 return CM_Connect_MachineW(NULL, phMachine);
1253
1254 if (pSetupCaptureAndConvertAnsiArg(UNCServerName, &pServerNameW))
1255 return CR_INVALID_DATA;
1256
1257 ret = CM_Connect_MachineW(pServerNameW, phMachine);
1258
1259 MyFree(pServerNameW);
1260
1261 return ret;
1262}
1263
1264
1265/***********************************************************************
1266 * CM_Connect_MachineW [SETUPAPI.@]
1267 */
1269WINAPI
1271 _In_opt_ PCWSTR UNCServerName,
1272 _Out_ PHMACHINE phMachine)
1273{
1274 PMACHINE_INFO pMachine;
1275
1276 TRACE("CM_Connect_MachineW(%s %p)\n",
1277 debugstr_w(UNCServerName), phMachine);
1278
1279 if (phMachine == NULL)
1280 return CR_INVALID_POINTER;
1281
1282 *phMachine = NULL;
1283
1284 pMachine = HeapAlloc(GetProcessHeap(), 0, sizeof(MACHINE_INFO));
1285 if (pMachine == NULL)
1286 return CR_OUT_OF_MEMORY;
1287
1288 if (UNCServerName == NULL || *UNCServerName == 0)
1289 {
1290 pMachine->bLocal = TRUE;
1291
1292 /* FIXME: store the computers name in pMachine->szMachineName */
1293
1294 if (!PnpGetLocalHandles(&pMachine->BindingHandle,
1295 &pMachine->StringTable))
1296 {
1297 HeapFree(GetProcessHeap(), 0, pMachine);
1298 return CR_FAILURE;
1299 }
1300 }
1301 else
1302 {
1303 pMachine->bLocal = FALSE;
1304 if (wcslen(UNCServerName) >= SP_MAX_MACHINENAME_LENGTH - 1)
1305 {
1306 HeapFree(GetProcessHeap(), 0, pMachine);
1308 }
1309 lstrcpyW(pMachine->szMachineName, UNCServerName);
1310
1312 if (pMachine->StringTable == NULL)
1313 {
1314 HeapFree(GetProcessHeap(), 0, pMachine);
1315 return CR_FAILURE;
1316 }
1317
1318 pSetupStringTableAddString(pMachine->StringTable, L"PLT", 1);
1319
1320 if (!PnpBindRpc(UNCServerName, &pMachine->BindingHandle))
1321 {
1323 HeapFree(GetProcessHeap(), 0, pMachine);
1325 }
1326 }
1327
1328 *phMachine = (PHMACHINE)pMachine;
1329
1330 return CR_SUCCESS;
1331}
1332
1333
1334/***********************************************************************
1335 * CM_Create_DevNodeA [SETUPAPI.@]
1336 */
1338WINAPI
1340 _Out_ PDEVINST pdnDevInst,
1341 _In_ DEVINSTID_A pDeviceID,
1342 _In_ DEVINST dnParent,
1343 _In_ ULONG ulFlags)
1344{
1345 TRACE("CM_Create_DevNodeA(%p %s %p %lx)\n",
1346 pdnDevInst, debugstr_a(pDeviceID), dnParent, ulFlags);
1347
1348 return CM_Create_DevNode_ExA(pdnDevInst, pDeviceID, dnParent,
1349 ulFlags, NULL);
1350}
1351
1352
1353/***********************************************************************
1354 * CM_Create_DevNodeW [SETUPAPI.@]
1355 */
1357WINAPI
1359 _Out_ PDEVINST pdnDevInst,
1360 _In_ DEVINSTID_W pDeviceID,
1361 _In_ DEVINST dnParent,
1362 _In_ ULONG ulFlags)
1363{
1364 TRACE("CM_Create_DevNodeW(%p %s %p %lx)\n",
1365 pdnDevInst, debugstr_w(pDeviceID), dnParent, ulFlags);
1366
1367 return CM_Create_DevNode_ExW(pdnDevInst, pDeviceID, dnParent,
1368 ulFlags, NULL);
1369}
1370
1371
1372/***********************************************************************
1373 * CM_Create_DevNode_ExA [SETUPAPI.@]
1374 */
1376WINAPI
1378 _Out_ PDEVINST pdnDevInst,
1379 _In_ DEVINSTID_A pDeviceID,
1380 _In_ DEVINST dnParent,
1381 _In_ ULONG ulFlags,
1382 _In_opt_ HANDLE hMachine)
1383{
1384 DEVINSTID_W pDeviceIDW;
1385 CONFIGRET ret;
1386
1387 TRACE("CM_Create_DevNode_ExA(%p %s %p %lx %p)\n",
1388 pdnDevInst, debugstr_a(pDeviceID), dnParent, ulFlags, hMachine);
1389
1390 if (pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDeviceIDW))
1391 return CR_INVALID_DATA;
1392
1393 ret = CM_Create_DevNode_ExW(pdnDevInst, pDeviceIDW, dnParent, ulFlags,
1394 hMachine);
1395
1396 MyFree(pDeviceIDW);
1397
1398 return ret;
1399}
1400
1401
1402/***********************************************************************
1403 * CM_Create_DevNode_ExW [SETUPAPI.@]
1404 */
1406WINAPI
1408 _Out_ PDEVINST pdnDevInst,
1409 _In_ DEVINSTID_W pDeviceID,
1410 _In_ DEVINST dnParent,
1411 _In_ ULONG ulFlags,
1412 _In_opt_ HANDLE hMachine)
1413{
1415 HSTRING_TABLE StringTable = NULL;
1416 LPWSTR lpParentDevInst;
1418 WCHAR szLocalDeviceID[MAX_DEVICE_ID_LEN];
1419
1420 TRACE("CM_Create_DevNode_ExW(%p %s %p %lx %p)\n",
1421 pdnDevInst, debugstr_w(pDeviceID), dnParent, ulFlags, hMachine);
1422
1423 if (!pSetupIsUserAdmin())
1424 return CR_ACCESS_DENIED;
1425
1426 if (pdnDevInst == NULL)
1427 return CR_INVALID_POINTER;
1428
1429 if (pDeviceID == NULL || wcslen(pDeviceID) == 0 || wcslen(pDeviceID) >= MAX_DEVICE_ID_LEN)
1430 return CR_INVALID_DEVICE_ID;
1431
1432 if (dnParent == 0)
1433 return CR_INVALID_DEVNODE;
1434
1435 if (ulFlags & ~CM_CREATE_DEVNODE_BITS)
1436 return CR_INVALID_FLAG;
1437
1438 if (hMachine != NULL)
1439 {
1440 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1441 if (BindingHandle == NULL)
1442 return CR_FAILURE;
1443
1444 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1445 if (StringTable == 0)
1446 return CR_FAILURE;
1447 }
1448 else
1449 {
1450 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
1451 return CR_FAILURE;
1452 }
1453
1454 lpParentDevInst = pSetupStringTableStringFromId(StringTable, dnParent);
1455 if (lpParentDevInst == NULL)
1456 return CR_INVALID_DEVNODE;
1457
1458 wcscpy(szLocalDeviceID, pDeviceID);
1459
1461 {
1463 szLocalDeviceID,
1464 lpParentDevInst,
1466 ulFlags);
1467 }
1469 {
1471 }
1473
1474 if (ret == CR_SUCCESS)
1475 {
1476 /* If CM_CREATE_DEVINST_GENERATE_ID was passed in, PNP_CreateDevInst
1477 * will return the generated device ID in szLocalDeviceID */
1478 *pdnDevInst = pSetupStringTableAddString(StringTable, szLocalDeviceID, 1);
1479 if (*pdnDevInst == 0)
1481 }
1482
1483 return ret;
1484}
1485
1486
1487/***********************************************************************
1488 * CM_Create_Range_List [SETUPAPI.@]
1489 */
1491WINAPI
1493 _Out_ PRANGE_LIST prlh,
1494 _In_ ULONG ulFlags)
1495{
1496 PINTERNAL_RANGE_LIST pRangeList;
1497
1498 FIXME("CM_Create_Range_List(%p %lx)\n",
1499 prlh, ulFlags);
1500
1501 if (ulFlags != 0)
1502 return CR_INVALID_FLAG;
1503
1504 if (prlh == NULL)
1505 return CR_INVALID_POINTER;
1506
1507 /* Allocate the range list */
1509 if (pRangeList == NULL)
1510 return CR_OUT_OF_MEMORY;
1511
1512 /* Set the magic value */
1513 pRangeList->ulMagic = RANGE_LIST_MAGIC;
1514
1515 /* Initialize the mutex for synchonized access */
1516 pRangeList->hMutex = CreateMutex(NULL, FALSE, NULL);
1517 if (pRangeList->hMutex == NULL)
1518 {
1519 HeapFree(GetProcessHeap(), 0, pRangeList);
1520 return CR_FAILURE;
1521 }
1522
1523 InitializeListHead(&pRangeList->ListHead);
1524
1525 *prlh = (RANGE_LIST)pRangeList;
1526
1527 return CR_SUCCESS;
1528}
1529
1530
1531/***********************************************************************
1532 * CM_Delete_Class_Key [SETUPAPI.@]
1533 */
1535WINAPI
1537 _In_ LPGUID ClassGuid,
1538 _In_ ULONG ulFlags)
1539{
1540 TRACE("CM_Delete_Class_Key(%p %lx)\n",
1541 ClassGuid, ulFlags);
1542
1543 return CM_Delete_Class_Key_Ex(ClassGuid, ulFlags, NULL);
1544}
1545
1546
1547/***********************************************************************
1548 * CM_Delete_Class_Key_Ex [SETUPAPI.@]
1549 */
1551WINAPI
1553 _In_ LPGUID ClassGuid,
1554 _In_ ULONG ulFlags,
1555 _In_opt_ HANDLE hMachine)
1556{
1557 WCHAR szGuidString[MAX_GUID_STRING_LEN];
1559 CONFIGRET ret;
1560
1561 TRACE("CM_Delete_Class_Key_Ex(%p %lx %p)\n",
1562 ClassGuid, ulFlags, hMachine);
1563
1564 if (ClassGuid == NULL)
1565 return CR_INVALID_POINTER;
1566
1567 if (ulFlags & ~CM_DELETE_CLASS_BITS)
1568 return CR_INVALID_FLAG;
1569
1570 if (!GuidToString(ClassGuid, szGuidString))
1571 return CR_INVALID_DATA;
1572
1573 if (hMachine != NULL)
1574 {
1575 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1576 if (BindingHandle == NULL)
1577 return CR_FAILURE;
1578 }
1579 else
1580 {
1582 return CR_FAILURE;
1583 }
1584
1586 {
1588 szGuidString,
1589 ulFlags);
1590 }
1592 {
1594 }
1596
1597 return ret;
1598}
1599
1600
1601/***********************************************************************
1602 * CM_Delete_DevNode_Key [SETUPAPI.@]
1603 */
1605WINAPI
1607 _In_ DEVINST dnDevInst,
1608 _In_ ULONG ulHardwareProfile,
1609 _In_ ULONG ulFlags)
1610{
1611 TRACE("CM_Delete_DevNode_Key(%p %lu %lx)\n",
1612 dnDevInst, ulHardwareProfile, ulFlags);
1613
1614 return CM_Delete_DevNode_Key_Ex(dnDevInst, ulHardwareProfile, ulFlags,
1615 NULL);
1616}
1617
1618
1619/***********************************************************************
1620 * CM_Delete_DevNode_Key_Ex [SETUPAPI.@]
1621 */
1623WINAPI
1625 _In_ DEVINST dnDevInst,
1626 _In_ ULONG ulHardwareProfile,
1627 _In_ ULONG ulFlags,
1628 _In_opt_ HANDLE hMachine)
1629{
1631 HSTRING_TABLE StringTable = NULL;
1632 PWSTR pszDevInst, pszKeyPath = NULL, pszInstancePath = NULL;
1633 CONFIGRET ret;
1634
1635 FIXME("CM_Delete_DevNode_Key_Ex(%p %lu %lx %p)\n",
1636 dnDevInst, ulHardwareProfile, ulFlags, hMachine);
1637
1638 if (dnDevInst == 0)
1639 return CR_INVALID_DEVINST;
1640
1641 if (ulFlags & ~CM_REGISTRY_BITS)
1642 return CR_INVALID_FLAG;
1643
1644 if ((ulFlags & CM_REGISTRY_USER) && (ulFlags & CM_REGISTRY_CONFIG))
1645 return CR_INVALID_FLAG;
1646
1647 if (hMachine != NULL)
1648 {
1649 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1650 if (BindingHandle == NULL)
1651 return CR_FAILURE;
1652
1653 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1654 if (StringTable == 0)
1655 return CR_FAILURE;
1656 }
1657 else
1658 {
1659 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
1660 return CR_FAILURE;
1661 }
1662
1663 pszDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
1664 if (pszDevInst == NULL)
1665 return CR_INVALID_DEVNODE;
1666
1667 TRACE("pszDevInst: %S\n", pszDevInst);
1668
1669 pszKeyPath = MyMalloc(512 * sizeof(WCHAR));
1670 if (pszKeyPath == NULL)
1671 {
1673 goto done;
1674 }
1675
1676 pszInstancePath = MyMalloc(512 * sizeof(WCHAR));
1677 if (pszInstancePath == NULL)
1678 {
1680 goto done;
1681 }
1682
1684 pszDevInst,
1685 pszKeyPath,
1686 pszInstancePath,
1687 ulHardwareProfile,
1688 ulFlags);
1689 if (ret != CR_SUCCESS)
1690 goto done;
1691
1692 TRACE("pszKeyPath: %S\n", pszKeyPath);
1693 TRACE("pszInstancePath: %S\n", pszInstancePath);
1694
1695 if (ulFlags & CM_REGISTRY_USER)
1696 {
1697 FIXME("The CM_REGISTRY_USER flag is not supported yet!\n");
1698 }
1699 else
1700 {
1701#if 0
1702 if (!pSetupIsUserAdmin())
1703 {
1705 goto done;
1706 }
1707#endif
1708
1709 if (!(ulFlags & CM_REGISTRY_CONFIG))
1710 ulHardwareProfile = 0;
1711
1713 {
1715 pszDevInst,
1716 pszKeyPath,
1717 pszInstancePath,
1718 ulHardwareProfile);
1719 }
1721 {
1723 }
1725 }
1726
1727done:
1728 if (pszInstancePath != NULL)
1729 MyFree(pszInstancePath);
1730
1731 if (pszKeyPath != NULL)
1732 MyFree(pszKeyPath);
1733
1734 return ret;
1735}
1736
1737
1738/***********************************************************************
1739 * CM_Delete_Range [SETUPAPI.@]
1740 */
1742WINAPI
1744 _In_ DWORDLONG ullStartValue,
1745 _In_ DWORDLONG ullEndValue,
1746 _In_ RANGE_LIST rlh,
1747 _In_ ULONG ulFlags)
1748{
1749 FIXME("CM_Delete_Range(%I64u %I64u %p %lx)\n",
1750 ullStartValue, ullEndValue, rlh, ulFlags);
1751
1753}
1754
1755
1756/***********************************************************************
1757 * CM_Detect_Resource_Conflict [SETUPAPI.@]
1758 */
1760WINAPI
1762 _In_ DEVINST dnDevInst,
1763 _In_ RESOURCEID ResourceID,
1764 _In_reads_bytes_(ResourceLen) PCVOID ResourceData,
1765 _In_ ULONG ResourceLen,
1766 _Out_ PBOOL pbConflictDetected,
1767 _In_ ULONG ulFlags)
1768{
1769 TRACE("CM_Detect_Resource_Conflict(%p %lu %p %lu %p 0x%lx)\n",
1770 dnDevInst, ResourceID, ResourceData, ResourceLen,
1771 pbConflictDetected, ulFlags);
1772
1773 return CM_Detect_Resource_Conflict_Ex(dnDevInst,
1774 ResourceID,
1775 ResourceData,
1776 ResourceLen,
1777 pbConflictDetected,
1778 ulFlags,
1779 NULL);
1780}
1781
1782
1783/***********************************************************************
1784 * CM_Detect_Resource_Conflict_Ex [SETUPAPI.@]
1785 */
1787WINAPI
1789 _In_ DEVINST dnDevInst,
1790 _In_ RESOURCEID ResourceID,
1791 _In_reads_bytes_(ResourceLen) PCVOID ResourceData,
1792 _In_ ULONG ResourceLen,
1793 _Out_ PBOOL pbConflictDetected,
1794 _In_ ULONG ulFlags,
1795 _In_opt_ HMACHINE hMachine)
1796{
1797 FIXME("CM_Detect_Resource_Conflict_Ex(%p %lu %p %lu %p 0x%lx %p)\n",
1798 dnDevInst, ResourceID, ResourceData, ResourceLen,
1799 pbConflictDetected, ulFlags, hMachine);
1800
1802}
1803
1804
1805/***********************************************************************
1806 * CM_Disable_DevNode [SETUPAPI.@]
1807 */
1809WINAPI
1811 _In_ DEVINST dnDevInst,
1812 _In_ ULONG ulFlags)
1813{
1814 TRACE("CM_Disable_DevNode(%p %lx)\n",
1815 dnDevInst, ulFlags);
1816
1817 return CM_Disable_DevNode_Ex(dnDevInst, ulFlags, NULL);
1818}
1819
1820
1821/***********************************************************************
1822 * CM_Disable_DevNode_Ex [SETUPAPI.@]
1823 */
1825WINAPI
1827 _In_ DEVINST dnDevInst,
1828 _In_ ULONG ulFlags,
1829 _In_opt_ HMACHINE hMachine)
1830{
1832 HSTRING_TABLE StringTable = NULL;
1833 LPWSTR lpDevInst;
1834 CONFIGRET ret;
1835
1836 TRACE("CM_Disable_DevNode_Ex(%p %lx %p)\n",
1837 dnDevInst, ulFlags, hMachine);
1838
1839 if (!pSetupIsUserAdmin())
1840 return CR_ACCESS_DENIED;
1841
1842 if (dnDevInst == 0)
1843 return CR_INVALID_DEVINST;
1844
1845 if (ulFlags != 0)
1846 return CR_INVALID_FLAG;
1847
1848 if (hMachine != NULL)
1849 {
1850 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1851 if (BindingHandle == NULL)
1852 return CR_FAILURE;
1853
1854 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1855 if (StringTable == 0)
1856 return CR_FAILURE;
1857 }
1858 else
1859 {
1860 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
1861 return CR_FAILURE;
1862 }
1863
1864 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
1865 if (lpDevInst == NULL)
1866 return CR_INVALID_DEVNODE;
1867
1869 {
1871 lpDevInst,
1872 NULL,
1873 NULL,
1874 0,
1875 ulFlags);
1876 }
1878 {
1880 }
1882
1883 return ret;
1884}
1885
1886
1887/***********************************************************************
1888 * CM_Disconnect_Machine [SETUPAPI.@]
1889 */
1891WINAPI
1893 _In_opt_ HMACHINE hMachine)
1894{
1895 PMACHINE_INFO pMachine;
1896
1897 TRACE("CM_Disconnect_Machine(%p)\n", hMachine);
1898
1899 pMachine = (PMACHINE_INFO)hMachine;
1900 if (pMachine == NULL)
1901 return CR_SUCCESS;
1902
1903 if (pMachine->bLocal == FALSE)
1904 {
1905 if (pMachine->StringTable != NULL)
1907
1908 if (!PnpUnbindRpc(pMachine->BindingHandle))
1909 return CR_ACCESS_DENIED;
1910 }
1911
1912 HeapFree(GetProcessHeap(), 0, pMachine);
1913
1914 return CR_SUCCESS;
1915}
1916
1917
1918/***********************************************************************
1919 * CM_Dup_Range_List [SETUPAPI.@]
1920 */
1922WINAPI
1924 _In_ RANGE_LIST rlhOld,
1925 _In_ RANGE_LIST rlhNew,
1926 _In_ ULONG ulFlags)
1927{
1928 PINTERNAL_RANGE_LIST pOldRangeList, pNewRangeList;
1929 PINTERNAL_RANGE pOldRange, pNewRange;
1930 PLIST_ENTRY ListEntry;
1932
1933 FIXME("CM_Dup_Range_List(%p %p %lx)\n",
1934 rlhOld, rlhNew, ulFlags);
1935
1936 pOldRangeList = (PINTERNAL_RANGE_LIST)rlhOld;
1937 pNewRangeList = (PINTERNAL_RANGE_LIST)rlhNew;
1938
1939 if (!IsValidRangeList(pOldRangeList))
1940 return CR_INVALID_RANGE_LIST;
1941
1942 if (!IsValidRangeList(pNewRangeList))
1943 return CR_INVALID_RANGE_LIST;
1944
1945 if (ulFlags != 0)
1946 return CR_INVALID_FLAG;
1947
1948 /* Lock the range lists */
1949 WaitForSingleObject(pOldRangeList->hMutex, INFINITE);
1950 WaitForSingleObject(pNewRangeList->hMutex, INFINITE);
1951
1952 /* Delete the new range list, if ist is not empty */
1953 while (!IsListEmpty(&pNewRangeList->ListHead))
1954 {
1955 ListEntry = RemoveHeadList(&pNewRangeList->ListHead);
1956 pNewRange = CONTAINING_RECORD(ListEntry, INTERNAL_RANGE, ListEntry);
1957 HeapFree(GetProcessHeap(), 0, pNewRange);
1958 }
1959
1960 /* Copy the old range list into the new range list */
1961 ListEntry = &pOldRangeList->ListHead;
1962 while (ListEntry->Flink == &pOldRangeList->ListHead)
1963 {
1964 pOldRange = CONTAINING_RECORD(ListEntry, INTERNAL_RANGE, ListEntry);
1965
1966 pNewRange = HeapAlloc(GetProcessHeap(), 0, sizeof(INTERNAL_RANGE));
1967 if (pNewRange == NULL)
1968 {
1970 goto done;
1971 }
1972
1973 pNewRange->pRangeList = pNewRangeList;
1974 pNewRange->ullStart = pOldRange->ullStart;
1975 pNewRange->ullEnd = pOldRange->ullEnd;
1976
1977 InsertTailList(&pNewRangeList->ListHead, &pNewRange->ListEntry);
1978
1979 ListEntry = ListEntry->Flink;
1980 }
1981
1982done:
1983 /* Unlock the range lists */
1984 ReleaseMutex(pNewRangeList->hMutex);
1985 ReleaseMutex(pOldRangeList->hMutex);
1986
1987 return ret;
1988}
1989
1990
1991/***********************************************************************
1992 * CM_Enable_DevNode [SETUPAPI.@]
1993 */
1995WINAPI
1997 _In_ DEVINST dnDevInst,
1998 _In_ ULONG ulFlags)
1999{
2000 TRACE("CM_Enable_DevNode(%p %lx)\n",
2001 dnDevInst, ulFlags);
2002
2003 return CM_Enable_DevNode_Ex(dnDevInst, ulFlags, NULL);
2004}
2005
2006
2007/***********************************************************************
2008 * CM_Enable_DevNode_Ex [SETUPAPI.@]
2009 */
2011WINAPI
2013 _In_ DEVINST dnDevInst,
2014 _In_ ULONG ulFlags,
2015 _In_opt_ HMACHINE hMachine)
2016{
2018 HSTRING_TABLE StringTable = NULL;
2019 LPWSTR lpDevInst;
2020 CONFIGRET ret;
2021
2022 TRACE("CM_Enable_DevNode_Ex(%p %lx %p)\n",
2023 dnDevInst, ulFlags, hMachine);
2024
2025 if (!pSetupIsUserAdmin())
2026 return CR_ACCESS_DENIED;
2027
2028 if (dnDevInst == 0)
2029 return CR_INVALID_DEVINST;
2030
2031 if (ulFlags != 0)
2032 return CR_INVALID_FLAG;
2033
2034 if (hMachine != NULL)
2035 {
2036 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2037 if (BindingHandle == NULL)
2038 return CR_FAILURE;
2039
2040 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
2041 if (StringTable == 0)
2042 return CR_FAILURE;
2043 }
2044 else
2045 {
2046 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
2047 return CR_FAILURE;
2048 }
2049
2050 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
2051 if (lpDevInst == NULL)
2052 return CR_INVALID_DEVNODE;
2053
2055 {
2057 PNP_DEVINST_ENABLE,
2058 ulFlags,
2059 lpDevInst,
2060 NULL);
2061 }
2063 {
2065 }
2067
2068 return ret;
2069}
2070
2071
2072/***********************************************************************
2073 * CM_Enumerate_Classes [SETUPAPI.@]
2074 */
2076WINAPI
2078 _In_ ULONG ulClassIndex,
2079 _Out_ LPGUID ClassGuid,
2080 _In_ ULONG ulFlags)
2081{
2082 TRACE("CM_Enumerate_Classes(%lx %p %lx)\n",
2083 ulClassIndex, ClassGuid, ulFlags);
2084
2085 return CM_Enumerate_Classes_Ex(ulClassIndex, ClassGuid, ulFlags, NULL);
2086}
2087
2088
2089/***********************************************************************
2090 * CM_Enumerate_Classes_Ex [SETUPAPI.@]
2091 */
2093WINAPI
2095 _In_ ULONG ulClassIndex,
2096 _Out_ LPGUID ClassGuid,
2097 _In_ ULONG ulFlags,
2098 _In_opt_ HMACHINE hMachine)
2099{
2100 WCHAR szBuffer[MAX_GUID_STRING_LEN];
2103 ULONG ulLength = MAX_GUID_STRING_LEN;
2104
2105 TRACE("CM_Enumerate_Classes_Ex(%lx %p %lx %p)\n",
2106 ulClassIndex, ClassGuid, ulFlags, hMachine);
2107
2108 if (ClassGuid == NULL)
2109 return CR_INVALID_POINTER;
2110
2111 if (ulFlags != 0)
2112 return CR_INVALID_FLAG;
2113
2114 if (hMachine != NULL)
2115 {
2116 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2117 if (BindingHandle == NULL)
2118 return CR_FAILURE;
2119 }
2120 else
2121 {
2123 return CR_FAILURE;
2124 }
2125
2127 {
2129 PNP_CLASS_SUBKEYS,
2130 ulClassIndex,
2131 szBuffer,
2133 &ulLength,
2134 ulFlags);
2135 }
2137 {
2139 }
2141
2142 if (ret == CR_SUCCESS)
2143 {
2144 /* Remove the {} */
2145 szBuffer[MAX_GUID_STRING_LEN - 2] = UNICODE_NULL;
2146
2147 /* Convert the buffer to a GUID */
2148 if (UuidFromStringW(&szBuffer[1], ClassGuid) != RPC_S_OK)
2149 return CR_FAILURE;
2150 }
2151
2152 return ret;
2153}
2154
2155
2156/***********************************************************************
2157 * CM_Enumerate_EnumeratorsA [SETUPAPI.@]
2158 */
2160WINAPI
2162 _In_ ULONG ulEnumIndex,
2163 _Out_writes_(*pulLength) PCHAR Buffer,
2164 _Inout_ PULONG pulLength,
2165 _In_ ULONG ulFlags)
2166{
2167 TRACE("CM_Enumerate_EnumeratorsA(%lu %p %p %lx)\n",
2168 ulEnumIndex, Buffer, pulLength, ulFlags);
2169
2170 return CM_Enumerate_Enumerators_ExA(ulEnumIndex, Buffer, pulLength,
2171 ulFlags, NULL);
2172}
2173
2174
2175/***********************************************************************
2176 * CM_Enumerate_EnumeratorsW [SETUPAPI.@]
2177 */
2179WINAPI
2181 _In_ ULONG ulEnumIndex,
2182 _Out_writes_(*pulLength) PWCHAR Buffer,
2183 _Inout_ PULONG pulLength,
2184 _In_ ULONG ulFlags)
2185{
2186 TRACE("CM_Enumerate_EnumeratorsW(%lu %p %p %lx)\n",
2187 ulEnumIndex, Buffer, pulLength, ulFlags);
2188
2189 return CM_Enumerate_Enumerators_ExW(ulEnumIndex, Buffer, pulLength,
2190 ulFlags, NULL);
2191}
2192
2193
2194/***********************************************************************
2195 * CM_Enumerate_Enumerators_ExA [SETUPAPI.@]
2196 */
2198WINAPI
2200 _In_ ULONG ulEnumIndex,
2201 _Out_writes_(*pulLength) PCHAR Buffer,
2202 _Inout_ PULONG pulLength,
2203 _In_ ULONG ulFlags,
2204 _In_opt_ HMACHINE hMachine)
2205{
2206 WCHAR szBuffer[MAX_DEVICE_ID_LEN];
2207 ULONG ulOrigLength;
2208 ULONG ulLength;
2210
2211 TRACE("CM_Enumerate_Enumerators_ExA(%lu %p %p %lx %p)\n",
2212 ulEnumIndex, Buffer, pulLength, ulFlags, hMachine);
2213
2214 if (Buffer == NULL || pulLength == NULL)
2215 return CR_INVALID_POINTER;
2216
2217 if (ulFlags != 0)
2218 return CR_INVALID_FLAG;
2219
2220 ulOrigLength = *pulLength;
2221 *pulLength = 0;
2222
2223 ulLength = MAX_DEVICE_ID_LEN;
2224 ret = CM_Enumerate_Enumerators_ExW(ulEnumIndex, szBuffer, &ulLength,
2225 ulFlags, hMachine);
2226 if (ret == CR_SUCCESS)
2227 {
2229 0,
2230 szBuffer,
2231 ulLength,
2232 Buffer,
2233 ulOrigLength,
2234 NULL,
2235 NULL) == 0)
2236 ret = CR_FAILURE;
2237 else
2238 *pulLength = lstrlenA(Buffer) + 1;
2239 }
2240
2241 return ret;
2242}
2243
2244
2245/***********************************************************************
2246 * CM_Enumerate_Enumerators_ExW [SETUPAPI.@]
2247 */
2249WINAPI
2251 _In_ ULONG ulEnumIndex,
2252 _Out_writes_(*pulLength) PWCHAR Buffer,
2253 _Inout_ PULONG pulLength,
2254 _In_ ULONG ulFlags,
2255 _In_opt_ HMACHINE hMachine)
2256{
2258 CONFIGRET ret;
2259
2260 TRACE("CM_Enumerate_Enumerators_ExW(%lu %p %p %lx %p)\n",
2261 ulEnumIndex, Buffer, pulLength, ulFlags, hMachine);
2262
2263 if (Buffer == NULL || pulLength == NULL)
2264 return CR_INVALID_POINTER;
2265
2266 if (ulFlags != 0)
2267 return CR_INVALID_FLAG;
2268
2270
2271 if (hMachine != NULL)
2272 {
2273 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2274 if (BindingHandle == NULL)
2275 return CR_FAILURE;
2276 }
2277 else
2278 {
2280 return CR_FAILURE;
2281 }
2282
2284 {
2286 PNP_ENUMERATOR_SUBKEYS,
2287 ulEnumIndex,
2288 Buffer,
2289 *pulLength,
2290 pulLength,
2291 ulFlags);
2292 }
2294 {
2296 }
2298
2299 return ret;
2300}
2301
2302
2303/***********************************************************************
2304 * CM_Find_Range [SETUPAPI.@]
2305 */
2307WINAPI
2309 _Out_ PDWORDLONG pullStart,
2310 _In_ DWORDLONG ullStart,
2311 _In_ ULONG ulLength,
2312 _In_ DWORDLONG ullAlignment,
2313 _In_ DWORDLONG ullEnd,
2314 _In_ RANGE_LIST rlh,
2315 _In_ ULONG ulFlags)
2316{
2317 FIXME("CM_Find_Range(%p %I64u %lu %I64u %I64u %p %lx)\n",
2318 pullStart, ullStart, ulLength, ullAlignment, ullEnd, rlh, ulFlags);
2319
2321}
2322
2323
2324/***********************************************************************
2325 * CM_First_Range [SETUPAPI.@]
2326 */
2328WINAPI
2330 _In_ RANGE_LIST rlh,
2331 _Out_ PDWORDLONG pullStart,
2332 _Out_ PDWORDLONG pullEnd,
2333 _Out_ PRANGE_ELEMENT preElement,
2334 _In_ ULONG ulFlags)
2335{
2336 PINTERNAL_RANGE_LIST pRangeList;
2337 PINTERNAL_RANGE pRange;
2338 PLIST_ENTRY ListEntry;
2340
2341 FIXME("CM_First_Range(%p %p %p %p %lx)\n",
2342 rlh, pullStart, pullEnd, preElement, ulFlags);
2343
2344 pRangeList = (PINTERNAL_RANGE_LIST)rlh;
2345
2346 if (!IsValidRangeList(pRangeList))
2347 return CR_INVALID_RANGE_LIST;
2348
2349 if (pullStart == NULL || pullEnd == NULL || preElement == NULL)
2350 return CR_INVALID_POINTER;
2351
2352 if (ulFlags != 0)
2353 return CR_INVALID_FLAG;
2354
2355 /* Lock the range list */
2356 WaitForSingleObject(pRangeList->hMutex, INFINITE);
2357
2358 /* Fail, if the list is empty */
2359 if (IsListEmpty(&pRangeList->ListHead))
2360 {
2361 ret = CR_FAILURE;
2362 goto done;
2363 }
2364
2365 /* Get the first range */
2366 ListEntry = pRangeList->ListHead.Flink;
2367 pRange = CONTAINING_RECORD(ListEntry, INTERNAL_RANGE, ListEntry);
2368
2369 /* Return the range data */
2370 *pullStart = pRange->ullStart;
2371 *pullEnd = pRange->ullEnd;
2372 *preElement = (RANGE_ELEMENT)pRange;
2373
2374done:
2375 /* Unlock the range list */
2376 ReleaseMutex(pRangeList->hMutex);
2377
2378 return ret;
2379}
2380
2381
2382/***********************************************************************
2383 * CM_Free_Log_Conf [SETUPAPI.@]
2384 */
2386WINAPI
2388 _In_ LOG_CONF lcLogConfToBeFreed,
2389 _In_ ULONG ulFlags)
2390{
2391 TRACE("CM_Free_Log_Conf(%lx %lx)\n",
2392 lcLogConfToBeFreed, ulFlags);
2393
2394 return CM_Free_Log_Conf_Ex(lcLogConfToBeFreed, ulFlags, NULL);
2395}
2396
2397
2398/***********************************************************************
2399 * CM_Free_Log_Conf_Ex [SETUPAPI.@]
2400 */
2402WINAPI
2404 _In_ LOG_CONF lcLogConfToBeFreed,
2405 _In_ ULONG ulFlags,
2406 _In_opt_ HMACHINE hMachine)
2407{
2409 HSTRING_TABLE StringTable = NULL;
2410 LPWSTR lpDevInst;
2411 PLOG_CONF_INFO pLogConfInfo;
2412 CONFIGRET ret;
2413
2414 TRACE("CM_Free_Log_Conf_Ex(%lx %lx %p)\n",
2415 lcLogConfToBeFreed, ulFlags, hMachine);
2416
2417 if (!pSetupIsUserAdmin())
2418 return CR_ACCESS_DENIED;
2419
2420 pLogConfInfo = (PLOG_CONF_INFO)lcLogConfToBeFreed;
2421 if (!IsValidLogConf(pLogConfInfo))
2422 return CR_INVALID_LOG_CONF;
2423
2424 if (ulFlags != 0)
2425 return CR_INVALID_FLAG;
2426
2427 if (hMachine != NULL)
2428 {
2429 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2430 if (BindingHandle == NULL)
2431 return CR_FAILURE;
2432
2433 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
2434 if (StringTable == 0)
2435 return CR_FAILURE;
2436 }
2437 else
2438 {
2439 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
2440 return CR_FAILURE;
2441 }
2442
2443 lpDevInst = pSetupStringTableStringFromId(StringTable, pLogConfInfo->dnDevInst);
2444 if (lpDevInst == NULL)
2445 return CR_INVALID_DEVNODE;
2446
2448 {
2450 lpDevInst,
2451 pLogConfInfo->ulType,
2452 pLogConfInfo->ulTag,
2453 0);
2454 }
2456 {
2458 }
2460
2461 return ret;
2462}
2463
2464
2465/***********************************************************************
2466 * CM_Free_Log_Conf_Handle [SETUPAPI.@]
2467 */
2469WINAPI
2471 _In_ LOG_CONF lcLogConf)
2472{
2473 PLOG_CONF_INFO pLogConfInfo;
2474
2475 TRACE("CM_Free_Log_Conf_Handle(%lx)\n", lcLogConf);
2476
2477 pLogConfInfo = (PLOG_CONF_INFO)lcLogConf;
2478 if (!IsValidLogConf(pLogConfInfo))
2479 return CR_INVALID_LOG_CONF;
2480
2481 HeapFree(GetProcessHeap(), 0, pLogConfInfo);
2482
2483 return CR_SUCCESS;
2484}
2485
2486
2487/***********************************************************************
2488 * CM_Free_Range_List [SETUPAPI.@]
2489 */
2491WINAPI
2493 _In_ RANGE_LIST RangeList,
2494 _In_ ULONG ulFlags)
2495{
2496 PINTERNAL_RANGE_LIST pRangeList;
2497 PINTERNAL_RANGE pRange;
2498 PLIST_ENTRY ListEntry;
2499
2500 FIXME("CM_Free_Range_List(%p %lx)\n",
2501 RangeList, ulFlags);
2502
2503 pRangeList = (PINTERNAL_RANGE_LIST)RangeList;
2504
2505 if (!IsValidRangeList(pRangeList))
2506 return CR_INVALID_RANGE_LIST;
2507
2508 if (ulFlags != 0)
2509 return CR_INVALID_FLAG;
2510
2511 /* Lock the range list */
2512 WaitForSingleObject(pRangeList->hMutex, INFINITE);
2513
2514 /* Free the list of ranges */
2515 while (!IsListEmpty(&pRangeList->ListHead))
2516 {
2517 ListEntry = RemoveHeadList(&pRangeList->ListHead);
2518 pRange = CONTAINING_RECORD(ListEntry, INTERNAL_RANGE, ListEntry);
2519 HeapFree(GetProcessHeap(), 0, pRange);
2520 }
2521
2522 /* Unlock the range list */
2523 ReleaseMutex(pRangeList->hMutex);
2524
2525 /* Close the mutex */
2526 CloseHandle(pRangeList->hMutex);
2527
2528 /* Free the range list */
2529 HeapFree(GetProcessHeap(), 0, pRangeList);
2530
2531 return CR_SUCCESS;
2532}
2533
2534
2535/***********************************************************************
2536 * CM_Free_Res_Des [SETUPAPI.@]
2537 */
2539WINAPI
2541 _Out_ PRES_DES prdResDes,
2542 _In_ RES_DES rdResDes,
2543 _In_ ULONG ulFlags)
2544{
2545 TRACE("CM_Free_Res_Des(%p %p %lx)\n",
2546 prdResDes, rdResDes, ulFlags);
2547
2548 return CM_Free_Res_Des_Ex(prdResDes, rdResDes, ulFlags, NULL);
2549}
2550
2551
2552/***********************************************************************
2553 * CM_Free_Res_Des_Ex [SETUPAPI.@]
2554 */
2556WINAPI
2558 _Out_ PRES_DES prdResDes,
2559 _In_ RES_DES rdResDes,
2560 _In_ ULONG ulFlags,
2561 _In_opt_ HMACHINE hMachine)
2562{
2563 FIXME("CM_Free_Res_Des_Ex(%p %p %lx %p)\n",
2564 prdResDes, rdResDes, ulFlags, hMachine);
2565
2567}
2568
2569
2570/***********************************************************************
2571 * CM_Free_Res_Des_Handle [SETUPAPI.@]
2572 */
2574WINAPI
2576 _In_ RES_DES rdResDes)
2577{
2578 PRES_DES_INFO pResDesInfo;
2579
2580 FIXME("CM_Free_Res_Des_Handle(%p)\n", rdResDes);
2581
2582 pResDesInfo = (PRES_DES_INFO)rdResDes;
2583 if (!IsValidResDes(pResDesInfo))
2584 return CR_INVALID_RES_DES;
2585
2586 HeapFree(GetProcessHeap(), 0, pResDesInfo);
2587
2588 return CR_SUCCESS;
2589}
2590
2591
2592/***********************************************************************
2593 * CM_Free_Resource_Conflict_Handle [SETUPAPI.@]
2594 */
2596WINAPI
2598 _In_ CONFLICT_LIST clConflictList)
2599{
2600 PCONFLICT_DATA pConflictData;
2601
2602 FIXME("CM_Free_Resource_Conflict_Handle(%p)\n",
2603 clConflictList);
2604
2605 pConflictData = (PCONFLICT_DATA)clConflictList;
2606 if (!IsValidConflictData(pConflictData))
2608
2609 if (pConflictData->pConflictList != NULL)
2610 MyFree(pConflictData->pConflictList);
2611
2612 MyFree(pConflictData);
2613
2614 return CR_SUCCESS;
2615}
2616
2617
2618/***********************************************************************
2619 * CM_Get_Child [SETUPAPI.@]
2620 */
2622WINAPI
2624 _Out_ PDEVINST pdnDevInst,
2625 _In_ DEVINST dnDevInst,
2626 _In_ ULONG ulFlags)
2627{
2628 TRACE("CM_Get_Child(%p %p %lx)\n",
2629 pdnDevInst, dnDevInst, ulFlags);
2630
2631 return CM_Get_Child_Ex(pdnDevInst, dnDevInst, ulFlags, NULL);
2632}
2633
2634
2635/***********************************************************************
2636 * CM_Get_Child_Ex [SETUPAPI.@]
2637 */
2639WINAPI
2641 _Out_ PDEVINST pdnDevInst,
2642 _In_ DEVINST dnDevInst,
2643 _In_ ULONG ulFlags,
2644 _In_opt_ HMACHINE hMachine)
2645{
2646 WCHAR szRelatedDevInst[MAX_DEVICE_ID_LEN];
2648 HSTRING_TABLE StringTable = NULL;
2649 LPWSTR lpDevInst;
2650 DWORD dwIndex, dwLength = MAX_DEVICE_ID_LEN;
2651 CONFIGRET ret;
2652
2653 TRACE("CM_Get_Child_Ex(%p %lx %lx %p)\n",
2654 pdnDevInst, dnDevInst, ulFlags, hMachine);
2655
2656 if (pdnDevInst == NULL)
2657 return CR_INVALID_POINTER;
2658
2659 if (dnDevInst == 0)
2660 return CR_INVALID_DEVINST;
2661
2662 if (ulFlags != 0)
2663 return CR_INVALID_FLAG;
2664
2665 *pdnDevInst = -1;
2666
2667 if (hMachine != NULL)
2668 {
2669 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2670 if (BindingHandle == NULL)
2671 return CR_FAILURE;
2672
2673 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
2674 if (StringTable == 0)
2675 return CR_FAILURE;
2676 }
2677 else
2678 {
2679 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
2680 return CR_FAILURE;
2681 }
2682
2683 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
2684 if (lpDevInst == NULL)
2685 return CR_INVALID_DEVNODE;
2686
2688 {
2690 PNP_GET_CHILD_DEVICE_INSTANCE,
2691 lpDevInst,
2692 szRelatedDevInst,
2693 &dwLength,
2694 0);
2695 }
2697 {
2699 }
2701
2702 if (ret != CR_SUCCESS)
2703 return ret;
2704
2705 TRACE("szRelatedDevInst: %s\n", debugstr_w(szRelatedDevInst));
2706
2707 dwIndex = pSetupStringTableAddString(StringTable, szRelatedDevInst, 1);
2708 if (dwIndex == -1)
2709 return CR_FAILURE;
2710
2711 *pdnDevInst = dwIndex;
2712
2713 return CR_SUCCESS;
2714}
2715
2716
2717/***********************************************************************
2718 * CM_Get_Class_Key_NameA [SETUPAPI.@]
2719 */
2721WINAPI
2723 _In_ LPGUID ClassGuid,
2724 _Out_writes_opt_(*pulLength) LPSTR pszKeyName,
2725 _Inout_ PULONG pulLength,
2726 _In_ ULONG ulFlags)
2727{
2728 TRACE("CM_Get_Class_Key_NameA(%p %p %p %lx)\n",
2729 ClassGuid, pszKeyName, pulLength, ulFlags);
2730
2731 return CM_Get_Class_Key_Name_ExA(ClassGuid, pszKeyName, pulLength,
2732 ulFlags, NULL);
2733}
2734
2735
2736/***********************************************************************
2737 * CM_Get_Class_Key_NameW [SETUPAPI.@]
2738 */
2740WINAPI
2742 _In_ LPGUID ClassGuid,
2743 _Out_writes_opt_(*pulLength) LPWSTR pszKeyName,
2744 _Inout_ PULONG pulLength,
2745 _In_ ULONG ulFlags)
2746{
2747 TRACE("CM_Get_Class_Key_NameW(%p %p %p %lx)\n",
2748 ClassGuid, pszKeyName, pulLength, ulFlags);
2749
2750 return CM_Get_Class_Key_Name_ExW(ClassGuid, pszKeyName, pulLength,
2751 ulFlags, NULL);
2752}
2753
2754
2755/***********************************************************************
2756 * CM_Get_Class_Key_Name_ExA [SETUPAPI.@]
2757 */
2759WINAPI
2761 _In_ LPGUID ClassGuid,
2762 _Out_writes_opt_(*pulLength) LPSTR pszKeyName,
2763 _Inout_ PULONG pulLength,
2764 _In_ ULONG ulFlags,
2765 _In_opt_ HMACHINE hMachine)
2766{
2767 WCHAR szBuffer[MAX_GUID_STRING_LEN];
2769 ULONG ulLength;
2770 ULONG ulOrigLength;
2771
2772 TRACE("CM_Get_Class_Key_Name_ExA(%p %p %p %lx %p)\n",
2773 ClassGuid, pszKeyName, pulLength, ulFlags, hMachine);
2774
2775 if (ClassGuid == NULL || pszKeyName == NULL || pulLength == NULL)
2776 return CR_INVALID_POINTER;
2777
2778 ulOrigLength = *pulLength;
2779 *pulLength = 0;
2780
2781 ulLength = MAX_GUID_STRING_LEN;
2782 ret = CM_Get_Class_Key_Name_ExW(ClassGuid, szBuffer, &ulLength,
2783 ulFlags, hMachine);
2784 if (ret == CR_SUCCESS)
2785 {
2787 0,
2788 szBuffer,
2789 ulLength,
2790 pszKeyName,
2791 ulOrigLength,
2792 NULL,
2793 NULL) == 0)
2794 ret = CR_FAILURE;
2795 else
2796 *pulLength = lstrlenA(pszKeyName) + 1;
2797 }
2798
2799 return CR_SUCCESS;
2800}
2801
2802
2803/***********************************************************************
2804 * CM_Get_Class_Key_Name_ExW [SETUPAPI.@]
2805 */
2807WINAPI
2809 _In_ LPGUID ClassGuid,
2810 _Out_writes_opt_(*pulLength) LPWSTR pszKeyName,
2811 _Inout_ PULONG pulLength,
2812 _In_ ULONG ulFlags,
2813 _In_opt_ HMACHINE hMachine)
2814{
2815 TRACE("CM_Get_Class_Key_Name_ExW(%p %p %p %lx %p)\n",
2816 ClassGuid, pszKeyName, pulLength, ulFlags, hMachine);
2817
2818 if (ClassGuid == NULL || pszKeyName == NULL || pulLength == NULL)
2819 return CR_INVALID_POINTER;
2820
2821 if (ulFlags != 0)
2822 return CR_INVALID_FLAG;
2823
2824 if (*pulLength < MAX_GUID_STRING_LEN)
2825 {
2826 *pulLength = 0;
2827 return CR_BUFFER_SMALL;
2828 }
2829
2830 if (!GuidToString(ClassGuid, pszKeyName))
2831 return CR_INVALID_DATA;
2832
2833 *pulLength = MAX_GUID_STRING_LEN;
2834
2835 return CR_SUCCESS;
2836}
2837
2838
2839/***********************************************************************
2840 * CM_Get_Class_NameA [SETUPAPI.@]
2841 */
2843WINAPI
2845 _In_ LPGUID ClassGuid,
2846 _Out_writes_opt_(*pulLength) PCHAR Buffer,
2847 _Inout_ PULONG pulLength,
2848 _In_ ULONG ulFlags)
2849{
2850 TRACE("CM_Get_Class_NameA(%p %p %p %lx)\n",
2851 ClassGuid, Buffer, pulLength, ulFlags);
2852
2853 return CM_Get_Class_Name_ExA(ClassGuid, Buffer, pulLength, ulFlags,
2854 NULL);
2855}
2856
2857
2858/***********************************************************************
2859 * CM_Get_Class_NameW [SETUPAPI.@]
2860 */
2862WINAPI
2864 _In_ LPGUID ClassGuid,
2865 _Out_writes_opt_(*pulLength) PWCHAR Buffer,
2866 _Inout_ PULONG pulLength,
2867 _In_ ULONG ulFlags)
2868{
2869 TRACE("CM_Get_Class_NameW(%p %p %p %lx)\n",
2870 ClassGuid, Buffer, pulLength, ulFlags);
2871
2872 return CM_Get_Class_Name_ExW(ClassGuid, Buffer, pulLength, ulFlags,
2873 NULL);
2874}
2875
2876
2877/***********************************************************************
2878 * CM_Get_Class_Name_ExA [SETUPAPI.@]
2879 */
2881WINAPI
2883 _In_ LPGUID ClassGuid,
2884 _Out_writes_opt_(*pulLength) PCHAR Buffer,
2885 _Inout_ PULONG pulLength,
2886 _In_ ULONG ulFlags,
2887 _In_opt_ HMACHINE hMachine)
2888{
2889 WCHAR szBuffer[MAX_CLASS_NAME_LEN];
2891 ULONG ulLength;
2892 ULONG ulOrigLength;
2893
2894 TRACE("CM_Get_Class_Name_ExA(%p %p %p %lx %p)\n",
2895 ClassGuid, Buffer, pulLength, ulFlags, hMachine);
2896
2897 if (ClassGuid == NULL || Buffer == NULL || pulLength == NULL)
2898 return CR_INVALID_POINTER;
2899
2900 ulOrigLength = *pulLength;
2901 *pulLength = 0;
2902
2903 ulLength = MAX_CLASS_NAME_LEN;
2904 ret = CM_Get_Class_Name_ExW(ClassGuid, szBuffer, &ulLength,
2905 ulFlags, hMachine);
2906 if (ret == CR_SUCCESS)
2907 {
2909 0,
2910 szBuffer,
2911 ulLength,
2912 Buffer,
2913 ulOrigLength,
2914 NULL,
2915 NULL) == 0)
2916 ret = CR_FAILURE;
2917 else
2918 *pulLength = lstrlenA(Buffer) + 1;
2919 }
2920
2921 return ret;
2922}
2923
2924
2925/***********************************************************************
2926 * CM_Get_Class_Name_ExW [SETUPAPI.@]
2927 */
2929WINAPI
2931 _In_ LPGUID ClassGuid,
2932 _Out_writes_opt_(*pulLength) PWCHAR Buffer,
2933 _Inout_ PULONG pulLength,
2934 _In_ ULONG ulFlags,
2935 _In_opt_ HMACHINE hMachine)
2936{
2937 WCHAR szGuidString[MAX_GUID_STRING_LEN];
2939 CONFIGRET ret;
2940
2941 TRACE("CM_Get_Class_Name_ExW(%p %p %p %lx %p\n",
2942 ClassGuid, Buffer, pulLength, ulFlags, hMachine);
2943
2944 if (ClassGuid == NULL || Buffer == NULL || pulLength == NULL)
2945 return CR_INVALID_POINTER;
2946
2947 if (ulFlags != 0)
2948 return CR_INVALID_FLAG;
2949
2950 if (!GuidToString(ClassGuid, szGuidString))
2951 return CR_INVALID_DATA;
2952
2953 TRACE("Guid %s\n", debugstr_w(szGuidString));
2954
2955 if (hMachine != NULL)
2956 {
2957 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2958 if (BindingHandle == NULL)
2959 return CR_FAILURE;
2960 }
2961 else
2962 {
2964 return CR_FAILURE;
2965 }
2966
2968 {
2970 szGuidString,
2971 Buffer,
2972 pulLength,
2973 ulFlags);
2974 }
2976 {
2978 }
2980
2981 return ret;
2982}
2983
2984
2985/***********************************************************************
2986 * CM_Get_Class_Registry_PropertyA [SETUPAPI.@]
2987 */
2989WINAPI
2991 LPGUID ClassGuid,
2992 ULONG ulProperty,
2993 PULONG pulRegDataType,
2994 PVOID Buffer,
2995 PULONG pulLength,
2996 ULONG ulFlags,
2997 HMACHINE hMachine)
2998{
2999 PWSTR BufferW;
3000 ULONG ulLength = 0;
3001 ULONG ulType;
3002 CONFIGRET ret;
3003
3004 TRACE("CM_Get_Class_Registry_PropertyA(%p %lu %p %p %p %lx %p)\n",
3005 ClassGuid, ulProperty, pulRegDataType, Buffer, pulLength,
3006 ulFlags, hMachine);
3007
3008 if (pulLength == NULL)
3009 return CR_INVALID_POINTER;
3010
3011 if (ulProperty < CM_CRP_MIN || ulProperty > CM_CRP_MAX)
3012 return CR_INVALID_PROPERTY;
3013
3014 ulType = GetRegistryPropertyType(ulProperty);
3015 if (ulType == REG_SZ || ulType == REG_MULTI_SZ)
3016 {
3017 /* Get the required buffer size */
3018 ret = CM_Get_Class_Registry_PropertyW(ClassGuid, ulProperty, pulRegDataType,
3019 NULL, &ulLength, ulFlags, hMachine);
3020 if (ret != CR_BUFFER_SMALL)
3021 return ret;
3022
3023 /* Allocate the unicode buffer */
3024 BufferW = HeapAlloc(GetProcessHeap(), 0, ulLength);
3025 if (BufferW == NULL)
3026 return CR_OUT_OF_MEMORY;
3027
3028 /* Get the property */
3029 ret = CM_Get_Class_Registry_PropertyW(ClassGuid, ulProperty, pulRegDataType,
3030 BufferW, &ulLength, ulFlags, hMachine);
3031 if (ret != CR_SUCCESS)
3032 {
3033 HeapFree(GetProcessHeap(), 0, BufferW);
3034 return ret;
3035 }
3036
3037 /* Do W->A conversion */
3038 *pulLength = WideCharToMultiByte(CP_ACP,
3039 0,
3040 BufferW,
3041 ulLength,
3042 Buffer,
3043 *pulLength,
3044 NULL,
3045 NULL);
3046
3047 /* Release the unicode buffer */
3048 HeapFree(GetProcessHeap(), 0, BufferW);
3049
3050 if (*pulLength == 0)
3051 ret = CR_FAILURE;
3052 }
3053 else
3054 {
3055 /* Get the property */
3056 ret = CM_Get_Class_Registry_PropertyW(ClassGuid, ulProperty, pulRegDataType,
3057 Buffer, pulLength, ulFlags, hMachine);
3058 }
3059
3060 return ret;
3061}
3062
3063
3064/***********************************************************************
3065 * CM_Get_Class_Registry_PropertyW [SETUPAPI.@]
3066 */
3068WINAPI
3070 LPGUID ClassGuid,
3071 ULONG ulProperty,
3072 PULONG pulRegDataType,
3073 PVOID Buffer,
3074 PULONG pulLength,
3075 ULONG ulFlags,
3076 HMACHINE hMachine)
3077{
3079 WCHAR szGuidString[PNP_MAX_GUID_STRING_LEN + 1];
3080 ULONG ulType = 0;
3081 ULONG ulTransferLength = 0;
3082 CONFIGRET ret;
3083
3084 TRACE("CM_Get_Class_Registry_PropertyW(%p %lu %p %p %p %lx %p)\n",
3085 ClassGuid, ulProperty, pulRegDataType, Buffer, pulLength,
3086 ulFlags, hMachine);
3087
3088 if (ClassGuid == NULL || pulLength == NULL)
3089 return CR_INVALID_POINTER;
3090
3091 if (ulFlags != 0)
3092 return CR_INVALID_FLAG;
3093
3094 if (pSetupStringFromGuid(ClassGuid,
3095 szGuidString,
3097 return CR_INVALID_DATA;
3098
3099 if (ulProperty < CM_CRP_MIN || ulProperty > CM_CRP_MAX)
3100 return CR_INVALID_PROPERTY;
3101
3102 if (hMachine != NULL)
3103 {
3104 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3105 if (BindingHandle == NULL)
3106 return CR_FAILURE;
3107 }
3108 else
3109 {
3111 return CR_FAILURE;
3112 }
3113
3114 ulTransferLength = *pulLength;
3115
3117 {
3119 szGuidString,
3120 ulProperty,
3121 &ulType,
3122 Buffer,
3123 &ulTransferLength,
3124 pulLength,
3125 ulFlags);
3126 }
3128 {
3130 }
3132
3133 if (ret == CR_SUCCESS)
3134 {
3135 if (pulRegDataType != NULL)
3136 *pulRegDataType = ulType;
3137 }
3138
3139 return ret;
3140}
3141
3142
3143/***********************************************************************
3144 * CM_Get_Depth [SETUPAPI.@]
3145 */
3147WINAPI
3149 _Out_ PULONG pulDepth,
3150 _In_ DEVINST dnDevInst,
3151 _In_ ULONG ulFlags)
3152{
3153 TRACE("CM_Get_Depth(%p %lx %lx)\n",
3154 pulDepth, dnDevInst, ulFlags);
3155
3156 return CM_Get_Depth_Ex(pulDepth, dnDevInst, ulFlags, NULL);
3157}
3158
3159
3160/***********************************************************************
3161 * CM_Get_Depth_Ex [SETUPAPI.@]
3162 */
3164WINAPI
3166 _Out_ PULONG pulDepth,
3167 _In_ DEVINST dnDevInst,
3168 _In_ ULONG ulFlags,
3169 _In_opt_ HMACHINE hMachine)
3170{
3172 HSTRING_TABLE StringTable = NULL;
3173 LPWSTR lpDevInst;
3174 CONFIGRET ret;
3175
3176 TRACE("CM_Get_Depth_Ex(%p %lx %lx %p)\n",
3177 pulDepth, dnDevInst, ulFlags, hMachine);
3178
3179 if (pulDepth == NULL)
3180 return CR_INVALID_POINTER;
3181
3182 if (dnDevInst == 0)
3183 return CR_INVALID_DEVINST;
3184
3185 if (ulFlags != 0)
3186 return CR_INVALID_FLAG;
3187
3188 if (hMachine != NULL)
3189 {
3190 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3191 if (BindingHandle == NULL)
3192 return CR_FAILURE;
3193
3194 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3195 if (StringTable == 0)
3196 return CR_FAILURE;
3197 }
3198 else
3199 {
3200 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
3201 return CR_FAILURE;
3202 }
3203
3204 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
3205 if (lpDevInst == NULL)
3206 return CR_INVALID_DEVNODE;
3207
3209 {
3211 lpDevInst,
3212 pulDepth,
3213 ulFlags);
3214 }
3216 {
3218 }
3220
3221 return ret;
3222}
3223
3224
3225/***********************************************************************
3226 * CM_Get_DevNode_Custom_PropertyA [SETUPAPI.@]
3227 */
3229WINAPI
3231 _In_ DEVINST dnDevInst,
3232 _In_ PCSTR pszCustomPropertyName,
3233 _Out_opt_ PULONG pulRegDataType,
3235 _Inout_ PULONG pulLength,
3236 _In_ ULONG ulFlags)
3237{
3238 TRACE("CM_Get_DevNode_Custom_PropertyA(%lx %s %p %p %p %lx)\n",
3239 dnDevInst, pszCustomPropertyName, pulRegDataType,
3240 Buffer, pulLength, ulFlags);
3241
3242 return CM_Get_DevNode_Custom_Property_ExA(dnDevInst, pszCustomPropertyName,
3243 pulRegDataType, Buffer,
3244 pulLength, ulFlags, NULL);
3245}
3246
3247
3248/***********************************************************************
3249 * CM_Get_DevNode_Custom_PropertyW [SETUPAPI.@]
3250 */
3252WINAPI
3254 _In_ DEVINST dnDevInst,
3255 _In_ PCWSTR pszCustomPropertyName,
3256 _Out_opt_ PULONG pulRegDataType,
3258 _Inout_ PULONG pulLength,
3259 _In_ ULONG ulFlags)
3260{
3261 TRACE("CM_Get_DevNode_Custom_PropertyW(%lx %s %p %p %p %lx)\n",
3262 dnDevInst, debugstr_w(pszCustomPropertyName), pulRegDataType,
3263 Buffer, pulLength, ulFlags);
3264
3265 return CM_Get_DevNode_Custom_Property_ExW(dnDevInst, pszCustomPropertyName,
3266 pulRegDataType, Buffer,
3267 pulLength, ulFlags, NULL);
3268}
3269
3270
3271/***********************************************************************
3272 * CM_Get_DevNode_Custom_Property_ExA [SETUPAPI.@]
3273 */
3275WINAPI
3277 _In_ DEVINST dnDevInst,
3278 _In_ PCSTR pszCustomPropertyName,
3279 _Out_opt_ PULONG pulRegDataType,
3281 _Inout_ PULONG pulLength,
3282 _In_ ULONG ulFlags,
3283 _In_opt_ HMACHINE hMachine)
3284{
3285 LPWSTR pszPropertyNameW;
3286 PVOID BufferW;
3287 ULONG ulLengthW;
3288 ULONG ulDataType = REG_NONE;
3289 CONFIGRET ret;
3290
3291 TRACE("CM_Get_DevNode_Custom_Property_ExA(%lx %s %p %p %p %lx %p)\n",
3292 dnDevInst, pszCustomPropertyName, pulRegDataType,
3293 Buffer, pulLength, ulFlags, hMachine);
3294
3295 if (!pulLength)
3296 return CR_INVALID_POINTER;
3297
3298 ulLengthW = *pulLength * sizeof(WCHAR);
3299 BufferW = HeapAlloc(GetProcessHeap(), 0, ulLengthW);
3300 if (!BufferW)
3301 return CR_OUT_OF_MEMORY;
3302
3303 pszPropertyNameW = pSetupMultiByteToUnicode(pszCustomPropertyName,
3304 CP_ACP);
3305 if (pszPropertyNameW == NULL)
3306 {
3307 HeapFree(GetProcessHeap(), 0, BufferW);
3308 return CR_OUT_OF_MEMORY;
3309 }
3310
3312 pszPropertyNameW,
3313 &ulDataType,
3314 BufferW,
3315 &ulLengthW,
3316 ulFlags,
3317 hMachine);
3318 if (ret == CR_SUCCESS)
3319 {
3320 if (ulDataType == REG_SZ ||
3321 ulDataType == REG_EXPAND_SZ ||
3322 ulDataType == REG_MULTI_SZ)
3323 {
3324 /* Do W->A conversion */
3325 *pulLength = WideCharToMultiByte(CP_ACP,
3326 0,
3327 BufferW,
3328 lstrlenW(BufferW) + 1,
3329 Buffer,
3330 *pulLength,
3331 NULL,
3332 NULL);
3333 if (*pulLength == 0)
3334 ret = CR_FAILURE;
3335 }
3336 else
3337 {
3338 /* Directly copy the value */
3339 if (ulLengthW <= *pulLength)
3340 memcpy(Buffer, BufferW, ulLengthW);
3341 else
3342 {
3343 *pulLength = ulLengthW;
3345 }
3346 }
3347 }
3348
3349 if (pulRegDataType)
3350 *pulRegDataType = ulDataType;
3351
3352 HeapFree(GetProcessHeap(), 0, BufferW);
3353 MyFree(pszPropertyNameW);
3354
3355 return ret;
3356}
3357
3358
3359/***********************************************************************
3360 * CM_Get_DevNode_Custom_Property_ExW [SETUPAPI.@]
3361 */
3363WINAPI
3365 _In_ DEVINST dnDevInst,
3366 _In_ PCWSTR pszCustomPropertyName,
3367 _Out_opt_ PULONG pulRegDataType,
3369 _Inout_ PULONG pulLength,
3370 _In_ ULONG ulFlags,
3371 _In_opt_ HMACHINE hMachine)
3372{
3374 HSTRING_TABLE StringTable = NULL;
3375 LPWSTR lpDevInst;
3376 ULONG ulDataType = REG_NONE;
3377 ULONG ulTransferLength;
3379
3380 TRACE("CM_Get_DevNode_Custom_Property_ExW(%lx %s %p %p %p %lx %p)\n",
3381 dnDevInst, debugstr_w(pszCustomPropertyName), pulRegDataType,
3382 Buffer, pulLength, ulFlags, hMachine);
3383
3384 if (dnDevInst == 0)
3385 return CR_INVALID_DEVNODE;
3386
3387 if (pszCustomPropertyName == NULL ||
3388 pulLength == NULL ||
3389 *pulLength == 0)
3390 return CR_INVALID_POINTER;
3391
3392 if (ulFlags & ~CM_CUSTOMDEVPROP_BITS)
3393 return CR_INVALID_FLAG;
3394
3395 if (hMachine != NULL)
3396 {
3397 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3398 if (BindingHandle == NULL)
3399 return CR_FAILURE;
3400
3401 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3402 if (StringTable == 0)
3403 return CR_FAILURE;
3404 }
3405 else
3406 {
3407 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
3408 return CR_FAILURE;
3409 }
3410
3411 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
3412 if (lpDevInst == NULL)
3413 return CR_INVALID_DEVNODE;
3414
3415 ulTransferLength = *pulLength;
3416
3418 {
3420 lpDevInst,
3421 (LPWSTR)pszCustomPropertyName,
3422 &ulDataType,
3423 Buffer,
3424 &ulTransferLength,
3425 pulLength,
3426 ulFlags);
3427 }
3429 {
3431 }
3433
3434 if (ret == CR_SUCCESS)
3435 {
3436 if (pulRegDataType != NULL)
3437 *pulRegDataType = ulDataType;
3438 }
3439
3440 return ret;
3441}
3442
3443
3444/***********************************************************************
3445 * CM_Get_DevNode_Registry_PropertyA [SETUPAPI.@]
3446 */
3448WINAPI
3450 _In_ DEVINST dnDevInst,
3451 _In_ ULONG ulProperty,
3452 _Out_opt_ PULONG pulRegDataType,
3454 _Inout_ PULONG pulLength,
3455 _In_ ULONG ulFlags)
3456{
3457 TRACE("CM_Get_DevNode_Registry_PropertyA(%lx %lu %p %p %p %lx)\n",
3458 dnDevInst, ulProperty, pulRegDataType, Buffer, pulLength, ulFlags);
3459
3460 return CM_Get_DevNode_Registry_Property_ExA(dnDevInst, ulProperty,
3461 pulRegDataType, Buffer,
3462 pulLength, ulFlags, NULL);
3463}
3464
3465
3466/***********************************************************************
3467 * CM_Get_DevNode_Registry_PropertyW [SETUPAPI.@]
3468 */
3470WINAPI
3472 _In_ DEVINST dnDevInst,
3473 _In_ ULONG ulProperty,
3474 _Out_opt_ PULONG pulRegDataType,
3476 _Inout_ PULONG pulLength,
3477 _In_ ULONG ulFlags)
3478{
3479 TRACE("CM_Get_DevNode_Registry_PropertyW(%lx %lu %p %p %p %lx)\n",
3480 dnDevInst, ulProperty, pulRegDataType, Buffer, pulLength, ulFlags);
3481
3482 return CM_Get_DevNode_Registry_Property_ExW(dnDevInst, ulProperty,
3483 pulRegDataType, Buffer,
3484 pulLength, ulFlags, NULL);
3485}
3486
3487
3488/***********************************************************************
3489 * CM_Get_DevNode_Registry_Property_ExA [SETUPAPI.@]
3490 */
3492WINAPI
3494 _In_ DEVINST dnDevInst,
3495 _In_ ULONG ulProperty,
3496 _Out_opt_ PULONG pulRegDataType,
3498 _Inout_ PULONG pulLength,
3499 _In_ ULONG ulFlags,
3500 _In_opt_ HMACHINE hMachine)
3501{
3502 PVOID BufferW;
3503 ULONG LengthW;
3504 ULONG ulDataType = REG_NONE;
3505 CONFIGRET ret;
3506
3507 TRACE("CM_Get_DevNode_Registry_Property_ExA(%lx %lu %p %p %p %lx %p)\n",
3508 dnDevInst, ulProperty, pulRegDataType, Buffer, pulLength,
3509 ulFlags, hMachine);
3510
3511 if (!pulLength)
3512 return CR_INVALID_POINTER;
3513
3514 LengthW = *pulLength * sizeof(WCHAR);
3515 BufferW = HeapAlloc(GetProcessHeap(), 0, LengthW);
3516 if (!BufferW)
3517 return CR_OUT_OF_MEMORY;
3518
3520 ulProperty,
3521 &ulDataType,
3522 BufferW,
3523 &LengthW,
3524 ulFlags,
3525 hMachine);
3526
3527 if (ret == CR_SUCCESS)
3528 {
3529 if (ulDataType == REG_SZ ||
3530 ulDataType == REG_EXPAND_SZ ||
3531 ulDataType == REG_MULTI_SZ)
3532 {
3533 /* Do W->A conversion */
3534 *pulLength = WideCharToMultiByte(CP_ACP,
3535 0,
3536 BufferW,
3537 lstrlenW(BufferW) + 1,
3538 Buffer,
3539 *pulLength,
3540 NULL,
3541 NULL);
3542 if (*pulLength == 0)
3543 ret = CR_FAILURE;
3544 }
3545 else
3546 {
3547 /* Directly copy the value */
3548 if (LengthW <= *pulLength)
3549 memcpy(Buffer, BufferW, LengthW);
3550 else
3551 {
3552 *pulLength = LengthW;
3554 }
3555 }
3556 }
3557
3558 if (pulRegDataType)
3559 *pulRegDataType = ulDataType;
3560
3561 HeapFree(GetProcessHeap(), 0, BufferW);
3562
3563 return ret;
3564}
3565
3566
3567/***********************************************************************
3568 * CM_Get_DevNode_Registry_Property_ExW [SETUPAPI.@]
3569 */
3571WINAPI
3573 _In_ DEVINST dnDevInst,
3574 _In_ ULONG ulProperty,
3575 _Out_opt_ PULONG pulRegDataType,
3577 _Inout_ PULONG pulLength,
3578 _In_ ULONG ulFlags,
3579 _In_opt_ HMACHINE hMachine)
3580{
3582 HSTRING_TABLE StringTable = NULL;
3584 LPWSTR lpDevInst;
3585 ULONG ulDataType = REG_NONE;
3586 ULONG ulTransferLength = 0;
3587
3588 TRACE("CM_Get_DevNode_Registry_Property_ExW(%lx %lu %p %p %p %lx %p)\n",
3589 dnDevInst, ulProperty, pulRegDataType, Buffer, pulLength,
3590 ulFlags, hMachine);
3591
3592 if (dnDevInst == 0)
3593 return CR_INVALID_DEVNODE;
3594
3595 if (ulProperty < CM_DRP_MIN || ulProperty > CM_DRP_MAX)
3596 return CR_INVALID_PROPERTY;
3597
3598 /* pulRegDataType is optional */
3599
3600 /* Buffer is optional */
3601
3602 if (pulLength == NULL)
3603 return CR_INVALID_POINTER;
3604
3605 if (*pulLength == 0)
3606 return CR_INVALID_POINTER;
3607
3608 if (ulFlags != 0)
3609 return CR_INVALID_FLAG;
3610
3611 if (hMachine != NULL)
3612 {
3613 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3614 if (BindingHandle == NULL)
3615 return CR_FAILURE;
3616
3617 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3618 if (StringTable == 0)
3619 return CR_FAILURE;
3620 }
3621 else
3622 {
3623 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
3624 return CR_FAILURE;
3625 }
3626
3627 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
3628 if (lpDevInst == NULL)
3629 return CR_INVALID_DEVNODE;
3630
3631 ulTransferLength = *pulLength;
3632
3634 {
3636 lpDevInst,
3637 ulProperty,
3638 &ulDataType,
3639 Buffer,
3640 &ulTransferLength,
3641 pulLength,
3642 ulFlags);
3643 }
3645 {
3647 }
3649
3650 if (ret == CR_SUCCESS)
3651 {
3652 if (pulRegDataType != NULL)
3653 *pulRegDataType = ulDataType;
3654 }
3655
3656 return ret;
3657}
3658
3659
3660/***********************************************************************
3661 * CM_Get_DevNode_Status [SETUPAPI.@]
3662 */
3664WINAPI
3666 _Out_ PULONG pulStatus,
3667 _Out_ PULONG pulProblemNumber,
3668 _In_ DEVINST dnDevInst,
3669 _In_ ULONG ulFlags)
3670{
3671 TRACE("CM_Get_DevNode_Status(%p %p %lx %lx)\n",
3672 pulStatus, pulProblemNumber, dnDevInst, ulFlags);
3673
3674 return CM_Get_DevNode_Status_Ex(pulStatus, pulProblemNumber, dnDevInst,
3675 ulFlags, NULL);
3676}
3677
3678
3679/***********************************************************************
3680 * CM_Get_DevNode_Status_Ex [SETUPAPI.@]
3681 */
3683WINAPI
3685 _Out_ PULONG pulStatus,
3686 _Out_ PULONG pulProblemNumber,
3687 _In_ DEVINST dnDevInst,
3688 _In_ ULONG ulFlags,
3689 _In_opt_ HMACHINE hMachine)
3690{
3692 HSTRING_TABLE StringTable = NULL;
3693 LPWSTR lpDevInst;
3694 CONFIGRET ret;
3695
3696 TRACE("CM_Get_DevNode_Status_Ex(%p %p %lx %lx %p)\n",
3697 pulStatus, pulProblemNumber, dnDevInst, ulFlags, hMachine);
3698
3699 if (pulStatus == NULL || pulProblemNumber == NULL)
3700 return CR_INVALID_POINTER;
3701
3702 if (dnDevInst == 0)
3703 return CR_INVALID_DEVINST;
3704
3705 if (ulFlags != 0)
3706 return CR_INVALID_FLAG;
3707
3708 if (hMachine != NULL)
3709 {
3710 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3711 if (BindingHandle == NULL)
3712 return CR_FAILURE;
3713
3714 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3715 if (StringTable == 0)
3716 return CR_FAILURE;
3717 }
3718 else
3719 {
3720 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
3721 return CR_FAILURE;
3722 }
3723
3724 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
3725 if (lpDevInst == NULL)
3726 return CR_INVALID_DEVNODE;
3727
3729 {
3731 lpDevInst,
3732 pulStatus,
3733 pulProblemNumber,
3734 ulFlags);
3735 }
3737 {
3739 }
3741
3742 return ret;
3743}
3744
3745
3746/***********************************************************************
3747 * CM_Get_Device_IDA [SETUPAPI.@]
3748 */
3750WINAPI
3752 _In_ DEVINST dnDevInst,
3753 _Out_writes_(BufferLen) PCHAR Buffer,
3754 _In_ ULONG BufferLen,
3755 _In_ ULONG ulFlags)
3756{
3757 TRACE("CM_Get_Device_IDA(%lx %p %lu %lx)\n",
3758 dnDevInst, Buffer, BufferLen, ulFlags);
3759
3760 return CM_Get_Device_ID_ExA(dnDevInst, Buffer, BufferLen, ulFlags, NULL);
3761}
3762
3763
3764/***********************************************************************
3765 * CM_Get_Device_IDW [SETUPAPI.@]
3766 */
3768WINAPI
3770 _In_ DEVINST dnDevInst,
3771 _Out_writes_(BufferLen) PWCHAR Buffer,
3772 _In_ ULONG BufferLen,
3773 _In_ ULONG ulFlags)
3774{
3775 TRACE("CM_Get_Device_IDW(%lx %p %lu %lx)\n",
3776 dnDevInst, Buffer, BufferLen, ulFlags);
3777
3778 return CM_Get_Device_ID_ExW(dnDevInst, Buffer, BufferLen, ulFlags, NULL);
3779}
3780
3781
3782/***********************************************************************
3783 * CM_Get_Device_ID_ExA [SETUPAPI.@]
3784 */
3786WINAPI
3788 _In_ DEVINST dnDevInst,
3789 _Out_writes_(BufferLen) PCHAR Buffer,
3790 _In_ ULONG BufferLen,
3791 _In_ ULONG ulFlags,
3792 _In_opt_ HMACHINE hMachine)
3793{
3794 WCHAR szBufferW[MAX_DEVICE_ID_LEN];
3796
3797 TRACE("CM_Get_Device_ID_ExA(%lx %p %lu %lx %p)\n",
3798 dnDevInst, Buffer, BufferLen, ulFlags, hMachine);
3799
3800 if (Buffer == NULL)
3801 return CR_INVALID_POINTER;
3802
3803 ret = CM_Get_Device_ID_ExW(dnDevInst,
3804 szBufferW,
3806 ulFlags,
3807 hMachine);
3808 if (ret == CR_SUCCESS)
3809 {
3811 0,
3812 szBufferW,
3813 lstrlenW(szBufferW) + 1,
3814 Buffer,
3815 BufferLen,
3816 NULL,
3817 NULL) == 0)
3818 ret = CR_FAILURE;
3819 }
3820
3821 return ret;
3822}
3823
3824
3825/***********************************************************************
3826 * CM_Get_Device_ID_ExW [SETUPAPI.@]
3827 */
3829WINAPI
3831 _In_ DEVINST dnDevInst,
3832 _Out_writes_(BufferLen) PWCHAR Buffer,
3833 _In_ ULONG BufferLen,
3834 _In_ ULONG ulFlags,
3835 _In_opt_ HMACHINE hMachine)
3836{
3837 HSTRING_TABLE StringTable = NULL;
3838
3839 TRACE("CM_Get_Device_ID_ExW(%lx %p %lu %lx %p)\n",
3840 dnDevInst, Buffer, BufferLen, ulFlags, hMachine);
3841
3842 if (dnDevInst == 0)
3843 return CR_INVALID_DEVINST;
3844
3845 if (Buffer == NULL)
3846 return CR_INVALID_POINTER;
3847
3848 if (ulFlags != 0)
3849 return CR_INVALID_FLAG;
3850
3851 if (hMachine != NULL)
3852 {
3853 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3854 if (StringTable == NULL)
3855 return CR_FAILURE;
3856 }
3857 else
3858 {
3859 if (!PnpGetLocalHandles(NULL, &StringTable))
3860 return CR_FAILURE;
3861 }
3862
3863 if (!pSetupStringTableStringFromIdEx(StringTable,
3864 dnDevInst,
3865 Buffer,
3866 &BufferLen))
3867 return CR_FAILURE;
3868
3869 return CR_SUCCESS;
3870}
3871
3872
3873/***********************************************************************
3874 * CM_Get_Device_ID_ListA [SETUPAPI.@]
3875 */
3877WINAPI
3879 _In_ PCSTR pszFilter,
3880 _Out_writes_(BufferLen) PCHAR Buffer,
3881 _In_ ULONG BufferLen,
3882 _In_ ULONG ulFlags)
3883{
3884 TRACE("CM_Get_Device_ID_ListA(%p %p %lu %lx)\n",
3885 pszFilter, Buffer, BufferLen, ulFlags);
3886
3887 return CM_Get_Device_ID_List_ExA(pszFilter, Buffer, BufferLen,
3888 ulFlags, NULL);
3889}
3890
3891
3892/***********************************************************************
3893 * CM_Get_Device_ID_ListW [SETUPAPI.@]
3894 */
3896WINAPI
3898 _In_ PCWSTR pszFilter,
3899 _Out_writes_(BufferLen) PWCHAR Buffer,
3900 _In_ ULONG BufferLen,
3901 _In_ ULONG ulFlags)
3902{
3903 TRACE("CM_Get_Device_ID_ListW(%p %p %lu %lx)\n",
3904 pszFilter, Buffer, BufferLen, ulFlags);
3905
3906 return CM_Get_Device_ID_List_ExW(pszFilter, Buffer, BufferLen,
3907 ulFlags, NULL);
3908}
3909
3910
3911/***********************************************************************
3912 * CM_Get_Device_ID_List_ExA [SETUPAPI.@]
3913 */
3915WINAPI
3917 _In_ PCSTR pszFilter,
3918 _Out_writes_(BufferLen) PCHAR Buffer,
3919 _In_ ULONG BufferLen,
3920 _In_ ULONG ulFlags,
3921 _In_opt_ HMACHINE hMachine)
3922{
3923 LPWSTR BufferW = NULL;
3924 LPWSTR pszFilterW = NULL;
3926
3927 TRACE("CM_Get_Device_ID_List_ExA(%p %p %lu %lx %p)\n",
3928 pszFilter, Buffer, BufferLen, ulFlags, hMachine);
3929
3930 BufferW = MyMalloc(BufferLen * sizeof(WCHAR));
3931 if (BufferW == NULL)
3932 return CR_OUT_OF_MEMORY;
3933
3934 if (pszFilter == NULL)
3935 {
3937 BufferW,
3938 BufferLen,
3939 ulFlags,
3940 hMachine);
3941 }
3942 else
3943 {
3944 if (pSetupCaptureAndConvertAnsiArg(pszFilter, &pszFilterW))
3945 {
3947 goto Done;
3948 }
3949
3950 ret = CM_Get_Device_ID_List_ExW(pszFilterW,
3951 BufferW,
3952 BufferLen,
3953 ulFlags,
3954 hMachine);
3955
3956 MyFree(pszFilterW);
3957 }
3958
3960 0,
3961 BufferW,
3962 BufferLen,
3963 Buffer,
3964 BufferLen,
3965 NULL,
3966 NULL) == 0)
3967 ret = CR_FAILURE;
3968
3969Done:
3970 MyFree(BufferW);
3971
3972 return ret;
3973}
3974
3975
3976/***********************************************************************
3977 * CM_Get_Device_ID_List_ExW [SETUPAPI.@]
3978 */
3980WINAPI
3982 _In_ PCWSTR pszFilter,
3983 _Out_writes_(BufferLen) PWCHAR Buffer,
3984 _In_ ULONG BufferLen,
3985 _In_ ULONG ulFlags,
3986 _In_opt_ HMACHINE hMachine)
3987{
3989 CONFIGRET ret;
3990
3991 TRACE("CM_Get_Device_ID_List_ExW(%p %p %lu %lx %p)\n",
3992 pszFilter, Buffer, BufferLen, ulFlags, hMachine);
3993
3994 if (Buffer == NULL || BufferLen == 0)
3995 return CR_INVALID_POINTER;
3996
3997 if (ulFlags & ~CM_GETIDLIST_FILTER_BITS)
3998 return CR_INVALID_FLAG;
3999
4000 if (hMachine != NULL)
4001 {
4002 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4003 if (BindingHandle == NULL)
4004 return CR_FAILURE;
4005 }
4006 else
4007 {
4009 return CR_FAILURE;
4010 }
4011
4012 *Buffer = 0;
4013
4015 {
4017 (LPWSTR)pszFilter,
4018 Buffer,
4019 &BufferLen,
4020 ulFlags);
4021 }
4023 {
4025 }
4027
4028 return ret;
4029}
4030
4031
4032/***********************************************************************
4033 * CM_Get_Device_ID_List_SizeA [SETUPAPI.@]
4034 */
4036WINAPI
4038 _Out_ PULONG pulLen,
4039 _In_opt_ PCSTR pszFilter,
4040 _In_ ULONG ulFlags)
4041{
4042 TRACE("CM_Get_Device_ID_List_SizeA(%p %s %lx)\n",
4043 pulLen, debugstr_a(pszFilter), ulFlags);
4044
4045 return CM_Get_Device_ID_List_Size_ExA(pulLen, pszFilter, ulFlags, NULL);
4046}
4047
4048
4049/***********************************************************************
4050 * CM_Get_Device_ID_List_SizeW [SETUPAPI.@]
4051 */
4053WINAPI
4055 _Out_ PULONG pulLen,
4056 _In_opt_ PCWSTR pszFilter,
4057 _In_ ULONG ulFlags)
4058{
4059 TRACE("CM_Get_Device_ID_List_SizeW(%p %s %lx)\n",
4060 pulLen, debugstr_w(pszFilter), ulFlags);
4061
4062 return CM_Get_Device_ID_List_Size_ExW(pulLen, pszFilter, ulFlags, NULL);
4063}
4064
4065
4066/***********************************************************************
4067 * CM_Get_Device_ID_List_Size_ExA [SETUPAPI.@]
4068 */
4070WINAPI
4072 _Out_ PULONG pulLen,
4073 _In_opt_ PCSTR pszFilter,
4074 _In_ ULONG ulFlags,
4075 _In_opt_ HMACHINE hMachine)
4076{
4077 LPWSTR pszFilterW = NULL;
4079
4080 FIXME("CM_Get_Device_ID_List_Size_ExA(%p %s %lx %p)\n",
4081 pulLen, debugstr_a(pszFilter), ulFlags, hMachine);
4082
4083 if (pszFilter == NULL)
4084 {
4086 NULL,
4087 ulFlags,
4088 hMachine);
4089 }
4090 else
4091 {
4092 if (pSetupCaptureAndConvertAnsiArg(pszFilter, &pszFilterW))
4093 return CR_INVALID_DEVICE_ID;
4094
4096 pszFilterW,
4097 ulFlags,
4098 hMachine);
4099
4100 MyFree(pszFilterW);
4101 }
4102
4103 return ret;
4104}
4105
4106
4107/***********************************************************************
4108 * CM_Get_Device_ID_List_Size_ExW [SETUPAPI.@]
4109 */
4111WINAPI
4113 _Out_ PULONG pulLen,
4114 _In_opt_ PCWSTR pszFilter,
4115 _In_ ULONG ulFlags,
4116 _In_opt_ HMACHINE hMachine)
4117{
4119 CONFIGRET ret;
4120
4121 FIXME("CM_Get_Device_ID_List_Size_ExW(%p %s %lx %p)\n",
4122 pulLen, debugstr_w(pszFilter), ulFlags, hMachine);
4123
4124 if (pulLen == NULL)
4125 return CR_INVALID_POINTER;
4126
4127 if (ulFlags & ~CM_GETIDLIST_FILTER_BITS)
4128 return CR_INVALID_FLAG;
4129
4130 if (hMachine != NULL)
4131 {
4132 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4133 if (BindingHandle == NULL)
4134 return CR_FAILURE;
4135 }
4136 else
4137 {
4139 return CR_FAILURE;
4140 }
4141
4142 *pulLen = 0;
4143
4145 {
4147 (LPWSTR)pszFilter,
4148 pulLen,
4149 ulFlags);
4150 }
4152 {
4154 }
4156
4157 return ret;
4158}
4159
4160
4161/***********************************************************************
4162 * CM_Get_Device_ID_Size [SETUPAPI.@]
4163 */
4165WINAPI
4167 _Out_ PULONG pulLen,
4168 _In_ DEVINST dnDevInst,
4169 _In_ ULONG ulFlags)
4170{
4171 TRACE("CM_Get_Device_ID_Size(%p %lx %lx)\n",
4172 pulLen, dnDevInst, ulFlags);
4173
4174 return CM_Get_Device_ID_Size_Ex(pulLen, dnDevInst, ulFlags, NULL);
4175}
4176
4177
4178/***********************************************************************
4179 * CM_Get_Device_ID_Size_Ex [SETUPAPI.@]
4180 */
4182WINAPI
4184 _Out_ PULONG pulLen,
4185 _In_ DEVINST dnDevInst,
4186 _In_ ULONG ulFlags,
4187 _In_opt_ HMACHINE hMachine)
4188{
4189 HSTRING_TABLE StringTable = NULL;
4190 LPWSTR DeviceId;
4191
4192 TRACE("CM_Get_Device_ID_Size_Ex(%p %lx %lx %p)\n",
4193 pulLen, dnDevInst, ulFlags, hMachine);
4194
4195 if (pulLen == NULL)
4196 return CR_INVALID_POINTER;
4197
4198 if (dnDevInst == 0)
4199 return CR_INVALID_DEVINST;
4200
4201 if (ulFlags != 0)
4202 return CR_INVALID_FLAG;
4203
4204 if (hMachine != NULL)
4205 {
4206 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4207 if (StringTable == NULL)
4208 return CR_FAILURE;
4209 }
4210 else
4211 {
4212 if (!PnpGetLocalHandles(NULL, &StringTable))
4213 return CR_FAILURE;
4214 }
4215
4216 DeviceId = pSetupStringTableStringFromId(StringTable, dnDevInst);
4217 if (DeviceId == NULL)
4218 {
4219 *pulLen = 0;
4220 return CR_SUCCESS;
4221 }
4222
4223 *pulLen = lstrlenW(DeviceId);
4224
4225 return CR_SUCCESS;
4226}
4227
4228
4229/***********************************************************************
4230 * CM_Get_Device_Interface_AliasA [SETUPAPI.@]
4231 */
4233WINAPI
4235 _In_ LPCSTR pszDeviceInterface,
4236 _In_ LPGUID AliasInterfaceGuid,
4237 _Out_writes_(*pulLength) LPSTR pszAliasDeviceInterface,
4238 _Inout_ PULONG pulLength,
4239 _In_ ULONG ulFlags)
4240{
4241 TRACE("CM_Get_Device_Interface_AliasA(%p %p %p %p %lx)\n",
4242 pszDeviceInterface, AliasInterfaceGuid,
4243 pszAliasDeviceInterface, pulLength, ulFlags);
4244
4245 return CM_Get_Device_Interface_Alias_ExA(pszDeviceInterface,
4246 AliasInterfaceGuid, pszAliasDeviceInterface, pulLength,
4247 ulFlags, NULL);
4248}
4249
4250
4251/***********************************************************************
4252 * CM_Get_Device_Interface_AliasW [SETUPAPI.@]
4253 */
4255WINAPI
4257 _In_ LPCWSTR pszDeviceInterface,
4258 _In_ LPGUID AliasInterfaceGuid,
4259 _Out_writes_(*pulLength) LPWSTR pszAliasDeviceInterface,
4260 _Inout_ PULONG pulLength,
4261 _In_ ULONG ulFlags)
4262{
4263 TRACE("CM_Get_Device_Interface_AliasW(%p %p %p %p %lx)\n",
4264 pszDeviceInterface, AliasInterfaceGuid,
4265 pszAliasDeviceInterface, pulLength, ulFlags);
4266
4267 return CM_Get_Device_Interface_Alias_ExW(pszDeviceInterface,
4268 AliasInterfaceGuid, pszAliasDeviceInterface, pulLength,
4269 ulFlags, NULL);
4270}
4271
4272
4273/***********************************************************************
4274 * CM_Get_Device_Interface_Alias_ExA [SETUPAPI.@]
4275 */
4277WINAPI
4279 _In_ LPCSTR pszDeviceInterface,
4280 _In_ LPGUID AliasInterfaceGuid,
4281 _Out_writes_(*pulLength) LPSTR pszAliasDeviceInterface,
4282 _Inout_ PULONG pulLength,
4283 _In_ ULONG ulFlags,
4284 _In_opt_ HMACHINE hMachine)
4285{
4286 FIXME("CM_Get_Device_Interface_Alias_ExA(%p %p %p %p %lx %p)\n",
4287 pszDeviceInterface, AliasInterfaceGuid,
4288 pszAliasDeviceInterface, pulLength, ulFlags, hMachine);
4289
4291}
4292
4293
4294/***********************************************************************
4295 * CM_Get_Device_Interface_Alias_ExW [SETUPAPI.@]
4296 */
4298WINAPI
4300 _In_ LPCWSTR pszDeviceInterface,
4301 _In_ LPGUID AliasInterfaceGuid,
4302 _Out_writes_(*pulLength) LPWSTR pszAliasDeviceInterface,
4303 _Inout_ PULONG pulLength,
4304 _In_ ULONG ulFlags,
4305 _In_opt_ HMACHINE hMachine)
4306{
4308 ULONG ulTransferLength;
4310
4311 TRACE("CM_Get_Device_Interface_Alias_ExW(%p %p %p %p %lx %p)\n",
4312 pszDeviceInterface, AliasInterfaceGuid,
4313 pszAliasDeviceInterface, pulLength, ulFlags, hMachine);
4314
4315 if (pszDeviceInterface == NULL ||
4316 AliasInterfaceGuid == NULL ||
4317 pszAliasDeviceInterface == NULL ||
4318 pulLength == NULL)
4319 return CR_INVALID_POINTER;
4320
4321 if (ulFlags != 0)
4322 return CR_INVALID_FLAG;
4323
4324 if (hMachine != NULL)
4325 {
4326 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4327 if (BindingHandle == NULL)
4328 return CR_FAILURE;
4329 }
4330 else
4331 {
4333 return CR_FAILURE;
4334 }
4335
4336 ulTransferLength = *pulLength;
4337
4339 {
4341 (LPWSTR)pszDeviceInterface,
4342 AliasInterfaceGuid,
4343 pszAliasDeviceInterface,
4344 pulLength,
4345 &ulTransferLength,
4346 0);
4347 }
4349 {
4351 }
4353
4354 return ret;
4355}
4356
4357
4358/***********************************************************************
4359 * CM_Get_Device_Interface_ListA (SETUPAPI.@)
4360 */
4362WINAPI
4365 _In_opt_ DEVINSTID_A pDeviceID,
4366 _Out_writes_(BufferLen) PCHAR Buffer,
4367 _In_ ULONG BufferLen,
4368 _In_ ULONG ulFlags)
4369{
4370 TRACE("CM_Get_Device_Interface_ListA(%s %s %p %lu 0x%08lx)\n",
4372 Buffer, BufferLen, ulFlags);
4373
4375 Buffer, BufferLen, ulFlags, NULL);
4376}
4377
4378
4379/***********************************************************************
4380 * CM_Get_Device_Interface_ListW (SETUPAPI.@)
4381 */
4383WINAPI
4386 _In_opt_ DEVINSTID_W pDeviceID,
4387 _Out_writes_(BufferLen) PWCHAR Buffer,
4388 _In_ ULONG BufferLen,
4389 _In_ ULONG ulFlags)
4390{
4391 TRACE("CM_Get_Device_Interface_ListW(%s %s %p %lu 0x%08lx)\n",
4393 Buffer, BufferLen, ulFlags);
4394
4396 Buffer, BufferLen, ulFlags, NULL);
4397}
4398
4399
4400/***********************************************************************
4401 * CM_Get_Device_Interface_List_ExA (SETUPAPI.@)
4402 */
4404WINAPI
4407 _In_opt_ DEVINSTID_A pDeviceID,
4408 _Out_writes_(BufferLen) PCHAR Buffer,
4409 _In_ ULONG BufferLen,
4410 _In_ ULONG ulFlags,
4411 _In_opt_ HMACHINE hMachine)
4412{
4413 DEVINSTID_W pDeviceIdW = NULL;
4414 PWCHAR BufferW = NULL;
4416
4417 TRACE("CM_Get_Device_Interface_List_ExA(%s %s %p %lu 0x%08lx %p)\n",
4419 Buffer, BufferLen, ulFlags, hMachine);
4420
4421 if (Buffer == NULL ||
4422 BufferLen == 0)
4423 return CR_INVALID_POINTER;
4424
4425 if (pDeviceID != NULL)
4426 {
4427 if (!pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDeviceIdW))
4428 return CR_INVALID_DEVICE_ID;
4429 }
4430
4431 BufferW = MyMalloc(BufferLen * sizeof(WCHAR));
4432 if (BufferW == NULL)
4433 {
4435 goto Done;
4436 }
4437
4439 BufferW, BufferLen, ulFlags,
4440 hMachine);
4441 if (ret != CR_SUCCESS)
4442 goto Done;
4443
4445 0,
4446 BufferW,
4447 BufferLen,
4448 Buffer,
4449 BufferLen,
4450 NULL,
4451 NULL) == 0)
4452 ret = CR_FAILURE;
4453
4454Done:
4455 if (BufferW != NULL)
4456 MyFree(BufferW);
4457
4458 if (pDeviceIdW != NULL)
4459 MyFree(pDeviceIdW);
4460
4461 return ret;
4462}
4463
4464
4465/***********************************************************************
4466 * CM_Get_Device_Interface_List_ExW (SETUPAPI.@)
4467 */
4469WINAPI
4472 _In_opt_ DEVINSTID_W pDeviceID,
4473 _Out_writes_(BufferLen) PWCHAR Buffer,
4474 _In_ ULONG BufferLen,
4475 _In_ ULONG ulFlags,
4476 _In_opt_ HMACHINE hMachine)
4477{
4481
4482 TRACE("CM_Get_Device_Interface_List_ExW(%s %s %p %lu 0x%08lx %p)\n",
4484 Buffer, BufferLen, ulFlags, hMachine);
4485
4486 if (Buffer == NULL ||
4487 BufferLen == 0)
4488 return CR_INVALID_POINTER;
4489
4490 if (ulFlags & ~CM_GET_DEVICE_INTERFACE_LIST_BITS)
4491 return CR_INVALID_FLAG;
4492
4493 if (hMachine != NULL)
4494 {
4495 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4496 if (BindingHandle == NULL)
4497 return CR_FAILURE;
4498 }
4499 else
4500 {
4502 return CR_FAILURE;
4503 }
4504
4505 *Buffer = 0;
4506 BufferSize = BufferLen;
4507
4509 {
4512 pDeviceID,
4513 (LPBYTE)Buffer,
4514 &BufferSize,
4515 ulFlags);
4516 }
4518 {
4520 }
4522
4523 return ret;
4524}
4525
4526
4527/***********************************************************************
4528 * CM_Get_Device_Interface_List_SizeA (SETUPAPI.@)
4529 */
4531WINAPI
4533 _Out_ PULONG pulLen,
4535 _In_opt_ DEVINSTID_A pDeviceID,
4536 _In_ ULONG ulFlags)
4537{
4538 TRACE("CM_Get_Device_Interface_List_SizeA(%p %p %s 0x%08lx)\n",
4539 pulLen, InterfaceClassGuid, debugstr_a(pDeviceID), ulFlags);
4540
4542 pDeviceID, ulFlags, NULL);
4543}
4544
4545
4546/***********************************************************************
4547 * CM_Get_Device_Interface_List_SizeW (SETUPAPI.@)
4548 */
4550WINAPI
4552 _Out_ PULONG pulLen,
4554 _In_opt_ DEVINSTID_W pDeviceID,
4555 _In_ ULONG ulFlags)
4556{
4557 TRACE("CM_Get_Device_Interface_List_SizeW(%p %p %s 0x%08lx)\n",
4558 pulLen, InterfaceClassGuid, debugstr_w(pDeviceID), ulFlags);
4559
4561 pDeviceID, ulFlags, NULL);
4562}
4563
4564
4565/***********************************************************************
4566 * CM_Get_Device_Interface_List_Size_ExA (SETUPAPI.@)
4567 */
4569WINAPI
4571 _Out_ PULONG pulLen,
4573 _In_opt_ DEVINSTID_A pDeviceID,
4574 _In_ ULONG ulFlags,
4575 _In_opt_ HMACHINE hMachine)
4576{
4577 DEVINSTID_W pDeviceIdW = NULL;
4579
4580 TRACE("CM_Get_Device_Interface_List_Size_ExA(%p %p %s 0x%08lx %p)\n",
4581 pulLen, InterfaceClassGuid, debugstr_a(pDeviceID), ulFlags, hMachine);
4582
4583 if (pulLen == NULL)
4584 return CR_INVALID_POINTER;
4585
4586 if (pDeviceID != NULL)
4587 {
4588 if (!pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDeviceIdW))
4589 return CR_INVALID_DEVICE_ID;
4590 }
4591
4592 *pulLen = 0;
4593
4595 pDeviceIdW, ulFlags, hMachine);
4596
4597 if (pDeviceIdW != NULL)
4598 MyFree(pDeviceIdW);
4599
4600 return ret;
4601}
4602
4603
4604/***********************************************************************
4605 * CM_Get_Device_Interface_List_Size_ExW (SETUPAPI.@)
4606 */
4608WINAPI
4610 _Out_ PULONG pulLen,
4612 _In_opt_ DEVINSTID_W pDeviceID,
4613 _In_ ULONG ulFlags,
4614 _In_opt_ HMACHINE hMachine)
4615{
4618
4619 TRACE("CM_Get_Device_Interface_List_Size_ExW(%p %p %s 0x%08lx %p)\n",
4620 pulLen, InterfaceClassGuid, debugstr_w(pDeviceID), ulFlags, hMachine);
4621
4622 if (pulLen == NULL)
4623 return CR_INVALID_POINTER;
4624
4625 if (ulFlags & ~CM_GET_DEVICE_INTERFACE_LIST_BITS)
4626 return CR_INVALID_FLAG;
4627
4628 if (hMachine != NULL)
4629 {
4630 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4631 if (BindingHandle == NULL)
4632 return CR_FAILURE;
4633 }
4634 else
4635 {
4637 return CR_FAILURE;
4638 }
4639
4640 *pulLen = 0;
4641
4643 {
4645 pulLen,
4647 pDeviceID,
4648 ulFlags);
4649 }
4651 {
4653 }
4655
4656 return ret;
4657}
4658
4659
4660/***********************************************************************
4661 * CM_Get_First_Log_Conf [SETUPAPI.@]
4662 */
4664WINAPI
4666 _Out_opt_ PLOG_CONF plcLogConf,
4667 _In_ DEVINST dnDevInst,
4668 _In_ ULONG ulFlags)
4669{
4670 TRACE("CM_Get_First_Log_Conf(%p %lx %lx)\n",
4671 plcLogConf, dnDevInst, ulFlags);
4672
4673 return CM_Get_First_Log_Conf_Ex(plcLogConf, dnDevInst, ulFlags, NULL);
4674}
4675
4676
4677/***********************************************************************
4678 * CM_Get_First_Log_Conf_Ex [SETUPAPI.@]
4679 */
4681WINAPI
4683 _Out_opt_ PLOG_CONF plcLogConf,
4684 _In_ DEVINST dnDevInst,
4685 _In_ ULONG ulFlags,
4686 _In_opt_ HMACHINE hMachine)
4687{
4689 HSTRING_TABLE StringTable = NULL;
4690 LPWSTR lpDevInst = NULL;
4692 ULONG ulTag;
4693 PLOG_CONF_INFO pLogConfInfo;
4694
4695 FIXME("CM_Get_First_Log_Conf_Ex(%p %lx %lx %p)\n",
4696 plcLogConf, dnDevInst, ulFlags, hMachine);
4697
4698 if (dnDevInst == 0)
4699 return CR_INVALID_DEVINST;
4700
4701 if (ulFlags & ~LOG_CONF_BITS)
4702 return CR_INVALID_FLAG;
4703
4704 if (plcLogConf)
4705 *plcLogConf = 0;
4706
4707 if (hMachine != NULL)
4708 {
4709 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4710 if (BindingHandle == NULL)
4711 return CR_FAILURE;
4712
4713 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4714 if (StringTable == 0)
4715 return CR_FAILURE;
4716 }
4717 else
4718 {
4719 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
4720 return CR_FAILURE;
4721 }
4722
4723 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
4724 if (lpDevInst == NULL)
4725 return CR_INVALID_DEVNODE;
4726
4728 {
4730 lpDevInst,
4731 ulFlags,
4732 &ulTag,
4733 ulFlags);
4734 }
4736 {
4738 }
4740
4741 if (ret != CR_SUCCESS)
4742 return ret;
4743
4744 if (plcLogConf)
4745 {
4746 pLogConfInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(LOG_CONF_INFO));
4747 if (pLogConfInfo == NULL)
4748 return CR_OUT_OF_MEMORY;
4749
4750 pLogConfInfo->ulMagic = LOG_CONF_MAGIC;
4751 pLogConfInfo->dnDevInst = dnDevInst;
4752 pLogConfInfo->ulType = ulFlags;
4753 pLogConfInfo->ulTag = ulTag;
4754
4755 *plcLogConf = (LOG_CONF)pLogConfInfo;
4756 }
4757
4758 return CR_SUCCESS;
4759}
4760
4761
4762/***********************************************************************
4763 * CM_Get_Global_State [SETUPAPI.@]
4764 */
4766WINAPI
4768 _Out_ PULONG pulState,
4769 _In_ ULONG ulFlags)
4770{
4771 TRACE("CM_Get_Global_State(%p %lx)\n",
4772 pulState, ulFlags);
4773
4774 return CM_Get_Global_State_Ex(pulState, ulFlags, NULL);
4775}
4776
4777
4778/***********************************************************************
4779 * CM_Get_Global_State_Ex [SETUPAPI.@]
4780 */
4782WINAPI
4784 _Out_ PULONG pulState,
4785 _In_ ULONG ulFlags,
4786 _In_opt_ HMACHINE hMachine)
4787{
4789 CONFIGRET ret;
4790
4791 TRACE("CM_Get_Global_State_Ex(%p %lx %p)\n",
4792 pulState, ulFlags, hMachine);
4793
4794 if (pulState == NULL)
4795 return CR_INVALID_POINTER;
4796
4797 if (ulFlags != 0)
4798 return CR_INVALID_FLAG;
4799
4800 if (hMachine != NULL)
4801 {
4802 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4803 if (BindingHandle == NULL)
4804 return CR_FAILURE;
4805 }
4806 else
4807 {
4809 return CR_FAILURE;
4810 }
4811
4813 {
4814 ret = PNP_GetGlobalState(BindingHandle, pulState, ulFlags);
4815 }
4817 {
4819 }
4821
4822 return ret;
4823}
4824
4825
4826/***********************************************************************
4827 * CM_Get_HW_Prof_FlagsA [SETUPAPI.@]
4828 */
4830WINAPI
4832 _In_ DEVINSTID_A szDevInstName,
4833 _In_ ULONG ulHardwareProfile,
4834 _Out_ PULONG pulValue,
4835 _In_ ULONG ulFlags)
4836{
4837 TRACE("CM_Get_HW_Prof_FlagsA(%s %lu %p %lx)\n",
4838 debugstr_a(szDevInstName), ulHardwareProfile, pulValue, ulFlags);
4839
4840 return CM_Get_HW_Prof_Flags_ExA(szDevInstName, ulHardwareProfile,
4841 pulValue, ulFlags, NULL);
4842}
4843
4844
4845/***********************************************************************
4846 * CM_Get_HW_Prof_FlagsW [SETUPAPI.@]
4847 */
4849WINAPI
4851 _In_ DEVINSTID_W szDevInstName,
4852 _In_ ULONG ulHardwareProfile,
4853 _Out_ PULONG pulValue,
4854 _In_ ULONG ulFlags)
4855{
4856 TRACE("CM_Get_HW_Prof_FlagsW(%s %lu %p %lx)\n",
4857 debugstr_w(szDevInstName), ulHardwareProfile, pulValue, ulFlags);
4858
4859 return CM_Get_HW_Prof_Flags_ExW(szDevInstName, ulHardwareProfile,
4860 pulValue, ulFlags, NULL);
4861}
4862
4863
4864/***********************************************************************
4865 * CM_Get_HW_Prof_Flags_ExA [SETUPAPI.@]
4866 */
4868WINAPI
4870 _In_ DEVINSTID_A szDevInstName,
4871 _In_ ULONG ulHardwareProfile,
4872 _Out_ PULONG pulValue,
4873 _In_ ULONG ulFlags,
4874 _In_opt_ HMACHINE hMachine)
4875{
4876 DEVINSTID_W pszDevIdW = NULL;
4878
4879 TRACE("CM_Get_HW_Prof_Flags_ExA(%s %lu %p %lx %p)\n",
4880 debugstr_a(szDevInstName), ulHardwareProfile, pulValue, ulFlags, hMachine);
4881
4882 if (szDevInstName != NULL)
4883 {
4884 if (pSetupCaptureAndConvertAnsiArg(szDevInstName, &pszDevIdW))
4885 return CR_INVALID_DEVICE_ID;
4886 }
4887
4888 ret = CM_Get_HW_Prof_Flags_ExW(pszDevIdW, ulHardwareProfile,
4889 pulValue, ulFlags, hMachine);
4890
4891 if (pszDevIdW != NULL)
4892 MyFree(pszDevIdW);
4893
4894 return ret;
4895}
4896
4897
4898/***********************************************************************
4899 * CM_Get_HW_Prof_Flags_ExW [SETUPAPI.@]
4900 */
4902WINAPI
4904 _In_ DEVINSTID_W szDevInstName,
4905 _In_ ULONG ulHardwareProfile,
4906 _Out_ PULONG pulValue,
4907 _In_ ULONG ulFlags,
4908 _In_opt_ HMACHINE hMachine)
4909{
4911 CONFIGRET ret;
4912
4913 FIXME("CM_Get_HW_Prof_Flags_ExW(%s %lu %p %lx %p)\n",
4914 debugstr_w(szDevInstName), ulHardwareProfile, pulValue, ulFlags, hMachine);
4915
4916 if ((szDevInstName == NULL) || (pulValue == NULL))
4917 return CR_INVALID_POINTER;
4918
4919 if (ulFlags != 0)
4920 return CR_INVALID_FLAG;
4921
4922 /* FIXME: Check whether szDevInstName is valid */
4923
4924 if (hMachine != NULL)
4925 {
4926 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4927 if (BindingHandle == NULL)
4928 return CR_FAILURE;
4929 }
4930 else
4931 {
4933 return CR_FAILURE;
4934 }
4935
4937 {
4938 ret = PNP_HwProfFlags(BindingHandle, PNP_GET_HWPROFFLAGS, szDevInstName,
4939 ulHardwareProfile, pulValue, NULL, NULL, 0, 0);
4940 }
4942 {
4944 }
4946
4947 return ret;
4948}
4949
4950
4951/***********************************************************************
4952 * CM_Get_Hardware_Profile_InfoA [SETUPAPI.@]
4953 */
4955WINAPI
4957 _In_ ULONG ulIndex,
4958 _Out_ PHWPROFILEINFO_A pHWProfileInfo,
4959 _In_ ULONG ulFlags)
4960{
4961 TRACE("CM_Get_Hardware_Profile_InfoA(%lu %p %lx)\n",
4962 ulIndex, pHWProfileInfo, ulFlags);
4963
4964 return CM_Get_Hardware_Profile_Info_ExA(ulIndex, pHWProfileInfo,
4965 ulFlags, NULL);
4966}
4967
4968
4969/***********************************************************************
4970 * CM_Get_Hardware_Profile_InfoW [SETUPAPI.@]
4971 */
4973WINAPI
4975 _In_ ULONG ulIndex,
4976 _Out_ PHWPROFILEINFO_W pHWProfileInfo,
4977 _In_ ULONG ulFlags)
4978{
4979 TRACE("CM_Get_Hardware_Profile_InfoW(%lu %p %lx)\n",
4980 ulIndex, pHWProfileInfo, ulFlags);
4981
4982 return CM_Get_Hardware_Profile_Info_ExW(ulIndex, pHWProfileInfo,
4983 ulFlags, NULL);
4984}
4985
4986
4987/***********************************************************************
4988 * CM_Get_Hardware_Profile_Info_ExA [SETUPAPI.@]
4989 */
4991WINAPI
4993 _In_ ULONG ulIndex,
4994 _Out_ PHWPROFILEINFO_A pHWProfileInfo,
4995 _In_ ULONG ulFlags,
4996 _In_opt_ HMACHINE hMachine)
4997{
4998 HWPROFILEINFO_W LocalProfileInfo;
4999 CONFIGRET ret;
5000
5001 TRACE("CM_Get_Hardware_Profile_Info_ExA(%lu %p %lx %p)\n",
5002 ulIndex, pHWProfileInfo, ulFlags, hMachine);
5003
5004 if (pHWProfileInfo == NULL)
5005 return CR_INVALID_POINTER;
5006
5007 ret = CM_Get_Hardware_Profile_Info_ExW(ulIndex, &LocalProfileInfo,
5008 ulFlags, hMachine);
5009 if (ret == CR_SUCCESS)
5010 {
5011 pHWProfileInfo->HWPI_ulHWProfile = LocalProfileInfo.HWPI_ulHWProfile;
5012 pHWProfileInfo->HWPI_dwFlags = LocalProfileInfo.HWPI_dwFlags;
5013
5015 0,
5016 LocalProfileInfo.HWPI_szFriendlyName,
5017 lstrlenW(LocalProfileInfo.HWPI_szFriendlyName) + 1,
5018 pHWProfileInfo->HWPI_szFriendlyName,
5020 NULL,
5021 NULL) == 0)
5022 ret = CR_FAILURE;
5023 }
5024
5025 return ret;
5026}
5027
5028
5029/***********************************************************************
5030 * CM_Get_Hardware_Profile_Info_ExW [SETUPAPI.@]
5031 */
5033WINAPI
5035 _In_ ULONG ulIndex,
5036 _Out_ PHWPROFILEINFO_W pHWProfileInfo,
5037 _In_ ULONG ulFlags,
5038 _In_opt_ HMACHINE hMachine)
5039{
5041 CONFIGRET ret;
5042
5043 TRACE("CM_Get_Hardware_Profile_Info_ExW(%lu %p %lx %p)\n",
5044 ulIndex, pHWProfileInfo, ulFlags, hMachine);
5045
5046 if (pHWProfileInfo == NULL)
5047 return CR_INVALID_POINTER;
5048
5049 if (ulFlags != 0)
5050 return CR_INVALID_FLAG;
5051
5052 if (hMachine != NULL)
5053 {
5054 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5055 if (BindingHandle == NULL)
5056 return CR_FAILURE;
5057 }
5058 else
5059 {
5061 return CR_FAILURE;
5062 }
5063
5065 {
5066 ret = PNP_GetHwProfInfo(BindingHandle, ulIndex, pHWProfileInfo,
5067 sizeof(HWPROFILEINFO_W), 0);
5068 }
5070 {
5072 }
5074
5075 return ret;
5076}
5077
5078
5079/***********************************************************************
5080 * CM_Get_Log_Conf_Priority [SETUPAPI.@]
5081 */
5083WINAPI
5085 _In_ LOG_CONF lcLogConf,
5086 _Out_ PPRIORITY pPriority,
5087 _In_ ULONG ulFlags)
5088{
5089 TRACE("CM_Get_Log_Conf_Priority(%p %p %lx)\n",
5090 lcLogConf, pPriority, ulFlags);
5091
5092 return CM_Get_Log_Conf_Priority_Ex(lcLogConf, pPriority, ulFlags, NULL);
5093}
5094
5095
5096/***********************************************************************
5097 * CM_Get_Log_Conf_Priority_Ex [SETUPAPI.@]
5098 */
5100WINAPI
5102 _In_ LOG_CONF lcLogConf,
5103 _Out_ PPRIORITY pPriority,
5104 _In_ ULONG ulFlags,
5105 _In_opt_ HMACHINE hMachine)
5106{
5108 HSTRING_TABLE StringTable = NULL;
5109 PLOG_CONF_INFO pLogConfInfo;
5110 LPWSTR lpDevInst;
5111 CONFIGRET ret;
5112
5113 FIXME("CM_Get_Log_Conf_Priority_Ex(%p %p %lx %p)\n",
5114 lcLogConf, pPriority, ulFlags, hMachine);
5115
5116 pLogConfInfo = (PLOG_CONF_INFO)lcLogConf;
5117 if (!IsValidLogConf(pLogConfInfo))
5118 return CR_INVALID_LOG_CONF;
5119
5120 if (pPriority == NULL)
5121 return CR_INVALID_POINTER;
5122
5123 if (ulFlags != 0)
5124 return CR_INVALID_FLAG;
5125
5126 if (hMachine != NULL)
5127 {
5128 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5129 if (BindingHandle == NULL)
5130 return CR_FAILURE;
5131
5132 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5133 if (StringTable == 0)
5134 return CR_FAILURE;
5135 }
5136 else
5137 {
5138 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5139 return CR_FAILURE;
5140 }
5141
5142 lpDevInst = pSetupStringTableStringFromId(StringTable, pLogConfInfo->dnDevInst);
5143 if (lpDevInst == NULL)
5144 return CR_INVALID_DEVNODE;
5145
5147 {
5149 lpDevInst,
5150 pLogConfInfo->ulType,
5151 pLogConfInfo->ulTag,
5152 pPriority,
5153 0);
5154 }
5156 {
5158 }
5160
5161 return ret;
5162}
5163
5164
5165/***********************************************************************
5166 * CM_Get_Next_Log_Conf [SETUPAPI.@]
5167 */
5169WINAPI
5171 _Out_opt_ PLOG_CONF plcLogConf,
5172 _In_ LOG_CONF lcLogConf,
5173 _In_ ULONG ulFlags)
5174{
5175 TRACE("CM_Get_Next_Log_Conf(%p %p %lx)\n",
5176 plcLogConf, lcLogConf, ulFlags);
5177
5178 return CM_Get_Next_Log_Conf_Ex(plcLogConf, lcLogConf, ulFlags, NULL);
5179}
5180
5181
5182/***********************************************************************
5183 * CM_Get_Next_Log_Conf_Ex [SETUPAPI.@]
5184 */
5186WINAPI
5188 _Out_opt_ PLOG_CONF plcLogConf,
5189 _In_ LOG_CONF lcLogConf,
5190 _In_ ULONG ulFlags,
5191 _In_opt_ HMACHINE hMachine)
5192{
5194 HSTRING_TABLE StringTable = NULL;
5195 PLOG_CONF_INFO pLogConfInfo;
5196 PLOG_CONF_INFO pNewLogConfInfo;
5197 ULONG ulNewTag;
5198 LPWSTR lpDevInst;
5199 CONFIGRET ret;
5200
5201 FIXME("CM_Get_Next_Log_Conf_Ex(%p %p %lx %p)\n",
5202 plcLogConf, lcLogConf, ulFlags, hMachine);
5203
5204 if (plcLogConf)
5205 *plcLogConf = 0;
5206
5207 pLogConfInfo = (PLOG_CONF_INFO)lcLogConf;
5208 if (!IsValidLogConf(pLogConfInfo))
5209 return CR_INVALID_LOG_CONF;
5210
5211 if (ulFlags != 0)
5212 return CR_INVALID_FLAG;
5213
5214 if (hMachine != NULL)
5215 {
5216 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5217 if (BindingHandle == NULL)
5218 return CR_FAILURE;
5219
5220 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5221 if (StringTable == 0)
5222 return CR_FAILURE;
5223 }
5224 else
5225 {
5226 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5227 return CR_FAILURE;
5228 }
5229
5230 lpDevInst = pSetupStringTableStringFromId(StringTable, pLogConfInfo->dnDevInst);
5231 if (lpDevInst == NULL)
5232 return CR_INVALID_DEVNODE;
5233
5235 {
5237 lpDevInst,
5238 pLogConfInfo->ulType,
5239 pLogConfInfo->ulTag,
5240 &ulNewTag,
5241 0);
5242 }
5244 {
5246 }
5248
5249 if (ret != CR_SUCCESS)
5250 return ret;
5251
5252 if (plcLogConf)
5253 {
5254 pNewLogConfInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(LOG_CONF_INFO));
5255 if (pNewLogConfInfo == NULL)
5256 return CR_OUT_OF_MEMORY;
5257
5258 pNewLogConfInfo->ulMagic = LOG_CONF_MAGIC;
5259 pNewLogConfInfo->dnDevInst = pLogConfInfo->dnDevInst;
5260 pNewLogConfInfo->ulType = pLogConfInfo->ulType;
5261 pNewLogConfInfo->ulTag = ulNewTag;
5262
5263 *plcLogConf = (LOG_CONF)pNewLogConfInfo;
5264 }
5265
5266 return CR_SUCCESS;
5267}
5268
5269
5270/***********************************************************************
5271 * CM_Get_Next_Res_Des [SETUPAPI.@]
5272 */
5274WINAPI
5276 _Out_ PRES_DES prdResDes,
5277 _In_ RES_DES rdResDes,
5278 _In_ RESOURCEID ForResource,
5279 _Out_opt_ PRESOURCEID pResourceID,
5280 _In_ ULONG ulFlags)
5281{
5282 TRACE("CM_Get_Next_Res_Des(%p %p %lu %p %lx)\n",
5283 prdResDes, rdResDes, ForResource, pResourceID, ulFlags);
5284
5285 return CM_Get_Next_Res_Des_Ex(prdResDes, rdResDes, ForResource,
5286 pResourceID, ulFlags, NULL);
5287}
5288
5289
5290/***********************************************************************
5291 * CM_Get_Next_Re_Des_Ex [SETUPAPI.@]
5292 */
5294WINAPI
5296 _Out_ PRES_DES prdResDes,
5297 _In_ RES_DES rdResDes,
5298 _In_ RESOURCEID ForResource,
5299 _Out_opt_ PRESOURCEID pResourceID,
5300 _In_ ULONG ulFlags,
5301 _In_opt_ HMACHINE hMachine)
5302{
5304 HSTRING_TABLE StringTable = NULL;
5305 PRES_DES_INFO pNewResDesInfo = NULL;
5306 ULONG ulLogConfTag, ulLogConfType, ulResDesTag;
5307 ULONG ulNextResDesType = 0, ulNextResDesTag = 0;
5308 LPWSTR lpDevInst;
5309 DEVINST dnDevInst;
5310 CONFIGRET ret;
5311
5312 FIXME("CM_Get_Next_Res_Des_Ex(%p %p %lu %p %lx %p)\n",
5313 prdResDes, rdResDes, ForResource, pResourceID, ulFlags, hMachine);
5314
5315 if (prdResDes == NULL)
5316 return CR_INVALID_POINTER;
5317
5318 if (IsValidLogConf((PLOG_CONF_INFO)rdResDes))
5319 {
5320 FIXME("LogConf found!\n");
5321 dnDevInst = ((PLOG_CONF_INFO)rdResDes)->dnDevInst;
5322 ulLogConfTag = ((PLOG_CONF_INFO)rdResDes)->ulTag;
5323 ulLogConfType = ((PLOG_CONF_INFO)rdResDes)->ulType;
5324 ulResDesTag = (ULONG)-1;
5325 }
5326 else if (IsValidResDes((PRES_DES_INFO)rdResDes))
5327 {
5328 FIXME("ResDes found!\n");
5329 dnDevInst = ((PRES_DES_INFO)rdResDes)->dnDevInst;
5330 ulLogConfTag = ((PRES_DES_INFO)rdResDes)->ulLogConfTag;
5331 ulLogConfType = ((PRES_DES_INFO)rdResDes)->ulLogConfType;
5332 ulResDesTag = ((PRES_DES_INFO)rdResDes)->ulResDesTag;
5333 }
5334 else
5335 {
5336 return CR_INVALID_RES_DES;
5337 }
5338
5339 if ((ForResource == ResType_All) && (pResourceID == NULL))
5340 return CR_INVALID_POINTER;
5341
5342 if (ulFlags != 0)
5343 return CR_INVALID_FLAG;
5344
5345 if (hMachine != NULL)
5346 {
5347 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5348 if (BindingHandle == NULL)
5349 return CR_FAILURE;
5350
5351 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5352 if (StringTable == 0)
5353 return CR_FAILURE;
5354 }
5355 else
5356 {
5357 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5358 return CR_FAILURE;
5359 }
5360
5361 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
5362 if (lpDevInst == NULL)
5363 return CR_INVALID_DEVNODE;
5364
5366 {
5368 lpDevInst,
5369 ulLogConfTag,
5370 ulLogConfType,
5371 ForResource,
5372 ulResDesTag,
5373 &ulNextResDesTag,
5374 &ulNextResDesType,
5375 0);
5376 }
5378 {
5380 }
5382
5383 if (ret != CR_SUCCESS)
5384 return ret;
5385
5386 if (ForResource == ResType_All)
5387 *pResourceID = ulNextResDesType;
5388
5389 if (prdResDes)
5390 {
5391 pNewResDesInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(RES_DES_INFO));
5392 if (pNewResDesInfo == NULL)
5393 return CR_OUT_OF_MEMORY;
5394
5395 pNewResDesInfo->ulMagic = LOG_CONF_MAGIC;
5396 pNewResDesInfo->dnDevInst = dnDevInst;
5397 pNewResDesInfo->ulLogConfType = ulLogConfType;
5398 pNewResDesInfo->ulLogConfTag = ulLogConfTag;
5399 pNewResDesInfo->ulResDesType = ulNextResDesType;
5400 pNewResDesInfo->ulResDesTag = ulNextResDesTag;
5401
5402 *prdResDes = (RES_DES)pNewResDesInfo;
5403 }
5404
5405 return CR_SUCCESS;
5406}
5407
5408
5409/***********************************************************************
5410 * CM_Get_Parent [SETUPAPI.@]
5411 */
5413WINAPI
5415 _Out_ PDEVINST pdnDevInst,
5416 _In_ DEVINST dnDevInst,
5417 _In_ ULONG ulFlags)
5418{
5419 TRACE("CM_Get_Parent(%p %p %lx)\n",
5420 pdnDevInst, dnDevInst, ulFlags);
5421
5422 return CM_Get_Parent_Ex(pdnDevInst, dnDevInst, ulFlags, NULL);
5423}
5424
5425
5426/***********************************************************************
5427 * CM_Get_Parent_Ex [SETUPAPI.@]
5428 */
5430WINAPI
5432 _Out_ PDEVINST pdnDevInst,
5433 _In_ DEVINST dnDevInst,
5434 _In_ ULONG ulFlags,
5435 _In_opt_ HMACHINE hMachine)
5436{
5437 WCHAR szRelatedDevInst[MAX_DEVICE_ID_LEN];
5439 HSTRING_TABLE StringTable = NULL;
5440 LPWSTR lpDevInst;
5441 DWORD dwIndex, dwLength = MAX_DEVICE_ID_LEN;
5442 CONFIGRET ret;
5443
5444 TRACE("CM_Get_Parent_Ex(%p %lx %lx %p)\n",
5445 pdnDevInst, dnDevInst, ulFlags, hMachine);
5446
5447 if (pdnDevInst == NULL)
5448 return CR_INVALID_POINTER;
5449
5450 if (dnDevInst == 0)
5451 return CR_INVALID_DEVINST;
5452
5453 if (ulFlags != 0)
5454 return CR_INVALID_FLAG;
5455
5456 *pdnDevInst = -1;
5457
5458 if (hMachine != NULL)
5459 {
5460 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5461 if (BindingHandle == NULL)
5462 return CR_FAILURE;
5463
5464 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5465 if (StringTable == 0)
5466 return CR_FAILURE;
5467 }
5468 else
5469 {
5470 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5471 return CR_FAILURE;
5472 }
5473
5474 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
5475 if (lpDevInst == NULL)
5476 return CR_INVALID_DEVNODE;
5477
5479 {
5481 PNP_GET_PARENT_DEVICE_INSTANCE,
5482 lpDevInst,
5483 szRelatedDevInst,
5484 &dwLength,
5485 0);
5486 }
5488 {
5490 }
5492
5493 if (ret != CR_SUCCESS)
5494 return ret;
5495
5496 TRACE("szRelatedDevInst: %s\n", debugstr_w(szRelatedDevInst));
5497
5498 dwIndex = pSetupStringTableAddString(StringTable, szRelatedDevInst, 1);
5499 if (dwIndex == -1)
5500 return CR_FAILURE;
5501
5502 *pdnDevInst = dwIndex;
5503
5504 return CR_SUCCESS;
5505}
5506
5507
5508/***********************************************************************
5509 * CM_Get_Res_Des_Data [SETUPAPI.@]
5510 */
5512WINAPI
5514 _In_ RES_DES rdResDes,
5515 _Out_writes_bytes_(BufferLen) PVOID Buffer,
5516 _In_ ULONG BufferLen,
5517 _In_ ULONG ulFlags)
5518{
5519 TRACE("CM_Get_Res_Des_Data(%p %p %lu %lx)\n",
5520 rdResDes, Buffer, BufferLen, ulFlags);
5521
5522 return CM_Get_Res_Des_Data_Ex(rdResDes, Buffer, BufferLen, ulFlags, NULL);
5523}
5524
5525
5526/***********************************************************************
5527 * CM_Get_Res_Des_Data_Ex [SETUPAPI.@]
5528 */
5530WINAPI
5532 _In_ RES_DES rdResDes,
5533 _Out_writes_bytes_(BufferLen) PVOID Buffer,
5534 _In_ ULONG BufferLen,
5535 _In_ ULONG ulFlags,
5536 _In_opt_ HMACHINE hMachine)
5537{
5538 FIXME("CM_Get_Res_Des_Data_Ex(%p %p %lu %lx %p)\n",
5539 rdResDes, Buffer, BufferLen, ulFlags, hMachine);
5540
5542}
5543
5544
5545/***********************************************************************
5546 * CM_Get_Res_Des_Size [SETUPAPI.@]
5547 */
5549WINAPI
5552 _In_ RES_DES rdResDes,
5553 _In_ ULONG ulFlags)
5554{
5555 TRACE("CM_Get_Res_Des_Data_Size(%p %p %lx)\n",
5556 pulSize, rdResDes, ulFlags);
5557
5558 return CM_Get_Res_Des_Data_Size_Ex(pulSize, rdResDes, ulFlags, NULL);
5559}
5560
5561
5562/***********************************************************************
5563 * CM_Get_Res_Des_Size_Ex [SETUPAPI.@]
5564 */
5566WINAPI
5569 _In_ RES_DES rdResDes,
5570 _In_ ULONG ulFlags,
5571 _In_opt_ HMACHINE hMachine)
5572{
5573 TRACE("CM_Get_Res_Des_Data_Size_Ex(%p %p %lx %p)\n",
5574 pulSize, rdResDes, ulFlags, hMachine);
5575
5577}
5578
5579
5580/***********************************************************************
5581 * CM_Get_Resource_Conflict_Count [SETUPAPI.@]
5582 */
5584WINAPI
5586 _In_ CONFLICT_LIST clConflictList,
5587 _Out_ PULONG pulCount)
5588{
5589 PCONFLICT_DATA pConflictData;
5590
5591 FIXME("CM_Get_Resource_Conflict_Count(%p %p)\n",
5592 clConflictList, pulCount);
5593
5594 pConflictData = (PCONFLICT_DATA)clConflictList;
5595 if (!IsValidConflictData(pConflictData))
5597
5598 if (pulCount == NULL)
5599 return CR_INVALID_POINTER;
5600
5601 *pulCount = pConflictData->pConflictList->ConflictsListed;
5602
5603 return CR_SUCCESS;
5604}
5605
5606
5607/***********************************************************************
5608 * CM_Get_Resource_Conflict_DetailsA [SETUPAPI.@]
5609 */
5611WINAPI
5613 _In_ CONFLICT_LIST clConflictList,
5614 _In_ ULONG ulIndex,
5615 _Inout_ PCONFLICT_DETAILS_A pConflictDetails)
5616{
5617 FIXME("CM_Get_Resource_Conflict_CountA(%p %lu %p)\n",
5618 clConflictList, ulIndex, pConflictDetails);
5619
5621}
5622
5623
5624/***********************************************************************
5625 * CM_Get_Resource_Conflict_DetailsW [SETUPAPI.@]
5626 */
5628WINAPI
5630 _In_ CONFLICT_LIST clConflictList,
5631 _In_ ULONG ulIndex,
5632 _Inout_ PCONFLICT_DETAILS_W pConflictDetails)
5633{
5634 FIXME("CM_Get_Resource_Conflict_CountW(%p %lu %p)\n",
5635 clConflictList, ulIndex, pConflictDetails);
5636
5638}
5639
5640
5641/***********************************************************************
5642 * CM_Get_Sibling [SETUPAPI.@]
5643 */
5645WINAPI
5647 _Out_ PDEVINST pdnDevInst,
5648 _In_ DEVINST dnDevInst,
5649 _In_ ULONG ulFlags)
5650{
5651 TRACE("CM_Get_Sibling(%p %p %lx)\n",
5652 pdnDevInst, dnDevInst, ulFlags);
5653
5654 return CM_Get_Sibling_Ex(pdnDevInst, dnDevInst, ulFlags, NULL);
5655}
5656
5657
5658/***********************************************************************
5659 * CM_Get_Sibling_Ex [SETUPAPI.@]
5660 */
5662WINAPI
5664 _Out_ PDEVINST pdnDevInst,
5665 _In_ DEVINST dnDevInst,
5666 _In_ ULONG ulFlags,
5667 _In_opt_ HMACHINE hMachine)
5668{
5669 WCHAR szRelatedDevInst[MAX_DEVICE_ID_LEN];
5671 HSTRING_TABLE StringTable = NULL;
5672 LPWSTR lpDevInst;
5673 DWORD dwIndex, dwLength = MAX_DEVICE_ID_LEN;
5674 CONFIGRET ret;
5675
5676 TRACE("CM_Get_Sibling_Ex(%p %lx %lx %p)\n",
5677 pdnDevInst, dnDevInst, ulFlags, hMachine);
5678
5679 if (pdnDevInst == NULL)
5680 return CR_INVALID_POINTER;
5681
5682 if (dnDevInst == 0)
5683 return CR_INVALID_DEVINST;
5684
5685 if (ulFlags != 0)
5686 return CR_INVALID_FLAG;
5687
5688 *pdnDevInst = -1;
5689
5690 if (hMachine != NULL)
5691 {
5692 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5693 if (BindingHandle == NULL)
5694 return CR_FAILURE;
5695
5696 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5697 if (StringTable == 0)
5698 return CR_FAILURE;
5699 }
5700 else
5701 {
5702 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5703 return CR_FAILURE;
5704 }
5705
5706 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
5707 if (lpDevInst == NULL)
5708 return CR_INVALID_DEVNODE;
5709
5711 {
5713 PNP_GET_SIBLING_DEVICE_INSTANCE,
5714 lpDevInst,
5715 szRelatedDevInst,
5716 &dwLength,
5717 0);
5718 }
5720 {
5722 }
5724
5725 if (ret != CR_SUCCESS)
5726 return ret;
5727
5728 TRACE("szRelatedDevInst: %s\n", debugstr_w(szRelatedDevInst));
5729
5730 dwIndex = pSetupStringTableAddString(StringTable, szRelatedDevInst, 1);
5731 if (dwIndex == -1)
5732 return CR_FAILURE;
5733
5734 *pdnDevInst = dwIndex;
5735
5736 return CR_SUCCESS;
5737}
5738
5739
5740/***********************************************************************
5741 * CM_Get_Version [SETUPAPI.@]
5742 */
5743WORD
5744WINAPI
5746{
5747 TRACE("CM_Get_Version()\n");
5748
5749 return CM_Get_Version_Ex(NULL);
5750}
5751
5752
5753/***********************************************************************
5754 * CM_Get_Version_Ex [SETUPAPI.@]
5755 */
5756WORD
5757WINAPI
5759 _In_opt_ HMACHINE hMachine)
5760{
5762 WORD Version = 0;
5763 CONFIGRET ret;
5764
5765 TRACE("CM_Get_Version_Ex(%p)\n", hMachine);
5766
5767 if (hMachine != NULL)
5768 {
5769 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5770 if (BindingHandle == NULL)
5771 return 0;
5772 }
5773 else
5774 {
5776 return CR_FAILURE;
5777 }
5778
5780 {
5782 }
5784 {
5786 }
5788
5789 if (ret != CR_SUCCESS)
5790 return 0;
5791
5792 return Version;
5793}
5794
5795
5796/***********************************************************************
5797 * CM_Intersect_Range_List [SETUPAPI.@]
5798 */
5800WINAPI
5802 _In_ RANGE_LIST rlhOld1,
5803 _In_ RANGE_LIST rlhOld2,
5804 _In_ RANGE_LIST rlhNew,
5805 _In_ ULONG ulFlags)
5806{
5807 FIXME("CM_Intersect_Range_List(%p %p %p %lx)\n",
5808 rlhOld1, rlhOld2, rlhNew, ulFlags);
5809
5811}
5812
5813
5814/***********************************************************************
5815 * CM_Invert_Range_List [SETUPAPI.@]
5816 */
5818WINAPI
5820 _In_ RANGE_LIST rlhOld,
5821 _In_ RANGE_LIST rlhNew,
5822 _In_ DWORDLONG ullMaxValue,
5823 _In_ ULONG ulFlags)
5824{
5825 FIXME("CM_Invert_Range_List(%p %p %I64u %lx)\n",
5826 rlhOld, rlhNew, ullMaxValue, ulFlags);
5827
5829}
5830
5831
5832/***********************************************************************
5833 * CM_Is_Dock_Station_Present [SETUPAPI.@]
5834 */
5836WINAPI
5838 _Out_ PBOOL pbPresent)
5839{
5840 TRACE("CM_Is_Dock_Station_Present(%p)\n",
5841 pbPresent);
5842
5843 return CM_Is_Dock_Station_Present_Ex(pbPresent, NULL);
5844}
5845
5846
5847/***********************************************************************
5848 * CM_Is_Dock_Station_Present_Ex [SETUPAPI.@]
5849 */
5851WINAPI
5853 _Out_ PBOOL pbPresent,
5854 _In_opt_ HMACHINE hMachine)
5855{
5857 CONFIGRET ret;
5858
5859 TRACE("CM_Is_Dock_Station_Present_Ex(%p %p)\n",
5860 pbPresent, hMachine);
5861
5862 if (pbPresent == NULL)
5863 return CR_INVALID_POINTER;
5864
5865 *pbPresent = FALSE;
5866
5867 if (hMachine != NULL)
5868 {
5869 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5870 if (BindingHandle == NULL)
5871 return CR_FAILURE;
5872 }
5873 else
5874 {
5876 return CR_FAILURE;
5877 }
5878
5880 {
5882 pbPresent);
5883 }
5885 {
5887 }
5889
5890 return ret;
5891}
5892
5893
5894/***********************************************************************
5895 * CM_Is_Version_Available_Ex [SETUPAPI.@]
5896 */
5897BOOL
5898WINAPI
5900 _In_ WORD wVersion)
5901{
5902 TRACE("CM_Is_Version_Available(%hu)\n",
5903 wVersion);
5904
5905 return CM_Is_Version_Available_Ex(wVersion, NULL);
5906}
5907
5908
5909/***********************************************************************
5910 * CM_Is_Version_Available_Ex [SETUPAPI.@]
5911 */
5912BOOL
5913WINAPI
5915 _In_ WORD wVersion,
5916 _In_opt_ HMACHINE hMachine)
5917{
5919 WORD wServerVersion;
5920 CONFIGRET ret;
5921
5922 TRACE("CM_Is_Version_Available_Ex(%hu %p)\n",
5923 wVersion, hMachine);
5924
5925 if (wVersion <= 0x400)
5926 return TRUE;
5927
5928 if (hMachine != NULL)
5929 {
5930 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5931 if (BindingHandle == NULL)
5932 return FALSE;
5933 }
5934 else
5935 {
5937 return FALSE;
5938 }
5939
5941 {
5942 ret = PNP_GetVersion(BindingHandle, &wServerVersion);
5943 }
5945 {
5947 }
5949
5950 if (ret != CR_SUCCESS)
5951 return FALSE;
5952
5953 return (wServerVersion >= wVersion);
5954}
5955
5956
5957/***********************************************************************
5958 * CM_Locate_DevNodeA [SETUPAPI.@]
5959 */
5961WINAPI
5963 _Out_ PDEVINST pdnDevInst,
5964 _In_opt_ DEVINSTID_A pDeviceID,
5965 _In_ ULONG ulFlags)
5966{
5967 TRACE("CM_Locate_DevNodeA(%p %s %lx)\n",
5968 pdnDevInst, debugstr_a(pDeviceID), ulFlags);
5969
5970 return CM_Locate_DevNode_ExA(pdnDevInst, pDeviceID, ulFlags, NULL);
5971}
5972
5973
5974/***********************************************************************
5975 * CM_Locate_DevNodeW [SETUPAPI.@]
5976 */
5978WINAPI
5980 _Out_ PDEVINST pdnDevInst,
5981 _In_opt_ DEVINSTID_W pDeviceID,
5982 _In_ ULONG ulFlags)
5983{
5984 TRACE("CM_Locate_DevNodeW(%p %s %lx)\n",
5985 pdnDevInst, debugstr_w(pDeviceID), ulFlags);
5986
5987 return CM_Locate_DevNode_ExW(pdnDevInst, pDeviceID, ulFlags, NULL);
5988}
5989
5990
5991/***********************************************************************
5992 * CM_Locate_DevNode_ExA [SETUPAPI.@]
5993 */
5995WINAPI
5997 _Out_ PDEVINST pdnDevInst,
5998 _In_opt_ DEVINSTID_A pDeviceID,
5999 _In_ ULONG ulFlags,
6000 _In_opt_ HMACHINE hMachine)
6001{
6002 DEVINSTID_W pDevIdW = NULL;
6004
6005 TRACE("CM_Locate_DevNode_ExA(%p %s %lx %p)\n",
6006 pdnDevInst, debugstr_a(pDeviceID), ulFlags, hMachine);
6007
6008 if (pDeviceID != NULL)
6009 {
6010 if (pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDevIdW))
6011 return CR_INVALID_DEVICE_ID;
6012 }
6013
6014 ret = CM_Locate_DevNode_ExW(pdnDevInst, pDevIdW, ulFlags, hMachine);
6015
6016 if (pDevIdW != NULL)
6017 MyFree(pDevIdW);
6018
6019 return ret;
6020}
6021
6022
6023/***********************************************************************
6024 * CM_Locate_DevNode_ExW [SETUPAPI.@]
6025 */
6027WINAPI
6029 _Out_ PDEVINST pdnDevInst,
6030 _In_opt_ DEVINSTID_W pDeviceID,
6031 _In_ ULONG ulFlags,
6032 _In_opt_ HMACHINE hMachine)
6033{
6034 WCHAR DeviceIdBuffer[MAX_DEVICE_ID_LEN];
6036 HSTRING_TABLE StringTable = NULL;
6038
6039 TRACE("CM_Locate_DevNode_ExW(%p %s %lx %p)\n",
6040 pdnDevInst, debugstr_w(pDeviceID), ulFlags, hMachine);
6041
6042 if (pdnDevInst == NULL)
6043 return CR_INVALID_POINTER;
6044
6045 if (ulFlags & ~CM_LOCATE_DEVNODE_BITS)
6046 return CR_INVALID_FLAG;
6047
6048 if (hMachine != NULL)
6049 {
6050 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6051 if (BindingHandle == NULL)
6052 return CR_FAILURE;
6053
6054 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6055 if (StringTable == 0)
6056 return CR_FAILURE;
6057 }
6058 else
6059 {
6060 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6061 return CR_FAILURE;
6062 }
6063
6064 if (pDeviceID != NULL && lstrlenW(pDeviceID) != 0)
6065 {
6066 lstrcpyW(DeviceIdBuffer, pDeviceID);
6067
6069 {
6070 /* Validate the device ID */
6072 DeviceIdBuffer,
6073 ulFlags);
6074 }
6076 {
6078 }
6080 }
6081 else
6082 {
6084 {
6085 /* Get the root device ID */
6087 DeviceIdBuffer,
6089 }
6091 {
6093 }
6095 }
6096
6097 TRACE("DeviceIdBuffer: %s\n", debugstr_w(DeviceIdBuffer));
6098
6099 if (ret == CR_SUCCESS)
6100 {
6101 *pdnDevInst = pSetupStringTableAddString(StringTable, DeviceIdBuffer, 1);
6102 if (*pdnDevInst == -1)
6103 ret = CR_FAILURE;
6104 }
6105
6106 return ret;
6107}
6108
6109
6110/***********************************************************************
6111 * CM_Merge_Range_List [SETUPAPI.@]
6112 */
6114WINAPI
6116 _In_ RANGE_LIST rlhOld1,
6117 _In_ RANGE_LIST rlhOld2,
6118 _In_ RANGE_LIST rlhNew,
6119 _In_ ULONG ulFlags)
6120{
6121 FIXME("CM_Merge_Range_List(%p %p %p %lx)\n",
6122 rlhOld1, rlhOld2, rlhNew, ulFlags);
6123
6125}
6126
6127
6128/***********************************************************************
6129 * CM_Modify_Res_Des [SETUPAPI.@]
6130 */
6132WINAPI
6134 _Out_ PRES_DES prdResDes,
6135 _In_ RES_DES rdResDes,
6136 _In_ RESOURCEID ResourceID,
6137 _In_reads_bytes_(ResourceLen) PCVOID ResourceData,
6138 _In_ ULONG ResourceLen,
6139 _In_ ULONG ulFlags)
6140{
6141 TRACE("CM_Modify_Res_Des(%p %p %lx %p %lu %lx)\n",
6142 prdResDes, rdResDes, ResourceID, ResourceData,
6143 ResourceLen, ulFlags);
6144
6145 return CM_Modify_Res_Des_Ex(prdResDes, rdResDes, ResourceID, ResourceData,
6146 ResourceLen, ulFlags, NULL);
6147}
6148
6149
6150/***********************************************************************
6151 * CM_Modify_Res_Des_Ex [SETUPAPI.@]
6152 */
6154WINAPI
6156 _Out_ PRES_DES prdResDes,
6157 _In_ RES_DES rdResDes,
6158 _In_ RESOURCEID ResourceID,
6159 _In_reads_bytes_(ResourceLen) PCVOID ResourceData,
6160 _In_ ULONG ResourceLen,
6161 _In_ ULONG ulFlags,
6162 _In_opt_ HMACHINE hMachine)
6163{
6164 FIXME("CM_Modify_Res_Des_Ex(%p %p %lx %p %lu %lx %p)\n",
6165 prdResDes, rdResDes, ResourceID, ResourceData,
6166 ResourceLen, ulFlags, hMachine);
6167
6169}
6170
6171
6172/***********************************************************************
6173 * CM_Move_DevNode [SETUPAPI.@]
6174 */
6176WINAPI
6178 _In_ DEVINST dnFromDevInst,
6179 _In_ DEVINST dnToDevInst,
6180 _In_ ULONG ulFlags)
6181{
6182 TRACE("CM_Move_DevNode(%lx %lx %lx)\n",
6183 dnFromDevInst, dnToDevInst, ulFlags);
6184
6185 return CM_Move_DevNode_Ex(dnFromDevInst, dnToDevInst, ulFlags, NULL);
6186}
6187
6188
6189/***********************************************************************
6190 * CM_Move_DevNode_Ex [SETUPAPI.@]
6191 */
6193WINAPI
6195 _In_ DEVINST dnFromDevInst,
6196 _In_ DEVINST dnToDevInst,
6197 _In_ ULONG ulFlags,
6198 _In_opt_ HMACHINE hMachine)
6199{
6201 HSTRING_TABLE StringTable = NULL;
6202 LPWSTR lpFromDevInst;
6203 LPWSTR lpToDevInst;
6204 CONFIGRET ret;
6205
6206 FIXME("CM_Move_DevNode_Ex(%lx %lx %lx %p)\n",
6207 dnFromDevInst, dnToDevInst, ulFlags, hMachine);
6208
6209 if (!pSetupIsUserAdmin())
6210 return CR_ACCESS_DENIED;
6211
6212 if (dnFromDevInst == 0 || dnToDevInst == 0)
6213 return CR_INVALID_DEVNODE;
6214
6215 if (ulFlags != 0)
6216 return CR_INVALID_FLAG;
6217
6218 if (hMachine != NULL)
6219 {
6220 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6221 if (BindingHandle == NULL)
6222 return CR_FAILURE;
6223
6224 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6225 if (StringTable == 0)
6226 return CR_FAILURE;
6227 }
6228 else
6229 {
6230 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6231 return CR_FAILURE;
6232 }
6233
6234 lpFromDevInst = pSetupStringTableStringFromId(StringTable, dnFromDevInst);
6235 if (lpFromDevInst == NULL)
6236 return CR_INVALID_DEVNODE;
6237
6238 lpToDevInst = pSetupStringTableStringFromId(StringTable, dnToDevInst);
6239 if (lpToDevInst == NULL)
6240 return CR_INVALID_DEVNODE;
6241
6243 {
6245 PNP_DEVINST_MOVE,
6246 ulFlags,
6247 lpFromDevInst,
6248 lpToDevInst);
6249 }
6251 {
6253 }
6255
6256 return ret;
6257}
6258
6259
6260/***********************************************************************
6261 * CM_Next_Range [SETUPAPI.@]
6262 */
6264WINAPI
6266 _Inout_ PRANGE_ELEMENT preElement,
6267 _Out_ PDWORDLONG pullStart,
6268 _Out_ PDWORDLONG pullEnd,
6269 _In_ ULONG ulFlags)
6270{
6271 PINTERNAL_RANGE_LIST pRangeList;
6272 PINTERNAL_RANGE pRange;
6273 PLIST_ENTRY ListEntry;
6275
6276 FIXME("CM_Next_Range(%p %p %p %lx)\n",
6277 preElement, pullStart, pullEnd, ulFlags);
6278
6279 pRange = (PINTERNAL_RANGE)preElement;
6280
6281 if (pRange == NULL || pRange->pRangeList == NULL)
6282 return CR_FAILURE;
6283
6284 if (pullStart == NULL || pullEnd == NULL)
6285 return CR_INVALID_POINTER;
6286
6287 if (ulFlags != 0)
6288 return CR_INVALID_FLAG;
6289
6290 pRangeList = pRange->pRangeList;
6291
6292 /* Lock the range list */
6293 WaitForSingleObject(pRangeList->hMutex, INFINITE);
6294
6295 /* Fail, if we reached the end of the list */
6296 if (pRange->ListEntry.Flink == &pRangeList->ListHead)
6297 {
6298 ret = CR_FAILURE;
6299 goto done;
6300 }
6301
6302 /* Get the next range */
6303 ListEntry = pRangeList->ListHead.Flink;
6304 pRange = CONTAINING_RECORD(ListEntry, INTERNAL_RANGE, ListEntry);
6305
6306 /* Return the range data */
6307 *pullStart = pRange->ullStart;
6308 *pullEnd = pRange->ullEnd;
6309 *preElement = (RANGE_ELEMENT)pRange;
6310
6311done:
6312 /* Unlock the range list */
6313 ReleaseMutex(pRangeList->hMutex);
6314
6315 return ret;
6316}
6317
6318
6319/***********************************************************************
6320 * CM_Open_Class_KeyA [SETUPAPI.@]
6321 */
6323WINAPI
6325 _In_opt_ LPGUID pClassGuid,
6326 _In_opt_ LPCSTR pszClassName,
6327 _In_ REGSAM samDesired,
6329 _Out_ PHKEY phkClass,
6330 _In_ ULONG ulFlags)
6331{
6332 TRACE("CM_Open_Class_KeyA(%p %s %lx %lx %p %lx)\n",
6333 debugstr_guid(pClassGuid), debugstr_a(pszClassName),
6334 samDesired, Disposition, phkClass, ulFlags);
6335
6336 return CM_Open_Class_Key_ExA(pClassGuid, pszClassName, samDesired,
6337 Disposition, phkClass, ulFlags, NULL);
6338}
6339
6340
6341/***********************************************************************
6342 * CM_Open_Class_KeyW [SETUPAPI.@]
6343 */
6345WINAPI
6347 _In_opt_ LPGUID pClassGuid,
6348 _In_opt_ LPCWSTR pszClassName,
6349 _In_ REGSAM samDesired,
6351 _Out_ PHKEY phkClass,
6352 _In_ ULONG ulFlags)
6353{
6354 TRACE("CM_Open_Class_KeyW(%p %s %lx %lx %p %lx)\n",
6355 debugstr_guid(pClassGuid), debugstr_w(pszClassName),
6356 samDesired, Disposition, phkClass, ulFlags);
6357
6358 return CM_Open_Class_Key_ExW(pClassGuid, pszClassName, samDesired,
6359 Disposition, phkClass, ulFlags, NULL);
6360}
6361
6362
6363/***********************************************************************
6364 * CM_Open_Class_Key_ExA [SETUPAPI.@]
6365 */
6367WINAPI
6369 _In_opt_ LPGUID pClassGuid,
6370 _In_opt_ LPCSTR pszClassName,
6371 _In_ REGSAM samDesired,
6373 _Out_ PHKEY phkClass,
6374 _In_ ULONG ulFlags,
6375 _In_opt_ HMACHINE hMachine)
6376{
6377 LPWSTR pszClassNameW = NULL;
6378 CONFIGRET ret;
6379
6380 TRACE("CM_Open_Class_Key_ExA(%p %s %lx %lx %p %lx %p)\n",
6381 debugstr_guid(pClassGuid), debugstr_a(pszClassName),
6382 samDesired, Disposition, phkClass, ulFlags, hMachine);
6383
6384 if (pszClassName != NULL)
6385 {
6386 if (pSetupCaptureAndConvertAnsiArg(pszClassName, &pszClassNameW))
6387 return CR_INVALID_DATA;
6388 }
6389
6390 ret = CM_Open_Class_Key_ExW(pClassGuid, pszClassNameW, samDesired,
6391 Disposition, phkClass, ulFlags, hMachine);
6392
6393 if (pszClassNameW != NULL)
6394 MyFree(pszClassNameW);
6395
6396 return ret;
6397}
6398
6399
6400/***********************************************************************
6401 * CM_Open_Class_Key_ExW [SETUPAPI.@]
6402 */
6404WINAPI
6406 _In_opt_ LPGUID pClassGuid,
6407 _In_opt_ LPCWSTR pszClassName,
6408 _In_ REGSAM samDesired,
6410 _Out_ PHKEY phkClass,
6411 _In_ ULONG ulFlags,
6412 _In_opt_ HMACHINE hMachine)
6413{
6414 WCHAR szKeyName[MAX_PATH];
6415 LPWSTR lpGuidString;
6416 DWORD dwDisposition;
6417 DWORD dwError;
6418 HKEY hKey;
6419
6420 TRACE("CM_Open_Class_Key_ExW(%p %s %lx %lx %p %lx %p)\n",
6421 debugstr_guid(pClassGuid), debugstr_w(pszClassName),
6422 samDesired, Disposition, phkClass, ulFlags, hMachine);
6423
6424 /* Check Disposition and ulFlags */
6426 (ulFlags & ~CM_OPEN_CLASS_KEY_BITS))
6427 return CR_INVALID_FLAG;
6428
6429 /* Check phkClass */
6430 if (phkClass == NULL)
6431 return CR_INVALID_POINTER;
6432
6433 *phkClass = NULL;
6434
6435 if (ulFlags == CM_OPEN_CLASS_KEY_INTERFACE &&
6436 pszClassName != NULL)
6437 return CR_INVALID_DATA;
6438
6439 if (hMachine == NULL)
6440 {
6442 }
6443 else
6444 {
6445 if (RegConnectRegistryW(((PMACHINE_INFO)hMachine)->szMachineName,
6447 &hKey))
6448 return CR_REGISTRY_ERROR;
6449 }
6450
6451 if (ulFlags & CM_OPEN_CLASS_KEY_INTERFACE)
6452 {
6453 lstrcpyW(szKeyName, DeviceClasses);
6454 }
6455 else
6456 {
6457 lstrcpyW(szKeyName, ControlClass);
6458 }
6459
6460 if (pClassGuid != NULL)
6461 {
6462 if (UuidToStringW((UUID*)pClassGuid, &lpGuidString) != RPC_S_OK)
6463 {
6465 return CR_INVALID_DATA;
6466 }
6467
6468 lstrcatW(szKeyName, BackslashOpenBrace);
6469 lstrcatW(szKeyName, lpGuidString);
6470 lstrcatW(szKeyName, CloseBrace);
6471 }
6472
6474 {
6475 dwError = RegCreateKeyExW(hKey, szKeyName, 0, NULL, 0, samDesired,
6476 NULL, phkClass, &dwDisposition);
6477 }
6478 else
6479 {
6480 dwError = RegOpenKeyExW(hKey, szKeyName, 0, samDesired, phkClass);
6481 }
6482
6484
6485 if (pClassGuid != NULL)
6486 RpcStringFreeW(&lpGuidString);
6487
6488 if (dwError != ERROR_SUCCESS)
6489 {
6490 *phkClass = NULL;
6492 }
6493
6494 if (pszClassName != NULL)
6495 {
6496 RegSetValueExW(*phkClass, Class, 0, REG_SZ, (LPBYTE)pszClassName,
6497 (lstrlenW(pszClassName) + 1) * sizeof(WCHAR));
6498 }
6499
6500 return CR_SUCCESS;
6501}
6502
6503
6504/***********************************************************************
6505 * CM_Open_DevNode_Key [SETUPAPI.@]
6506 */
6508WINAPI
6510 _In_ DEVINST dnDevNode,
6511 _In_ REGSAM samDesired,
6512 _In_ ULONG ulHardwareProfile,
6514 _Out_ PHKEY phkDevice,
6515 _In_ ULONG ulFlags)
6516{
6517 TRACE("CM_Open_DevNode_Key(%lx %lx %lu %lx %p %lx)\n",
6518 dnDevNode, samDesired, ulHardwareProfile, Disposition, phkDevice, ulFlags);
6519
6520 return CM_Open_DevNode_Key_Ex(dnDevNode, samDesired, ulHardwareProfile,
6521 Disposition, phkDevice, ulFlags, NULL);
6522}
6523
6524
6525/***********************************************************************
6526 * CM_Open_DevNode_Key_Ex [SETUPAPI.@]
6527 */
6529WINAPI
6531 _In_ DEVINST dnDevNode,
6532 _In_ REGSAM samDesired,
6533 _In_ ULONG ulHardwareProfile,
6535 _Out_ PHKEY phkDevice,
6536 _In_ ULONG ulFlags,
6537 _In_opt_ HMACHINE hMachine)
6538{
6540 HSTRING_TABLE StringTable = NULL;
6541 LPWSTR pszDevInst, pszKeyPath = NULL, pszInstancePath = NULL;
6542 LONG lError;
6543 DWORD dwDisposition;
6544 HKEY hRootKey = NULL;
6546
6547 TRACE("CM_Open_DevNode_Key_Ex(%lx %lx %lu %lx %p %lx %p)\n",
6548 dnDevNode, samDesired, ulHardwareProfile, Disposition, phkDevice, ulFlags, hMachine);
6549
6550 if (phkDevice == NULL)
6551 return CR_INVALID_POINTER;
6552
6553 *phkDevice = NULL;
6554
6555 if (dnDevNode == 0)
6556 return CR_INVALID_DEVNODE;
6557
6558 if (ulFlags & ~CM_REGISTRY_BITS)
6559 return CR_INVALID_FLAG;
6560
6562 return CR_INVALID_DATA;
6563
6564 if (hMachine != NULL)
6565 {
6566 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6567 if (BindingHandle == NULL)
6568 return CR_FAILURE;
6569
6570 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6571 if (StringTable == 0)
6572 return CR_FAILURE;
6573 }
6574 else
6575 {
6576 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6577 return CR_FAILURE;
6578 }
6579
6580 pszDevInst = pSetupStringTableStringFromId(StringTable, dnDevNode);
6581 if (pszDevInst == NULL)
6582 return CR_INVALID_DEVNODE;
6583
6584 TRACE("pszDevInst: %S\n", pszDevInst);
6585
6586 pszKeyPath = MyMalloc(512 * sizeof(WCHAR));
6587 if (pszKeyPath == NULL)
6588 {
6590 goto done;
6591 }
6592
6593 pszInstancePath = MyMalloc(512 * sizeof(WCHAR));
6594 if (pszInstancePath == NULL)
6595 {
6597 goto done;
6598 }
6599
6601 pszDevInst,
6602 pszKeyPath,
6603 pszInstancePath,
6604 ulHardwareProfile,
6605 ulFlags);
6606 if (ret != CR_SUCCESS)
6607 goto done;
6608
6609 TRACE("pszKeyPath: %S\n", pszKeyPath);
6610 TRACE("pszInstancePath: %S\n", pszInstancePath);
6611
6612 wcscat(pszKeyPath, L"\\");
6613 wcscat(pszKeyPath, pszInstancePath);
6614
6615 TRACE("pszKeyPath: %S\n", pszKeyPath);
6616
6617 if (hMachine == NULL)
6618 {
6619 hRootKey = HKEY_LOCAL_MACHINE;
6620 }
6621 else
6622 {
6623 if (RegConnectRegistryW(((PMACHINE_INFO)hMachine)->szMachineName,
6625 &hRootKey))
6626 {
6628 goto done;
6629 }
6630 }
6631
6633 {
6634 lError = RegCreateKeyExW(hRootKey,
6635 pszKeyPath,
6636 0,
6637 NULL,
6638 0,
6639 samDesired,
6640 NULL,
6641 phkDevice,
6642 &dwDisposition);
6643 }
6644 else
6645 {
6646 lError = RegOpenKeyExW(hRootKey,
6647 pszKeyPath,
6648 0,
6649 samDesired,
6650 phkDevice);
6651 }
6652
6653 if (lError != ERROR_SUCCESS)
6654 {
6655 *phkDevice = NULL;
6657 }
6658
6659done:
6660 if ((hRootKey != NULL) && (hRootKey != HKEY_LOCAL_MACHINE))
6661 RegCloseKey(hRootKey);
6662
6663 if (pszInstancePath != NULL)
6664 MyFree(pszInstancePath);
6665
6666 if (pszKeyPath != NULL)
6667 MyFree(pszKeyPath);
6668
6669 return ret;
6670}
6671
6672
6673/***********************************************************************
6674 * CM_Query_And_Remove_SubTreeA [SETUPAPI.@]
6675 */
6677WINAPI
6679 _In_ DEVINST dnAncestor,
6680 _Out_opt_ PPNP_VETO_TYPE pVetoType,
6681 _Out_writes_opt_(ulNameLength) LPSTR pszVetoName,
6682 _In_ ULONG ulNameLength,
6683 _In_ ULONG ulFlags)
6684{
6685 TRACE("CM_Query_And_Remove_SubTreeA(%lx %p %p %lu %lx)\n",
6686 dnAncestor, pVetoType, pszVetoName, ulNameLength, ulFlags);
6687
6688 return CM_Query_And_Remove_SubTree_ExA(dnAncestor, pVetoType, pszVetoName,
6689 ulNameLength, ulFlags, NULL);
6690}
6691
6692
6693/***********************************************************************
6694 * CM_Query_And_Remove_SubTreeW [SETUPAPI.@]
6695 */
6697WINAPI
6699 _In_ DEVINST dnAncestor,
6700 _Out_opt_ PPNP_VETO_TYPE pVetoType,
6701 _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName,
6702 _In_ ULONG ulNameLength,
6703 _In_ ULONG ulFlags)
6704{
6705 TRACE("CM_Query_And_Remove_SubTreeW(%lx %p %p %lu %lx)\n",
6706 dnAncestor, pVetoType, pszVetoName, ulNameLength, ulFlags);
6707
6708 return CM_Query_And_Remove_SubTree_ExW(dnAncestor, pVetoType, pszVetoName,
6709 ulNameLength, ulFlags, NULL);
6710}
6711
6712
6713/***********************************************************************
6714 * CM_Query_And_Remove_SubTree_ExA [SETUPAPI.@]
6715 */
6717WINAPI
6719 _In_ DEVINST dnAncestor,
6720 _Out_opt_ PPNP_VETO_TYPE pVetoType,
6721 _Out_writes_opt_(ulNameLength) LPSTR pszVetoName,
6722 _In_ ULONG ulNameLength,
6723 _In_ ULONG ulFlags,
6724 _In_opt_ HMACHINE hMachine)
6725{
6726 LPWSTR lpLocalVetoName;
6727 CONFIGRET ret;
6728
6729 TRACE("CM_Query_And_Remove_SubTree_ExA(%lx %p %p %lu %lx %p)\n",
6730 dnAncestor, pVetoType, pszVetoName, ulNameLength,
6731 ulFlags, hMachine);
6732
6733 if (pszVetoName == NULL && ulNameLength == 0)
6734 return CR_INVALID_POINTER;
6735
6736 lpLocalVetoName = HeapAlloc(GetProcessHeap(), 0, ulNameLength * sizeof(WCHAR));
6737 if (lpLocalVetoName == NULL)
6738 return CR_OUT_OF_MEMORY;
6739
6740 ret = CM_Query_And_Remove_SubTree_ExW(dnAncestor, pVetoType, lpLocalVetoName,
6741 ulNameLength, ulFlags, hMachine);
6742 if (ret == CR_REMOVE_VETOED)
6743 {
6745 0,
6746 lpLocalVetoName,
6747 ulNameLength,
6748 pszVetoName,
6749 ulNameLength,
6750 NULL,
6751 NULL) == 0)
6752 ret = CR_FAILURE;
6753 }
6754
6755 HeapFree(GetProcessHeap(), 0, lpLocalVetoName);
6756
6757 return ret;
6758}
6759
6760
6761/***********************************************************************
6762 * CM_Query_And_Remove_SubTree_ExW [SETUPAPI.@]
6763 */
6765WINAPI
6767 _In_ DEVINST dnAncestor,
6768 _Out_opt_ PPNP_VETO_TYPE pVetoType,
6769 _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName,
6770 _In_ ULONG ulNameLength,
6771 _In_ ULONG ulFlags,
6772 _In_opt_ HMACHINE hMachine)
6773{
6775 HSTRING_TABLE StringTable = NULL;
6776 LPWSTR lpDevInst;
6777 CONFIGRET ret;
6778
6779 TRACE("CM_Query_And_Remove_SubTree_ExW(%lx %p %p %lu %lx %p)\n",
6780 dnAncestor, pVetoType, pszVetoName, ulNameLength,
6781 ulFlags, hMachine);
6782
6783 if (dnAncestor == 0)
6784 return CR_INVALID_DEVNODE;
6785
6786 if (ulFlags & ~CM_REMOVE_BITS)
6787 return CR_INVALID_FLAG;
6788
6789 if (pszVetoName == NULL && ulNameLength == 0)
6790 return CR_INVALID_POINTER;
6791
6792 if (hMachine != NULL)
6793 {
6794 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6795 if (BindingHandle == NULL)
6796 return CR_FAILURE;
6797
6798 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6799 if (StringTable == 0)
6800 return CR_FAILURE;
6801 }
6802 else
6803 {
6804 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6805 return CR_FAILURE;
6806 }
6807
6808 lpDevInst = pSetupStringTableStringFromId(StringTable, dnAncestor);
6809 if (lpDevInst == NULL)
6810 return CR_INVALID_DEVNODE;
6811
6813 {
6815 lpDevInst,
6816 pVetoType,
6817 pszVetoName,
6818 ulNameLength,
6819 ulFlags);
6820 }
6822 {
6824 }
6826
6827 return ret;
6828}
6829
6830
6831/***********************************************************************
6832 * CM_Query_Arbitrator_Free_Data [SETUPAPI.@]
6833 */
6835WINAPI
6838 _In_ ULONG DataLen,
6839 _In_ DEVINST dnDevInst,
6840 _In_ RESOURCEID ResourceID,
6841 _In_ ULONG ulFlags)
6842{
6843 TRACE("CM_Query_Arbitrator_Free_Data(%p %lu %lx %lu 0x%08lx)\n",
6844 pData, DataLen, dnDevInst, ResourceID, ulFlags);
6845
6846 return CM_Query_Arbitrator_Free_Data_Ex(pData, DataLen, dnDevInst,
6847 ResourceID, ulFlags, NULL);
6848}
6849
6850
6851/***********************************************************************
6852 * CM_Query_Arbitrator_Free_Data_Ex [SETUPAPI.@]
6853 */
6855WINAPI
6858 _In_ ULONG DataLen,
6859 _In_ DEVINST dnDevInst,
6860 _In_ RESOURCEID ResourceID,
6861 _In_ ULONG ulFlags,
6862 _In_opt_ HMACHINE hMachine)
6863{
6865 HSTRING_TABLE StringTable = NULL;
6866 LPWSTR lpDevInst;
6867 CONFIGRET ret;
6868
6869 TRACE("CM_Query_Arbitrator_Free_Data_Ex(%p %lu %lx %lu 0x%08lx %p)\n",
6870 pData, DataLen, dnDevInst, ResourceID, ulFlags, hMachine);
6871
6872 if (pData == NULL || DataLen == 0)
6873 return CR_INVALID_POINTER;
6874
6875 if (dnDevInst == 0)
6876 return CR_INVALID_DEVINST;
6877
6878 if (ulFlags & ~CM_QUERY_ARBITRATOR_BITS)
6879 return CR_INVALID_FLAG;
6880
6881 if (hMachine != NULL)
6882 {
6883 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6884 if (BindingHandle == NULL)
6885 return CR_FAILURE;
6886
6887 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6888 if (StringTable == 0)
6889 return CR_FAILURE;
6890 }
6891 else
6892 {
6893 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6894 return CR_FAILURE;
6895 }
6896
6897 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
6898 if (lpDevInst == NULL)
6899 return CR_INVALID_DEVNODE;
6900
6902 {
6904 pData,
6905 DataLen,
6906 lpDevInst,
6907 ResourceID,
6908 ulFlags);
6909 }
6911 {
6913 }
6915
6916 return ret;
6917}
6918
6919
6920/***********************************************************************
6921 * CM_Query_Arbitrator_Free_Size [SETUPAPI.@]
6922 */
6924WINAPI
6927 _In_ DEVINST dnDevInst,
6928 _In_ RESOURCEID ResourceID,
6929 _In_ ULONG ulFlags)
6930{
6931 TRACE("CM_Query_Arbitrator_Free_Size(%p %lu %lx 0x%08lx)\n",
6932 pulSize, dnDevInst,ResourceID, ulFlags);
6933
6934 return CM_Query_Arbitrator_Free_Size_Ex(pulSize, dnDevInst, ResourceID,
6935 ulFlags, NULL);
6936}
6937
6938
6939/***********************************************************************
6940 * CM_Query_Arbitrator_Free_Size_Ex [SETUPAPI.@]
6941 */
6943WINAPI
6946 _In_ DEVINST dnDevInst,
6947 _In_ RESOURCEID ResourceID,
6948 _In_ ULONG ulFlags,
6949 _In_opt_ HMACHINE hMachine)
6950{
6952 HSTRING_TABLE StringTable = NULL;
6953 LPWSTR lpDevInst;
6954 CONFIGRET ret;
6955
6956 TRACE("CM_Query_Arbitrator_Free_Size_Ex(%p %lu %lx 0x%08lx %p)\n",
6957 pulSize, dnDevInst,ResourceID, ulFlags, hMachine);
6958
6959 if (pulSize == NULL)
6960 return CR_INVALID_POINTER;
6961
6962 if (dnDevInst == 0)
6963 return CR_INVALID_DEVINST;
6964
6965 if (ulFlags & ~CM_QUERY_ARBITRATOR_BITS)
6966 return CR_INVALID_FLAG;
6967
6968 if (hMachine != NULL)
6969 {
6970 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6971 if (BindingHandle == NULL)
6972 return CR_FAILURE;
6973
6974 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6975 if (StringTable == 0)
6976 return CR_FAILURE;
6977 }
6978 else
6979 {
6980 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6981 return CR_FAILURE;
6982 }
6983
6984 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
6985 if (lpDevInst == NULL)
6986 return CR_INVALID_DEVNODE;
6987
6989 {
6991 pulSize,
6992 lpDevInst,
6993 ResourceID,
6994 ulFlags);
6995 }
6997 {
6999 }
7001
7002 return ret;
7003}
7004
7005
7006/***********************************************************************
7007 * CM_Query_Remove_SubTree [SETUPAPI.@]
7008 *
7009 * This function is obsolete in Windows XP and above.
7010 */
7012WINAPI
7014 _In_ DEVINST dnAncestor,
7015 _In_ ULONG ulFlags)
7016{
7017 TRACE("CM_Query_Remove_SubTree(%lx %lx)\n",
7018 dnAncestor, ulFlags);
7019
7021}
7022
7023
7024/***********************************************************************
7025 * CM_Query_Remove_SubTree_Ex [SETUPAPI.@]
7026 *
7027 * This function is obsolete in Windows XP and above.
7028 */
7030WINAPI
7032 _In_ DEVINST dnAncestor,
7033 _In_ ULONG ulFlags,
7034 _In_opt_ HMACHINE hMachine)
7035{
7036 TRACE("CM_Query_Remove_SubTree_Ex(%lx %lx %p)\n",
7037 dnAncestor, ulFlags, hMachine);
7038
7040}
7041
7042
7043/***********************************************************************
7044 * CM_Query_Resource_Conflict_List [SETUPAPI.@]
7045 */
7047WINAPI
7049 _Out_ PCONFLICT_LIST pclConflictList,
7050 _In_ DEVINST dnDevInst,
7051 _In_ RESOURCEID ResourceID,
7052 _In_ PCVOID ResourceData,
7053 _In_ ULONG ResourceLen,
7054 _In_ ULONG ulFlags,
7055 _In_opt_ HMACHINE hMachine)
7056{
7058 HSTRING_TABLE StringTable = NULL;
7059 PPNP_CONFLICT_LIST pConflictBuffer = NULL;
7060 PCONFLICT_DATA pConflictData = NULL;
7061 ULONG ulBufferLength;
7062 LPWSTR lpDevInst;
7063 CONFIGRET ret;
7064
7065 FIXME("CM_Query_Resource_Conflict_List(%p %lx %lu %p %lu %lx %p)\n",
7066 pclConflictList, dnDevInst, ResourceID, ResourceData,
7067 ResourceLen, ulFlags, hMachine);
7068
7069 if (dnDevInst == 0)
7070 return CR_INVALID_DEVNODE;
7071
7072 if (ulFlags & ~CM_RESDES_WIDTH_BITS)
7073 return CR_INVALID_FLAG;
7074
7075 if (pclConflictList == NULL ||
7076 ResourceData == NULL ||
7077 ResourceLen == 0)
7078 return CR_INVALID_POINTER;
7079
7080 if (ResourceID == 0)
7081 return CR_INVALID_RESOURCEID;
7082
7083 *pclConflictList = 0;
7084
7085 if (hMachine != NULL)
7086 {
7087 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7088 if (BindingHandle == NULL)
7089 return CR_FAILURE;
7090
7091 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7092 if (StringTable == 0)
7093 return CR_FAILURE;
7094 }
7095 else
7096 {
7097 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7098 return CR_FAILURE;
7099 }
7100
7101 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7102 if (lpDevInst == NULL)
7103 return CR_INVALID_DEVNODE;
7104
7105 pConflictData = MyMalloc(sizeof(CONFLICT_DATA));
7106 if (pConflictData == NULL)
7107 {
7109 goto done;
7110 }
7111
7112 ulBufferLength = sizeof(PNP_CONFLICT_LIST) +
7113 sizeof(PNP_CONFLICT_STRINGS) +
7114 (sizeof(wchar_t) * 200);
7115 pConflictBuffer = MyMalloc(ulBufferLength);
7116 if (pConflictBuffer == NULL)
7117 {
7119 goto done;
7120 }
7121
7123 {
7125 lpDevInst,
7126 ResourceID,
7127 (PBYTE)ResourceData,
7128 ResourceLen,
7129 (PBYTE)pConflictBuffer,
7130 ulBufferLength,
7131 ulFlags);
7132 }
7134 {
7136 }
7138
7139 if (ret != CR_SUCCESS)
7140 goto done;
7141
7142 pConflictData->ulMagic = CONFLICT_MAGIC;
7143 pConflictData->pConflictList = pConflictBuffer;
7144
7145 *pclConflictList = (CONFLICT_LIST)pConflictData;
7146
7147done:
7148 if (ret != CR_SUCCESS)
7149 {
7150 if (pConflictBuffer != NULL)
7151 MyFree(pConflictBuffer);
7152
7153 if (pConflictData != NULL)
7154 MyFree(pConflictData);
7155 }
7156
7157 return ret;
7158}
7159
7160
7161/***********************************************************************
7162 * CM_Reenumerate_DevNode [SETUPAPI.@]
7163 */
7165WINAPI
7167 _In_ DEVINST dnDevInst,
7168 _In_ ULONG ulFlags)
7169{
7170 TRACE("CM_Reenumerate_DevNode(%lx %lx)\n",
7171 dnDevInst, ulFlags);
7172
7173 return CM_Reenumerate_DevNode_Ex(dnDevInst, ulFlags, NULL);
7174}
7175
7176
7177/***********************************************************************
7178 * CM_Reenumerate_DevNode_Ex [SETUPAPI.@]
7179 */
7182 _In_ DEVINST dnDevInst,
7183 _In_ ULONG ulFlags,
7184 _In_opt_ HMACHINE hMachine)
7185{
7187 HSTRING_TABLE StringTable = NULL;
7188 LPWSTR lpDevInst;
7189 CONFIGRET ret;
7190
7191 FIXME("CM_Reenumerate_DevNode_Ex(%lx %lx %p)\n",
7192 dnDevInst, ulFlags, hMachine);
7193
7194 if (dnDevInst == 0)
7195 return CR_INVALID_DEVNODE;
7196
7197 if (ulFlags & ~CM_REENUMERATE_BITS)
7198 return CR_INVALID_FLAG;
7199
7200 if (hMachine != NULL)
7201 {
7202 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7203 if (BindingHandle == NULL)
7204 return CR_FAILURE;
7205
7206 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7207 if (StringTable == 0)
7208 return CR_FAILURE;
7209 }
7210 else
7211 {
7212 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7213 return CR_FAILURE;
7214 }
7215
7216 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7217 if (lpDevInst == NULL)
7218 return CR_INVALID_DEVNODE;
7219
7221 {
7223 PNP_DEVINST_REENUMERATE,
7224 ulFlags,
7225 lpDevInst,
7226 NULL);
7227 }
7229 {
7231 }
7233
7234 return ret;
7235}
7236
7237
7238/***********************************************************************
7239 * CM_Register_Device_Driver [SETUPAPI.@]
7240 */
7242WINAPI
7244 _In_ DEVINST dnDevInst,
7245 _In_ ULONG ulFlags)
7246{
7247 TRACE("CM_Register_Device_Driver(%lx 0x%08lx)\n",
7248 dnDevInst, ulFlags);
7249
7250 return CM_Register_Device_Driver_Ex(dnDevInst, ulFlags, NULL);
7251}
7252
7253
7254/***********************************************************************
7255 * CM_Register_Device_Driver_Ex [SETUPAPI.@]
7256 */
7258WINAPI
7260 _In_ DEVINST dnDevInst,
7261 _In_ ULONG ulFlags,
7262 _In_opt_ HMACHINE hMachine)
7263{
7265 HSTRING_TABLE StringTable = NULL;
7266 LPWSTR lpDevInst;
7267 CONFIGRET ret;
7268
7269 TRACE("CM_Register_Device_Driver_Ex(%lx 0x%08lx %p)\n",
7270 dnDevInst, ulFlags, hMachine);
7271
7272 if (dnDevInst == 0)
7273 return CR_INVALID_DEVNODE;
7274
7275 if (ulFlags & ~CM_REGISTER_DEVICE_DRIVER_BITS)
7276 return CR_INVALID_FLAG;
7277
7278 if (hMachine != NULL)
7279 {
7280 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7281 if (BindingHandle == NULL)
7282 return CR_FAILURE;
7283
7284 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7285 if (StringTable == 0)
7286 return CR_FAILURE;
7287 }
7288 else
7289 {
7290 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7291 return CR_FAILURE;
7292 }
7293
7294 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7295 if (lpDevInst == NULL)
7296 return CR_INVALID_DEVNODE;
7297
7299 {
7301 lpDevInst,
7302 ulFlags);
7303 }
7305 {
7307 }
7309
7310 return ret;
7311}
7312
7313
7314/***********************************************************************
7315 * CM_Register_Device_InterfaceA [SETUPAPI.@]
7316 */
7318WINAPI
7320 _In_ DEVINST dnDevInst,
7322 _In_opt_ LPCSTR pszReference,
7323 _Out_writes_(*pulLength) LPSTR pszDeviceInterface,
7324 _Inout_ PULONG pulLength,
7325 _In_ ULONG ulFlags)
7326{
7327 TRACE("CM_Register_Device_InterfaceA(%lx %s %s %p %p %lx)\n",
7329 pszReference, pszDeviceInterface, pulLength, ulFlags);
7330
7332 pszReference, pszDeviceInterface,
7333 pulLength, ulFlags, NULL);
7334}
7335
7336
7337/***********************************************************************
7338 * CM_Register_Device_InterfaceW [SETUPAPI.@]
7339 */
7341WINAPI
7343 _In_ DEVINST dnDevInst,
7345 _In_opt_ LPCWSTR pszReference,
7346 _Out_writes_(*pulLength) LPWSTR pszDeviceInterface,
7347 _Inout_ PULONG pulLength,
7348 _In_ ULONG ulFlags)
7349{
7350 TRACE("CM_Register_Device_InterfaceW(%lx %s %s %p %p %lx)\n",
7352 debugstr_w(pszReference), pszDeviceInterface, pulLength, ulFlags);
7353
7355 pszReference, pszDeviceInterface,
7356 pulLength, ulFlags, NULL);
7357}
7358
7359
7360/***********************************************************************
7361 * CM_Register_Device_Interface_ExA [SETUPAPI.@]
7362 */
7364WINAPI
7366 _In_ DEVINST dnDevInst,
7368 _In_opt_ LPCSTR pszReference,
7369 _Out_writes_(*pulLength) LPSTR pszDeviceInterface,
7370 _Inout_ PULONG pulLength,
7371 _In_ ULONG ulFlags,
7372 _In_opt_ HMACHINE hMachine)
7373{
7374 LPWSTR pszReferenceW = NULL;
7375 LPWSTR pszDeviceInterfaceW;
7376 ULONG ulLength;
7377 CONFIGRET ret;
7378
7379 TRACE("CM_Register_Device_Interface_ExA(%lx %s %s %p %p %lx %p)\n",
7380 dnDevInst, debugstr_guid(InterfaceClassGuid), debugstr_a(pszReference),
7381 pszDeviceInterface, pulLength, ulFlags, hMachine);
7382
7383 if (pulLength == NULL || pszDeviceInterface == NULL)
7384 return CR_INVALID_POINTER;
7385
7386 if (pszReference != NULL)
7387 {
7388 if (pSetupCaptureAndConvertAnsiArg(pszReference, &pszReferenceW))
7389 return CR_INVALID_DATA;
7390 }
7391
7392 ulLength = *pulLength;
7393
7394 pszDeviceInterfaceW = HeapAlloc(GetProcessHeap(), 0, ulLength * sizeof(WCHAR));
7395 if (pszDeviceInterfaceW == NULL)
7396 {
7398 goto Done;
7399 }
7400
7403 pszReferenceW,
7404 pszDeviceInterfaceW,
7405 &ulLength,
7406 ulFlags,
7407 hMachine);
7408 if (ret == CR_SUCCESS)
7409 {
7411 0,
7412 pszDeviceInterfaceW,
7413 ulLength,
7414 pszDeviceInterface,
7415 *pulLength,
7416 NULL,
7417 NULL) == 0)
7418 ret = CR_FAILURE;
7419 }
7420
7421 *pulLength = ulLength;
7422
7423Done:
7424 if (pszDeviceInterfaceW != NULL)
7425 HeapFree(GetProcessHeap(), 0, pszDeviceInterfaceW);
7426
7427 if (pszReferenceW != NULL)
7428 MyFree(pszReferenceW);
7429
7430 return ret;
7431}
7432
7433
7434/***********************************************************************
7435 * CM_Register_Device_Interface_ExW [SETUPAPI.@]
7436 */
7438WINAPI
7440 _In_ DEVINST dnDevInst,
7442 _In_opt_ LPCWSTR pszReference,
7443 _Out_writes_(*pulLength) LPWSTR pszDeviceInterface,
7444 _Inout_ PULONG pulLength,
7445 _In_ ULONG ulFlags,
7446 _In_opt_ HMACHINE hMachine)
7447{
7449 HSTRING_TABLE StringTable = NULL;
7450 LPWSTR lpDevInst;
7451 ULONG ulTransferLength;
7452 CONFIGRET ret;
7453
7454 TRACE("CM_Register_Device_Interface_ExW(%lx %s %s %p %p %lx %p)\n",
7455 dnDevInst, debugstr_guid(InterfaceClassGuid), debugstr_w(pszReference),
7456 pszDeviceInterface, pulLength, ulFlags, hMachine);
7457
7458 if (dnDevInst == 0)
7459 return CR_INVALID_DEVNODE;
7460
7461 if (InterfaceClassGuid == NULL ||
7462 pszDeviceInterface == NULL ||
7463 pulLength == NULL)
7464 return CR_INVALID_POINTER;
7465
7466 if (ulFlags != 0)
7467 return CR_INVALID_FLAG;
7468
7469 if (hMachine != NULL)
7470 {
7471 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7472 if (BindingHandle == NULL)
7473 return CR_FAILURE;
7474
7475 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7476 if (StringTable == 0)
7477 return CR_FAILURE;
7478 }
7479 else
7480 {
7481 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7482 return CR_FAILURE;
7483 }
7484
7485 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7486 if (lpDevInst == NULL)
7487 return CR_INVALID_DEVNODE;
7488
7489 ulTransferLength = *pulLength;
7490
7492 {
7494 lpDevInst,
7496 (LPWSTR)pszReference,
7497 pszDeviceInterface,
7498 pulLength,
7499 &ulTransferLength,
7500 0);
7501 }
7503 {
7505 }
7507
7508 return ret;
7509}
7510
7511
7512/***********************************************************************
7513 * CM_Remove_SubTree [SETUPAPI.@]
7514 *
7515 * This function is obsolete in Windows XP and above.
7516 */
7518WINAPI
7520 _In_ DEVINST dnAncestor,
7521 _In_ ULONG ulFlags)
7522{
7523 TRACE("CM_Remove_SubTree(%lx %lx)\n",
7524 dnAncestor, ulFlags);
7525
7527}
7528
7529
7530/***********************************************************************
7531 * CM_Remove_SubTree_Ex [SETUPAPI.@]
7532 *
7533 * This function is obsolete in Windows XP and above.
7534 */
7536WINAPI
7538 _In_ DEVINST dnAncestor,
7539 _In_ ULONG ulFlags,
7540 _In_opt_ HMACHINE hMachine)
7541{
7542 TRACE("CM_Remove_SubTree_Ex(%lx %lx %p)\n",
7543 dnAncestor, ulFlags, hMachine);
7544
7546}
7547
7548
7549/***********************************************************************
7550 * CM_Request_Device_EjectA [SETUPAPI.@]
7551 */
7553WINAPI
7555 _In_ DEVINST dnDevInst,
7556 _Out_opt_ PPNP_VETO_TYPE pVetoType,
7557 _Out_writes_opt_(ulNameLength) LPSTR pszVetoName,
7558 _In_ ULONG ulNameLength,
7559 _In_ ULONG ulFlags)
7560{
7561 TRACE("CM_Request_Device_EjectA(%lx %p %p %lu %lx)\n",
7562 dnDevInst, pVetoType, pszVetoName, ulNameLength, ulFlags);
7563
7564 return CM_Request_Device_Eject_ExA(dnDevInst, pVetoType, pszVetoName,
7565 ulNameLength, ulFlags, NULL);
7566}
7567
7568
7569/***********************************************************************
7570 * CM_Request_Device_EjectW [SETUPAPI.@]
7571 */
7573WINAPI
7575 _In_ DEVINST dnDevInst,
7576 _Out_opt_ PPNP_VETO_TYPE pVetoType,
7577 _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName,
7578 _In_ ULONG ulNameLength,
7579 _In_ ULONG ulFlags)
7580{
7581 TRACE("CM_Request_Device_EjectW(%lx %p %p %lu %lx)\n",
7582 dnDevInst, pVetoType, pszVetoName, ulNameLength, ulFlags);
7583
7584 return CM_Request_Device_Eject_ExW(dnDevInst, pVetoType, pszVetoName,
7585 ulNameLength, ulFlags, NULL);
7586}
7587
7588
7589/***********************************************************************
7590 * CM_Request_Device_Eject_ExA [SETUPAPI.@]
7591 */
7593WINAPI
7595 _In_ DEVINST dnDevInst,
7596 _Out_opt_ PPNP_VETO_TYPE pVetoType,
7597 _Out_writes_opt_(ulNameLength) LPSTR pszVetoName,
7598 _In_ ULONG ulNameLength,
7599 _In_ ULONG ulFlags,
7600 _In_opt_ HMACHINE hMachine)
7601{
7602 LPWSTR lpLocalVetoName = NULL;
7603 CONFIGRET ret;
7604
7605 TRACE("CM_Request_Device_Eject_ExA(%lx %p %p %lu %lx %p)\n",
7606 dnDevInst, pVetoType, pszVetoName, ulNameLength, ulFlags, hMachine);
7607
7608 if (ulNameLength != 0)
7609 {
7610 if (pszVetoName == NULL)
7611 return CR_INVALID_POINTER;
7612
7613 lpLocalVetoName = HeapAlloc(GetProcessHeap(), 0, ulNameLength * sizeof(WCHAR));
7614 if (lpLocalVetoName == NULL)
7615 return CR_OUT_OF_MEMORY;
7616 }
7617
7618 ret = CM_Request_Device_Eject_ExW(dnDevInst, pVetoType, lpLocalVetoName,
7619 ulNameLength, ulFlags, hMachine);
7620 if (ret == CR_REMOVE_VETOED && ulNameLength != 0)
7621 {
7623 0,
7624 lpLocalVetoName,
7625 ulNameLength,
7626 pszVetoName,
7627 ulNameLength,
7628 NULL,
7629 NULL) == 0)
7630 ret = CR_FAILURE;
7631 }
7632
7633 HeapFree(GetProcessHeap(), 0, lpLocalVetoName);
7634
7635 return ret;
7636}
7637
7638
7639/***********************************************************************
7640 * CM_Request_Device_Eject_ExW [SETUPAPI.@]
7641 */
7643WINAPI
7645 _In_ DEVINST dnDevInst,
7646 _Out_opt_ PPNP_VETO_TYPE pVetoType,
7647 _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName,
7648 _In_ ULONG ulNameLength,
7649 _In_ ULONG ulFlags,
7650 _In_opt_ HMACHINE hMachine)
7651{
7653 HSTRING_TABLE StringTable = NULL;
7654 LPWSTR lpDevInst;
7655 CONFIGRET ret;
7656
7657 TRACE("CM_Request_Device_Eject_ExW(%lx %p %p %lu %lx %p)\n",
7658 dnDevInst, pVetoType, pszVetoName, ulNameLength, ulFlags, hMachine);
7659
7660 if (dnDevInst == 0)
7661 return CR_INVALID_DEVNODE;
7662
7663 if (ulFlags != 0)
7664 return CR_INVALID_FLAG;
7665
7666 if (pszVetoName == NULL && ulNameLength != 0)
7667 return CR_INVALID_POINTER;
7668
7669 /* Windows 2003 SP2 ignores pszVetoName when ulNameLength is zero
7670 * and behaves like when pszVetoName is NULL */
7671 if (ulNameLength == 0)
7672 pszVetoName = NULL;
7673
7674 if (hMachine != NULL)
7675 {
7676 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7677 if (BindingHandle == NULL)
7678 return CR_FAILURE;
7679
7680 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7681 if (StringTable == 0)
7682 return CR_FAILURE;
7683 }
7684 else
7685 {
7686 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7687 return CR_FAILURE;
7688 }
7689
7690 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7691 if (lpDevInst == NULL)
7692 return CR_INVALID_DEVNODE;
7693
7695 {
7697 lpDevInst,
7698 pVetoType,
7699 pszVetoName,
7700 ulNameLength,
7701 ulFlags);
7702 }
7704 {
7706 }
7708
7709 return ret;
7710}
7711
7712
7713/***********************************************************************
7714 * CM_Request_Eject_PC [SETUPAPI.@]
7715 */
7717WINAPI
7719{
7720 TRACE("CM_Request_Eject_PC()\n");
7721
7723}
7724
7725
7726/***********************************************************************
7727 * CM_Request_Eject_PC_Ex [SETUPAPI.@]
7728 */
7730WINAPI
7732 _In_opt_ HMACHINE hMachine)
7733{
7735 CONFIGRET ret;
7736
7737 TRACE("CM_Request_Eject_PC_Ex(%p)\n", hMachine);
7738
7739 if (hMachine != NULL)
7740 {
7741 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7742 if (BindingHandle == NULL)
7743 return CR_FAILURE;
7744 }
7745 else
7746 {
7748 return CR_FAILURE;
7749 }
7750
7752 {
7754 }
7756 {
7758 }
7760
7761 return ret;
7762}
7763
7764
7765/***********************************************************************
7766 * CM_Run_Detection [SETUPAPI.@]
7767 */
7769WINAPI
7771 _In_ ULONG ulFlags)
7772{
7773 TRACE("CM_Run_Detection(%lx)\n", ulFlags);
7774
7775 return CM_Run_Detection_Ex(ulFlags, NULL);
7776}
7777
7778
7779/***********************************************************************
7780 * CM_Run_Detection_Ex [SETUPAPI.@]
7781 */
7783WINAPI
7785 _In_ ULONG ulFlags,
7786 _In_opt_ HMACHINE hMachine)
7787{
7789 CONFIGRET ret;
7790
7791 TRACE("CM_Run_Detection_Ex(%lx %p)\n",
7792 ulFlags, hMachine);
7793
7794 if (!pSetupIsUserAdmin())
7795 return CR_ACCESS_DENIED;
7796
7797 if (ulFlags & ~CM_DETECT_BITS)
7798 return CR_INVALID_FLAG;
7799
7800 if (hMachine != NULL)
7801 {
7802 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7803 if (BindingHandle == NULL)
7804 return CR_FAILURE;
7805 }
7806 else
7807 {
7809 return CR_FAILURE;
7810 }
7811
7813 {
7815 ulFlags);
7816 }
7818 {
7820 }
7822
7823 return ret;
7824}
7825
7826
7827/***********************************************************************
7828 * CM_Set_Class_Registry_PropertyA [SETUPAPI.@]
7829 */
7831WINAPI
7833 _In_ LPGUID ClassGuid,
7834 _In_ ULONG ulProperty,
7836 _In_ ULONG ulLength,
7837 _In_ ULONG ulFlags,
7838 _In_opt_ HMACHINE hMachine)
7839{
7841 ULONG ulType;
7842 CONFIGRET ret;
7843
7844 TRACE("CM_Set_Class_Registry_PropertyA(%p %lx %p %lu %lx %p)\n",
7845 ClassGuid, ulProperty, Buffer, ulLength, ulFlags, hMachine);
7846
7847 if (ClassGuid == NULL)
7848 return CR_INVALID_POINTER;
7849
7850 if ((Buffer == NULL) && (ulLength != 0))
7851 return CR_INVALID_POINTER;
7852
7853 if (ulFlags != 0)
7854 return CR_INVALID_FLAG;
7855
7856 if (Buffer == NULL)
7857 {
7859 ulProperty,
7860 Buffer,
7861 ulLength,
7862 ulFlags,
7863 hMachine);
7864 }
7865 else
7866 {
7867 /* Get property type */
7868 ulType = GetRegistryPropertyType(ulProperty);
7869
7870 /* Allocate buffer if needed */
7871 if ((ulType == REG_SZ) || (ulType == REG_MULTI_SZ))
7872 {
7873 lpBuffer = MyMalloc(ulLength * sizeof(WCHAR));
7874 if (lpBuffer == NULL)
7875 {
7877 }
7878 else
7879 {
7881 ulLength, lpBuffer, ulLength))
7882 {
7884 ret = CR_FAILURE;
7885 }
7886 else
7887 {
7889 ulProperty,
7890 lpBuffer,
7891 ulLength * sizeof(WCHAR),
7892 ulFlags,
7893 hMachine);
7895 }
7896 }
7897 }
7898 else
7899 {
7901 ulProperty,
7902 Buffer,
7903 ulLength,
7904 ulFlags,
7905 hMachine);
7906 }
7907
7908 }
7909
7910 return ret;
7911}
7912
7913
7914/***********************************************************************
7915 * CM_Set_Class_Registry_PropertyW [SETUPAPI.@]
7916 */
7918WINAPI
7920 _In_ LPGUID ClassGuid,
7921 _In_ ULONG ulProperty,
7923 _In_ ULONG ulLength,
7924 _In_ ULONG ulFlags,
7925 _In_opt_ HMACHINE hMachine)
7926{
7928 WCHAR szGuidString[PNP_MAX_GUID_STRING_LEN + 1];
7929 ULONG ulType = 0;
7930 PSECURITY_DESCRIPTOR pSecurityDescriptor = NULL;
7931 ULONG SecurityDescriptorSize = 0;
7932 CONFIGRET ret;
7933
7934 TRACE("CM_Set_Class_Registry_PropertyW(%p %lx %p %lu %lx %p)\n",
7935 ClassGuid, ulProperty, Buffer, ulLength, ulFlags, hMachine);
7936
7937 if (ClassGuid == NULL)
7938 return CR_INVALID_POINTER;
7939
7940 if ((Buffer == NULL) && (ulLength != 0))
7941 return CR_INVALID_POINTER;
7942
7943 if (ulFlags != 0)
7944 return CR_INVALID_FLAG;
7945
7946 if (pSetupStringFromGuid(ClassGuid,
7947 szGuidString,
7949 return CR_INVALID_DATA;
7950
7951 if ((ulProperty < CM_CRP_MIN) || (ulProperty > CM_CRP_MAX))
7952 return CR_INVALID_PROPERTY;
7953
7954 if (hMachine != NULL)
7955 {
7956 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7957 if (BindingHandle == NULL)
7958 return CR_FAILURE;
7959 }
7960 else
7961 {
7963 return CR_FAILURE;
7964 }
7965
7966 ulType = GetRegistryPropertyType(ulProperty);
7967 if ((ulType == REG_DWORD) && (ulLength != sizeof(DWORD)))
7968 return CR_INVALID_DATA;
7969
7970 if (ulProperty == CM_CRP_SECURITY_SDS)
7971 {
7972 if (ulLength != 0)
7973 {
7976 &pSecurityDescriptor,
7977 &SecurityDescriptorSize))
7978 {
7979 ERR("ConvertStringSecurityDescriptorToSecurityDescriptorW() failed (Error %lu)\n", GetLastError());
7980 return CR_INVALID_DATA;
7981 }
7982
7983 Buffer = (PCVOID)pSecurityDescriptor;
7984 ulLength = SecurityDescriptorSize;
7985 }
7986
7987 ulProperty = CM_CRP_SECURITY;
7989 }
7990
7992 {
7994 szGuidString,
7995 ulProperty,
7996 ulType,
7997 (LPBYTE)Buffer,
7998 ulLength,
7999 ulFlags);
8000 }
8002 {
8004 }
8006
8007 if (pSecurityDescriptor)
8008 LocalFree(pSecurityDescriptor);
8009
8010 return ret;
8011}
8012
8013
8014/***********************************************************************
8015 * CM_Set_DevNode_Problem [SETUPAPI.@]
8016 */
8018WINAPI
8020 _In_ DEVINST dnDevInst,
8021 _In_ ULONG ulProblem,
8022 _In_ ULONG ulFlags)
8023{
8024 TRACE("CM_Set_DevNode_Problem(%lx %lx %lx)\n",
8025 dnDevInst, ulProblem, ulFlags);
8026
8027 return CM_Set_DevNode_Problem_Ex(dnDevInst, ulProblem, ulFlags, NULL);
8028}
8029
8030
8031/***********************************************************************
8032 * CM_Set_DevNode_Problem_Ex [SETUPAPI.@]
8033 */
8035WINAPI
8037 _In_ DEVINST dnDevInst,
8038 _In_ ULONG ulProblem,
8039 _In_ ULONG ulFlags,
8040 _In_opt_ HMACHINE hMachine)
8041{
8043 HSTRING_TABLE StringTable = NULL;
8044 LPWSTR lpDevInst;
8045 CONFIGRET ret;
8046
8047 TRACE("CM_Set_DevNode_Problem_Ex(%lx %lx %lx %p)\n",
8048 dnDevInst, ulProblem, ulFlags, hMachine);
8049
8050 if (dnDevInst == 0)
8051 return CR_INVALID_DEVNODE;
8052
8053 if (ulFlags & ~CM_SET_DEVNODE_PROBLEM_BITS)
8054 return CR_INVALID_FLAG;
8055
8056 if (hMachine != NULL)
8057 {
8058 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8059 if (BindingHandle == NULL)
8060 return CR_FAILURE;
8061
8062 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
8063 if (StringTable == 0)
8064 return CR_FAILURE;
8065 }
8066 else
8067 {
8068 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
8069 return CR_FAILURE;
8070 }
8071
8072 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
8073 if (lpDevInst == NULL)
8074 return CR_INVALID_DEVNODE;
8075
8077 {
8079 lpDevInst,
8080 ulProblem,
8081 ulFlags);
8082 }
8084 {
8086 }
8088
8089 return ret;
8090}
8091
8092
8093/***********************************************************************
8094 * CM_Set_DevNode_Registry_PropertyA [SETUPAPI.@]
8095 */
8097WINAPI
8099 _In_ DEVINST dnDevInst,
8100 _In_ ULONG ulProperty,
8102 _In_ ULONG ulLength,
8103 _In_ ULONG ulFlags)
8104{
8105 TRACE("CM_Set_DevNode_Registry_PropertyA(%lx %lu %p %lx %lx)\n",
8106 dnDevInst, ulProperty, Buffer, ulLength, ulFlags);
8107
8108 return CM_Set_DevNode_Registry_Property_ExA(dnDevInst, ulProperty,
8109 Buffer, ulLength,
8110 ulFlags, NULL);
8111}
8112
8113
8114/***********************************************************************
8115 * CM_Set_DevNode_Registry_PropertyW [SETUPAPI.@]
8116 */
8118WINAPI
8120 _In_ DEVINST dnDevInst,
8121 _In_ ULONG ulProperty,
8123 _In_ ULONG ulLength,
8124 _In_ ULONG ulFlags)
8125{
8126 TRACE("CM_Set_DevNode_Registry_PropertyW(%lx %lu %p %lx %lx)\n",
8127 dnDevInst, ulProperty, Buffer, ulLength, ulFlags);
8128
8129 return CM_Set_DevNode_Registry_Property_ExW(dnDevInst, ulProperty,
8130 Buffer, ulLength,
8131 ulFlags, NULL);
8132}
8133
8134
8135/***********************************************************************
8136 * CM_Set_DevNode_Registry_Property_ExA [SETUPAPI.@]
8137 */
8139WINAPI
8141 _In_ DEVINST dnDevInst,
8142 _In_ ULONG ulProperty,
8144 _In_ ULONG ulLength,
8145 _In_ ULONG ulFlags,
8146 _In_opt_ HMACHINE hMachine)
8147{
8150 ULONG ulType;
8151
8152 FIXME("CM_Set_DevNode_Registry_Property_ExA(%lx %lu %p %lx %lx %p)\n",
8153 dnDevInst, ulProperty, Buffer, ulLength, ulFlags, hMachine);
8154
8155 if (Buffer == NULL && ulLength != 0)
8156 return CR_INVALID_POINTER;
8157
8158 if (ulProperty < CM_DRP_MIN || ulProperty > CM_DRP_MAX)
8159 return CR_INVALID_PROPERTY;
8160
8161 if (Buffer == NULL)
8162 {
8164 ulProperty,
8165 NULL,
8166 0,
8167 ulFlags,
8168 hMachine);
8169 }
8170 else
8171 {
8172 /* Get property type */
8173 ulType = GetRegistryPropertyType(ulProperty);
8174
8175 /* Allocate buffer if needed */
8176 if (ulType == REG_SZ ||
8178 {
8179 lpBuffer = MyMalloc(ulLength * sizeof(WCHAR));
8180 if (lpBuffer == NULL)
8181 {
8183 }
8184 else
8185 {
8187 ulLength, lpBuffer, ulLength))
8188 {
8190 ret = CR_FAILURE;
8191 }
8192 else
8193 {
8195 ulProperty,
8196 lpBuffer,
8197 ulLength * sizeof(WCHAR),
8198 ulFlags,
8199 hMachine);
8201 }
8202 }
8203 }
8204 else
8205 {
8207 ulProperty,
8208 Buffer,
8209 ulLength,
8210 ulFlags,
8211 hMachine);
8212 }
8213
8215 }
8216
8217 return ret;
8218}
8219
8220
8221/***********************************************************************
8222 * CM_Set_DevNode_Registry_Property_ExW [SETUPAPI.@]
8223 */
8225WINAPI
8227 _In_ DEVINST dnDevInst,
8228 _In_ ULONG ulProperty,
8230 _In_ ULONG ulLength,
8231 _In_ ULONG ulFlags,
8232 _In_opt_ HMACHINE hMachine)
8233{
8235 HSTRING_TABLE StringTable = NULL;
8236 LPWSTR lpDevInst;
8237 ULONG ulType;
8238 CONFIGRET ret;
8239
8240 TRACE("CM_Set_DevNode_Registry_Property_ExW(%lx %lu %p %lx %lx %p)\n",
8241 dnDevInst, ulProperty, Buffer, ulLength, ulFlags, hMachine);
8242
8243 if (dnDevInst == 0)
8244 return CR_INVALID_DEVNODE;
8245
8246 if (ulProperty < CM_DRP_MIN || ulProperty > CM_DRP_MAX)
8247 return CR_INVALID_PROPERTY;
8248
8249 if (Buffer != NULL && ulLength == 0)
8250 return CR_INVALID_POINTER;
8251
8252 if (ulFlags != 0)
8253 return CR_INVALID_FLAG;
8254
8255 if (hMachine != NULL)
8256 {
8257 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8258 if (BindingHandle == NULL)
8259 return CR_FAILURE;
8260
8261 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
8262 if (StringTable == 0)
8263 return CR_FAILURE;
8264 }
8265 else
8266 {
8267 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
8268 return CR_FAILURE;
8269 }
8270
8271 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
8272 if (lpDevInst == NULL)
8273 return CR_INVALID_DEVNODE;
8274
8275 /* Get property type */
8276 ulType = GetRegistryPropertyType(ulProperty);
8277
8279 {
8281 lpDevInst,
8282 ulProperty,
8283 ulType,
8284 (BYTE *)Buffer,
8285 ulLength,
8286 ulFlags);
8287 }
8289 {
8291 }
8293
8294 return ret;
8295}
8296
8297
8298/***********************************************************************
8299 * CM_Set_HW_Prof [SETUPAPI.@]
8300 */
8302WINAPI
8304 _In_ ULONG ulHardwareProfile,
8305 _In_ ULONG ulFlags)
8306{
8307 TRACE("CM_Set_HW_Prof(%lu %lx)\n",
8308 ulHardwareProfile, ulFlags);
8309
8310 return CM_Set_HW_Prof_Ex(ulHardwareProfile, ulFlags, NULL);
8311}
8312
8313
8314/***********************************************************************
8315 * CM_Set_HW_Prof_Ex [SETUPAPI.@]
8316 */
8318WINAPI
8320 _In_ ULONG ulHardwareProfile,
8321 _In_ ULONG ulFlags,
8322 _In_opt_ HMACHINE hMachine)
8323{
8325 CONFIGRET ret;
8326
8327 TRACE("CM_Set_HW_Prof_Ex(%lu %lx %p)\n",
8328 ulHardwareProfile, ulFlags, hMachine);
8329
8330 if (!pSetupIsUserAdmin())
8331 return CR_ACCESS_DENIED;
8332
8333 if (ulFlags != 0)
8334 return CR_INVALID_FLAG;
8335
8336 if (hMachine != NULL)
8337 {
8338 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8339 if (BindingHandle == NULL)
8340 return CR_FAILURE;
8341 }
8342 else
8343 {
8345 return CR_FAILURE;
8346 }
8347
8349 {
8350 ret = PNP_SetHwProf(BindingHandle, ulHardwareProfile, ulFlags);
8351 }
8353 {
8355 }
8357
8358 return ret;
8359}
8360
8361
8362/***********************************************************************
8363 * CM_Set_HW_Prof_FlagsA [SETUPAPI.@]
8364 */
8366WINAPI
8368 _In_ DEVINSTID_A szDevInstName,
8369 _In_ ULONG ulConfig,
8370 _In_ ULONG ulValue,
8371 _In_ ULONG ulFlags)
8372{
8373 TRACE("CM_Set_HW_Prof_FlagsA(%s %lu %lu %lx)\n",
8374 debugstr_a(szDevInstName), ulConfig, ulValue, ulFlags);
8375
8376 return CM_Set_HW_Prof_Flags_ExA(szDevInstName, ulConfig, ulValue,
8377 ulFlags, NULL);
8378}
8379
8380
8381/***********************************************************************
8382 * CM_Set_HW_Prof_FlagsW [SETUPAPI.@]
8383 */
8385WINAPI
8387 _In_ DEVINSTID_W szDevInstName,
8388 _In_ ULONG ulConfig,
8389 _In_ ULONG ulValue,
8390 _In_ ULONG ulFlags)
8391{
8392 TRACE("CM_Set_HW_Prof_FlagsW(%s %lu %lu %lx)\n",
8393 debugstr_w(szDevInstName), ulConfig, ulValue, ulFlags);
8394
8395 return CM_Set_HW_Prof_Flags_ExW(szDevInstName, ulConfig, ulValue,
8396 ulFlags, NULL);
8397}
8398
8399
8400/***********************************************************************
8401 * CM_Set_HW_Prof_Flags_ExA [SETUPAPI.@]
8402 */
8404WINAPI
8406 _In_ DEVINSTID_A szDevInstName,
8407 _In_ ULONG ulConfig,
8408 _In_ ULONG ulValue,
8409 _In_ ULONG ulFlags,
8410 _In_opt_ HMACHINE hMachine)
8411{
8412 DEVINSTID_W pszDevIdW = NULL;
8414
8415 TRACE("CM_Set_HW_Prof_Flags_ExA(%s %lu %lu %lx %p)\n",
8416 debugstr_a(szDevInstName), ulConfig, ulValue, ulFlags, hMachine);
8417
8418 if (szDevInstName != NULL)
8419 {
8420 if (pSetupCaptureAndConvertAnsiArg(szDevInstName, &pszDevIdW))
8421 return CR_INVALID_DEVICE_ID;
8422 }
8423
8424 ret = CM_Set_HW_Prof_Flags_ExW(pszDevIdW, ulConfig, ulValue,
8425 ulFlags, hMachine);
8426
8427 if (pszDevIdW != NULL)
8428 MyFree(pszDevIdW);
8429
8430 return ret;
8431}
8432
8433
8434/***********************************************************************
8435 * CM_Set_HW_Prof_Flags_ExW [SETUPAPI.@]
8436 */
8438WINAPI
8440 _In_ DEVINSTID_W szDevInstName,
8441 _In_ ULONG ulConfig,
8442 _In_ ULONG ulValue,
8443 _In_ ULONG ulFlags,
8444 _In_opt_ HMACHINE hMachine)
8445{
8447 CONFIGRET ret;
8448
8449 FIXME("CM_Set_HW_Prof_Flags_ExW(%s %lu %lu %lx %p)\n",
8450 debugstr_w(szDevInstName), ulConfig, ulValue, ulFlags, hMachine);
8451
8452 if (szDevInstName == NULL)
8453 return CR_INVALID_POINTER;
8454
8455 if (ulFlags & ~ CM_SET_HW_PROF_FLAGS_BITS)
8456 return CR_INVALID_FLAG;
8457
8458 /* FIXME: Check whether szDevInstName is valid */
8459
8460 if (hMachine != NULL)
8461 {
8462 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8463 if (BindingHandle == NULL)
8464 return CR_FAILURE;
8465 }
8466 else
8467 {
8469 return CR_FAILURE;
8470 }
8471
8473 {
8474 ret = PNP_HwProfFlags(BindingHandle, PNP_SET_HWPROFFLAGS, szDevInstName,
8475 ulConfig, &ulValue, NULL, NULL, 0, 0);
8476 }
8478 {
8480 }
8482
8483 return ret;
8484}
8485
8486
8487/***********************************************************************
8488 * CM_Setup_DevNode [SETUPAPI.@]
8489 */
8491WINAPI
8493 _In_ DEVINST dnDevInst,
8494 _In_ ULONG ulFlags)
8495{
8496 TRACE("CM_Setup_DevNode(%lx %lx)\n",
8497 dnDevInst, ulFlags);
8498
8499 return CM_Setup_DevNode_Ex(dnDevInst, ulFlags, NULL);
8500}
8501
8502
8503/***********************************************************************
8504 * CM_Setup_DevNode_Ex [SETUPAPI.@]
8505 */
8507WINAPI
8509 _In_ DEVINST dnDevInst,
8510 _In_ ULONG ulFlags,
8511 _In_opt_ HMACHINE hMachine)
8512{
8514 HSTRING_TABLE StringTable = NULL;
8515 LPWSTR lpDevInst;
8516 CONFIGRET ret;
8517
8518 FIXME("CM_Setup_DevNode_Ex(%lx %lx %p)\n",
8519 dnDevInst, ulFlags, hMachine);
8520
8521 if (!pSetupIsUserAdmin())
8522 return CR_ACCESS_DENIED;
8523
8524 if (dnDevInst == 0)
8525 return CR_INVALID_DEVNODE;
8526
8527 if (ulFlags & ~CM_SETUP_BITS)
8528 return CR_INVALID_FLAG;
8529
8530 if (hMachine != NULL)
8531 {
8532 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8533 if (BindingHandle == NULL)
8534 return CR_FAILURE;
8535
8536 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
8537 if (StringTable == 0)
8538 return CR_FAILURE;
8539 }
8540 else
8541 {
8542 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
8543 return CR_FAILURE;
8544 }
8545
8546 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
8547 if (lpDevInst == NULL)
8548 return CR_INVALID_DEVNODE;
8549
8551 {
8553 PNP_DEVINST_SETUP,
8554 ulFlags,
8555 lpDevInst,
8556 NULL);
8557 }
8559 {
8561 }
8563
8564 return ret;
8565}
8566
8567
8568/***********************************************************************
8569 * CM_Test_Range_Available [SETUPAPI.@]
8570 */
8572WINAPI
8574 _In_ DWORDLONG ullStartValue,
8575 _In_ DWORDLONG ullEndValue,
8576 _In_ RANGE_LIST rlh,
8577 _In_ ULONG ulFlags)
8578{
8579 PINTERNAL_RANGE_LIST pRangeList;
8580 PINTERNAL_RANGE pRange;
8581 PLIST_ENTRY ListEntry;
8583
8584 FIXME("CM_Test_Range_Available(%I64u %I64u %p %lx)\n",
8585 ullStartValue, ullEndValue, rlh, ulFlags);
8586
8587 pRangeList = (PINTERNAL_RANGE_LIST)rlh;
8588
8589 if (!IsValidRangeList(pRangeList))
8590 return CR_INVALID_RANGE_LIST;
8591
8592 if (ulFlags != 0)
8593 return CR_INVALID_FLAG;
8594
8595 if (ullStartValue > ullEndValue)
8596 return CR_INVALID_RANGE;
8597
8598 /* Lock the range list */
8599 WaitForSingleObject(pRangeList->hMutex, INFINITE);
8600
8601 /* Check the ranges */
8602 ListEntry = &pRangeList->ListHead;
8603 while (ListEntry->Flink == &pRangeList->ListHead)
8604 {
8605 pRange = CONTAINING_RECORD(ListEntry, INTERNAL_RANGE, ListEntry);
8606
8607 /* Check if the start value is within the current range */
8608 if ((ullStartValue >= pRange->ullStart) && (ullStartValue <= pRange->ullEnd))
8609 {
8610 ret = CR_FAILURE;
8611 break;
8612 }
8613
8614 /* Check if the end value is within the current range */
8615 if ((ullEndValue >= pRange->ullStart) && (ullEndValue <= pRange->ullEnd))
8616 {
8617 ret = CR_FAILURE;
8618 break;
8619 }
8620
8621 /* Check if the current range lies inside of the start-end interval */
8622 if ((ullStartValue <= pRange->ullStart) && (ullEndValue >= pRange->ullEnd))
8623 {
8624 ret = CR_FAILURE;
8625 break;
8626 }
8627
8628 ListEntry = ListEntry->Flink;
8629 }
8630
8631 /* Unlock the range list */
8632 ReleaseMutex(pRangeList->hMutex);
8633
8634 return ret;
8635}
8636
8637
8638/***********************************************************************
8639 * CM_Uninstall_DevNode [SETUPAPI.@]
8640 */
8642WINAPI
8644 _In_ DEVINST dnPhantom,
8645 _In_ ULONG ulFlags)
8646{
8647 TRACE("CM_Uninstall_DevNode(%lx %lx)\n",
8648 dnPhantom, ulFlags);
8649
8650 return CM_Uninstall_DevNode_Ex(dnPhantom, ulFlags, NULL);
8651}
8652
8653
8654/***********************************************************************
8655 * CM_Uninstall_DevNode_Ex [SETUPAPI.@]
8656 */
8658WINAPI
8660 _In_ DEVINST dnPhantom,
8661 _In_ ULONG ulFlags,
8662 _In_opt_ HMACHINE hMachine)
8663{
8665 HSTRING_TABLE StringTable = NULL;
8666 LPWSTR lpDevInst;
8667 CONFIGRET ret;
8668
8669 TRACE("CM_Uninstall_DevNode_Ex(%lx %lx %p)\n",
8670 dnPhantom, ulFlags, hMachine);
8671
8672 if (dnPhantom == 0)
8673 return CR_INVALID_DEVNODE;
8674
8675 if (ulFlags != 0)
8676 return CR_INVALID_FLAG;
8677
8678 if (hMachine != NULL)
8679 {
8680 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8681 if (BindingHandle == NULL)
8682 return CR_FAILURE;
8683
8684 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
8685 if (StringTable == 0)
8686 return CR_FAILURE;
8687 }
8688 else
8689 {
8690 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
8691 return CR_FAILURE;
8692 }
8693
8694 lpDevInst = pSetupStringTableStringFromId(StringTable, dnPhantom);
8695 if (lpDevInst == NULL)
8696 return CR_INVALID_DEVNODE;
8697
8699 {
8701 lpDevInst,
8702 ulFlags);
8703 }
8705 {
8707 }
8709
8710 return ret;
8711}
8712
8713
8714/***********************************************************************
8715 * CM_Unregister_Device_InterfaceA [SETUPAPI.@]
8716 */
8718WINAPI
8720 _In_ LPCSTR pszDeviceInterface,
8721 _In_ ULONG ulFlags)
8722{
8723 TRACE("CM_Unregister_Device_InterfaceA(%s %lx)\n",
8724 debugstr_a(pszDeviceInterface), ulFlags);
8725
8726 return CM_Unregister_Device_Interface_ExA(pszDeviceInterface,
8727 ulFlags, NULL);
8728}
8729
8730
8731/***********************************************************************
8732 * CM_Unregister_Device_InterfaceW [SETUPAPI.@]
8733 */
8735WINAPI
8737 _In_ LPCWSTR pszDeviceInterface,
8738 _In_ ULONG ulFlags)
8739{
8740 TRACE("CM_Unregister_Device_InterfaceW(%s %lx)\n",
8741 debugstr_w(pszDeviceInterface), ulFlags);
8742
8743 return CM_Unregister_Device_Interface_ExW(pszDeviceInterface,
8744 ulFlags, NULL);
8745}
8746
8747
8748/***********************************************************************
8749 * CM_Unregister_Device_Interface_ExA [SETUPAPI.@]
8750 */
8752WINAPI
8754 _In_ LPCSTR pszDeviceInterface,
8755 _In_ ULONG ulFlags,
8756 _In_opt_ HMACHINE hMachine)
8757{
8758 LPWSTR pszDeviceInterfaceW = NULL;
8759 CONFIGRET ret;
8760
8761 TRACE("CM_Unregister_Device_Interface_ExA(%s %lx %p)\n",
8762 debugstr_a(pszDeviceInterface), ulFlags, hMachine);
8763
8764 if (pszDeviceInterface == NULL)
8765 return CR_INVALID_POINTER;
8766
8767 if (pSetupCaptureAndConvertAnsiArg(pszDeviceInterface, &pszDeviceInterfaceW))
8768 return CR_INVALID_DATA;
8769
8770 ret = CM_Unregister_Device_Interface_ExW(pszDeviceInterfaceW,
8771 ulFlags, hMachine);
8772
8773 if (pszDeviceInterfaceW != NULL)
8774 MyFree(pszDeviceInterfaceW);
8775
8776 return ret;
8777}
8778
8779
8780/***********************************************************************
8781 * CM_Unregister_Device_Interface_ExW [SETUPAPI.@]
8782 */
8784WINAPI
8786 _In_ LPCWSTR pszDeviceInterface,
8787 _In_ ULONG ulFlags,
8788 _In_opt_ HMACHINE hMachine)
8789{
8791 CONFIGRET ret;
8792
8793 TRACE("CM_Unregister_Device_Interface_ExW(%s %lx %p)\n",
8794 debugstr_w(pszDeviceInterface), ulFlags, hMachine);
8795
8796 if (pszDeviceInterface == NULL)
8797 return CR_INVALID_POINTER;
8798
8799 if (ulFlags != 0)
8800 return CR_INVALID_FLAG;
8801
8802 if (hMachine != NULL)
8803 {
8804 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8805 if (BindingHandle == NULL)
8806 return CR_FAILURE;
8807 }
8808 else
8809 {
8811 return CR_FAILURE;
8812 }
8813
8815 {
8817 (LPWSTR)pszDeviceInterface,
8818 ulFlags);
8819 }
8821 {
8823 }
8825
8826 return ret;
8827}
static SERVICE_STATUS_HANDLE(WINAPI *pRegisterServiceCtrlHandlerExA)(LPCSTR
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
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_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_UnregisterDeviceClassAssociation(handle_t hBinding, LPWSTR pszInterfaceDevice, DWORD ulFlags)
Definition: rpcserver.c:2762
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_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
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
DWORD WINAPI PNP_UninstallDevInst(handle_t hBinding, LPWSTR pDeviceID, DWORD ulFlags)
Definition: rpcserver.c:3620
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
DWORD WINAPI PNP_DeviceInstanceAction(handle_t hBinding, DWORD ulMajorAction, DWORD ulMinorAction, LPWSTR pszDeviceInstance1, LPWSTR pszDeviceInstance2)
Definition: rpcserver.c:3414
DWORD WINAPI PNP_RegisterDriver(handle_t hBinding, LPWSTR pszDeviceID, DWORD ulFlags)
Definition: rpcserver.c:3782
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
DWORD WINAPI PNP_DisableDevInst(handle_t hBinding, LPWSTR pDeviceID, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, DWORD ulNameLength, DWORD ulFlags)
Definition: rpcserver.c:3590
DWORD WINAPI PNP_GetClassName(handle_t hBinding, LPWSTR pszClassGuid, LPWSTR Buffer, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
Definition: rpcserver.c:2542
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_GetLogConfPriority(handle_t hBinding, LPWSTR pDeviceID, DWORD ulType, DWORD ulTag, DWORD *pPriority, DWORD ulFlags)
Definition: rpcserver.c:4708
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
DWORD WINAPI PNP_RequestEjectPC(handle_t hBinding)
Definition: rpcserver.c:3958
DWORD WINAPI PNP_CreateDevInst(handle_t hBinding, LPWSTR pszDeviceID, LPWSTR pszParentDeviceID, PNP_RPC_STRING_LEN ulLength, DWORD ulFlags)
Definition: rpcserver.c:3174
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
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
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
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_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
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_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_QueryArbitratorFreeData(handle_t hBinding, BYTE *pData, DWORD DataLen, LPWSTR pDeviceID, RESOURCEID ResourceID, DWORD ulFlags)
Definition: rpcserver.c:4967
DWORD WINAPI PNP_ReportLogOn(handle_t hBinding, BOOL Admin, DWORD ProcessId)
Definition: rpcserver.c:760
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_ValidateDeviceInstance(handle_t hBinding, LPWSTR pDeviceID, DWORD ulFlags)
Definition: rpcserver.c:815
DWORD WINAPI PNP_QueryArbitratorFreeSize(handle_t hBinding, DWORD *pulSize, LPWSTR pDeviceID, RESOURCEID ResourceID, DWORD ulFlags)
Definition: rpcserver.c:4982
DWORD WINAPI PNP_DeleteClassKey(handle_t hBinding, LPWSTR pszClassGuid, DWORD ulFlags)
Definition: rpcserver.c:2600
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
#define FIXME(fmt,...)
Definition: precomp.h:53
#define ERR(fmt,...)
Definition: precomp.h:57
#define UNIMPLEMENTED
Definition: ntoskrnl.c:15
#define RegCloseKey(hKey)
Definition: registry.h:49
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
ULONG_PTR CONFLICT_LIST
Definition: cfgmgr32.h:111
#define CM_DRP_CONFIGFLAGS
Definition: cfgmgr32.h:686
#define CR_INVALID_PROPERTY
Definition: cfgmgr32.h:899
#define CM_DRP_SECURITY_SDS
Definition: cfgmgr32.h:707
#define MAX_PROFILE_LEN
Definition: cfgmgr32.h:54
#define CM_OPEN_CLASS_KEY_INTERFACE
Definition: cfgmgr32.h:773
#define MAX_CLASS_NAME_LEN
Definition: cfgmgr32.h:52
DWORD_PTR RES_DES
Definition: cfgmgr32.h:93
#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_GET_DEVICE_INTERFACE_LIST_BITS
Definition: cfgmgr32.h:674
RANGE_ELEMENT * PRANGE_ELEMENT
Definition: cfgmgr32.h:106
#define CM_DRP_ENUMERATOR_NAME
Definition: cfgmgr32.h:704
#define CM_DRP_REMOVAL_POLICY_HW_DEFAULT
Definition: cfgmgr32.h:720
#define CR_INVALID_DEVICE_ID
Definition: cfgmgr32.h:876
#define CM_SET_HW_PROF_FLAGS_BITS
Definition: cfgmgr32.h:816
#define CM_DRP_BUSTYPEGUID
Definition: cfgmgr32.h:701
#define CM_ADD_RANGE_BITS
Definition: cfgmgr32.h:594
DEVNODE * PDEVINST
Definition: cfgmgr32.h:77
#define CR_OUT_OF_MEMORY
Definition: cfgmgr32.h:844
#define CR_INVALID_CONFLICT_LIST
Definition: cfgmgr32.h:903
DWORD_PTR RANGE_LIST
Definition: cfgmgr32.h:102
#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 CR_INVALID_PRIORITY
Definition: cfgmgr32.h:885
#define CM_SET_DEVNODE_PROBLEM_BITS
Definition: cfgmgr32.h:808
#define CM_CRP_MAX
Definition: cfgmgr32.h:733
#define RegDisposition_Bits
Definition: cfgmgr32.h:611
#define CM_DRP_MFG
Definition: cfgmgr32.h:687
#define CM_DRP_EXCLUSIVE
Definition: cfgmgr32.h:711
_Null_terminated_ CHAR * DEVINSTID_A
Definition: cfgmgr32.h:79
#define CM_DRP_DRIVER
Definition: cfgmgr32.h:685
#define CM_CRP_SECURITY_SDS
Definition: cfgmgr32.h:708
#define CM_SETUP_BITS
Definition: cfgmgr32.h:828
DWORD_PTR LOG_CONF
Definition: cfgmgr32.h:90
#define CM_DRP_REMOVAL_POLICY_OVERRIDE
Definition: cfgmgr32.h:721
#define CM_DRP_CAPABILITIES
Definition: cfgmgr32.h:691
#define CM_CRP_MIN
Definition: cfgmgr32.h:731
_Null_terminated_ WCHAR * DEVINSTID_W
Definition: cfgmgr32.h:80
#define CM_DRP_UPPERFILTERS
Definition: cfgmgr32.h:693
#define CR_FAILURE
Definition: cfgmgr32.h:865
#define CM_REGISTRY_BITS
Definition: cfgmgr32.h:804
#define CM_DRP_CLASSGUID
Definition: cfgmgr32.h:684
#define ResType_All
Definition: cfgmgr32.h:575
#define CR_INVALID_RES_DES
Definition: cfgmgr32.h:849
#define CM_DRP_COMPATIBLEIDS
Definition: cfgmgr32.h:678
ULONG RESOURCEID
Definition: cfgmgr32.h:96
#define CM_REGISTRY_SOFTWARE
Definition: cfgmgr32.h:801
#define CR_INVALID_DEVINST
Definition: cfgmgr32.h:848
#define CM_DRP_DEVICEDESC
Definition: cfgmgr32.h:676
#define CR_INVALID_RESOURCEID
Definition: cfgmgr32.h:855
LOG_CONF * PLOG_CONF
Definition: cfgmgr32.h:91
HMACHINE * PHMACHINE
Definition: cfgmgr32.h:109
#define LOG_CONF_BITS
Definition: cfgmgr32.h:603
CONFLICT_LIST * PCONFLICT_LIST
Definition: cfgmgr32.h:112
#define CM_REENUMERATE_BITS
Definition: cfgmgr32.h:793
#define CM_DRP_CLASS
Definition: cfgmgr32.h:683
DWORD DEVINST
Definition: cfgmgr32.h:76
RES_DES * PRES_DES
Definition: cfgmgr32.h:94
#define CM_DELETE_CLASS_BITS
Definition: cfgmgr32.h:639
#define CM_CRP_SECURITY
Definition: cfgmgr32.h:706
CONST VOID * PCVOID
Definition: cfgmgr32.h:44
#define PRIORITY_BIT
Definition: cfgmgr32.h:607
#define CM_DETECT_BITS
Definition: cfgmgr32.h:646
#define CR_ACCESS_DENIED
Definition: cfgmgr32.h:897
#define CR_INVALID_MACHINENAME
Definition: cfgmgr32.h:893
#define CM_RESDES_WIDTH_BITS
Definition: cfgmgr32.h:402
#define CM_DRP_LEGACYBUSTYPE
Definition: cfgmgr32.h:702
#define CM_DRP_PHYSICAL_DEVICE_OBJECT_NAME
Definition: cfgmgr32.h:690
#define CR_INVALID_RANGE
Definition: cfgmgr32.h:864
#define CR_INVALID_FLAG
Definition: cfgmgr32.h:846
#define CM_DRP_DEVTYPE
Definition: cfgmgr32.h:709
PRIORITY * PPRIORITY
Definition: cfgmgr32.h:100
ULONG PRIORITY
Definition: cfgmgr32.h:99
#define CM_REGISTRY_USER
Definition: cfgmgr32.h:802
#define CM_LOCATE_DEVNODE_BITS
Definition: cfgmgr32.h:764
#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 CM_DRP_CHARACTERISTICS
Definition: cfgmgr32.h:713
ULONG REGDISPOSITION
Definition: cfgmgr32.h:152
#define CR_NO_SUCH_DEVNODE
Definition: cfgmgr32.h:857
#define CM_CREATE_DEVNODE_BITS
Definition: cfgmgr32.h:624
DWORD_PTR RANGE_ELEMENT
Definition: cfgmgr32.h:105
#define CM_OPEN_CLASS_KEY_BITS
Definition: cfgmgr32.h:774
#define CR_BUFFER_SMALL
Definition: cfgmgr32.h:872
#define RegDisposition_OpenAlways
Definition: cfgmgr32.h:609
#define CM_REGISTRY_CONFIG
Definition: cfgmgr32.h:803
#define CR_CALL_NOT_IMPLEMENTED
Definition: cfgmgr32.h:898
RANGE_LIST * PRANGE_LIST
Definition: cfgmgr32.h:103
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_DRP_MAX
Definition: cfgmgr32.h:732
#define CR_SUCCESS
Definition: cfgmgr32.h:842
#define CM_DRP_ADDRESS
Definition: cfgmgr32.h:715
#define CM_QUERY_ARBITRATOR_BITS
Definition: cfgmgr32.h:832
RESOURCEID * PRESOURCEID
Definition: cfgmgr32.h:97
#define CM_REMOVE_BITS
Definition: cfgmgr32.h:780
#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_ADD_ID_BITS
Definition: cfgmgr32.h:616
#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_INVALID_RANGE_LIST
Definition: cfgmgr32.h:863
#define CR_REMOVE_VETOED
Definition: cfgmgr32.h:869
CONFIGRET WINAPI CM_Get_Device_ID_List_SizeW(_Out_ PULONG pulLen, _In_opt_ PCWSTR pszFilter, _In_ ULONG ulFlags)
Definition: cfgmgr.c:4054
struct _INTERNAL_RANGE_LIST * PINTERNAL_RANGE_LIST
CONFIGRET WINAPI CM_Delete_DevNode_Key_Ex(_In_ DEVINST dnDevInst, _In_ ULONG ulHardwareProfile, _In_ ULONG ulFlags, _In_opt_ HANDLE hMachine)
Definition: cfgmgr.c:1624
CONFIGRET WINAPI CM_Get_HW_Prof_Flags_ExA(_In_ DEVINSTID_A szDevInstName, _In_ ULONG ulHardwareProfile, _Out_ PULONG pulValue, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4869
CONFIGRET WINAPI CM_Request_Device_EjectW(_In_ DEVINST dnDevInst, _Out_opt_ PPNP_VETO_TYPE pVetoType, _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName, _In_ ULONG ulNameLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:7574
struct _NOTIFY_DATA * PNOTIFY_DATA
CONFIGRET WINAPI CM_Invert_Range_List(_In_ RANGE_LIST rlhOld, _In_ RANGE_LIST rlhNew, _In_ DWORDLONG ullMaxValue, _In_ ULONG ulFlags)
Definition: cfgmgr.c:5819
struct _INTERNAL_RANGE * PINTERNAL_RANGE
CONFIGRET WINAPI CM_Free_Res_Des_Ex(_Out_ PRES_DES prdResDes, _In_ RES_DES rdResDes, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:2557
static const WCHAR ControlClass[]
Definition: cfgmgr.c:38
CONFIGRET WINAPI CM_Unregister_Device_Interface_ExA(_In_ LPCSTR pszDeviceInterface, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:8753
CONFIGRET WINAPI CM_Enable_DevNode(_In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
Definition: cfgmgr.c:1996
CONFIGRET WINAPI CM_Uninstall_DevNode(_In_ DEVINST dnPhantom, _In_ ULONG ulFlags)
Definition: cfgmgr.c:8643
CONFIGRET WINAPI CM_Get_DevNode_Registry_Property_ExW(_In_ DEVINST dnDevInst, _In_ ULONG ulProperty, _Out_opt_ PULONG pulRegDataType, _Out_writes_bytes_opt_(*pulLength) PVOID Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:3572
BOOL IsValidResDes(_In_opt_ PRES_DES_INFO pResDesInfo)
Definition: cfgmgr.c:443
CONFIGRET WINAPI CM_Add_Empty_Log_Conf_Ex(_Out_ PLOG_CONF plcLogConf, _In_ DEVINST dnDevInst, _In_ PRIORITY Priority, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:913
CONFIGRET WINAPI CM_Register_Device_Driver(_In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
Definition: cfgmgr.c:7243
CONFIGRET WINAPI CM_Add_ID_ExW(_In_ DEVINST dnDevInst, _In_ PWSTR pszID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:1067
CONFIGRET WINAPI CM_Disconnect_Machine(_In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:1892
CONFIGRET WINAPI CM_Run_Detection_Ex(_In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7784
CONFIGRET WINAPI CM_Get_First_Log_Conf_Ex(_Out_opt_ PLOG_CONF plcLogConf, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4682
CONFIGRET WINAPI CM_Request_Device_EjectA(_In_ DEVINST dnDevInst, _Out_opt_ PPNP_VETO_TYPE pVetoType, _Out_writes_opt_(ulNameLength) LPSTR pszVetoName, _In_ ULONG ulNameLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:7554
CONFIGRET WINAPI CM_Get_DevNode_Status(_Out_ PULONG pulStatus, _Out_ PULONG pulProblemNumber, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
Definition: cfgmgr.c:3665
CONFIGRET WINAPI CM_Get_Log_Conf_Priority_Ex(_In_ LOG_CONF lcLogConf, _Out_ PPRIORITY pPriority, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5101
CONFIGRET WINAPI CM_Open_Class_Key_ExA(_In_opt_ LPGUID pClassGuid, _In_opt_ LPCSTR pszClassName, _In_ REGSAM samDesired, _In_ REGDISPOSITION Disposition, _Out_ PHKEY phkClass, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:6368
CONFIGRET WINAPI CM_Get_Device_ID_List_Size_ExW(_Out_ PULONG pulLen, _In_opt_ PCWSTR pszFilter, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4112
CONFIGRET WINAPI CM_Set_DevNode_Registry_Property_ExA(_In_ DEVINST dnDevInst, _In_ ULONG ulProperty, _In_reads_bytes_opt_(ulLength) PCVOID Buffer, _In_ ULONG ulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:8140
CONFIGRET WINAPI CM_Query_Resource_Conflict_List(_Out_ PCONFLICT_LIST pclConflictList, _In_ DEVINST dnDevInst, _In_ RESOURCEID ResourceID, _In_ PCVOID ResourceData, _In_ ULONG ResourceLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7048
CONFIGRET WINAPI CM_Get_Global_State_Ex(_Out_ PULONG pulState, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4783
CONFIGRET WINAPI CM_Register_Device_Driver_Ex(_In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7259
CONFIGRET WINAPI CM_Query_Arbitrator_Free_Data_Ex(_Out_writes_bytes_(DataLen) PVOID pData, _In_ ULONG DataLen, _In_ DEVINST dnDevInst, _In_ RESOURCEID ResourceID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:6856
CONFIGRET WINAPI CM_Get_Child(_Out_ PDEVINST pdnDevInst, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
Definition: cfgmgr.c:2623
CONFIGRET WINAPI CM_Unregister_Device_Interface_ExW(_In_ LPCWSTR pszDeviceInterface, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:8785
#define CONFLICT_MAGIC
Definition: cfgmgr.c:111
CONFIGRET WINAPI CM_Register_Device_InterfaceW(_In_ DEVINST dnDevInst, _In_ LPGUID InterfaceClassGuid, _In_opt_ LPCWSTR pszReference, _Out_writes_(*pulLength) LPWSTR pszDeviceInterface, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:7342
#define RANGE_LIST_MAGIC
Definition: cfgmgr.c:103
CONFIGRET WINAPI CM_Disable_DevNode(_In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
Definition: cfgmgr.c:1810
CONFIGRET WINAPI CM_Request_Eject_PC_Ex(_In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7731
CONFIGRET WINAPI CM_Unregister_Device_InterfaceW(_In_ LPCWSTR pszDeviceInterface, _In_ ULONG ulFlags)
Definition: cfgmgr.c:8736
CONFIGRET WINAPI CM_Set_HW_Prof_FlagsA(_In_ DEVINSTID_A szDevInstName, _In_ ULONG ulConfig, _In_ ULONG ulValue, _In_ ULONG ulFlags)
Definition: cfgmgr.c:8367
CONFIGRET WINAPI CM_Get_Device_IDW(_In_ DEVINST dnDevInst, _Out_writes_(BufferLen) PWCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags)
Definition: cfgmgr.c:3769
CONFIGRET WINAPI CM_Merge_Range_List(_In_ RANGE_LIST rlhOld1, _In_ RANGE_LIST rlhOld2, _In_ RANGE_LIST rlhNew, _In_ ULONG ulFlags)
Definition: cfgmgr.c:6115
CONFIGRET WINAPI CM_Delete_Class_Key(_In_ LPGUID ClassGuid, _In_ ULONG ulFlags)
Definition: cfgmgr.c:1536
CONFIGRET WINAPI CMP_WaitServicesAvailable(_In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:854
CONFIGRET WINAPI CM_Remove_SubTree(_In_ DEVINST dnAncestor, _In_ ULONG ulFlags)
Definition: cfgmgr.c:7519
CONFIGRET WINAPI CM_Create_DevNodeA(_Out_ PDEVINST pdnDevInst, _In_ DEVINSTID_A pDeviceID, _In_ DEVINST dnParent, _In_ ULONG ulFlags)
Definition: cfgmgr.c:1339
BOOL IsValidLogConf(_In_opt_ PLOG_CONF_INFO pLogConfInfo)
Definition: cfgmgr.c:419
CONFIGRET WINAPI CM_Get_Device_Interface_List_Size_ExA(_Out_ PULONG pulLen, _In_ LPGUID InterfaceClassGuid, _In_opt_ DEVINSTID_A pDeviceID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4570
CONFIGRET WINAPI CM_Detect_Resource_Conflict(_In_ DEVINST dnDevInst, _In_ RESOURCEID ResourceID, _In_reads_bytes_(ResourceLen) PCVOID ResourceData, _In_ ULONG ResourceLen, _Out_ PBOOL pbConflictDetected, _In_ ULONG ulFlags)
Definition: cfgmgr.c:1761
CONFIGRET WINAPI CM_Free_Resource_Conflict_Handle(_In_ CONFLICT_LIST clConflictList)
Definition: cfgmgr.c:2597
CONFIGRET WINAPI CM_Get_Device_ID_Size_Ex(_Out_ PULONG pulLen, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4183
CONFIGRET WINAPI CM_Set_HW_Prof_FlagsW(_In_ DEVINSTID_W szDevInstName, _In_ ULONG ulConfig, _In_ ULONG ulValue, _In_ ULONG ulFlags)
Definition: cfgmgr.c:8386
CONFIGRET WINAPI CM_Get_Device_Interface_ListA(_In_ LPGUID InterfaceClassGuid, _In_opt_ DEVINSTID_A pDeviceID, _Out_writes_(BufferLen) PCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags)
Definition: cfgmgr.c:4363
CONFIGRET WINAPI CM_Create_DevNode_ExA(_Out_ PDEVINST pdnDevInst, _In_ DEVINSTID_A pDeviceID, _In_ DEVINST dnParent, _In_ ULONG ulFlags, _In_opt_ HANDLE hMachine)
Definition: cfgmgr.c:1377
CONFIGRET WINAPI CM_Get_Class_Registry_PropertyA(LPGUID ClassGuid, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine)
Definition: cfgmgr.c:2990
CONFIGRET WINAPI CM_Get_First_Log_Conf(_Out_opt_ PLOG_CONF plcLogConf, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
Definition: cfgmgr.c:4665
CONFIGRET WINAPI CM_Get_Device_Interface_AliasW(_In_ LPCWSTR pszDeviceInterface, _In_ LPGUID AliasInterfaceGuid, _Out_writes_(*pulLength) LPWSTR pszAliasDeviceInterface, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:4256
CONFIGRET WINAPI CM_Reenumerate_DevNode_Ex(_In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7181
CONFIGRET WINAPI CM_Get_Class_Key_Name_ExA(_In_ LPGUID ClassGuid, _Out_writes_opt_(*pulLength) LPSTR pszKeyName, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:2760
CONFIGRET WINAPI CM_Get_Hardware_Profile_InfoA(_In_ ULONG ulIndex, _Out_ PHWPROFILEINFO_A pHWProfileInfo, _In_ ULONG ulFlags)
Definition: cfgmgr.c:4956
CONFIGRET WINAPI CM_Intersect_Range_List(_In_ RANGE_LIST rlhOld1, _In_ RANGE_LIST rlhOld2, _In_ RANGE_LIST rlhNew, _In_ ULONG ulFlags)
Definition: cfgmgr.c:5801
CONFIGRET WINAPI CM_Set_DevNode_Registry_PropertyW(_In_ DEVINST dnDevInst, _In_ ULONG ulProperty, _In_reads_bytes_opt_(ulLength) PCVOID Buffer, _In_ ULONG ulLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:8119
CONFIGRET WINAPI CM_Get_Sibling_Ex(_Out_ PDEVINST pdnDevInst, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5663
struct _LOG_CONF_INFO * PLOG_CONF_INFO
#define NOTIFY_MAGIC
Definition: cfgmgr.c:85
CONFIGRET WINAPI CM_Open_DevNode_Key_Ex(_In_ DEVINST dnDevNode, _In_ REGSAM samDesired, _In_ ULONG ulHardwareProfile, _In_ REGDISPOSITION Disposition, _Out_ PHKEY phkDevice, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:6530
CONFIGRET WINAPI CM_Connect_MachineA(_In_opt_ PCSTR UNCServerName, _Out_ PHMACHINE phMachine)
Definition: cfgmgr.c:1241
WORD WINAPI CM_Get_Version(VOID)
Definition: cfgmgr.c:5745
CONFIGRET WINAPI CM_Add_Res_Des(_Out_opt_ PRES_DES prdResDes, _In_ LOG_CONF lcLogConf, _In_ RESOURCEID ResourceID, _In_reads_bytes_(ResourceLen) PCVOID ResourceData, _In_ ULONG ResourceLen, _In_ ULONG ulFlags)
Definition: cfgmgr.c:1198
CONFIGRET WINAPI CM_Modify_Res_Des_Ex(_Out_ PRES_DES prdResDes, _In_ RES_DES rdResDes, _In_ RESOURCEID ResourceID, _In_reads_bytes_(ResourceLen) PCVOID ResourceData, _In_ ULONG ResourceLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:6155
CONFIGRET WINAPI CM_Query_Arbitrator_Free_Size(_Out_ PULONG pulSize, _In_ DEVINST dnDevInst, _In_ RESOURCEID ResourceID, _In_ ULONG ulFlags)
Definition: cfgmgr.c:6925
CONFIGRET WINAPI CM_Get_Device_Interface_List_ExA(_In_ LPGUID InterfaceClassGuid, _In_opt_ DEVINSTID_A pDeviceID, _Out_writes_(BufferLen) PCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4405
CONFIGRET WINAPI CM_Delete_Range(_In_ DWORDLONG ullStartValue, _In_ DWORDLONG ullEndValue, _In_ RANGE_LIST rlh, _In_ ULONG ulFlags)
Definition: cfgmgr.c:1743
CONFIGRET WINAPI CM_Query_Remove_SubTree(_In_ DEVINST dnAncestor, _In_ ULONG ulFlags)
Definition: cfgmgr.c:7013
CONFIGRET WINAPI CM_Detect_Resource_Conflict_Ex(_In_ DEVINST dnDevInst, _In_ RESOURCEID ResourceID, _In_reads_bytes_(ResourceLen) PCVOID ResourceData, _In_ ULONG ResourceLen, _Out_ PBOOL pbConflictDetected, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:1788
static const WCHAR BackslashOpenBrace[]
Definition: cfgmgr.c:34
CONFIGRET WINAPI CM_Add_ID_ExA(_In_ DEVINST dnDevInst, _In_ PSTR pszID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:1039
CONFIGRET WINAPI CM_Get_Device_Interface_List_Size_ExW(_Out_ PULONG pulLen, _In_ LPGUID InterfaceClassGuid, _In_opt_ DEVINSTID_W pDeviceID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4609
CONFIGRET WINAPI CM_Enumerate_Classes(_In_ ULONG ulClassIndex, _Out_ LPGUID ClassGuid, _In_ ULONG ulFlags)
Definition: cfgmgr.c:2077
CONFIGRET WINAPI CM_Get_Class_NameW(_In_ LPGUID ClassGuid, _Out_writes_opt_(*pulLength) PWCHAR Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:2863
CONFIGRET WINAPI CM_Get_HW_Prof_FlagsA(_In_ DEVINSTID_A szDevInstName, _In_ ULONG ulHardwareProfile, _Out_ PULONG pulValue, _In_ ULONG ulFlags)
Definition: cfgmgr.c:4831
CONFIGRET WINAPI CM_Register_Device_Interface_ExA(_In_ DEVINST dnDevInst, _In_ LPGUID InterfaceClassGuid, _In_opt_ LPCSTR pszReference, _Out_writes_(*pulLength) LPSTR pszDeviceInterface, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7365
CONFIGRET WINAPI CM_Test_Range_Available(_In_ DWORDLONG ullStartValue, _In_ DWORDLONG ullEndValue, _In_ RANGE_LIST rlh, _In_ ULONG ulFlags)
Definition: cfgmgr.c:8573
CONFIGRET WINAPI CM_Create_DevNode_ExW(_Out_ PDEVINST pdnDevInst, _In_ DEVINSTID_W pDeviceID, _In_ DEVINST dnParent, _In_ ULONG ulFlags, _In_opt_ HANDLE hMachine)
Definition: cfgmgr.c:1407
CONFIGRET WINAPI CM_Query_Arbitrator_Free_Data(_Out_writes_bytes_(DataLen) PVOID pData, _In_ ULONG DataLen, _In_ DEVINST dnDevInst, _In_ RESOURCEID ResourceID, _In_ ULONG ulFlags)
Definition: cfgmgr.c:6836
CONFIGRET WINAPI CMP_GetBlockedDriverInfo(_Out_opt_ LPWSTR pszNames, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:495
CONFIGRET WINAPI CM_Get_Class_Registry_PropertyW(LPGUID ClassGuid, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine)
Definition: cfgmgr.c:3069
CONFIGRET WINAPI CM_Is_Dock_Station_Present_Ex(_Out_ PBOOL pbPresent, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5852
CONFIGRET WINAPI CM_Open_Class_Key_ExW(_In_opt_ LPGUID pClassGuid, _In_opt_ LPCWSTR pszClassName, _In_ REGSAM samDesired, _In_ REGDISPOSITION Disposition, _Out_ PHKEY phkClass, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:6405
CONFIGRET WINAPI CM_Get_Device_Interface_List_SizeW(_Out_ PULONG pulLen, _In_ LPGUID InterfaceClassGuid, _In_opt_ DEVINSTID_W pDeviceID, _In_ ULONG ulFlags)
Definition: cfgmgr.c:4551
CONFIGRET WINAPI CM_Set_DevNode_Problem_Ex(_In_ DEVINST dnDevInst, _In_ ULONG ulProblem, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:8036
CONFIGRET WINAPI CM_Query_Arbitrator_Free_Size_Ex(_Out_ PULONG pulSize, _In_ DEVINST dnDevInst, _In_ RESOURCEID ResourceID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:6944
static const WCHAR DeviceClasses[]
Definition: cfgmgr.c:43
CONFIGRET WINAPI CM_Open_DevNode_Key(_In_ DEVINST dnDevNode, _In_ REGSAM samDesired, _In_ ULONG ulHardwareProfile, _In_ REGDISPOSITION Disposition, _Out_ PHKEY phkDevice, _In_ ULONG ulFlags)
Definition: cfgmgr.c:6509
static CONFIGRET RpcStatusToCmStatus(_In_ RPC_STATUS Status)
Definition: cfgmgr.c:141
CONFIGRET WINAPI CM_Get_DevNode_Status_Ex(_Out_ PULONG pulStatus, _Out_ PULONG pulProblemNumber, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:3684
CONFIGRET WINAPI CM_Enumerate_Enumerators_ExW(_In_ ULONG ulEnumIndex, _Out_writes_(*pulLength) PWCHAR Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:2250
CONFIGRET WINAPI CM_Dup_Range_List(_In_ RANGE_LIST rlhOld, _In_ RANGE_LIST rlhNew, _In_ ULONG ulFlags)
Definition: cfgmgr.c:1923
CONFIGRET WINAPI CM_Get_DevNode_Registry_Property_ExA(_In_ DEVINST dnDevInst, _In_ ULONG ulProperty, _Out_opt_ PULONG pulRegDataType, _Out_writes_bytes_opt_(*pulLength) PVOID Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:3493
struct _INTERNAL_RANGE INTERNAL_RANGE
CONFIGRET WINAPI CM_Add_IDA(_In_ DEVINST dnDevInst, _In_ PSTR pszID, _In_ ULONG ulFlags)
Definition: cfgmgr.c:1005
CONFIGRET WINAPI CM_Setup_DevNode(_In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
Definition: cfgmgr.c:8492
CONFIGRET WINAPI CM_Get_Hardware_Profile_Info_ExA(_In_ ULONG ulIndex, _Out_ PHWPROFILEINFO_A pHWProfileInfo, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4992
CONFIGRET WINAPI CM_Set_DevNode_Registry_PropertyA(_In_ DEVINST dnDevInst, _In_ ULONG ulProperty, _In_reads_bytes_opt_(ulLength) PCVOID Buffer, _In_ ULONG ulLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:8098
CONFIGRET WINAPI CM_Query_And_Remove_SubTree_ExA(_In_ DEVINST dnAncestor, _Out_opt_ PPNP_VETO_TYPE pVetoType, _Out_writes_opt_(ulNameLength) LPSTR pszVetoName, _In_ ULONG ulNameLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:6718
CONFIGRET WINAPI CM_Get_DevNode_Custom_Property_ExA(_In_ DEVINST dnDevInst, _In_ PCSTR pszCustomPropertyName, _Out_opt_ PULONG pulRegDataType, _Out_writes_bytes_opt_(*pulLength) PVOID Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:3276
CONFIGRET WINAPI CM_Get_Device_ID_ExW(_In_ DEVINST dnDevInst, _Out_writes_(BufferLen) PWCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:3830
BOOL WINAPI CM_Is_Version_Available_Ex(_In_ WORD wVersion, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5914
CONFIGRET WINAPI CM_Get_Device_IDA(_In_ DEVINST dnDevInst, _Out_writes_(BufferLen) PCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags)
Definition: cfgmgr.c:3751
CONFIGRET WINAPI CM_Locate_DevNodeA(_Out_ PDEVINST pdnDevInst, _In_opt_ DEVINSTID_A pDeviceID, _In_ ULONG ulFlags)
Definition: cfgmgr.c:5962
CONFIGRET WINAPI CM_Request_Device_Eject_ExW(_In_ DEVINST dnDevInst, _Out_opt_ PPNP_VETO_TYPE pVetoType, _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName, _In_ ULONG ulNameLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7644
BOOL IsValidConflictData(_In_opt_ PCONFLICT_DATA pConflictData)
Definition: cfgmgr.c:467
CONFIGRET WINAPI CM_Free_Res_Des(_Out_ PRES_DES prdResDes, _In_ RES_DES rdResDes, _In_ ULONG ulFlags)
Definition: cfgmgr.c:2540
CONFIGRET WINAPI CM_Get_Global_State(_Out_ PULONG pulState, _In_ ULONG ulFlags)
Definition: cfgmgr.c:4767
CONFIGRET WINAPI CM_Get_DevNode_Custom_Property_ExW(_In_ DEVINST dnDevInst, _In_ PCWSTR pszCustomPropertyName, _Out_opt_ PULONG pulRegDataType, _Out_writes_bytes_opt_(*pulLength) PVOID Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:3364
CONFIGRET WINAPI CM_Set_HW_Prof_Ex(_In_ ULONG ulHardwareProfile, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:8319
CONFIGRET WINAPI CM_Get_Next_Res_Des_Ex(_Out_ PRES_DES prdResDes, _In_ RES_DES rdResDes, _In_ RESOURCEID ForResource, _Out_opt_ PRESOURCEID pResourceID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5295
CONFIGRET WINAPI CM_Create_DevNodeW(_Out_ PDEVINST pdnDevInst, _In_ DEVINSTID_W pDeviceID, _In_ DEVINST dnParent, _In_ ULONG ulFlags)
Definition: cfgmgr.c:1358
CONFIGRET WINAPI CM_Locate_DevNode_ExA(_Out_ PDEVINST pdnDevInst, _In_opt_ DEVINSTID_A pDeviceID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5996
CONFIGRET WINAPI CM_Get_Parent(_Out_ PDEVINST pdnDevInst, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
Definition: cfgmgr.c:5414
CONFIGRET WINAPI CM_Add_Empty_Log_Conf(_Out_ PLOG_CONF plcLogConf, _In_ DEVINST dnDevInst, _In_ PRIORITY Priority, _In_ ULONG ulFlags)
Definition: cfgmgr.c:894
CONFIGRET WINAPI CM_Get_Device_Interface_ListW(_In_ LPGUID InterfaceClassGuid, _In_opt_ DEVINSTID_W pDeviceID, _Out_writes_(BufferLen) PWCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags)
Definition: cfgmgr.c:4384
CONFIGRET WINAPI CM_Get_Device_ID_Size(_Out_ PULONG pulLen, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
Definition: cfgmgr.c:4166
CONFIGRET WINAPI CM_Create_Range_List(_Out_ PRANGE_LIST prlh, _In_ ULONG ulFlags)
Definition: cfgmgr.c:1492
CONFIGRET WINAPI CM_Get_Resource_Conflict_DetailsA(_In_ CONFLICT_LIST clConflictList, _In_ ULONG ulIndex, _Inout_ PCONFLICT_DETAILS_A pConflictDetails)
Definition: cfgmgr.c:5612
CONFIGRET WINAPI CM_Register_Device_InterfaceA(_In_ DEVINST dnDevInst, _In_ LPGUID InterfaceClassGuid, _In_opt_ LPCSTR pszReference, _Out_writes_(*pulLength) LPSTR pszDeviceInterface, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:7319
CONFIGRET WINAPI CM_Get_Child_Ex(_Out_ PDEVINST pdnDevInst, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:2640
CONFIGRET WINAPI CM_Get_DevNode_Registry_PropertyW(_In_ DEVINST dnDevInst, _In_ ULONG ulProperty, _Out_opt_ PULONG pulRegDataType, _Out_writes_bytes_opt_(*pulLength) PVOID Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:3471
CONFIGRET WINAPI CM_Modify_Res_Des(_Out_ PRES_DES prdResDes, _In_ RES_DES rdResDes, _In_ RESOURCEID ResourceID, _In_reads_bytes_(ResourceLen) PCVOID ResourceData, _In_ ULONG ResourceLen, _In_ ULONG ulFlags)
Definition: cfgmgr.c:6133
CONFIGRET WINAPI CM_Add_IDW(_In_ DEVINST dnDevInst, _In_ PWSTR pszID, _In_ ULONG ulFlags)
Definition: cfgmgr.c:1022
CONFIGRET WINAPI CM_Get_Log_Conf_Priority(_In_ LOG_CONF lcLogConf, _Out_ PPRIORITY pPriority, _In_ ULONG ulFlags)
Definition: cfgmgr.c:5084
CONFIGRET WINAPI CM_Reenumerate_DevNode(_In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
Definition: cfgmgr.c:7166
CONFIGRET WINAPI CM_Set_Class_Registry_PropertyA(_In_ LPGUID ClassGuid, _In_ ULONG ulProperty, _In_reads_bytes_opt_(ulLength) PCVOID Buffer, _In_ ULONG ulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7832
CONFIGRET WINAPI CM_Get_DevNode_Custom_PropertyA(_In_ DEVINST dnDevInst, _In_ PCSTR pszCustomPropertyName, _Out_opt_ PULONG pulRegDataType, _Out_writes_bytes_opt_(*pulLength) PVOID Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:3230
static VOID SplitDeviceInstanceId(_In_ PWSTR pszDeviceInstanceId, _Out_ PWSTR pszDeviceId, _Out_ PWSTR pszInstanceId)
Definition: cfgmgr.c:203
CONFIGRET WINAPI CM_Get_Parent_Ex(_Out_ PDEVINST pdnDevInst, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5431
CONFIGRET WINAPI CM_First_Range(_In_ RANGE_LIST rlh, _Out_ PDWORDLONG pullStart, _Out_ PDWORDLONG pullEnd, _Out_ PRANGE_ELEMENT preElement, _In_ ULONG ulFlags)
Definition: cfgmgr.c:2329
struct _RES_DES_INFO * PRES_DES_INFO
CONFIGRET WINAPI CM_Unregister_Device_InterfaceA(_In_ LPCSTR pszDeviceInterface, _In_ ULONG ulFlags)
Definition: cfgmgr.c:8719
CONFIGRET WINAPI CM_Set_DevNode_Problem(_In_ DEVINST dnDevInst, _In_ ULONG ulProblem, _In_ ULONG ulFlags)
Definition: cfgmgr.c:8019
CONFIGRET WINAPI CM_Register_Device_Interface_ExW(_In_ DEVINST dnDevInst, _In_ LPGUID InterfaceClassGuid, _In_opt_ LPCWSTR pszReference, _Out_writes_(*pulLength) LPWSTR pszDeviceInterface, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7439
CONFIGRET WINAPI CM_Get_Device_ID_List_ExA(_In_ PCSTR pszFilter, _Out_writes_(BufferLen) PCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:3916
CONFIGRET WINAPI CM_Get_Device_Interface_List_SizeA(_Out_ PULONG pulLen, _In_ LPGUID InterfaceClassGuid, _In_opt_ DEVINSTID_A pDeviceID, _In_ ULONG ulFlags)
Definition: cfgmgr.c:4532
static const WCHAR CloseBrace[]
Definition: cfgmgr.c:35
CONFIGRET WINAPI CM_Setup_DevNode_Ex(_In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:8508
struct _INTERNAL_RANGE_LIST INTERNAL_RANGE_LIST
CONFIGRET WINAPI CM_Delete_Class_Key_Ex(_In_ LPGUID ClassGuid, _In_ ULONG ulFlags, _In_opt_ HANDLE hMachine)
Definition: cfgmgr.c:1552
CONFIGRET WINAPI CM_Get_Device_Interface_Alias_ExW(_In_ LPCWSTR pszDeviceInterface, _In_ LPGUID AliasInterfaceGuid, _Out_writes_(*pulLength) LPWSTR pszAliasDeviceInterface, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4299
CONFIGRET WINAPI CM_Connect_MachineW(_In_opt_ PCWSTR UNCServerName, _Out_ PHMACHINE phMachine)
Definition: cfgmgr.c:1270
CONFIGRET WINAPI CM_Set_HW_Prof(_In_ ULONG ulHardwareProfile, _In_ ULONG ulFlags)
Definition: cfgmgr.c:8303
static CONFIGRET GetDeviceInstanceKeyPath(_In_ RPC_BINDING_HANDLE BindingHandle, _In_ PWSTR pszDeviceInst, _Out_ PWSTR pszKeyPath, _Out_ PWSTR pszInstancePath, _In_ ULONG ulHardwareProfile, _In_ ULONG ulFlags)
Definition: cfgmgr.c:229
CONFIGRET WINAPI CM_Get_Device_ID_List_Size_ExA(_Out_ PULONG pulLen, _In_opt_ PCSTR pszFilter, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4071
CONFIGRET WINAPI CM_Set_Class_Registry_PropertyW(_In_ LPGUID ClassGuid, _In_ ULONG ulProperty, _In_reads_bytes_opt_(ulLength) PCVOID Buffer, _In_ ULONG ulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7919
CONFIGRET WINAPI CM_Set_DevNode_Registry_Property_ExW(_In_ DEVINST dnDevInst, _In_ ULONG ulProperty, _In_reads_bytes_opt_(ulLength) PCVOID Buffer, _In_ ULONG ulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:8226
CONFIGRET WINAPI CM_Get_Next_Res_Des(_Out_ PRES_DES prdResDes, _In_ RES_DES rdResDes, _In_ RESOURCEID ForResource, _Out_opt_ PRESOURCEID pResourceID, _In_ ULONG ulFlags)
Definition: cfgmgr.c:5275
static ULONG GetRegistryPropertyType(_In_ ULONG ulProperty)
Definition: cfgmgr.c:150
#define RES_DES_MAGIC
Definition: cfgmgr.c:77
CONFIGRET WINAPI CM_Request_Eject_PC(VOID)
Definition: cfgmgr.c:7718
CONFIGRET WINAPI CM_Get_Device_Interface_Alias_ExA(_In_ LPCSTR pszDeviceInterface, _In_ LPGUID AliasInterfaceGuid, _Out_writes_(*pulLength) LPSTR pszAliasDeviceInterface, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4278
CONFIGRET WINAPI CM_Get_Class_Name_ExA(_In_ LPGUID ClassGuid, _Out_writes_opt_(*pulLength) PCHAR Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:2882
static BOOL GuidToString(_In_ LPGUID Guid, _Out_ LPWSTR String)
Definition: cfgmgr.c:118
CONFIGRET WINAPI CM_Get_Device_ID_ListA(_In_ PCSTR pszFilter, _Out_writes_(BufferLen) PCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags)
Definition: cfgmgr.c:3878
CONFIGRET WINAPI CM_Get_Res_Des_Data(_In_ RES_DES rdResDes, _Out_writes_bytes_(BufferLen) PVOID Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags)
Definition: cfgmgr.c:5513
BOOL WINAPI CM_Is_Version_Available(_In_ WORD wVersion)
Definition: cfgmgr.c:5899
CONFIGRET WINAPI CM_Get_Res_Des_Data_Size(_Out_ PULONG pulSize, _In_ RES_DES rdResDes, _In_ ULONG ulFlags)
Definition: cfgmgr.c:5550
struct _NOTIFY_DATA NOTIFY_DATA
struct _MACHINE_INFO MACHINE_INFO
CONFIGRET WINAPI CM_Get_Hardware_Profile_InfoW(_In_ ULONG ulIndex, _Out_ PHWPROFILEINFO_W pHWProfileInfo, _In_ ULONG ulFlags)
Definition: cfgmgr.c:4974
CONFIGRET WINAPI CM_Free_Log_Conf_Ex(_In_ LOG_CONF lcLogConfToBeFreed, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:2403
CONFIGRET WINAPI CM_Disable_DevNode_Ex(_In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:1826
CONFIGRET WINAPI CM_Next_Range(_Inout_ PRANGE_ELEMENT preElement, _Out_ PDWORDLONG pullStart, _Out_ PDWORDLONG pullEnd, _In_ ULONG ulFlags)
Definition: cfgmgr.c:6265
CONFIGRET WINAPI CM_Get_Sibling(_Out_ PDEVINST pdnDevInst, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
Definition: cfgmgr.c:5646
CONFIGRET WINAPI CM_Query_Remove_SubTree_Ex(_In_ DEVINST dnAncestor, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7031
CONFIGRET WINAPI CM_Free_Range_List(_In_ RANGE_LIST RangeList, _In_ ULONG ulFlags)
Definition: cfgmgr.c:2492
CONFIGRET WINAPI CM_Get_HW_Prof_FlagsW(_In_ DEVINSTID_W szDevInstName, _In_ ULONG ulHardwareProfile, _Out_ PULONG pulValue, _In_ ULONG ulFlags)
Definition: cfgmgr.c:4850
CONFIGRET WINAPI CM_Delete_DevNode_Key(_In_ DEVINST dnDevInst, _In_ ULONG ulHardwareProfile, _In_ ULONG ulFlags)
Definition: cfgmgr.c:1606
CONFIGRET WINAPI CM_Open_Class_KeyW(_In_opt_ LPGUID pClassGuid, _In_opt_ LPCWSTR pszClassName, _In_ REGSAM samDesired, _In_ REGDISPOSITION Disposition, _Out_ PHKEY phkClass, _In_ ULONG ulFlags)
Definition: cfgmgr.c:6346
CONFIGRET WINAPI CM_Get_Class_Name_ExW(_In_ LPGUID ClassGuid, _Out_writes_opt_(*pulLength) PWCHAR Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:2930
CONFIGRET WINAPI CM_Add_Range(_In_ DWORDLONG ullStartValue, _In_ DWORDLONG ullEndValue, _In_ RANGE_LIST rlh, _In_ ULONG ulFlags)
Definition: cfgmgr.c:1135
CONFIGRET WINAPI CM_Get_Depth_Ex(_Out_ PULONG pulDepth, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:3165
CONFIGRET WINAPI CM_Move_DevNode_Ex(_In_ DEVINST dnFromDevInst, _In_ DEVINST dnToDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:6194
#define LOG_CONF_MAGIC
Definition: cfgmgr.c:65
CONFIGRET WINAPI CMP_Report_LogOn(_In_ DWORD dwMagic, _In_ DWORD dwProcessId)
Definition: cfgmgr.c:739
CONFIGRET WINAPI CM_Get_Device_ID_List_ExW(_In_ PCWSTR pszFilter, _Out_writes_(BufferLen) PWCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:3981
CONFIGRET WINAPI CM_Get_Next_Log_Conf(_Out_opt_ PLOG_CONF plcLogConf, _In_ LOG_CONF lcLogConf, _In_ ULONG ulFlags)
Definition: cfgmgr.c:5170
CONFIGRET WINAPI CM_Get_Class_NameA(_In_ LPGUID ClassGuid, _Out_writes_opt_(*pulLength) PCHAR Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:2844
CONFIGRET WINAPI CM_Query_And_Remove_SubTreeW(_In_ DEVINST dnAncestor, _Out_opt_ PPNP_VETO_TYPE pVetoType, _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName, _In_ ULONG ulNameLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:6698
CONFIGRET WINAPI CM_Add_Res_Des_Ex(_Out_opt_ PRES_DES prdResDes, _In_ LOG_CONF lcLogConf, _In_ RESOURCEID ResourceID, _In_reads_bytes_(ResourceLen) PCVOID ResourceData, _In_ ULONG ResourceLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:1219
struct _CONFLICT_DATA * PCONFLICT_DATA
CONFIGRET WINAPI CM_Uninstall_DevNode_Ex(_In_ DEVINST dnPhantom, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:8659
CONFIGRET WINAPI CMP_Init_Detection(_In_ ULONG ulMagic)
Definition: cfgmgr.c:595
CONFIGRET WINAPI CM_Enumerate_Enumerators_ExA(_In_ ULONG ulEnumIndex, _Out_writes_(*pulLength) PCHAR Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:2199
CONFIGRET WINAPI CM_Get_Device_Interface_AliasA(_In_ LPCSTR pszDeviceInterface, _In_ LPGUID AliasInterfaceGuid, _Out_writes_(*pulLength) LPSTR pszAliasDeviceInterface, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:4234
CONFIGRET WINAPI CM_Remove_SubTree_Ex(_In_ DEVINST dnAncestor, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7537
CONFIGRET WINAPI CM_Get_Next_Log_Conf_Ex(_Out_opt_ PLOG_CONF plcLogConf, _In_ LOG_CONF lcLogConf, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5187
CONFIGRET WINAPI CM_Locate_DevNode_ExW(_Out_ PDEVINST pdnDevInst, _In_opt_ DEVINSTID_W pDeviceID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:6028
CONFIGRET WINAPI CMP_UnregisterNotification(_In_ HDEVNOTIFY hDevNotify)
Definition: cfgmgr.c:787
CONFIGRET WINAPI CM_Get_Hardware_Profile_Info_ExW(_In_ ULONG ulIndex, _Out_ PHWPROFILEINFO_W pHWProfileInfo, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5034
struct _MACHINE_INFO * PMACHINE_INFO
CONFIGRET WINAPI CM_Get_Resource_Conflict_Count(_In_ CONFLICT_LIST clConflictList, _Out_ PULONG pulCount)
Definition: cfgmgr.c:5585
CONFIGRET WINAPI CM_Find_Range(_Out_ PDWORDLONG pullStart, _In_ DWORDLONG ullStart, _In_ ULONG ulLength, _In_ DWORDLONG ullAlignment, _In_ DWORDLONG ullEnd, _In_ RANGE_LIST rlh, _In_ ULONG ulFlags)
Definition: cfgmgr.c:2308
CONFIGRET WINAPI CM_Free_Log_Conf(_In_ LOG_CONF lcLogConfToBeFreed, _In_ ULONG ulFlags)
Definition: cfgmgr.c:2387
CONFIGRET WINAPI CM_Get_Res_Des_Data_Ex(_In_ RES_DES rdResDes, _Out_writes_bytes_(BufferLen) PVOID Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5531
CONFIGRET WINAPI CM_Open_Class_KeyA(_In_opt_ LPGUID pClassGuid, _In_opt_ LPCSTR pszClassName, _In_ REGSAM samDesired, _In_ REGDISPOSITION Disposition, _Out_ PHKEY phkClass, _In_ ULONG ulFlags)
Definition: cfgmgr.c:6324
CONFIGRET WINAPI CM_Get_Class_Key_Name_ExW(_In_ LPGUID ClassGuid, _Out_writes_opt_(*pulLength) LPWSTR pszKeyName, _Inout_ PULONG pulLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:2808
CONFIGRET WINAPI CM_Get_HW_Prof_Flags_ExW(_In_ DEVINSTID_W szDevInstName, _In_ ULONG ulHardwareProfile, _Out_ PULONG pulValue, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4903
BOOL IsValidRangeList(_In_opt_ PINTERNAL_RANGE_LIST pRangeList)
Definition: cfgmgr.c:395
CONFIGRET WINAPI CM_Run_Detection(_In_ ULONG ulFlags)
Definition: cfgmgr.c:7770
CONFIGRET WINAPI CM_Free_Res_Des_Handle(_In_ RES_DES rdResDes)
Definition: cfgmgr.c:2575
CONFIGRET WINAPI CM_Query_And_Remove_SubTreeA(_In_ DEVINST dnAncestor, _Out_opt_ PPNP_VETO_TYPE pVetoType, _Out_writes_opt_(ulNameLength) LPSTR pszVetoName, _In_ ULONG ulNameLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:6678
CONFIGRET WINAPI CM_Request_Device_Eject_ExA(_In_ DEVINST dnDevInst, _Out_opt_ PPNP_VETO_TYPE pVetoType, _Out_writes_opt_(ulNameLength) LPSTR pszVetoName, _In_ ULONG ulNameLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7594
DWORD WINAPI CMP_WaitNoPendingInstallEvents(_In_ DWORD dwTimeout)
Definition: cfgmgr.c:831
CONFIGRET WINAPI CM_Get_Class_Key_NameW(_In_ LPGUID ClassGuid, _Out_writes_opt_(*pulLength) LPWSTR pszKeyName, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:2741
CONFIGRET WINAPI CM_Enumerate_Classes_Ex(_In_ ULONG ulClassIndex, _Out_ LPGUID ClassGuid, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:2094
struct _RES_DES_INFO RES_DES_INFO
CONFIGRET WINAPI CM_Get_Depth(_Out_ PULONG pulDepth, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
Definition: cfgmgr.c:3148
CONFIGRET WINAPI CM_Query_And_Remove_SubTree_ExW(_In_ DEVINST dnAncestor, _Out_opt_ PPNP_VETO_TYPE pVetoType, _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName, _In_ ULONG ulNameLength, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:6766
CONFIGRET WINAPI CM_Locate_DevNodeW(_Out_ PDEVINST pdnDevInst, _In_opt_ DEVINSTID_W pDeviceID, _In_ ULONG ulFlags)
Definition: cfgmgr.c:5979
CONFIGRET WINAPI CM_Move_DevNode(_In_ DEVINST dnFromDevInst, _In_ DEVINST dnToDevInst, _In_ ULONG ulFlags)
Definition: cfgmgr.c:6177
CONFIGRET WINAPI CM_Get_Class_Key_NameA(_In_ LPGUID ClassGuid, _Out_writes_opt_(*pulLength) LPSTR pszKeyName, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:2722
CONFIGRET WINAPI CM_Enumerate_EnumeratorsW(_In_ ULONG ulEnumIndex, _Out_writes_(*pulLength) PWCHAR Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:2180
CONFIGRET WINAPI CM_Get_Device_ID_ExA(_In_ DEVINST dnDevInst, _Out_writes_(BufferLen) PCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:3787
CONFIGRET WINAPI CMP_RegisterNotification(_In_ HANDLE hRecipient, _In_ LPVOID lpvNotificationFilter, _In_ ULONG ulFlags, _Out_ PHDEVNOTIFY phDevNotify)
Definition: cfgmgr.c:628
CONFIGRET WINAPI CM_Free_Log_Conf_Handle(_In_ LOG_CONF lcLogConf)
Definition: cfgmgr.c:2470
CONFIGRET WINAPI CM_Is_Dock_Station_Present(_Out_ PBOOL pbPresent)
Definition: cfgmgr.c:5837
CONFIGRET WINAPI CM_Get_Resource_Conflict_DetailsW(_In_ CONFLICT_LIST clConflictList, _In_ ULONG ulIndex, _Inout_ PCONFLICT_DETAILS_W pConflictDetails)
Definition: cfgmgr.c:5629
CONFIGRET WINAPI CM_Enumerate_EnumeratorsA(_In_ ULONG ulEnumIndex, _Out_writes_(*pulLength) PCHAR Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:2161
CONFIGRET WINAPI CM_Get_Device_ID_ListW(_In_ PCWSTR pszFilter, _Out_writes_(BufferLen) PWCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags)
Definition: cfgmgr.c:3897
CONFIGRET WINAPI CM_Get_Device_ID_List_SizeA(_Out_ PULONG pulLen, _In_opt_ PCSTR pszFilter, _In_ ULONG ulFlags)
Definition: cfgmgr.c:4037
CONFIGRET WINAPI CM_Get_DevNode_Registry_PropertyA(_In_ DEVINST dnDevInst, _In_ ULONG ulProperty, _Out_opt_ PULONG pulRegDataType, _Out_writes_bytes_opt_(*pulLength) PVOID Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:3449
CONFIGRET WINAPI CMP_GetServerSideDeviceInstallFlags(_Out_ PULONG pulSSDIFlags, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:545
WORD WINAPI CM_Get_Version_Ex(_In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5758
CONFIGRET WINAPI CM_Get_Device_Interface_List_ExW(_In_ LPGUID InterfaceClassGuid, _In_opt_ DEVINSTID_W pDeviceID, _Out_writes_(BufferLen) PWCHAR Buffer, _In_ ULONG BufferLen, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4470
CONFIGRET WINAPI CM_Enable_DevNode_Ex(_In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:2012
CONFIGRET WINAPI CM_Get_Res_Des_Data_Size_Ex(_Out_ PULONG pulSize, _In_ RES_DES rdResDes, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5567
CONFIGRET WINAPI CM_Set_HW_Prof_Flags_ExA(_In_ DEVINSTID_A szDevInstName, _In_ ULONG ulConfig, _In_ ULONG ulValue, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:8405
struct _LOG_CONF_INFO LOG_CONF_INFO
CONFIGRET WINAPI CM_Set_HW_Prof_Flags_ExW(_In_ DEVINSTID_W szDevInstName, _In_ ULONG ulConfig, _In_ ULONG ulValue, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:8439
struct _CONFLICT_DATA CONFLICT_DATA
CONFIGRET WINAPI CM_Get_DevNode_Custom_PropertyW(_In_ DEVINST dnDevInst, _In_ PCWSTR pszCustomPropertyName, _Out_opt_ PULONG pulRegDataType, _Out_writes_bytes_opt_(*pulLength) PVOID Buffer, _Inout_ PULONG pulLength, _In_ ULONG ulFlags)
Definition: cfgmgr.c:3253
Definition: bufpool.h:45
wcscat
wcscpy
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:175
#define ERROR_SUCCESS
Definition: deptool.c:10
#define MAX_DEVICE_ID_LEN
Definition: devaction.c:40
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define MAX_GUID_STRING_LEN
Definition: apphelp.c:29
#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 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 RegConnectRegistryW(LPCWSTR lpMachineName, HKEY hKey, PHKEY phkResult)
Definition: reg.c:874
BOOL WINAPI ConvertStringSecurityDescriptorToSecurityDescriptorW(LPCWSTR StringSecurityDescriptor, DWORD StringSDRevision, PSECURITY_DESCRIPTOR *SecurityDescriptor, PULONG SecurityDescriptorSize)
Definition: security.c:3062
#define CloseHandle
Definition: compat.h:739
#define wcschr
Definition: compat.h:17
#define GetProcessHeap()
Definition: compat.h:736
#define CP_ACP
Definition: compat.h:109
#define HeapAlloc
Definition: compat.h:733
#define MAX_PATH
Definition: compat.h:34
#define HeapFree(x, y, z)
Definition: compat.h:735
#define lstrcpyW
Definition: compat.h:749
#define WideCharToMultiByte
Definition: compat.h:111
#define MultiByteToWideChar
Definition: compat.h:110
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
#define lstrlenW
Definition: compat.h:750
static DWORD DWORD * dwLength
Definition: fusion.c:86
LPWSTR WINAPI pSetupMultiByteToUnicode(LPCSTR lpMultiByteStr, UINT uCodePage)
Definition: misc.c:281
LPVOID WINAPI MyMalloc(DWORD dwSize)
Definition: misc.c:147
DWORD WINAPI pSetupCaptureAndConvertAnsiArg(LPCSTR pSrc, LPWSTR *pDst)
Definition: misc.c:574
BOOL WINAPI pSetupIsUserAdmin(VOID)
Definition: misc.c:1817
VOID WINAPI MyFree(LPVOID lpMem)
Definition: misc.c:128
DWORD WINAPI pSetupStringFromGuid(LPGUID lpGUID, PWSTR pString, DWORD dwStringLen)
Definition: misc.c:1775
RPC_STATUS PnpBindRpc(LPCWSTR pszMachine, RPC_BINDING_HANDLE *BindingHandle)
Definition: rpc.c:28
BOOL PnpGetLocalHandles(RPC_BINDING_HANDLE *BindingHandle, HSTRING_TABLE *StringTable)
Definition: rpc.c:66
RPC_STATUS PnpUnbindRpc(RPC_BINDING_HANDLE *BindingHandle)
Definition: rpc.c:53
HSTRING_TABLE WINAPI pSetupStringTableInitialize(VOID)
Definition: stringtable.c:54
DWORD WINAPI pSetupStringTableAddString(HSTRING_TABLE hStringTable, LPWSTR lpString, DWORD dwFlags)
Definition: stringtable.c:196
LPWSTR WINAPI pSetupStringTableStringFromId(HSTRING_TABLE hStringTable, DWORD dwId)
Definition: stringtable.c:722
VOID WINAPI pSetupStringTableDestroy(HSTRING_TABLE hStringTable)
Definition: stringtable.c:145
BOOL WINAPI pSetupStringTableStringFromIdEx(HSTRING_TABLE hStringTable, DWORD dwId, LPWSTR lpBuffer, LPDWORD lpBufferLength)
Definition: stringtable.c:760
#define INFINITE
Definition: serial.h:102
#define InsertTailList(ListHead, Entry)
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
#define RemoveHeadList(ListHead)
Definition: env_spec_w32.h:964
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
FxAutoRegKey hKey
Status
Definition: gdiplustypes.h:25
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
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:90
unsigned long long DWORDLONG
Definition: intsafe.h:93
#define debugstr_guid
Definition: kernel32.h:35
#define debugstr_a
Definition: kernel32.h:31
#define debugstr_w
Definition: kernel32.h:32
#define REG_SZ
Definition: layer.c:22
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static PVOID ptr
Definition: dispmode.c:27
static HANDLE hEvent
Definition: comm.c:54
ULONGLONG * PDWORDLONG
Definition: ms-dtyp.idl:93
_In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Reserved_ ULONG _In_opt_ PUNICODE_STRING _In_ ULONG _Out_opt_ PULONG Disposition
Definition: cmfuncs.h:56
#define _In_reads_bytes_(s)
Definition: no_sal2.h:170
#define _Out_opt_
Definition: no_sal2.h:214
#define _Inout_
Definition: no_sal2.h:162
#define _Out_writes_opt_(s)
Definition: no_sal2.h:226
#define _Out_writes_bytes_opt_(s)
Definition: no_sal2.h:228
#define _Out_writes_(s)
Definition: no_sal2.h:176
#define _Out_
Definition: no_sal2.h:160
#define _In_
Definition: no_sal2.h:158
#define _In_opt_
Definition: no_sal2.h:212
#define _Out_writes_bytes_(s)
Definition: no_sal2.h:178
#define _In_reads_bytes_opt_(s)
Definition: no_sal2.h:224
#define SYNCHRONIZE
Definition: nt_native.h:61
#define REG_BINARY
Definition: nt_native.h:1496
#define REG_MULTI_SZ
Definition: nt_native.h:1501
#define REG_NONE
Definition: nt_native.h:1492
#define REG_EXPAND_SZ
Definition: nt_native.h:1494
#define UNICODE_NULL
#define L(x)
Definition: ntvdm.h:50
BYTE * PBYTE
Definition: pedump.c:66
long LONG
Definition: pedump.c:60
struct _PNP_CONFLICT_LIST PNP_CONFLICT_LIST
const unsigned long PNP_MAX_GUID_STRING_LEN
Definition: pnp.idl:12
unsigned long PNP_RPC_BUFFER_SIZE
Definition: pnp.idl:34
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:82
#define _SEH2_END
Definition: pseh2_64.h:171
#define _SEH2_TRY
Definition: pseh2_64.h:71
#define RPC_S_OK
Definition: rpcnterr.h:22
RPC_STATUS WINAPI UuidToStringW(UUID *Uuid, RPC_WSTR *StringUuid)
Definition: rpcrt4_main.c:540
RPC_STATUS WINAPI RpcStringFreeW(RPC_WSTR *String)
Definition: rpcrt4_main.c:175
RPC_STATUS WINAPI UuidFromStringW(RPC_WSTR s, UUID *uuid)
Definition: rpcrt4_main.c:614
DWORD WINAPI I_ScPnPGetServiceName(IN SERVICE_STATUS_HANDLE hServiceStatus, OUT LPWSTR lpServiceName, IN DWORD cchServiceName)
Definition: sctrl.c:869
#define REG_DWORD
Definition: sdbapi.c:596
#define SDDL_REVISION_1
Definition: sddl.h:30
#define RpcEndExcept
Definition: rpc.h:123
#define RpcTryExcept
Definition: rpc.h:121
#define RpcExcept(expr)
Definition: rpc.h:122
long RPC_STATUS
Definition: rpc.h:48
#define RpcExceptionCode()
Definition: rpc.h:127
#define SP_MAX_MACHINENAME_LENGTH
Definition: setupapi.h:27
#define TRACE(s)
Definition: solgame.cpp:4
ULONG HWPI_ulHWProfile
Definition: cfgmgr32.h:560
DWORD HWPI_dwFlags
Definition: cfgmgr32.h:562
WCHAR HWPI_szFriendlyName[MAX_PROFILE_LEN]
Definition: cfgmgr32.h:561
ULONG ulMagic
Definition: cfgmgr.c:107
PPNP_CONFLICT_LIST pConflictList
Definition: cfgmgr.c:108
LIST_ENTRY ListHead
Definition: cfgmgr.c:100
DWORDLONG ullEnd
Definition: cfgmgr.c:93
DWORDLONG ullStart
Definition: cfgmgr.c:92
struct _INTERNAL_RANGE_LIST * pRangeList
Definition: cfgmgr.c:91
LIST_ENTRY ListEntry
Definition: cfgmgr.c:90
Definition: typedefs.h:120
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
ULONG ulTag
Definition: cfgmgr.c:62
ULONG ulType
Definition: cfgmgr.c:61
DEVINST dnDevInst
Definition: cfgmgr.c:60
ULONG ulMagic
Definition: cfgmgr.c:59
WCHAR szMachineName[SP_MAX_MACHINENAME_LENGTH]
Definition: cfgmgr.c:50
HSTRING_TABLE StringTable
Definition: cfgmgr.c:52
RPC_BINDING_HANDLE BindingHandle
Definition: cfgmgr.c:51
BOOL bLocal
Definition: cfgmgr.c:53
ULONG ulMagic
Definition: cfgmgr.c:81
PVOID hNotifyHandle
Definition: cfgmgr.c:82
DWORD ConflictsListed
Definition: pnp.idl:240
ULONG ulLogConfTag
Definition: cfgmgr.c:72
DEVINST dnDevInst
Definition: cfgmgr.c:70
ULONG ulResDesType
Definition: cfgmgr.c:73
ULONG ulResDesTag
Definition: cfgmgr.c:74
ULONG ulLogConfType
Definition: cfgmgr.c:71
ULONG ulMagic
Definition: cfgmgr.c:69
HANDLE WINAPI DECLSPEC_HOTPATCH OpenEventW(IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN LPCWSTR lpName)
Definition: synch.c:682
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
VOID WINAPI DECLSPEC_HOTPATCH Sleep(IN DWORD dwMilliseconds)
Definition: synch.c:790
BOOL WINAPI DECLSPEC_HOTPATCH ReleaseMutex(IN HANDLE hMutex)
Definition: synch.c:618
_In_ ULONG _Out_ HANDLE * BindingHandle
Definition: tdikrnl.h:1147
#define wchar_t
Definition: wchar.h:102
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
char * PSTR
Definition: typedefs.h:51
const uint16_t * PCWSTR
Definition: typedefs.h:57
uint32_t DWORD_PTR
Definition: typedefs.h:65
unsigned char * LPBYTE
Definition: typedefs.h:53
int32_t INT
Definition: typedefs.h:58
const char * PCSTR
Definition: typedefs.h:52
uint16_t * PWCHAR
Definition: typedefs.h:56
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
char * PCHAR
Definition: typedefs.h:51
_In_z_ PCWSTR _In_ ULONG ulType
Definition: ntuser.h:43
#define CMP_MAGIC
Definition: userinit.c:29
int ret
_Must_inspect_result_ _In_ WDFDEVICE _In_ WDFSTRING String
Definition: wdfdevice.h:2433
_Must_inspect_result_ _In_ WDFDEVICE _In_ LPCGUID _Out_ PINTERFACE _In_ USHORT _In_ USHORT Version
Definition: wdffdo.h:469
_In_ WDFINTERRUPT _In_ WDF_INTERRUPT_POLICY _In_ WDF_INTERRUPT_PRIORITY Priority
Definition: wdfinterrupt.h:655
_In_ WDFMEMORY _Out_opt_ size_t * BufferSize
Definition: wdfmemory.h:254
_Must_inspect_result_ _In_ WDFOBJECT _In_ CONST GUID * Guid
Definition: wdfobject.h:762
int WINAPI GetWindowTextW(HWND hWnd, LPWSTR lpString, int nMaxCount)
Definition: window.c:1382
#define ZeroMemory
Definition: winbase.h:1744
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
#define CreateMutex
Definition: winbase.h:3788
DWORD WINAPI GetCurrentProcessId(void)
Definition: proc.c:1158
#define WAIT_FAILED
Definition: winbase.h:440
_In_ DWORD nLength
Definition: wincon.h:473
_In_ void _In_ PCCERT_CONTEXT _In_opt_ LPFILETIME _In_ DWORD _In_ DWORD dwTimeout
Definition: wincrypt.h:6081
_In_ ULONG _In_ ULONG ulTag
Definition: winddi.h:3942
_Check_return_ _Out_ PULONG pulSize
Definition: winddi.h:2120
BOOL * PBOOL
Definition: windef.h:161
#define WINAPI
Definition: msvc.h:6
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
ACCESS_MASK REGSAM
Definition: winreg.h:69
int WINAPIV wsprintfW(_Out_ LPWSTR, _In_ _Printf_format_string_ LPCWSTR,...)
HDEVNOTIFY * PHDEVNOTIFY
Definition: winuser.h:2931
_In_ CONST GUID * InterfaceClassGuid
Definition: iofuncs.h:1136
const char * LPCSTR
Definition: xmlstorage.h:183
char * LPSTR
Definition: xmlstorage.h:182
__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