ReactOS 0.4.16-dev-1537-g4e425b5
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
832 _In_ DWORD dwTimeout)
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
843 ret = WaitForSingleObject(hEvent, dwTimeout);
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 LPWSTR pszDeviceInterfaceW = NULL;
4287 LPWSTR pszAliasDeviceInterfaceW = NULL;
4289
4290 TRACE("CM_Get_Device_Interface_Alias_ExA(%p %p %p %p %lx %p)\n",
4291 pszDeviceInterface, AliasInterfaceGuid,
4292 pszAliasDeviceInterface, pulLength, ulFlags, hMachine);
4293
4294 if (pszDeviceInterface == NULL ||
4295 AliasInterfaceGuid == NULL ||
4296 pszAliasDeviceInterface == NULL ||
4297 pulLength == NULL)
4298 return CR_INVALID_POINTER;
4299
4300 if (ulFlags != 0)
4301 return CR_INVALID_FLAG;
4302
4303 if (!pSetupCaptureAndConvertAnsiArg(pszDeviceInterface, &pszDeviceInterfaceW))
4304 return CR_INVALID_POINTER;
4305
4306 pszAliasDeviceInterfaceW = MyMalloc(*pulLength * sizeof(WCHAR));
4307 if (pszAliasDeviceInterfaceW == NULL)
4308 {
4310 goto Done;
4311 }
4312
4313 ret = CM_Get_Device_Interface_Alias_ExW(pszDeviceInterfaceW,
4314 AliasInterfaceGuid,
4315 pszAliasDeviceInterfaceW,
4316 pulLength,
4317 ulFlags,
4318 hMachine);
4319 if (ret != CR_SUCCESS)
4320 goto Done;
4321
4323 0,
4324 pszAliasDeviceInterfaceW,
4325 *pulLength + 1,
4326 pszAliasDeviceInterface,
4327 *pulLength + 1,
4328 NULL,
4329 NULL) == 0)
4330 ret = CR_FAILURE;
4331
4332Done:
4333 if (pszAliasDeviceInterfaceW != NULL)
4334 MyFree(pszAliasDeviceInterfaceW);
4335
4336 if (pszDeviceInterfaceW != NULL)
4337 MyFree(pszDeviceInterfaceW);
4338
4339 return ret;
4340}
4341
4342
4343/***********************************************************************
4344 * CM_Get_Device_Interface_Alias_ExW [SETUPAPI.@]
4345 */
4347WINAPI
4349 _In_ LPCWSTR pszDeviceInterface,
4350 _In_ LPGUID AliasInterfaceGuid,
4351 _Out_writes_(*pulLength) LPWSTR pszAliasDeviceInterface,
4352 _Inout_ PULONG pulLength,
4353 _In_ ULONG ulFlags,
4354 _In_opt_ HMACHINE hMachine)
4355{
4357 ULONG ulTransferLength;
4359
4360 TRACE("CM_Get_Device_Interface_Alias_ExW(%p %p %p %p %lx %p)\n",
4361 pszDeviceInterface, AliasInterfaceGuid,
4362 pszAliasDeviceInterface, pulLength, ulFlags, hMachine);
4363
4364 if (pszDeviceInterface == NULL ||
4365 AliasInterfaceGuid == NULL ||
4366 pszAliasDeviceInterface == NULL ||
4367 pulLength == NULL)
4368 return CR_INVALID_POINTER;
4369
4370 if (ulFlags != 0)
4371 return CR_INVALID_FLAG;
4372
4373 if (hMachine != NULL)
4374 {
4375 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4376 if (BindingHandle == NULL)
4377 return CR_FAILURE;
4378 }
4379 else
4380 {
4382 return CR_FAILURE;
4383 }
4384
4385 ulTransferLength = *pulLength;
4386
4388 {
4390 (LPWSTR)pszDeviceInterface,
4391 AliasInterfaceGuid,
4392 pszAliasDeviceInterface,
4393 pulLength,
4394 &ulTransferLength,
4395 0);
4396 }
4398 {
4400 }
4402
4403 return ret;
4404}
4405
4406
4407/***********************************************************************
4408 * CM_Get_Device_Interface_ListA (SETUPAPI.@)
4409 */
4411WINAPI
4414 _In_opt_ DEVINSTID_A pDeviceID,
4415 _Out_writes_(BufferLen) PCHAR Buffer,
4416 _In_ ULONG BufferLen,
4417 _In_ ULONG ulFlags)
4418{
4419 TRACE("CM_Get_Device_Interface_ListA(%s %s %p %lu 0x%08lx)\n",
4421 Buffer, BufferLen, ulFlags);
4422
4424 Buffer, BufferLen, ulFlags, NULL);
4425}
4426
4427
4428/***********************************************************************
4429 * CM_Get_Device_Interface_ListW (SETUPAPI.@)
4430 */
4432WINAPI
4435 _In_opt_ DEVINSTID_W pDeviceID,
4436 _Out_writes_(BufferLen) PWCHAR Buffer,
4437 _In_ ULONG BufferLen,
4438 _In_ ULONG ulFlags)
4439{
4440 TRACE("CM_Get_Device_Interface_ListW(%s %s %p %lu 0x%08lx)\n",
4442 Buffer, BufferLen, ulFlags);
4443
4445 Buffer, BufferLen, ulFlags, NULL);
4446}
4447
4448
4449/***********************************************************************
4450 * CM_Get_Device_Interface_List_ExA (SETUPAPI.@)
4451 */
4453WINAPI
4456 _In_opt_ DEVINSTID_A pDeviceID,
4457 _Out_writes_(BufferLen) PCHAR Buffer,
4458 _In_ ULONG BufferLen,
4459 _In_ ULONG ulFlags,
4460 _In_opt_ HMACHINE hMachine)
4461{
4462 DEVINSTID_W pDeviceIdW = NULL;
4463 PWCHAR BufferW = NULL;
4465
4466 TRACE("CM_Get_Device_Interface_List_ExA(%s %s %p %lu 0x%08lx %p)\n",
4468 Buffer, BufferLen, ulFlags, hMachine);
4469
4470 if (Buffer == NULL ||
4471 BufferLen == 0)
4472 return CR_INVALID_POINTER;
4473
4474 if (pDeviceID != NULL)
4475 {
4476 if (!pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDeviceIdW))
4477 return CR_INVALID_DEVICE_ID;
4478 }
4479
4480 BufferW = MyMalloc(BufferLen * sizeof(WCHAR));
4481 if (BufferW == NULL)
4482 {
4484 goto Done;
4485 }
4486
4488 BufferW, BufferLen, ulFlags,
4489 hMachine);
4490 if (ret != CR_SUCCESS)
4491 goto Done;
4492
4494 0,
4495 BufferW,
4496 BufferLen,
4497 Buffer,
4498 BufferLen,
4499 NULL,
4500 NULL) == 0)
4501 ret = CR_FAILURE;
4502
4503Done:
4504 if (BufferW != NULL)
4505 MyFree(BufferW);
4506
4507 if (pDeviceIdW != NULL)
4508 MyFree(pDeviceIdW);
4509
4510 return ret;
4511}
4512
4513
4514/***********************************************************************
4515 * CM_Get_Device_Interface_List_ExW (SETUPAPI.@)
4516 */
4518WINAPI
4521 _In_opt_ DEVINSTID_W pDeviceID,
4522 _Out_writes_(BufferLen) PWCHAR Buffer,
4523 _In_ ULONG BufferLen,
4524 _In_ ULONG ulFlags,
4525 _In_opt_ HMACHINE hMachine)
4526{
4530
4531 TRACE("CM_Get_Device_Interface_List_ExW(%s %s %p %lu 0x%08lx %p)\n",
4533 Buffer, BufferLen, ulFlags, hMachine);
4534
4535 if (Buffer == NULL ||
4536 BufferLen == 0)
4537 return CR_INVALID_POINTER;
4538
4539 if (ulFlags & ~CM_GET_DEVICE_INTERFACE_LIST_BITS)
4540 return CR_INVALID_FLAG;
4541
4542 if (hMachine != NULL)
4543 {
4544 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4545 if (BindingHandle == NULL)
4546 return CR_FAILURE;
4547 }
4548 else
4549 {
4551 return CR_FAILURE;
4552 }
4553
4554 *Buffer = 0;
4555 BufferSize = BufferLen;
4556
4558 {
4561 pDeviceID,
4562 (LPBYTE)Buffer,
4563 &BufferSize,
4564 ulFlags);
4565 }
4567 {
4569 }
4571
4572 return ret;
4573}
4574
4575
4576/***********************************************************************
4577 * CM_Get_Device_Interface_List_SizeA (SETUPAPI.@)
4578 */
4580WINAPI
4582 _Out_ PULONG pulLen,
4584 _In_opt_ DEVINSTID_A pDeviceID,
4585 _In_ ULONG ulFlags)
4586{
4587 TRACE("CM_Get_Device_Interface_List_SizeA(%p %p %s 0x%08lx)\n",
4588 pulLen, InterfaceClassGuid, debugstr_a(pDeviceID), ulFlags);
4589
4591 pDeviceID, ulFlags, NULL);
4592}
4593
4594
4595/***********************************************************************
4596 * CM_Get_Device_Interface_List_SizeW (SETUPAPI.@)
4597 */
4599WINAPI
4601 _Out_ PULONG pulLen,
4603 _In_opt_ DEVINSTID_W pDeviceID,
4604 _In_ ULONG ulFlags)
4605{
4606 TRACE("CM_Get_Device_Interface_List_SizeW(%p %p %s 0x%08lx)\n",
4607 pulLen, InterfaceClassGuid, debugstr_w(pDeviceID), ulFlags);
4608
4610 pDeviceID, ulFlags, NULL);
4611}
4612
4613
4614/***********************************************************************
4615 * CM_Get_Device_Interface_List_Size_ExA (SETUPAPI.@)
4616 */
4618WINAPI
4620 _Out_ PULONG pulLen,
4622 _In_opt_ DEVINSTID_A pDeviceID,
4623 _In_ ULONG ulFlags,
4624 _In_opt_ HMACHINE hMachine)
4625{
4626 DEVINSTID_W pDeviceIdW = NULL;
4628
4629 TRACE("CM_Get_Device_Interface_List_Size_ExA(%p %p %s 0x%08lx %p)\n",
4630 pulLen, InterfaceClassGuid, debugstr_a(pDeviceID), ulFlags, hMachine);
4631
4632 if (pulLen == NULL)
4633 return CR_INVALID_POINTER;
4634
4635 if (pDeviceID != NULL)
4636 {
4637 if (!pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDeviceIdW))
4638 return CR_INVALID_DEVICE_ID;
4639 }
4640
4641 *pulLen = 0;
4642
4644 pDeviceIdW, ulFlags, hMachine);
4645
4646 if (pDeviceIdW != NULL)
4647 MyFree(pDeviceIdW);
4648
4649 return ret;
4650}
4651
4652
4653/***********************************************************************
4654 * CM_Get_Device_Interface_List_Size_ExW (SETUPAPI.@)
4655 */
4657WINAPI
4659 _Out_ PULONG pulLen,
4661 _In_opt_ DEVINSTID_W pDeviceID,
4662 _In_ ULONG ulFlags,
4663 _In_opt_ HMACHINE hMachine)
4664{
4667
4668 TRACE("CM_Get_Device_Interface_List_Size_ExW(%p %p %s 0x%08lx %p)\n",
4669 pulLen, InterfaceClassGuid, debugstr_w(pDeviceID), ulFlags, hMachine);
4670
4671 if (pulLen == NULL)
4672 return CR_INVALID_POINTER;
4673
4674 if (ulFlags & ~CM_GET_DEVICE_INTERFACE_LIST_BITS)
4675 return CR_INVALID_FLAG;
4676
4677 if (hMachine != NULL)
4678 {
4679 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4680 if (BindingHandle == NULL)
4681 return CR_FAILURE;
4682 }
4683 else
4684 {
4686 return CR_FAILURE;
4687 }
4688
4689 *pulLen = 0;
4690
4692 {
4694 pulLen,
4696 pDeviceID,
4697 ulFlags);
4698 }
4700 {
4702 }
4704
4705 return ret;
4706}
4707
4708
4709/***********************************************************************
4710 * CM_Get_First_Log_Conf [SETUPAPI.@]
4711 */
4713WINAPI
4715 _Out_opt_ PLOG_CONF plcLogConf,
4716 _In_ DEVINST dnDevInst,
4717 _In_ ULONG ulFlags)
4718{
4719 TRACE("CM_Get_First_Log_Conf(%p %lx %lx)\n",
4720 plcLogConf, dnDevInst, ulFlags);
4721
4722 return CM_Get_First_Log_Conf_Ex(plcLogConf, dnDevInst, ulFlags, NULL);
4723}
4724
4725
4726/***********************************************************************
4727 * CM_Get_First_Log_Conf_Ex [SETUPAPI.@]
4728 */
4730WINAPI
4732 _Out_opt_ PLOG_CONF plcLogConf,
4733 _In_ DEVINST dnDevInst,
4734 _In_ ULONG ulFlags,
4735 _In_opt_ HMACHINE hMachine)
4736{
4738 HSTRING_TABLE StringTable = NULL;
4739 LPWSTR lpDevInst = NULL;
4741 ULONG ulTag;
4742 PLOG_CONF_INFO pLogConfInfo;
4743
4744 FIXME("CM_Get_First_Log_Conf_Ex(%p %lx %lx %p)\n",
4745 plcLogConf, dnDevInst, ulFlags, hMachine);
4746
4747 if (dnDevInst == 0)
4748 return CR_INVALID_DEVINST;
4749
4750 if (ulFlags & ~LOG_CONF_BITS)
4751 return CR_INVALID_FLAG;
4752
4753 if (plcLogConf)
4754 *plcLogConf = 0;
4755
4756 if (hMachine != NULL)
4757 {
4758 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4759 if (BindingHandle == NULL)
4760 return CR_FAILURE;
4761
4762 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4763 if (StringTable == 0)
4764 return CR_FAILURE;
4765 }
4766 else
4767 {
4768 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
4769 return CR_FAILURE;
4770 }
4771
4772 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
4773 if (lpDevInst == NULL)
4774 return CR_INVALID_DEVNODE;
4775
4777 {
4779 lpDevInst,
4780 ulFlags,
4781 &ulTag,
4782 ulFlags);
4783 }
4785 {
4787 }
4789
4790 if (ret != CR_SUCCESS)
4791 return ret;
4792
4793 if (plcLogConf)
4794 {
4795 pLogConfInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(LOG_CONF_INFO));
4796 if (pLogConfInfo == NULL)
4797 return CR_OUT_OF_MEMORY;
4798
4799 pLogConfInfo->ulMagic = LOG_CONF_MAGIC;
4800 pLogConfInfo->dnDevInst = dnDevInst;
4801 pLogConfInfo->ulType = ulFlags;
4802 pLogConfInfo->ulTag = ulTag;
4803
4804 *plcLogConf = (LOG_CONF)pLogConfInfo;
4805 }
4806
4807 return CR_SUCCESS;
4808}
4809
4810
4811/***********************************************************************
4812 * CM_Get_Global_State [SETUPAPI.@]
4813 */
4815WINAPI
4817 _Out_ PULONG pulState,
4818 _In_ ULONG ulFlags)
4819{
4820 TRACE("CM_Get_Global_State(%p %lx)\n",
4821 pulState, ulFlags);
4822
4823 return CM_Get_Global_State_Ex(pulState, ulFlags, NULL);
4824}
4825
4826
4827/***********************************************************************
4828 * CM_Get_Global_State_Ex [SETUPAPI.@]
4829 */
4831WINAPI
4833 _Out_ PULONG pulState,
4834 _In_ ULONG ulFlags,
4835 _In_opt_ HMACHINE hMachine)
4836{
4838 CONFIGRET ret;
4839
4840 TRACE("CM_Get_Global_State_Ex(%p %lx %p)\n",
4841 pulState, ulFlags, hMachine);
4842
4843 if (pulState == NULL)
4844 return CR_INVALID_POINTER;
4845
4846 if (ulFlags != 0)
4847 return CR_INVALID_FLAG;
4848
4849 if (hMachine != NULL)
4850 {
4851 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4852 if (BindingHandle == NULL)
4853 return CR_FAILURE;
4854 }
4855 else
4856 {
4858 return CR_FAILURE;
4859 }
4860
4862 {
4863 ret = PNP_GetGlobalState(BindingHandle, pulState, ulFlags);
4864 }
4866 {
4868 }
4870
4871 return ret;
4872}
4873
4874
4875/***********************************************************************
4876 * CM_Get_HW_Prof_FlagsA [SETUPAPI.@]
4877 */
4879WINAPI
4881 _In_ DEVINSTID_A szDevInstName,
4882 _In_ ULONG ulHardwareProfile,
4883 _Out_ PULONG pulValue,
4884 _In_ ULONG ulFlags)
4885{
4886 TRACE("CM_Get_HW_Prof_FlagsA(%s %lu %p %lx)\n",
4887 debugstr_a(szDevInstName), ulHardwareProfile, pulValue, ulFlags);
4888
4889 return CM_Get_HW_Prof_Flags_ExA(szDevInstName, ulHardwareProfile,
4890 pulValue, ulFlags, NULL);
4891}
4892
4893
4894/***********************************************************************
4895 * CM_Get_HW_Prof_FlagsW [SETUPAPI.@]
4896 */
4898WINAPI
4900 _In_ DEVINSTID_W szDevInstName,
4901 _In_ ULONG ulHardwareProfile,
4902 _Out_ PULONG pulValue,
4903 _In_ ULONG ulFlags)
4904{
4905 TRACE("CM_Get_HW_Prof_FlagsW(%s %lu %p %lx)\n",
4906 debugstr_w(szDevInstName), ulHardwareProfile, pulValue, ulFlags);
4907
4908 return CM_Get_HW_Prof_Flags_ExW(szDevInstName, ulHardwareProfile,
4909 pulValue, ulFlags, NULL);
4910}
4911
4912
4913/***********************************************************************
4914 * CM_Get_HW_Prof_Flags_ExA [SETUPAPI.@]
4915 */
4917WINAPI
4919 _In_ DEVINSTID_A szDevInstName,
4920 _In_ ULONG ulHardwareProfile,
4921 _Out_ PULONG pulValue,
4922 _In_ ULONG ulFlags,
4923 _In_opt_ HMACHINE hMachine)
4924{
4925 DEVINSTID_W pszDevIdW = NULL;
4927
4928 TRACE("CM_Get_HW_Prof_Flags_ExA(%s %lu %p %lx %p)\n",
4929 debugstr_a(szDevInstName), ulHardwareProfile, pulValue, ulFlags, hMachine);
4930
4931 if (szDevInstName != NULL)
4932 {
4933 if (pSetupCaptureAndConvertAnsiArg(szDevInstName, &pszDevIdW))
4934 return CR_INVALID_DEVICE_ID;
4935 }
4936
4937 ret = CM_Get_HW_Prof_Flags_ExW(pszDevIdW, ulHardwareProfile,
4938 pulValue, ulFlags, hMachine);
4939
4940 if (pszDevIdW != NULL)
4941 MyFree(pszDevIdW);
4942
4943 return ret;
4944}
4945
4946
4947/***********************************************************************
4948 * CM_Get_HW_Prof_Flags_ExW [SETUPAPI.@]
4949 */
4951WINAPI
4953 _In_ DEVINSTID_W szDevInstName,
4954 _In_ ULONG ulHardwareProfile,
4955 _Out_ PULONG pulValue,
4956 _In_ ULONG ulFlags,
4957 _In_opt_ HMACHINE hMachine)
4958{
4960 CONFIGRET ret;
4961
4962 FIXME("CM_Get_HW_Prof_Flags_ExW(%s %lu %p %lx %p)\n",
4963 debugstr_w(szDevInstName), ulHardwareProfile, pulValue, ulFlags, hMachine);
4964
4965 if ((szDevInstName == NULL) || (pulValue == NULL))
4966 return CR_INVALID_POINTER;
4967
4968 if (ulFlags != 0)
4969 return CR_INVALID_FLAG;
4970
4971 /* FIXME: Check whether szDevInstName is valid */
4972
4973 if (hMachine != NULL)
4974 {
4975 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4976 if (BindingHandle == NULL)
4977 return CR_FAILURE;
4978 }
4979 else
4980 {
4982 return CR_FAILURE;
4983 }
4984
4986 {
4987 ret = PNP_HwProfFlags(BindingHandle, PNP_GET_HWPROFFLAGS, szDevInstName,
4988 ulHardwareProfile, pulValue, NULL, NULL, 0, 0);
4989 }
4991 {
4993 }
4995
4996 return ret;
4997}
4998
4999
5000/***********************************************************************
5001 * CM_Get_Hardware_Profile_InfoA [SETUPAPI.@]
5002 */
5004WINAPI
5006 _In_ ULONG ulIndex,
5007 _Out_ PHWPROFILEINFO_A pHWProfileInfo,
5008 _In_ ULONG ulFlags)
5009{
5010 TRACE("CM_Get_Hardware_Profile_InfoA(%lu %p %lx)\n",
5011 ulIndex, pHWProfileInfo, ulFlags);
5012
5013 return CM_Get_Hardware_Profile_Info_ExA(ulIndex, pHWProfileInfo,
5014 ulFlags, NULL);
5015}
5016
5017
5018/***********************************************************************
5019 * CM_Get_Hardware_Profile_InfoW [SETUPAPI.@]
5020 */
5022WINAPI
5024 _In_ ULONG ulIndex,
5025 _Out_ PHWPROFILEINFO_W pHWProfileInfo,
5026 _In_ ULONG ulFlags)
5027{
5028 TRACE("CM_Get_Hardware_Profile_InfoW(%lu %p %lx)\n",
5029 ulIndex, pHWProfileInfo, ulFlags);
5030
5031 return CM_Get_Hardware_Profile_Info_ExW(ulIndex, pHWProfileInfo,
5032 ulFlags, NULL);
5033}
5034
5035
5036/***********************************************************************
5037 * CM_Get_Hardware_Profile_Info_ExA [SETUPAPI.@]
5038 */
5040WINAPI
5042 _In_ ULONG ulIndex,
5043 _Out_ PHWPROFILEINFO_A pHWProfileInfo,
5044 _In_ ULONG ulFlags,
5045 _In_opt_ HMACHINE hMachine)
5046{
5047 HWPROFILEINFO_W LocalProfileInfo;
5048 CONFIGRET ret;
5049
5050 TRACE("CM_Get_Hardware_Profile_Info_ExA(%lu %p %lx %p)\n",
5051 ulIndex, pHWProfileInfo, ulFlags, hMachine);
5052
5053 if (pHWProfileInfo == NULL)
5054 return CR_INVALID_POINTER;
5055
5056 ret = CM_Get_Hardware_Profile_Info_ExW(ulIndex, &LocalProfileInfo,
5057 ulFlags, hMachine);
5058 if (ret == CR_SUCCESS)
5059 {
5060 pHWProfileInfo->HWPI_ulHWProfile = LocalProfileInfo.HWPI_ulHWProfile;
5061 pHWProfileInfo->HWPI_dwFlags = LocalProfileInfo.HWPI_dwFlags;
5062
5064 0,
5065 LocalProfileInfo.HWPI_szFriendlyName,
5066 lstrlenW(LocalProfileInfo.HWPI_szFriendlyName) + 1,
5067 pHWProfileInfo->HWPI_szFriendlyName,
5069 NULL,
5070 NULL) == 0)
5071 ret = CR_FAILURE;
5072 }
5073
5074 return ret;
5075}
5076
5077
5078/***********************************************************************
5079 * CM_Get_Hardware_Profile_Info_ExW [SETUPAPI.@]
5080 */
5082WINAPI
5084 _In_ ULONG ulIndex,
5085 _Out_ PHWPROFILEINFO_W pHWProfileInfo,
5086 _In_ ULONG ulFlags,
5087 _In_opt_ HMACHINE hMachine)
5088{
5090 CONFIGRET ret;
5091
5092 TRACE("CM_Get_Hardware_Profile_Info_ExW(%lu %p %lx %p)\n",
5093 ulIndex, pHWProfileInfo, ulFlags, hMachine);
5094
5095 if (pHWProfileInfo == NULL)
5096 return CR_INVALID_POINTER;
5097
5098 if (ulFlags != 0)
5099 return CR_INVALID_FLAG;
5100
5101 if (hMachine != NULL)
5102 {
5103 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5104 if (BindingHandle == NULL)
5105 return CR_FAILURE;
5106 }
5107 else
5108 {
5110 return CR_FAILURE;
5111 }
5112
5114 {
5115 ret = PNP_GetHwProfInfo(BindingHandle, ulIndex, pHWProfileInfo,
5116 sizeof(HWPROFILEINFO_W), 0);
5117 }
5119 {
5121 }
5123
5124 return ret;
5125}
5126
5127
5128/***********************************************************************
5129 * CM_Get_Log_Conf_Priority [SETUPAPI.@]
5130 */
5132WINAPI
5134 _In_ LOG_CONF lcLogConf,
5135 _Out_ PPRIORITY pPriority,
5136 _In_ ULONG ulFlags)
5137{
5138 TRACE("CM_Get_Log_Conf_Priority(%p %p %lx)\n",
5139 lcLogConf, pPriority, ulFlags);
5140
5141 return CM_Get_Log_Conf_Priority_Ex(lcLogConf, pPriority, ulFlags, NULL);
5142}
5143
5144
5145/***********************************************************************
5146 * CM_Get_Log_Conf_Priority_Ex [SETUPAPI.@]
5147 */
5149WINAPI
5151 _In_ LOG_CONF lcLogConf,
5152 _Out_ PPRIORITY pPriority,
5153 _In_ ULONG ulFlags,
5154 _In_opt_ HMACHINE hMachine)
5155{
5157 HSTRING_TABLE StringTable = NULL;
5158 PLOG_CONF_INFO pLogConfInfo;
5159 LPWSTR lpDevInst;
5160 CONFIGRET ret;
5161
5162 FIXME("CM_Get_Log_Conf_Priority_Ex(%p %p %lx %p)\n",
5163 lcLogConf, pPriority, ulFlags, hMachine);
5164
5165 pLogConfInfo = (PLOG_CONF_INFO)lcLogConf;
5166 if (!IsValidLogConf(pLogConfInfo))
5167 return CR_INVALID_LOG_CONF;
5168
5169 if (pPriority == NULL)
5170 return CR_INVALID_POINTER;
5171
5172 if (ulFlags != 0)
5173 return CR_INVALID_FLAG;
5174
5175 if (hMachine != NULL)
5176 {
5177 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5178 if (BindingHandle == NULL)
5179 return CR_FAILURE;
5180
5181 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5182 if (StringTable == 0)
5183 return CR_FAILURE;
5184 }
5185 else
5186 {
5187 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5188 return CR_FAILURE;
5189 }
5190
5191 lpDevInst = pSetupStringTableStringFromId(StringTable, pLogConfInfo->dnDevInst);
5192 if (lpDevInst == NULL)
5193 return CR_INVALID_DEVNODE;
5194
5196 {
5198 lpDevInst,
5199 pLogConfInfo->ulType,
5200 pLogConfInfo->ulTag,
5201 pPriority,
5202 0);
5203 }
5205 {
5207 }
5209
5210 return ret;
5211}
5212
5213
5214/***********************************************************************
5215 * CM_Get_Next_Log_Conf [SETUPAPI.@]
5216 */
5218WINAPI
5220 _Out_opt_ PLOG_CONF plcLogConf,
5221 _In_ LOG_CONF lcLogConf,
5222 _In_ ULONG ulFlags)
5223{
5224 TRACE("CM_Get_Next_Log_Conf(%p %p %lx)\n",
5225 plcLogConf, lcLogConf, ulFlags);
5226
5227 return CM_Get_Next_Log_Conf_Ex(plcLogConf, lcLogConf, ulFlags, NULL);
5228}
5229
5230
5231/***********************************************************************
5232 * CM_Get_Next_Log_Conf_Ex [SETUPAPI.@]
5233 */
5235WINAPI
5237 _Out_opt_ PLOG_CONF plcLogConf,
5238 _In_ LOG_CONF lcLogConf,
5239 _In_ ULONG ulFlags,
5240 _In_opt_ HMACHINE hMachine)
5241{
5243 HSTRING_TABLE StringTable = NULL;
5244 PLOG_CONF_INFO pLogConfInfo;
5245 PLOG_CONF_INFO pNewLogConfInfo;
5246 ULONG ulNewTag;
5247 LPWSTR lpDevInst;
5248 CONFIGRET ret;
5249
5250 FIXME("CM_Get_Next_Log_Conf_Ex(%p %p %lx %p)\n",
5251 plcLogConf, lcLogConf, ulFlags, hMachine);
5252
5253 if (plcLogConf)
5254 *plcLogConf = 0;
5255
5256 pLogConfInfo = (PLOG_CONF_INFO)lcLogConf;
5257 if (!IsValidLogConf(pLogConfInfo))
5258 return CR_INVALID_LOG_CONF;
5259
5260 if (ulFlags != 0)
5261 return CR_INVALID_FLAG;
5262
5263 if (hMachine != NULL)
5264 {
5265 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5266 if (BindingHandle == NULL)
5267 return CR_FAILURE;
5268
5269 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5270 if (StringTable == 0)
5271 return CR_FAILURE;
5272 }
5273 else
5274 {
5275 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5276 return CR_FAILURE;
5277 }
5278
5279 lpDevInst = pSetupStringTableStringFromId(StringTable, pLogConfInfo->dnDevInst);
5280 if (lpDevInst == NULL)
5281 return CR_INVALID_DEVNODE;
5282
5284 {
5286 lpDevInst,
5287 pLogConfInfo->ulType,
5288 pLogConfInfo->ulTag,
5289 &ulNewTag,
5290 0);
5291 }
5293 {
5295 }
5297
5298 if (ret != CR_SUCCESS)
5299 return ret;
5300
5301 if (plcLogConf)
5302 {
5303 pNewLogConfInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(LOG_CONF_INFO));
5304 if (pNewLogConfInfo == NULL)
5305 return CR_OUT_OF_MEMORY;
5306
5307 pNewLogConfInfo->ulMagic = LOG_CONF_MAGIC;
5308 pNewLogConfInfo->dnDevInst = pLogConfInfo->dnDevInst;
5309 pNewLogConfInfo->ulType = pLogConfInfo->ulType;
5310 pNewLogConfInfo->ulTag = ulNewTag;
5311
5312 *plcLogConf = (LOG_CONF)pNewLogConfInfo;
5313 }
5314
5315 return CR_SUCCESS;
5316}
5317
5318
5319/***********************************************************************
5320 * CM_Get_Next_Res_Des [SETUPAPI.@]
5321 */
5323WINAPI
5325 _Out_ PRES_DES prdResDes,
5326 _In_ RES_DES rdResDes,
5327 _In_ RESOURCEID ForResource,
5328 _Out_opt_ PRESOURCEID pResourceID,
5329 _In_ ULONG ulFlags)
5330{
5331 TRACE("CM_Get_Next_Res_Des(%p %p %lu %p %lx)\n",
5332 prdResDes, rdResDes, ForResource, pResourceID, ulFlags);
5333
5334 return CM_Get_Next_Res_Des_Ex(prdResDes, rdResDes, ForResource,
5335 pResourceID, ulFlags, NULL);
5336}
5337
5338
5339/***********************************************************************
5340 * CM_Get_Next_Re_Des_Ex [SETUPAPI.@]
5341 */
5343WINAPI
5345 _Out_ PRES_DES prdResDes,
5346 _In_ RES_DES rdResDes,
5347 _In_ RESOURCEID ForResource,
5348 _Out_opt_ PRESOURCEID pResourceID,
5349 _In_ ULONG ulFlags,
5350 _In_opt_ HMACHINE hMachine)
5351{
5353 HSTRING_TABLE StringTable = NULL;
5354 PRES_DES_INFO pNewResDesInfo = NULL;
5355 ULONG ulLogConfTag, ulLogConfType, ulResDesTag;
5356 ULONG ulNextResDesType = 0, ulNextResDesTag = 0;
5357 LPWSTR lpDevInst;
5358 DEVINST dnDevInst;
5359 CONFIGRET ret;
5360
5361 FIXME("CM_Get_Next_Res_Des_Ex(%p %p %lu %p %lx %p)\n",
5362 prdResDes, rdResDes, ForResource, pResourceID, ulFlags, hMachine);
5363
5364 if (prdResDes == NULL)
5365 return CR_INVALID_POINTER;
5366
5367 if (IsValidLogConf((PLOG_CONF_INFO)rdResDes))
5368 {
5369 FIXME("LogConf found!\n");
5370 dnDevInst = ((PLOG_CONF_INFO)rdResDes)->dnDevInst;
5371 ulLogConfTag = ((PLOG_CONF_INFO)rdResDes)->ulTag;
5372 ulLogConfType = ((PLOG_CONF_INFO)rdResDes)->ulType;
5373 ulResDesTag = (ULONG)-1;
5374 }
5375 else if (IsValidResDes((PRES_DES_INFO)rdResDes))
5376 {
5377 FIXME("ResDes found!\n");
5378 dnDevInst = ((PRES_DES_INFO)rdResDes)->dnDevInst;
5379 ulLogConfTag = ((PRES_DES_INFO)rdResDes)->ulLogConfTag;
5380 ulLogConfType = ((PRES_DES_INFO)rdResDes)->ulLogConfType;
5381 ulResDesTag = ((PRES_DES_INFO)rdResDes)->ulResDesTag;
5382 }
5383 else
5384 {
5385 return CR_INVALID_RES_DES;
5386 }
5387
5388 if ((ForResource == ResType_All) && (pResourceID == NULL))
5389 return CR_INVALID_POINTER;
5390
5391 if (ulFlags != 0)
5392 return CR_INVALID_FLAG;
5393
5394 if (hMachine != NULL)
5395 {
5396 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5397 if (BindingHandle == NULL)
5398 return CR_FAILURE;
5399
5400 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5401 if (StringTable == 0)
5402 return CR_FAILURE;
5403 }
5404 else
5405 {
5406 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5407 return CR_FAILURE;
5408 }
5409
5410 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
5411 if (lpDevInst == NULL)
5412 return CR_INVALID_DEVNODE;
5413
5415 {
5417 lpDevInst,
5418 ulLogConfTag,
5419 ulLogConfType,
5420 ForResource,
5421 ulResDesTag,
5422 &ulNextResDesTag,
5423 &ulNextResDesType,
5424 0);
5425 }
5427 {
5429 }
5431
5432 if (ret != CR_SUCCESS)
5433 return ret;
5434
5435 if (ForResource == ResType_All)
5436 *pResourceID = ulNextResDesType;
5437
5438 if (prdResDes)
5439 {
5440 pNewResDesInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(RES_DES_INFO));
5441 if (pNewResDesInfo == NULL)
5442 return CR_OUT_OF_MEMORY;
5443
5444 pNewResDesInfo->ulMagic = LOG_CONF_MAGIC;
5445 pNewResDesInfo->dnDevInst = dnDevInst;
5446 pNewResDesInfo->ulLogConfType = ulLogConfType;
5447 pNewResDesInfo->ulLogConfTag = ulLogConfTag;
5448 pNewResDesInfo->ulResDesType = ulNextResDesType;
5449 pNewResDesInfo->ulResDesTag = ulNextResDesTag;
5450
5451 *prdResDes = (RES_DES)pNewResDesInfo;
5452 }
5453
5454 return CR_SUCCESS;
5455}
5456
5457
5458/***********************************************************************
5459 * CM_Get_Parent [SETUPAPI.@]
5460 */
5462WINAPI
5464 _Out_ PDEVINST pdnDevInst,
5465 _In_ DEVINST dnDevInst,
5466 _In_ ULONG ulFlags)
5467{
5468 TRACE("CM_Get_Parent(%p %p %lx)\n",
5469 pdnDevInst, dnDevInst, ulFlags);
5470
5471 return CM_Get_Parent_Ex(pdnDevInst, dnDevInst, ulFlags, NULL);
5472}
5473
5474
5475/***********************************************************************
5476 * CM_Get_Parent_Ex [SETUPAPI.@]
5477 */
5479WINAPI
5481 _Out_ PDEVINST pdnDevInst,
5482 _In_ DEVINST dnDevInst,
5483 _In_ ULONG ulFlags,
5484 _In_opt_ HMACHINE hMachine)
5485{
5486 WCHAR szRelatedDevInst[MAX_DEVICE_ID_LEN];
5488 HSTRING_TABLE StringTable = NULL;
5489 LPWSTR lpDevInst;
5490 DWORD dwIndex, dwLength = MAX_DEVICE_ID_LEN;
5491 CONFIGRET ret;
5492
5493 TRACE("CM_Get_Parent_Ex(%p %lx %lx %p)\n",
5494 pdnDevInst, dnDevInst, ulFlags, hMachine);
5495
5496 if (pdnDevInst == NULL)
5497 return CR_INVALID_POINTER;
5498
5499 if (dnDevInst == 0)
5500 return CR_INVALID_DEVINST;
5501
5502 if (ulFlags != 0)
5503 return CR_INVALID_FLAG;
5504
5505 *pdnDevInst = -1;
5506
5507 if (hMachine != NULL)
5508 {
5509 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5510 if (BindingHandle == NULL)
5511 return CR_FAILURE;
5512
5513 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5514 if (StringTable == 0)
5515 return CR_FAILURE;
5516 }
5517 else
5518 {
5519 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5520 return CR_FAILURE;
5521 }
5522
5523 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
5524 if (lpDevInst == NULL)
5525 return CR_INVALID_DEVNODE;
5526
5528 {
5530 PNP_GET_PARENT_DEVICE_INSTANCE,
5531 lpDevInst,
5532 szRelatedDevInst,
5533 &dwLength,
5534 0);
5535 }
5537 {
5539 }
5541
5542 if (ret != CR_SUCCESS)
5543 return ret;
5544
5545 TRACE("szRelatedDevInst: %s\n", debugstr_w(szRelatedDevInst));
5546
5547 dwIndex = pSetupStringTableAddString(StringTable, szRelatedDevInst, 1);
5548 if (dwIndex == -1)
5549 return CR_FAILURE;
5550
5551 *pdnDevInst = dwIndex;
5552
5553 return CR_SUCCESS;
5554}
5555
5556
5557/***********************************************************************
5558 * CM_Get_Res_Des_Data [SETUPAPI.@]
5559 */
5561WINAPI
5563 _In_ RES_DES rdResDes,
5564 _Out_writes_bytes_(BufferLen) PVOID Buffer,
5565 _In_ ULONG BufferLen,
5566 _In_ ULONG ulFlags)
5567{
5568 TRACE("CM_Get_Res_Des_Data(%p %p %lu %lx)\n",
5569 rdResDes, Buffer, BufferLen, ulFlags);
5570
5571 return CM_Get_Res_Des_Data_Ex(rdResDes, Buffer, BufferLen, ulFlags, NULL);
5572}
5573
5574
5575/***********************************************************************
5576 * CM_Get_Res_Des_Data_Ex [SETUPAPI.@]
5577 */
5579WINAPI
5581 _In_ RES_DES rdResDes,
5582 _Out_writes_bytes_(BufferLen) PVOID Buffer,
5583 _In_ ULONG BufferLen,
5584 _In_ ULONG ulFlags,
5585 _In_opt_ HMACHINE hMachine)
5586{
5587 FIXME("CM_Get_Res_Des_Data_Ex(%p %p %lu %lx %p)\n",
5588 rdResDes, Buffer, BufferLen, ulFlags, hMachine);
5589
5591}
5592
5593
5594/***********************************************************************
5595 * CM_Get_Res_Des_Size [SETUPAPI.@]
5596 */
5598WINAPI
5601 _In_ RES_DES rdResDes,
5602 _In_ ULONG ulFlags)
5603{
5604 TRACE("CM_Get_Res_Des_Data_Size(%p %p %lx)\n",
5605 pulSize, rdResDes, ulFlags);
5606
5607 return CM_Get_Res_Des_Data_Size_Ex(pulSize, rdResDes, ulFlags, NULL);
5608}
5609
5610
5611/***********************************************************************
5612 * CM_Get_Res_Des_Size_Ex [SETUPAPI.@]
5613 */
5615WINAPI
5618 _In_ RES_DES rdResDes,
5619 _In_ ULONG ulFlags,
5620 _In_opt_ HMACHINE hMachine)
5621{
5622 TRACE("CM_Get_Res_Des_Data_Size_Ex(%p %p %lx %p)\n",
5623 pulSize, rdResDes, ulFlags, hMachine);
5624
5626}
5627
5628
5629/***********************************************************************
5630 * CM_Get_Resource_Conflict_Count [SETUPAPI.@]
5631 */
5633WINAPI
5635 _In_ CONFLICT_LIST clConflictList,
5636 _Out_ PULONG pulCount)
5637{
5638 PCONFLICT_DATA pConflictData;
5639
5640 FIXME("CM_Get_Resource_Conflict_Count(%p %p)\n",
5641 clConflictList, pulCount);
5642
5643 pConflictData = (PCONFLICT_DATA)clConflictList;
5644 if (!IsValidConflictData(pConflictData))
5646
5647 if (pulCount == NULL)
5648 return CR_INVALID_POINTER;
5649
5650 *pulCount = pConflictData->pConflictList->ConflictsListed;
5651
5652 return CR_SUCCESS;
5653}
5654
5655
5656/***********************************************************************
5657 * CM_Get_Resource_Conflict_DetailsA [SETUPAPI.@]
5658 */
5660WINAPI
5662 _In_ CONFLICT_LIST clConflictList,
5663 _In_ ULONG ulIndex,
5664 _Inout_ PCONFLICT_DETAILS_A pConflictDetails)
5665{
5666 FIXME("CM_Get_Resource_Conflict_CountA(%p %lu %p)\n",
5667 clConflictList, ulIndex, pConflictDetails);
5668
5670}
5671
5672
5673/***********************************************************************
5674 * CM_Get_Resource_Conflict_DetailsW [SETUPAPI.@]
5675 */
5677WINAPI
5679 _In_ CONFLICT_LIST clConflictList,
5680 _In_ ULONG ulIndex,
5681 _Inout_ PCONFLICT_DETAILS_W pConflictDetails)
5682{
5683 FIXME("CM_Get_Resource_Conflict_CountW(%p %lu %p)\n",
5684 clConflictList, ulIndex, pConflictDetails);
5685
5687}
5688
5689
5690/***********************************************************************
5691 * CM_Get_Sibling [SETUPAPI.@]
5692 */
5694WINAPI
5696 _Out_ PDEVINST pdnDevInst,
5697 _In_ DEVINST dnDevInst,
5698 _In_ ULONG ulFlags)
5699{
5700 TRACE("CM_Get_Sibling(%p %p %lx)\n",
5701 pdnDevInst, dnDevInst, ulFlags);
5702
5703 return CM_Get_Sibling_Ex(pdnDevInst, dnDevInst, ulFlags, NULL);
5704}
5705
5706
5707/***********************************************************************
5708 * CM_Get_Sibling_Ex [SETUPAPI.@]
5709 */
5711WINAPI
5713 _Out_ PDEVINST pdnDevInst,
5714 _In_ DEVINST dnDevInst,
5715 _In_ ULONG ulFlags,
5716 _In_opt_ HMACHINE hMachine)
5717{
5718 WCHAR szRelatedDevInst[MAX_DEVICE_ID_LEN];
5720 HSTRING_TABLE StringTable = NULL;
5721 LPWSTR lpDevInst;
5722 DWORD dwIndex, dwLength = MAX_DEVICE_ID_LEN;
5723 CONFIGRET ret;
5724
5725 TRACE("CM_Get_Sibling_Ex(%p %lx %lx %p)\n",
5726 pdnDevInst, dnDevInst, ulFlags, hMachine);
5727
5728 if (pdnDevInst == NULL)
5729 return CR_INVALID_POINTER;
5730
5731 if (dnDevInst == 0)
5732 return CR_INVALID_DEVINST;
5733
5734 if (ulFlags != 0)
5735 return CR_INVALID_FLAG;
5736
5737 *pdnDevInst = -1;
5738
5739 if (hMachine != NULL)
5740 {
5741 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5742 if (BindingHandle == NULL)
5743 return CR_FAILURE;
5744
5745 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5746 if (StringTable == 0)
5747 return CR_FAILURE;
5748 }
5749 else
5750 {
5751 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5752 return CR_FAILURE;
5753 }
5754
5755 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
5756 if (lpDevInst == NULL)
5757 return CR_INVALID_DEVNODE;
5758
5760 {
5762 PNP_GET_SIBLING_DEVICE_INSTANCE,
5763 lpDevInst,
5764 szRelatedDevInst,
5765 &dwLength,
5766 0);
5767 }
5769 {
5771 }
5773
5774 if (ret != CR_SUCCESS)
5775 return ret;
5776
5777 TRACE("szRelatedDevInst: %s\n", debugstr_w(szRelatedDevInst));
5778
5779 dwIndex = pSetupStringTableAddString(StringTable, szRelatedDevInst, 1);
5780 if (dwIndex == -1)
5781 return CR_FAILURE;
5782
5783 *pdnDevInst = dwIndex;
5784
5785 return CR_SUCCESS;
5786}
5787
5788
5789/***********************************************************************
5790 * CM_Get_Version [SETUPAPI.@]
5791 */
5792WORD
5793WINAPI
5795{
5796 TRACE("CM_Get_Version()\n");
5797
5798 return CM_Get_Version_Ex(NULL);
5799}
5800
5801
5802/***********************************************************************
5803 * CM_Get_Version_Ex [SETUPAPI.@]
5804 */
5805WORD
5806WINAPI
5808 _In_opt_ HMACHINE hMachine)
5809{
5811 WORD Version = 0;
5812 CONFIGRET ret;
5813
5814 TRACE("CM_Get_Version_Ex(%p)\n", hMachine);
5815
5816 if (hMachine != NULL)
5817 {
5818 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5819 if (BindingHandle == NULL)
5820 return 0;
5821 }
5822 else
5823 {
5825 return CR_FAILURE;
5826 }
5827
5829 {
5831 }
5833 {
5835 }
5837
5838 if (ret != CR_SUCCESS)
5839 return 0;
5840
5841 return Version;
5842}
5843
5844
5845/***********************************************************************
5846 * CM_Intersect_Range_List [SETUPAPI.@]
5847 */
5849WINAPI
5851 _In_ RANGE_LIST rlhOld1,
5852 _In_ RANGE_LIST rlhOld2,
5853 _In_ RANGE_LIST rlhNew,
5854 _In_ ULONG ulFlags)
5855{
5856 FIXME("CM_Intersect_Range_List(%p %p %p %lx)\n",
5857 rlhOld1, rlhOld2, rlhNew, ulFlags);
5858
5860}
5861
5862
5863/***********************************************************************
5864 * CM_Invert_Range_List [SETUPAPI.@]
5865 */
5867WINAPI
5869 _In_ RANGE_LIST rlhOld,
5870 _In_ RANGE_LIST rlhNew,
5871 _In_ DWORDLONG ullMaxValue,
5872 _In_ ULONG ulFlags)
5873{
5874 FIXME("CM_Invert_Range_List(%p %p %I64u %lx)\n",
5875 rlhOld, rlhNew, ullMaxValue, ulFlags);
5876
5878}
5879
5880
5881/***********************************************************************
5882 * CM_Is_Dock_Station_Present [SETUPAPI.@]
5883 */
5885WINAPI
5887 _Out_ PBOOL pbPresent)
5888{
5889 TRACE("CM_Is_Dock_Station_Present(%p)\n",
5890 pbPresent);
5891
5892 return CM_Is_Dock_Station_Present_Ex(pbPresent, NULL);
5893}
5894
5895
5896/***********************************************************************
5897 * CM_Is_Dock_Station_Present_Ex [SETUPAPI.@]
5898 */
5900WINAPI
5902 _Out_ PBOOL pbPresent,
5903 _In_opt_ HMACHINE hMachine)
5904{
5906 CONFIGRET ret;
5907
5908 TRACE("CM_Is_Dock_Station_Present_Ex(%p %p)\n",
5909 pbPresent, hMachine);
5910
5911 if (pbPresent == NULL)
5912 return CR_INVALID_POINTER;
5913
5914 *pbPresent = FALSE;
5915
5916 if (hMachine != NULL)
5917 {
5918 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5919 if (BindingHandle == NULL)
5920 return CR_FAILURE;
5921 }
5922 else
5923 {
5925 return CR_FAILURE;
5926 }
5927
5929 {
5931 pbPresent);
5932 }
5934 {
5936 }
5938
5939 return ret;
5940}
5941
5942
5943/***********************************************************************
5944 * CM_Is_Version_Available_Ex [SETUPAPI.@]
5945 */
5946BOOL
5947WINAPI
5949 _In_ WORD wVersion)
5950{
5951 TRACE("CM_Is_Version_Available(%hu)\n",
5952 wVersion);
5953
5954 return CM_Is_Version_Available_Ex(wVersion, NULL);
5955}
5956
5957
5958/***********************************************************************
5959 * CM_Is_Version_Available_Ex [SETUPAPI.@]
5960 */
5961BOOL
5962WINAPI
5964 _In_ WORD wVersion,
5965 _In_opt_ HMACHINE hMachine)
5966{
5968 WORD wServerVersion;
5969 CONFIGRET ret;
5970
5971 TRACE("CM_Is_Version_Available_Ex(%hu %p)\n",
5972 wVersion, hMachine);
5973
5974 if (wVersion <= 0x400)
5975 return TRUE;
5976
5977 if (hMachine != NULL)
5978 {
5979 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5980 if (BindingHandle == NULL)
5981 return FALSE;
5982 }
5983 else
5984 {
5986 return FALSE;
5987 }
5988
5990 {
5991 ret = PNP_GetVersion(BindingHandle, &wServerVersion);
5992 }
5994 {
5996 }
5998
5999 if (ret != CR_SUCCESS)
6000 return FALSE;
6001
6002 return (wServerVersion >= wVersion);
6003}
6004
6005
6006/***********************************************************************
6007 * CM_Locate_DevNodeA [SETUPAPI.@]
6008 */
6010WINAPI
6012 _Out_ PDEVINST pdnDevInst,
6013 _In_opt_ DEVINSTID_A pDeviceID,
6014 _In_ ULONG ulFlags)
6015{
6016 TRACE("CM_Locate_DevNodeA(%p %s %lx)\n",
6017 pdnDevInst, debugstr_a(pDeviceID), ulFlags);
6018
6019 return CM_Locate_DevNode_ExA(pdnDevInst, pDeviceID, ulFlags, NULL);
6020}
6021
6022
6023/***********************************************************************
6024 * CM_Locate_DevNodeW [SETUPAPI.@]
6025 */
6027WINAPI
6029 _Out_ PDEVINST pdnDevInst,
6030 _In_opt_ DEVINSTID_W pDeviceID,
6031 _In_ ULONG ulFlags)
6032{
6033 TRACE("CM_Locate_DevNodeW(%p %s %lx)\n",
6034 pdnDevInst, debugstr_w(pDeviceID), ulFlags);
6035
6036 return CM_Locate_DevNode_ExW(pdnDevInst, pDeviceID, ulFlags, NULL);
6037}
6038
6039
6040/***********************************************************************
6041 * CM_Locate_DevNode_ExA [SETUPAPI.@]
6042 */
6044WINAPI
6046 _Out_ PDEVINST pdnDevInst,
6047 _In_opt_ DEVINSTID_A pDeviceID,
6048 _In_ ULONG ulFlags,
6049 _In_opt_ HMACHINE hMachine)
6050{
6051 DEVINSTID_W pDevIdW = NULL;
6053
6054 TRACE("CM_Locate_DevNode_ExA(%p %s %lx %p)\n",
6055 pdnDevInst, debugstr_a(pDeviceID), ulFlags, hMachine);
6056
6057 if (pDeviceID != NULL)
6058 {
6059 if (pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDevIdW))
6060 return CR_INVALID_DEVICE_ID;
6061 }
6062
6063 ret = CM_Locate_DevNode_ExW(pdnDevInst, pDevIdW, ulFlags, hMachine);
6064
6065 if (pDevIdW != NULL)
6066 MyFree(pDevIdW);
6067
6068 return ret;
6069}
6070
6071
6072/***********************************************************************
6073 * CM_Locate_DevNode_ExW [SETUPAPI.@]
6074 */
6076WINAPI
6078 _Out_ PDEVINST pdnDevInst,
6079 _In_opt_ DEVINSTID_W pDeviceID,
6080 _In_ ULONG ulFlags,
6081 _In_opt_ HMACHINE hMachine)
6082{
6083 WCHAR DeviceIdBuffer[MAX_DEVICE_ID_LEN];
6085 HSTRING_TABLE StringTable = NULL;
6087
6088 TRACE("CM_Locate_DevNode_ExW(%p %s %lx %p)\n",
6089 pdnDevInst, debugstr_w(pDeviceID), ulFlags, hMachine);
6090
6091 if (pdnDevInst == NULL)
6092 return CR_INVALID_POINTER;
6093
6094 if (ulFlags & ~CM_LOCATE_DEVNODE_BITS)
6095 return CR_INVALID_FLAG;
6096
6097 if (hMachine != NULL)
6098 {
6099 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6100 if (BindingHandle == NULL)
6101 return CR_FAILURE;
6102
6103 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6104 if (StringTable == 0)
6105 return CR_FAILURE;
6106 }
6107 else
6108 {
6109 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6110 return CR_FAILURE;
6111 }
6112
6113 if (pDeviceID != NULL && lstrlenW(pDeviceID) != 0)
6114 {
6115 lstrcpyW(DeviceIdBuffer, pDeviceID);
6116
6118 {
6119 /* Validate the device ID */
6121 DeviceIdBuffer,
6122 ulFlags);
6123 }
6125 {
6127 }
6129 }
6130 else
6131 {
6133 {
6134 /* Get the root device ID */
6136 DeviceIdBuffer,
6138 }
6140 {
6142 }
6144 }
6145
6146 TRACE("DeviceIdBuffer: %s\n", debugstr_w(DeviceIdBuffer));
6147
6148 if (ret == CR_SUCCESS)
6149 {
6150 *pdnDevInst = pSetupStringTableAddString(StringTable, DeviceIdBuffer, 1);
6151 if (*pdnDevInst == -1)
6152 ret = CR_FAILURE;
6153 }
6154
6155 return ret;
6156}
6157
6158
6159/***********************************************************************
6160 * CM_Merge_Range_List [SETUPAPI.@]
6161 */
6163WINAPI
6165 _In_ RANGE_LIST rlhOld1,
6166 _In_ RANGE_LIST rlhOld2,
6167 _In_ RANGE_LIST rlhNew,
6168 _In_ ULONG ulFlags)
6169{
6170 FIXME("CM_Merge_Range_List(%p %p %p %lx)\n",
6171 rlhOld1, rlhOld2, rlhNew, ulFlags);
6172
6174}
6175
6176
6177/***********************************************************************
6178 * CM_Modify_Res_Des [SETUPAPI.@]
6179 */
6181WINAPI
6183 _Out_ PRES_DES prdResDes,
6184 _In_ RES_DES rdResDes,
6185 _In_ RESOURCEID ResourceID,
6186 _In_reads_bytes_(ResourceLen) PCVOID ResourceData,
6187 _In_ ULONG ResourceLen,
6188 _In_ ULONG ulFlags)
6189{
6190 TRACE("CM_Modify_Res_Des(%p %p %lx %p %lu %lx)\n",
6191 prdResDes, rdResDes, ResourceID, ResourceData,
6192 ResourceLen, ulFlags);
6193
6194 return CM_Modify_Res_Des_Ex(prdResDes, rdResDes, ResourceID, ResourceData,
6195 ResourceLen, ulFlags, NULL);
6196}
6197
6198
6199/***********************************************************************
6200 * CM_Modify_Res_Des_Ex [SETUPAPI.@]
6201 */
6203WINAPI
6205 _Out_ PRES_DES prdResDes,
6206 _In_ RES_DES rdResDes,
6207 _In_ RESOURCEID ResourceID,
6208 _In_reads_bytes_(ResourceLen) PCVOID ResourceData,
6209 _In_ ULONG ResourceLen,
6210 _In_ ULONG ulFlags,
6211 _In_opt_ HMACHINE hMachine)
6212{
6213 FIXME("CM_Modify_Res_Des_Ex(%p %p %lx %p %lu %lx %p)\n",
6214 prdResDes, rdResDes, ResourceID, ResourceData,
6215 ResourceLen, ulFlags, hMachine);
6216
6218}
6219
6220
6221/***********************************************************************
6222 * CM_Move_DevNode [SETUPAPI.@]
6223 */
6225WINAPI
6227 _In_ DEVINST dnFromDevInst,
6228 _In_ DEVINST dnToDevInst,
6229 _In_ ULONG ulFlags)
6230{
6231 TRACE("CM_Move_DevNode(%lx %lx %lx)\n",
6232 dnFromDevInst, dnToDevInst, ulFlags);
6233
6234 return CM_Move_DevNode_Ex(dnFromDevInst, dnToDevInst, ulFlags, NULL);
6235}
6236
6237
6238/***********************************************************************
6239 * CM_Move_DevNode_Ex [SETUPAPI.@]
6240 */
6242WINAPI
6244 _In_ DEVINST dnFromDevInst,
6245 _In_ DEVINST dnToDevInst,
6246 _In_ ULONG ulFlags,
6247 _In_opt_ HMACHINE hMachine)
6248{
6250 HSTRING_TABLE StringTable = NULL;
6251 LPWSTR lpFromDevInst;
6252 LPWSTR lpToDevInst;
6253 CONFIGRET ret;
6254
6255 FIXME("CM_Move_DevNode_Ex(%lx %lx %lx %p)\n",
6256 dnFromDevInst, dnToDevInst, ulFlags, hMachine);
6257
6258 if (!pSetupIsUserAdmin())
6259 return CR_ACCESS_DENIED;
6260
6261 if (dnFromDevInst == 0 || dnToDevInst == 0)
6262 return CR_INVALID_DEVNODE;
6263
6264 if (ulFlags != 0)
6265 return CR_INVALID_FLAG;
6266
6267 if (hMachine != NULL)
6268 {
6269 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6270 if (BindingHandle == NULL)
6271 return CR_FAILURE;
6272
6273 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6274 if (StringTable == 0)
6275 return CR_FAILURE;
6276 }
6277 else
6278 {
6279 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6280 return CR_FAILURE;
6281 }
6282
6283 lpFromDevInst = pSetupStringTableStringFromId(StringTable, dnFromDevInst);
6284 if (lpFromDevInst == NULL)
6285 return CR_INVALID_DEVNODE;
6286
6287 lpToDevInst = pSetupStringTableStringFromId(StringTable, dnToDevInst);
6288 if (lpToDevInst == NULL)
6289 return CR_INVALID_DEVNODE;
6290
6292 {
6294 PNP_DEVINST_MOVE,
6295 ulFlags,
6296 lpFromDevInst,
6297 lpToDevInst);
6298 }
6300 {
6302 }
6304
6305 return ret;
6306}
6307
6308
6309/***********************************************************************
6310 * CM_Next_Range [SETUPAPI.@]
6311 */
6313WINAPI
6315 _Inout_ PRANGE_ELEMENT preElement,
6316 _Out_ PDWORDLONG pullStart,
6317 _Out_ PDWORDLONG pullEnd,
6318 _In_ ULONG ulFlags)
6319{
6320 PINTERNAL_RANGE_LIST pRangeList;
6321 PINTERNAL_RANGE pRange;
6322 PLIST_ENTRY ListEntry;
6324
6325 FIXME("CM_Next_Range(%p %p %p %lx)\n",
6326 preElement, pullStart, pullEnd, ulFlags);
6327
6328 pRange = (PINTERNAL_RANGE)preElement;
6329
6330 if (pRange == NULL || pRange->pRangeList == NULL)
6331 return CR_FAILURE;
6332
6333 if (pullStart == NULL || pullEnd == NULL)
6334 return CR_INVALID_POINTER;
6335
6336 if (ulFlags != 0)
6337 return CR_INVALID_FLAG;
6338
6339 pRangeList = pRange->pRangeList;
6340
6341 /* Lock the range list */
6342 WaitForSingleObject(pRangeList->hMutex, INFINITE);
6343
6344 /* Fail, if we reached the end of the list */
6345 if (pRange->ListEntry.Flink == &pRangeList->ListHead)
6346 {
6347 ret = CR_FAILURE;
6348 goto done;
6349 }
6350
6351 /* Get the next range */
6352 ListEntry = pRangeList->ListHead.Flink;
6353 pRange = CONTAINING_RECORD(ListEntry, INTERNAL_RANGE, ListEntry);
6354
6355 /* Return the range data */
6356 *pullStart = pRange->ullStart;
6357 *pullEnd = pRange->ullEnd;
6358 *preElement = (RANGE_ELEMENT)pRange;
6359
6360done:
6361 /* Unlock the range list */
6362 ReleaseMutex(pRangeList->hMutex);
6363
6364 return ret;
6365}
6366
6367
6368/***********************************************************************
6369 * CM_Open_Class_KeyA [SETUPAPI.@]
6370 */
6372WINAPI
6374 _In_opt_ LPGUID pClassGuid,
6375 _In_opt_ LPCSTR pszClassName,
6376 _In_ REGSAM samDesired,
6378 _Out_ PHKEY phkClass,
6379 _In_ ULONG ulFlags)
6380{
6381 TRACE("CM_Open_Class_KeyA(%p %s %lx %lx %p %lx)\n",
6382 debugstr_guid(pClassGuid), debugstr_a(pszClassName),
6383 samDesired, Disposition, phkClass, ulFlags);
6384
6385 return CM_Open_Class_Key_ExA(pClassGuid, pszClassName, samDesired,
6386 Disposition, phkClass, ulFlags, NULL);
6387}
6388
6389
6390/***********************************************************************
6391 * CM_Open_Class_KeyW [SETUPAPI.@]
6392 */
6394WINAPI
6396 _In_opt_ LPGUID pClassGuid,
6397 _In_opt_ LPCWSTR pszClassName,
6398 _In_ REGSAM samDesired,
6400 _Out_ PHKEY phkClass,
6401 _In_ ULONG ulFlags)
6402{
6403 TRACE("CM_Open_Class_KeyW(%p %s %lx %lx %p %lx)\n",
6404 debugstr_guid(pClassGuid), debugstr_w(pszClassName),
6405 samDesired, Disposition, phkClass, ulFlags);
6406
6407 return CM_Open_Class_Key_ExW(pClassGuid, pszClassName, samDesired,
6408 Disposition, phkClass, ulFlags, NULL);
6409}
6410
6411
6412/***********************************************************************
6413 * CM_Open_Class_Key_ExA [SETUPAPI.@]
6414 */
6416WINAPI
6418 _In_opt_ LPGUID pClassGuid,
6419 _In_opt_ LPCSTR pszClassName,
6420 _In_ REGSAM samDesired,
6422 _Out_ PHKEY phkClass,
6423 _In_ ULONG ulFlags,
6424 _In_opt_ HMACHINE hMachine)
6425{
6426 LPWSTR pszClassNameW = NULL;
6427 CONFIGRET ret;
6428
6429 TRACE("CM_Open_Class_Key_ExA(%p %s %lx %lx %p %lx %p)\n",
6430 debugstr_guid(pClassGuid), debugstr_a(pszClassName),
6431 samDesired, Disposition, phkClass, ulFlags, hMachine);
6432
6433 if (pszClassName != NULL)
6434 {
6435 if (pSetupCaptureAndConvertAnsiArg(pszClassName, &pszClassNameW))
6436 return CR_INVALID_DATA;
6437 }
6438
6439 ret = CM_Open_Class_Key_ExW(pClassGuid, pszClassNameW, samDesired,
6440 Disposition, phkClass, ulFlags, hMachine);
6441
6442 if (pszClassNameW != NULL)
6443 MyFree(pszClassNameW);
6444
6445 return ret;
6446}
6447
6448
6449/***********************************************************************
6450 * CM_Open_Class_Key_ExW [SETUPAPI.@]
6451 */
6453WINAPI
6455 _In_opt_ LPGUID pClassGuid,
6456 _In_opt_ LPCWSTR pszClassName,
6457 _In_ REGSAM samDesired,
6459 _Out_ PHKEY phkClass,
6460 _In_ ULONG ulFlags,
6461 _In_opt_ HMACHINE hMachine)
6462{
6463 WCHAR szKeyName[MAX_PATH];
6464 LPWSTR lpGuidString;
6465 DWORD dwDisposition;
6466 DWORD dwError;
6467 HKEY hKey;
6468
6469 TRACE("CM_Open_Class_Key_ExW(%p %s %lx %lx %p %lx %p)\n",
6470 debugstr_guid(pClassGuid), debugstr_w(pszClassName),
6471 samDesired, Disposition, phkClass, ulFlags, hMachine);
6472
6473 /* Check Disposition and ulFlags */
6475 (ulFlags & ~CM_OPEN_CLASS_KEY_BITS))
6476 return CR_INVALID_FLAG;
6477
6478 /* Check phkClass */
6479 if (phkClass == NULL)
6480 return CR_INVALID_POINTER;
6481
6482 *phkClass = NULL;
6483
6484 if (ulFlags == CM_OPEN_CLASS_KEY_INTERFACE &&
6485 pszClassName != NULL)
6486 return CR_INVALID_DATA;
6487
6488 if (hMachine == NULL)
6489 {
6491 }
6492 else
6493 {
6494 if (RegConnectRegistryW(((PMACHINE_INFO)hMachine)->szMachineName,
6496 &hKey))
6497 return CR_REGISTRY_ERROR;
6498 }
6499
6500 if (ulFlags & CM_OPEN_CLASS_KEY_INTERFACE)
6501 {
6502 lstrcpyW(szKeyName, DeviceClasses);
6503 }
6504 else
6505 {
6506 lstrcpyW(szKeyName, ControlClass);
6507 }
6508
6509 if (pClassGuid != NULL)
6510 {
6511 if (UuidToStringW((UUID*)pClassGuid, &lpGuidString) != RPC_S_OK)
6512 {
6514 return CR_INVALID_DATA;
6515 }
6516
6517 lstrcatW(szKeyName, BackslashOpenBrace);
6518 lstrcatW(szKeyName, lpGuidString);
6519 lstrcatW(szKeyName, CloseBrace);
6520 }
6521
6523 {
6524 dwError = RegCreateKeyExW(hKey, szKeyName, 0, NULL, 0, samDesired,
6525 NULL, phkClass, &dwDisposition);
6526 }
6527 else
6528 {
6529 dwError = RegOpenKeyExW(hKey, szKeyName, 0, samDesired, phkClass);
6530 }
6531
6533
6534 if (pClassGuid != NULL)
6535 RpcStringFreeW(&lpGuidString);
6536
6537 if (dwError != ERROR_SUCCESS)
6538 {
6539 *phkClass = NULL;
6541 }
6542
6543 if (pszClassName != NULL)
6544 {
6545 RegSetValueExW(*phkClass, Class, 0, REG_SZ, (LPBYTE)pszClassName,
6546 (lstrlenW(pszClassName) + 1) * sizeof(WCHAR));
6547 }
6548
6549 return CR_SUCCESS;
6550}
6551
6552
6553/***********************************************************************
6554 * CM_Open_DevNode_Key [SETUPAPI.@]
6555 */
6557WINAPI
6559 _In_ DEVINST dnDevNode,
6560 _In_ REGSAM samDesired,
6561 _In_ ULONG ulHardwareProfile,
6563 _Out_ PHKEY phkDevice,
6564 _In_ ULONG ulFlags)
6565{
6566 TRACE("CM_Open_DevNode_Key(%lx %lx %lu %lx %p %lx)\n",
6567 dnDevNode, samDesired, ulHardwareProfile, Disposition, phkDevice, ulFlags);
6568
6569 return CM_Open_DevNode_Key_Ex(dnDevNode, samDesired, ulHardwareProfile,
6570 Disposition, phkDevice, ulFlags, NULL);
6571}
6572
6573
6574/***********************************************************************
6575 * CM_Open_DevNode_Key_Ex [SETUPAPI.@]
6576 */
6578WINAPI
6580 _In_ DEVINST dnDevNode,
6581 _In_ REGSAM samDesired,
6582 _In_ ULONG ulHardwareProfile,
6584 _Out_ PHKEY phkDevice,
6585 _In_ ULONG ulFlags,
6586 _In_opt_ HMACHINE hMachine)
6587{
6589 HSTRING_TABLE StringTable = NULL;
6590 LPWSTR pszDevInst, pszKeyPath = NULL, pszInstancePath = NULL;
6591 LONG lError;
6592 DWORD dwDisposition;
6593 HKEY hRootKey = NULL;
6595
6596 TRACE("CM_Open_DevNode_Key_Ex(%lx %lx %lu %lx %p %lx %p)\n",
6597 dnDevNode, samDesired, ulHardwareProfile, Disposition, phkDevice, ulFlags, hMachine);
6598
6599 if (phkDevice == NULL)
6600 return CR_INVALID_POINTER;
6601
6602 *phkDevice = NULL;
6603
6604 if (dnDevNode == 0)
6605 return CR_INVALID_DEVNODE;
6606
6607 if (ulFlags & ~CM_REGISTRY_BITS)
6608 return CR_INVALID_FLAG;
6609
6611 return CR_INVALID_DATA;
6612
6613 if (hMachine != NULL)
6614 {
6615 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6616 if (BindingHandle == NULL)
6617 return CR_FAILURE;
6618
6619 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6620 if (StringTable == 0)
6621 return CR_FAILURE;
6622 }
6623 else
6624 {
6625 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6626 return CR_FAILURE;
6627 }
6628
6629 pszDevInst = pSetupStringTableStringFromId(StringTable, dnDevNode);
6630 if (pszDevInst == NULL)
6631 return CR_INVALID_DEVNODE;
6632
6633 TRACE("pszDevInst: %S\n", pszDevInst);
6634
6635 pszKeyPath = MyMalloc(512 * sizeof(WCHAR));
6636 if (pszKeyPath == NULL)
6637 {
6639 goto done;
6640 }
6641
6642 pszInstancePath = MyMalloc(512 * sizeof(WCHAR));
6643 if (pszInstancePath == NULL)
6644 {
6646 goto done;
6647 }
6648
6650 pszDevInst,
6651 pszKeyPath,
6652 pszInstancePath,
6653 ulHardwareProfile,
6654 ulFlags);
6655 if (ret != CR_SUCCESS)
6656 goto done;
6657
6658 TRACE("pszKeyPath: %S\n", pszKeyPath);
6659 TRACE("pszInstancePath: %S\n", pszInstancePath);
6660
6661 wcscat(pszKeyPath, L"\\");
6662 wcscat(pszKeyPath, pszInstancePath);
6663
6664 TRACE("pszKeyPath: %S\n", pszKeyPath);
6665
6666 if (hMachine == NULL)
6667 {
6668 hRootKey = HKEY_LOCAL_MACHINE;
6669 }
6670 else
6671 {
6672 if (RegConnectRegistryW(((PMACHINE_INFO)hMachine)->szMachineName,
6674 &hRootKey))
6675 {
6677 goto done;
6678 }
6679 }
6680
6682 {
6683 lError = RegCreateKeyExW(hRootKey,
6684 pszKeyPath,
6685 0,
6686 NULL,
6687 0,
6688 samDesired,
6689 NULL,
6690 phkDevice,
6691 &dwDisposition);
6692 }
6693 else
6694 {
6695 lError = RegOpenKeyExW(hRootKey,
6696 pszKeyPath,
6697 0,
6698 samDesired,
6699 phkDevice);
6700 }
6701
6702 if (lError != ERROR_SUCCESS)
6703 {
6704 *phkDevice = NULL;
6706 }
6707
6708done:
6709 if ((hRootKey != NULL) && (hRootKey != HKEY_LOCAL_MACHINE))
6710 RegCloseKey(hRootKey);
6711
6712 if (pszInstancePath != NULL)
6713 MyFree(pszInstancePath);
6714
6715 if (pszKeyPath != NULL)
6716 MyFree(pszKeyPath);
6717
6718 return ret;
6719}
6720
6721
6722/***********************************************************************
6723 * CM_Query_And_Remove_SubTreeA [SETUPAPI.@]
6724 */
6726WINAPI
6728 _In_ DEVINST dnAncestor,
6729 _Out_opt_ PPNP_VETO_TYPE pVetoType,
6730 _Out_writes_opt_(ulNameLength) LPSTR pszVetoName,
6731 _In_ ULONG ulNameLength,
6732 _In_ ULONG ulFlags)
6733{
6734 TRACE("CM_Query_And_Remove_SubTreeA(%lx %p %p %lu %lx)\n",
6735 dnAncestor, pVetoType, pszVetoName, ulNameLength, ulFlags);
6736
6737 return CM_Query_And_Remove_SubTree_ExA(dnAncestor, pVetoType, pszVetoName,
6738 ulNameLength, ulFlags, NULL);
6739}
6740
6741
6742/***********************************************************************
6743 * CM_Query_And_Remove_SubTreeW [SETUPAPI.@]
6744 */
6746WINAPI
6748 _In_ DEVINST dnAncestor,
6749 _Out_opt_ PPNP_VETO_TYPE pVetoType,
6750 _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName,
6751 _In_ ULONG ulNameLength,
6752 _In_ ULONG ulFlags)
6753{
6754 TRACE("CM_Query_And_Remove_SubTreeW(%lx %p %p %lu %lx)\n",
6755 dnAncestor, pVetoType, pszVetoName, ulNameLength, ulFlags);
6756
6757 return CM_Query_And_Remove_SubTree_ExW(dnAncestor, pVetoType, pszVetoName,
6758 ulNameLength, ulFlags, NULL);
6759}
6760
6761
6762/***********************************************************************
6763 * CM_Query_And_Remove_SubTree_ExA [SETUPAPI.@]
6764 */
6766WINAPI
6768 _In_ DEVINST dnAncestor,
6769 _Out_opt_ PPNP_VETO_TYPE pVetoType,
6770 _Out_writes_opt_(ulNameLength) LPSTR pszVetoName,
6771 _In_ ULONG ulNameLength,
6772 _In_ ULONG ulFlags,
6773 _In_opt_ HMACHINE hMachine)
6774{
6775 LPWSTR lpLocalVetoName;
6776 CONFIGRET ret;
6777
6778 TRACE("CM_Query_And_Remove_SubTree_ExA(%lx %p %p %lu %lx %p)\n",
6779 dnAncestor, pVetoType, pszVetoName, ulNameLength,
6780 ulFlags, hMachine);
6781
6782 if (pszVetoName == NULL && ulNameLength == 0)
6783 return CR_INVALID_POINTER;
6784
6785 lpLocalVetoName = HeapAlloc(GetProcessHeap(), 0, ulNameLength * sizeof(WCHAR));
6786 if (lpLocalVetoName == NULL)
6787 return CR_OUT_OF_MEMORY;
6788
6789 ret = CM_Query_And_Remove_SubTree_ExW(dnAncestor, pVetoType, lpLocalVetoName,
6790 ulNameLength, ulFlags, hMachine);
6791 if (ret == CR_REMOVE_VETOED)
6792 {
6794 0,
6795 lpLocalVetoName,
6796 ulNameLength,
6797 pszVetoName,
6798 ulNameLength,
6799 NULL,
6800 NULL) == 0)
6801 ret = CR_FAILURE;
6802 }
6803
6804 HeapFree(GetProcessHeap(), 0, lpLocalVetoName);
6805
6806 return ret;
6807}
6808
6809
6810/***********************************************************************
6811 * CM_Query_And_Remove_SubTree_ExW [SETUPAPI.@]
6812 */
6814WINAPI
6816 _In_ DEVINST dnAncestor,
6817 _Out_opt_ PPNP_VETO_TYPE pVetoType,
6818 _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName,
6819 _In_ ULONG ulNameLength,
6820 _In_ ULONG ulFlags,
6821 _In_opt_ HMACHINE hMachine)
6822{
6824 HSTRING_TABLE StringTable = NULL;
6825 LPWSTR lpDevInst;
6826 CONFIGRET ret;
6827
6828 TRACE("CM_Query_And_Remove_SubTree_ExW(%lx %p %p %lu %lx %p)\n",
6829 dnAncestor, pVetoType, pszVetoName, ulNameLength,
6830 ulFlags, hMachine);
6831
6832 if (dnAncestor == 0)
6833 return CR_INVALID_DEVNODE;
6834
6835 if (ulFlags & ~CM_REMOVE_BITS)
6836 return CR_INVALID_FLAG;
6837
6838 if (pszVetoName == NULL && ulNameLength == 0)
6839 return CR_INVALID_POINTER;
6840
6841 if (hMachine != NULL)
6842 {
6843 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6844 if (BindingHandle == NULL)
6845 return CR_FAILURE;
6846
6847 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6848 if (StringTable == 0)
6849 return CR_FAILURE;
6850 }
6851 else
6852 {
6853 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6854 return CR_FAILURE;
6855 }
6856
6857 lpDevInst = pSetupStringTableStringFromId(StringTable, dnAncestor);
6858 if (lpDevInst == NULL)
6859 return CR_INVALID_DEVNODE;
6860
6862 {
6864 lpDevInst,
6865 pVetoType,
6866 pszVetoName,
6867 ulNameLength,
6868 ulFlags);
6869 }
6871 {
6873 }
6875
6876 return ret;
6877}
6878
6879
6880/***********************************************************************
6881 * CM_Query_Arbitrator_Free_Data [SETUPAPI.@]
6882 */
6884WINAPI
6887 _In_ ULONG DataLen,
6888 _In_ DEVINST dnDevInst,
6889 _In_ RESOURCEID ResourceID,
6890 _In_ ULONG ulFlags)
6891{
6892 TRACE("CM_Query_Arbitrator_Free_Data(%p %lu %lx %lu 0x%08lx)\n",
6893 pData, DataLen, dnDevInst, ResourceID, ulFlags);
6894
6895 return CM_Query_Arbitrator_Free_Data_Ex(pData, DataLen, dnDevInst,
6896 ResourceID, ulFlags, NULL);
6897}
6898
6899
6900/***********************************************************************
6901 * CM_Query_Arbitrator_Free_Data_Ex [SETUPAPI.@]
6902 */
6904WINAPI
6907 _In_ ULONG DataLen,
6908 _In_ DEVINST dnDevInst,
6909 _In_ RESOURCEID ResourceID,
6910 _In_ ULONG ulFlags,
6911 _In_opt_ HMACHINE hMachine)
6912{
6914 HSTRING_TABLE StringTable = NULL;
6915 LPWSTR lpDevInst;
6916 CONFIGRET ret;
6917
6918 TRACE("CM_Query_Arbitrator_Free_Data_Ex(%p %lu %lx %lu 0x%08lx %p)\n",
6919 pData, DataLen, dnDevInst, ResourceID, ulFlags, hMachine);
6920
6921 if (pData == NULL || DataLen == 0)
6922 return CR_INVALID_POINTER;
6923
6924 if (dnDevInst == 0)
6925 return CR_INVALID_DEVINST;
6926
6927 if (ulFlags & ~CM_QUERY_ARBITRATOR_BITS)
6928 return CR_INVALID_FLAG;
6929
6930 if (hMachine != NULL)
6931 {
6932 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6933 if (BindingHandle == NULL)
6934 return CR_FAILURE;
6935
6936 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6937 if (StringTable == 0)
6938 return CR_FAILURE;
6939 }
6940 else
6941 {
6942 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6943 return CR_FAILURE;
6944 }
6945
6946 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
6947 if (lpDevInst == NULL)
6948 return CR_INVALID_DEVNODE;
6949
6951 {
6953 pData,
6954 DataLen,
6955 lpDevInst,
6956 ResourceID,
6957 ulFlags);
6958 }
6960 {
6962 }
6964
6965 return ret;
6966}
6967
6968
6969/***********************************************************************
6970 * CM_Query_Arbitrator_Free_Size [SETUPAPI.@]
6971 */
6973WINAPI
6976 _In_ DEVINST dnDevInst,
6977 _In_ RESOURCEID ResourceID,
6978 _In_ ULONG ulFlags)
6979{
6980 TRACE("CM_Query_Arbitrator_Free_Size(%p %lu %lx 0x%08lx)\n",
6981 pulSize, dnDevInst,ResourceID, ulFlags);
6982
6983 return CM_Query_Arbitrator_Free_Size_Ex(pulSize, dnDevInst, ResourceID,
6984 ulFlags, NULL);
6985}
6986
6987
6988/***********************************************************************
6989 * CM_Query_Arbitrator_Free_Size_Ex [SETUPAPI.@]
6990 */
6992WINAPI
6995 _In_ DEVINST dnDevInst,
6996 _In_ RESOURCEID ResourceID,
6997 _In_ ULONG ulFlags,
6998 _In_opt_ HMACHINE hMachine)
6999{
7001 HSTRING_TABLE StringTable = NULL;
7002 LPWSTR lpDevInst;
7003 CONFIGRET ret;
7004
7005 TRACE("CM_Query_Arbitrator_Free_Size_Ex(%p %lu %lx 0x%08lx %p)\n",
7006 pulSize, dnDevInst,ResourceID, ulFlags, hMachine);
7007
7008 if (pulSize == NULL)
7009 return CR_INVALID_POINTER;
7010
7011 if (dnDevInst == 0)
7012 return CR_INVALID_DEVINST;
7013
7014 if (ulFlags & ~CM_QUERY_ARBITRATOR_BITS)
7015 return CR_INVALID_FLAG;
7016
7017 if (hMachine != NULL)
7018 {
7019 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7020 if (BindingHandle == NULL)
7021 return CR_FAILURE;
7022
7023 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7024 if (StringTable == 0)
7025 return CR_FAILURE;
7026 }
7027 else
7028 {
7029 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7030 return CR_FAILURE;
7031 }
7032
7033 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7034 if (lpDevInst == NULL)
7035 return CR_INVALID_DEVNODE;
7036
7038 {
7040 pulSize,
7041 lpDevInst,
7042 ResourceID,
7043 ulFlags);
7044 }
7046 {
7048 }
7050
7051 return ret;
7052}
7053
7054
7055/***********************************************************************
7056 * CM_Query_Remove_SubTree [SETUPAPI.@]
7057 *
7058 * This function is obsolete in Windows XP and above.
7059 */
7061WINAPI
7063 _In_ DEVINST dnAncestor,
7064 _In_ ULONG ulFlags)
7065{
7066 TRACE("CM_Query_Remove_SubTree(%lx %lx)\n",
7067 dnAncestor, ulFlags);
7068
7070}
7071
7072
7073/***********************************************************************
7074 * CM_Query_Remove_SubTree_Ex [SETUPAPI.@]
7075 *
7076 * This function is obsolete in Windows XP and above.
7077 */
7079WINAPI
7081 _In_ DEVINST dnAncestor,
7082 _In_ ULONG ulFlags,
7083 _In_opt_ HMACHINE hMachine)
7084{
7085 TRACE("CM_Query_Remove_SubTree_Ex(%lx %lx %p)\n",
7086 dnAncestor, ulFlags, hMachine);
7087
7089}
7090
7091
7092/***********************************************************************
7093 * CM_Query_Resource_Conflict_List [SETUPAPI.@]
7094 */
7096WINAPI
7098 _Out_ PCONFLICT_LIST pclConflictList,
7099 _In_ DEVINST dnDevInst,
7100 _In_ RESOURCEID ResourceID,
7101 _In_ PCVOID ResourceData,
7102 _In_ ULONG ResourceLen,
7103 _In_ ULONG ulFlags,
7104 _In_opt_ HMACHINE hMachine)
7105{
7107 HSTRING_TABLE StringTable = NULL;
7108 PPNP_CONFLICT_LIST pConflictBuffer = NULL;
7109 PCONFLICT_DATA pConflictData = NULL;
7110 ULONG ulBufferLength;
7111 LPWSTR lpDevInst;
7112 CONFIGRET ret;
7113
7114 FIXME("CM_Query_Resource_Conflict_List(%p %lx %lu %p %lu %lx %p)\n",
7115 pclConflictList, dnDevInst, ResourceID, ResourceData,
7116 ResourceLen, ulFlags, hMachine);
7117
7118 if (dnDevInst == 0)
7119 return CR_INVALID_DEVNODE;
7120
7121 if (ulFlags & ~CM_RESDES_WIDTH_BITS)
7122 return CR_INVALID_FLAG;
7123
7124 if (pclConflictList == NULL ||
7125 ResourceData == NULL ||
7126 ResourceLen == 0)
7127 return CR_INVALID_POINTER;
7128
7129 if (ResourceID == 0)
7130 return CR_INVALID_RESOURCEID;
7131
7132 *pclConflictList = 0;
7133
7134 if (hMachine != NULL)
7135 {
7136 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7137 if (BindingHandle == NULL)
7138 return CR_FAILURE;
7139
7140 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7141 if (StringTable == 0)
7142 return CR_FAILURE;
7143 }
7144 else
7145 {
7146 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7147 return CR_FAILURE;
7148 }
7149
7150 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7151 if (lpDevInst == NULL)
7152 return CR_INVALID_DEVNODE;
7153
7154 pConflictData = MyMalloc(sizeof(CONFLICT_DATA));
7155 if (pConflictData == NULL)
7156 {
7158 goto done;
7159 }
7160
7161 ulBufferLength = sizeof(PNP_CONFLICT_LIST) +
7162 sizeof(PNP_CONFLICT_STRINGS) +
7163 (sizeof(wchar_t) * 200);
7164 pConflictBuffer = MyMalloc(ulBufferLength);
7165 if (pConflictBuffer == NULL)
7166 {
7168 goto done;
7169 }
7170
7172 {
7174 lpDevInst,
7175 ResourceID,
7176 (PBYTE)ResourceData,
7177 ResourceLen,
7178 (PBYTE)pConflictBuffer,
7179 ulBufferLength,
7180 ulFlags);
7181 }
7183 {
7185 }
7187
7188 if (ret != CR_SUCCESS)
7189 goto done;
7190
7191 pConflictData->ulMagic = CONFLICT_MAGIC;
7192 pConflictData->pConflictList = pConflictBuffer;
7193
7194 *pclConflictList = (CONFLICT_LIST)pConflictData;
7195
7196done:
7197 if (ret != CR_SUCCESS)
7198 {
7199 if (pConflictBuffer != NULL)
7200 MyFree(pConflictBuffer);
7201
7202 if (pConflictData != NULL)
7203 MyFree(pConflictData);
7204 }
7205
7206 return ret;
7207}
7208
7209
7210/***********************************************************************
7211 * CM_Reenumerate_DevNode [SETUPAPI.@]
7212 */
7214WINAPI
7216 _In_ DEVINST dnDevInst,
7217 _In_ ULONG ulFlags)
7218{
7219 TRACE("CM_Reenumerate_DevNode(%lx %lx)\n",
7220 dnDevInst, ulFlags);
7221
7222 return CM_Reenumerate_DevNode_Ex(dnDevInst, ulFlags, NULL);
7223}
7224
7225
7226/***********************************************************************
7227 * CM_Reenumerate_DevNode_Ex [SETUPAPI.@]
7228 */
7231 _In_ DEVINST dnDevInst,
7232 _In_ ULONG ulFlags,
7233 _In_opt_ HMACHINE hMachine)
7234{
7236 HSTRING_TABLE StringTable = NULL;
7237 LPWSTR lpDevInst;
7238 CONFIGRET ret;
7239
7240 FIXME("CM_Reenumerate_DevNode_Ex(%lx %lx %p)\n",
7241 dnDevInst, ulFlags, hMachine);
7242
7243 if (dnDevInst == 0)
7244 return CR_INVALID_DEVNODE;
7245
7246 if (ulFlags & ~CM_REENUMERATE_BITS)
7247 return CR_INVALID_FLAG;
7248
7249 if (hMachine != NULL)
7250 {
7251 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7252 if (BindingHandle == NULL)
7253 return CR_FAILURE;
7254
7255 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7256 if (StringTable == 0)
7257 return CR_FAILURE;
7258 }
7259 else
7260 {
7261 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7262 return CR_FAILURE;
7263 }
7264
7265 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7266 if (lpDevInst == NULL)
7267 return CR_INVALID_DEVNODE;
7268
7270 {
7272 PNP_DEVINST_REENUMERATE,
7273 ulFlags,
7274 lpDevInst,
7275 NULL);
7276 }
7278 {
7280 }
7282
7283 return ret;
7284}
7285
7286
7287/***********************************************************************
7288 * CM_Register_Device_Driver [SETUPAPI.@]
7289 */
7291WINAPI
7293 _In_ DEVINST dnDevInst,
7294 _In_ ULONG ulFlags)
7295{
7296 TRACE("CM_Register_Device_Driver(%lx 0x%08lx)\n",
7297 dnDevInst, ulFlags);
7298
7299 return CM_Register_Device_Driver_Ex(dnDevInst, ulFlags, NULL);
7300}
7301
7302
7303/***********************************************************************
7304 * CM_Register_Device_Driver_Ex [SETUPAPI.@]
7305 */
7307WINAPI
7309 _In_ DEVINST dnDevInst,
7310 _In_ ULONG ulFlags,
7311 _In_opt_ HMACHINE hMachine)
7312{
7314 HSTRING_TABLE StringTable = NULL;
7315 LPWSTR lpDevInst;
7316 CONFIGRET ret;
7317
7318 TRACE("CM_Register_Device_Driver_Ex(%lx 0x%08lx %p)\n",
7319 dnDevInst, ulFlags, hMachine);
7320
7321 if (dnDevInst == 0)
7322 return CR_INVALID_DEVNODE;
7323
7324 if (ulFlags & ~CM_REGISTER_DEVICE_DRIVER_BITS)
7325 return CR_INVALID_FLAG;
7326
7327 if (hMachine != NULL)
7328 {
7329 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7330 if (BindingHandle == NULL)
7331 return CR_FAILURE;
7332
7333 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7334 if (StringTable == 0)
7335 return CR_FAILURE;
7336 }
7337 else
7338 {
7339 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7340 return CR_FAILURE;
7341 }
7342
7343 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7344 if (lpDevInst == NULL)
7345 return CR_INVALID_DEVNODE;
7346
7348 {
7350 lpDevInst,
7351 ulFlags);
7352 }
7354 {
7356 }
7358
7359 return ret;
7360}
7361
7362
7363/***********************************************************************
7364 * CM_Register_Device_InterfaceA [SETUPAPI.@]
7365 */
7367WINAPI
7369 _In_ DEVINST dnDevInst,
7371 _In_opt_ LPCSTR pszReference,
7372 _Out_writes_(*pulLength) LPSTR pszDeviceInterface,
7373 _Inout_ PULONG pulLength,
7374 _In_ ULONG ulFlags)
7375{
7376 TRACE("CM_Register_Device_InterfaceA(%lx %s %s %p %p %lx)\n",
7378 pszReference, pszDeviceInterface, pulLength, ulFlags);
7379
7381 pszReference, pszDeviceInterface,
7382 pulLength, ulFlags, NULL);
7383}
7384
7385
7386/***********************************************************************
7387 * CM_Register_Device_InterfaceW [SETUPAPI.@]
7388 */
7390WINAPI
7392 _In_ DEVINST dnDevInst,
7394 _In_opt_ LPCWSTR pszReference,
7395 _Out_writes_(*pulLength) LPWSTR pszDeviceInterface,
7396 _Inout_ PULONG pulLength,
7397 _In_ ULONG ulFlags)
7398{
7399 TRACE("CM_Register_Device_InterfaceW(%lx %s %s %p %p %lx)\n",
7401 debugstr_w(pszReference), pszDeviceInterface, pulLength, ulFlags);
7402
7404 pszReference, pszDeviceInterface,
7405 pulLength, ulFlags, NULL);
7406}
7407
7408
7409/***********************************************************************
7410 * CM_Register_Device_Interface_ExA [SETUPAPI.@]
7411 */
7413WINAPI
7415 _In_ DEVINST dnDevInst,
7417 _In_opt_ LPCSTR pszReference,
7418 _Out_writes_(*pulLength) LPSTR pszDeviceInterface,
7419 _Inout_ PULONG pulLength,
7420 _In_ ULONG ulFlags,
7421 _In_opt_ HMACHINE hMachine)
7422{
7423 LPWSTR pszReferenceW = NULL;
7424 LPWSTR pszDeviceInterfaceW;
7425 ULONG ulLength;
7426 CONFIGRET ret;
7427
7428 TRACE("CM_Register_Device_Interface_ExA(%lx %s %s %p %p %lx %p)\n",
7429 dnDevInst, debugstr_guid(InterfaceClassGuid), debugstr_a(pszReference),
7430 pszDeviceInterface, pulLength, ulFlags, hMachine);
7431
7432 if (pulLength == NULL || pszDeviceInterface == NULL)
7433 return CR_INVALID_POINTER;
7434
7435 if (pszReference != NULL)
7436 {
7437 if (pSetupCaptureAndConvertAnsiArg(pszReference, &pszReferenceW))
7438 return CR_INVALID_DATA;
7439 }
7440
7441 ulLength = *pulLength;
7442
7443 pszDeviceInterfaceW = HeapAlloc(GetProcessHeap(), 0, ulLength * sizeof(WCHAR));
7444 if (pszDeviceInterfaceW == NULL)
7445 {
7447 goto Done;
7448 }
7449
7452 pszReferenceW,
7453 pszDeviceInterfaceW,
7454 &ulLength,
7455 ulFlags,
7456 hMachine);
7457 if (ret == CR_SUCCESS)
7458 {
7460 0,
7461 pszDeviceInterfaceW,
7462 ulLength,
7463 pszDeviceInterface,
7464 *pulLength,
7465 NULL,
7466 NULL) == 0)
7467 ret = CR_FAILURE;
7468 }
7469
7470 *pulLength = ulLength;
7471
7472Done:
7473 if (pszDeviceInterfaceW != NULL)
7474 HeapFree(GetProcessHeap(), 0, pszDeviceInterfaceW);
7475
7476 if (pszReferenceW != NULL)
7477 MyFree(pszReferenceW);
7478
7479 return ret;
7480}
7481
7482
7483/***********************************************************************
7484 * CM_Register_Device_Interface_ExW [SETUPAPI.@]
7485 */
7487WINAPI
7489 _In_ DEVINST dnDevInst,
7491 _In_opt_ LPCWSTR pszReference,
7492 _Out_writes_(*pulLength) LPWSTR pszDeviceInterface,
7493 _Inout_ PULONG pulLength,
7494 _In_ ULONG ulFlags,
7495 _In_opt_ HMACHINE hMachine)
7496{
7498 HSTRING_TABLE StringTable = NULL;
7499 LPWSTR lpDevInst;
7500 ULONG ulTransferLength;
7501 CONFIGRET ret;
7502
7503 TRACE("CM_Register_Device_Interface_ExW(%lx %s %s %p %p %lx %p)\n",
7504 dnDevInst, debugstr_guid(InterfaceClassGuid), debugstr_w(pszReference),
7505 pszDeviceInterface, pulLength, ulFlags, hMachine);
7506
7507 if (dnDevInst == 0)
7508 return CR_INVALID_DEVNODE;
7509
7510 if (InterfaceClassGuid == NULL ||
7511 pszDeviceInterface == NULL ||
7512 pulLength == NULL)
7513 return CR_INVALID_POINTER;
7514
7515 if (ulFlags != 0)
7516 return CR_INVALID_FLAG;
7517
7518 if (hMachine != NULL)
7519 {
7520 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7521 if (BindingHandle == NULL)
7522 return CR_FAILURE;
7523
7524 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7525 if (StringTable == 0)
7526 return CR_FAILURE;
7527 }
7528 else
7529 {
7530 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7531 return CR_FAILURE;
7532 }
7533
7534 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7535 if (lpDevInst == NULL)
7536 return CR_INVALID_DEVNODE;
7537
7538 ulTransferLength = *pulLength;
7539
7541 {
7543 lpDevInst,
7545 (LPWSTR)pszReference,
7546 pszDeviceInterface,
7547 pulLength,
7548 &ulTransferLength,
7549 0);
7550 }
7552 {
7554 }
7556
7557 return ret;
7558}
7559
7560
7561/***********************************************************************
7562 * CM_Remove_SubTree [SETUPAPI.@]
7563 *
7564 * This function is obsolete in Windows XP and above.
7565 */
7567WINAPI
7569 _In_ DEVINST dnAncestor,
7570 _In_ ULONG ulFlags)
7571{
7572 TRACE("CM_Remove_SubTree(%lx %lx)\n",
7573 dnAncestor, ulFlags);
7574
7576}
7577
7578
7579/***********************************************************************
7580 * CM_Remove_SubTree_Ex [SETUPAPI.@]
7581 *
7582 * This function is obsolete in Windows XP and above.
7583 */
7585WINAPI
7587 _In_ DEVINST dnAncestor,
7588 _In_ ULONG ulFlags,
7589 _In_opt_ HMACHINE hMachine)
7590{
7591 TRACE("CM_Remove_SubTree_Ex(%lx %lx %p)\n",
7592 dnAncestor, ulFlags, hMachine);
7593
7595}
7596
7597
7598/***********************************************************************
7599 * CM_Request_Device_EjectA [SETUPAPI.@]
7600 */
7602WINAPI
7604 _In_ DEVINST dnDevInst,
7605 _Out_opt_ PPNP_VETO_TYPE pVetoType,
7606 _Out_writes_opt_(ulNameLength) LPSTR pszVetoName,
7607 _In_ ULONG ulNameLength,
7608 _In_ ULONG ulFlags)
7609{
7610 TRACE("CM_Request_Device_EjectA(%lx %p %p %lu %lx)\n",
7611 dnDevInst, pVetoType, pszVetoName, ulNameLength, ulFlags);
7612
7613 return CM_Request_Device_Eject_ExA(dnDevInst, pVetoType, pszVetoName,
7614 ulNameLength, ulFlags, NULL);
7615}
7616
7617
7618/***********************************************************************
7619 * CM_Request_Device_EjectW [SETUPAPI.@]
7620 */
7622WINAPI
7624 _In_ DEVINST dnDevInst,
7625 _Out_opt_ PPNP_VETO_TYPE pVetoType,
7626 _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName,
7627 _In_ ULONG ulNameLength,
7628 _In_ ULONG ulFlags)
7629{
7630 TRACE("CM_Request_Device_EjectW(%lx %p %p %lu %lx)\n",
7631 dnDevInst, pVetoType, pszVetoName, ulNameLength, ulFlags);
7632
7633 return CM_Request_Device_Eject_ExW(dnDevInst, pVetoType, pszVetoName,
7634 ulNameLength, ulFlags, NULL);
7635}
7636
7637
7638/***********************************************************************
7639 * CM_Request_Device_Eject_ExA [SETUPAPI.@]
7640 */
7642WINAPI
7644 _In_ DEVINST dnDevInst,
7645 _Out_opt_ PPNP_VETO_TYPE pVetoType,
7646 _Out_writes_opt_(ulNameLength) LPSTR pszVetoName,
7647 _In_ ULONG ulNameLength,
7648 _In_ ULONG ulFlags,
7649 _In_opt_ HMACHINE hMachine)
7650{
7651 LPWSTR lpLocalVetoName = NULL;
7652 CONFIGRET ret;
7653
7654 TRACE("CM_Request_Device_Eject_ExA(%lx %p %p %lu %lx %p)\n",
7655 dnDevInst, pVetoType, pszVetoName, ulNameLength, ulFlags, hMachine);
7656
7657 if (ulNameLength != 0)
7658 {
7659 if (pszVetoName == NULL)
7660 return CR_INVALID_POINTER;
7661
7662 lpLocalVetoName = HeapAlloc(GetProcessHeap(), 0, ulNameLength * sizeof(WCHAR));
7663 if (lpLocalVetoName == NULL)
7664 return CR_OUT_OF_MEMORY;
7665 }
7666
7667 ret = CM_Request_Device_Eject_ExW(dnDevInst, pVetoType, lpLocalVetoName,
7668 ulNameLength, ulFlags, hMachine);
7669 if (ret == CR_REMOVE_VETOED && ulNameLength != 0)
7670 {
7672 0,
7673 lpLocalVetoName,
7674 ulNameLength,
7675 pszVetoName,
7676 ulNameLength,
7677 NULL,
7678 NULL) == 0)
7679 ret = CR_FAILURE;
7680 }
7681
7682 HeapFree(GetProcessHeap(), 0, lpLocalVetoName);
7683
7684 return ret;
7685}
7686
7687
7688/***********************************************************************
7689 * CM_Request_Device_Eject_ExW [SETUPAPI.@]
7690 */
7692WINAPI
7694 _In_ DEVINST dnDevInst,
7695 _Out_opt_ PPNP_VETO_TYPE pVetoType,
7696 _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName,
7697 _In_ ULONG ulNameLength,
7698 _In_ ULONG ulFlags,
7699 _In_opt_ HMACHINE hMachine)
7700{
7702 HSTRING_TABLE StringTable = NULL;
7703 LPWSTR lpDevInst;
7704 CONFIGRET ret;
7705
7706 TRACE("CM_Request_Device_Eject_ExW(%lx %p %p %lu %lx %p)\n",
7707 dnDevInst, pVetoType, pszVetoName, ulNameLength, ulFlags, hMachine);
7708
7709 if (dnDevInst == 0)
7710 return CR_INVALID_DEVNODE;
7711
7712 if (ulFlags != 0)
7713 return CR_INVALID_FLAG;
7714
7715 if (pszVetoName == NULL && ulNameLength != 0)
7716 return CR_INVALID_POINTER;
7717
7718 /* Windows 2003 SP2 ignores pszVetoName when ulNameLength is zero
7719 * and behaves like when pszVetoName is NULL */
7720 if (ulNameLength == 0)
7721 pszVetoName = NULL;
7722
7723 if (hMachine != NULL)
7724 {
7725 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7726 if (BindingHandle == NULL)
7727 return CR_FAILURE;
7728
7729 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7730 if (StringTable == 0)
7731 return CR_FAILURE;
7732 }
7733 else
7734 {
7735 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7736 return CR_FAILURE;
7737 }
7738
7739 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7740 if (lpDevInst == NULL)
7741 return CR_INVALID_DEVNODE;
7742
7744 {
7746 lpDevInst,
7747 pVetoType,
7748 pszVetoName,
7749 ulNameLength,
7750 ulFlags);
7751 }
7753 {
7755 }
7757
7758 return ret;
7759}
7760
7761
7762/***********************************************************************
7763 * CM_Request_Eject_PC [SETUPAPI.@]
7764 */
7766WINAPI
7768{
7769 TRACE("CM_Request_Eject_PC()\n");
7770
7772}
7773
7774
7775/***********************************************************************
7776 * CM_Request_Eject_PC_Ex [SETUPAPI.@]
7777 */
7779WINAPI
7781 _In_opt_ HMACHINE hMachine)
7782{
7784 CONFIGRET ret;
7785
7786 TRACE("CM_Request_Eject_PC_Ex(%p)\n", hMachine);
7787
7788 if (hMachine != NULL)
7789 {
7790 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7791 if (BindingHandle == NULL)
7792 return CR_FAILURE;
7793 }
7794 else
7795 {
7797 return CR_FAILURE;
7798 }
7799
7801 {
7803 }
7805 {
7807 }
7809
7810 return ret;
7811}
7812
7813
7814/***********************************************************************
7815 * CM_Run_Detection [SETUPAPI.@]
7816 */
7818WINAPI
7820 _In_ ULONG ulFlags)
7821{
7822 TRACE("CM_Run_Detection(%lx)\n", ulFlags);
7823
7824 return CM_Run_Detection_Ex(ulFlags, NULL);
7825}
7826
7827
7828/***********************************************************************
7829 * CM_Run_Detection_Ex [SETUPAPI.@]
7830 */
7832WINAPI
7834 _In_ ULONG ulFlags,
7835 _In_opt_ HMACHINE hMachine)
7836{
7838 CONFIGRET ret;
7839
7840 TRACE("CM_Run_Detection_Ex(%lx %p)\n",
7841 ulFlags, hMachine);
7842
7843 if (!pSetupIsUserAdmin())
7844 return CR_ACCESS_DENIED;
7845
7846 if (ulFlags & ~CM_DETECT_BITS)
7847 return CR_INVALID_FLAG;
7848
7849 if (hMachine != NULL)
7850 {
7851 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7852 if (BindingHandle == NULL)
7853 return CR_FAILURE;
7854 }
7855 else
7856 {
7858 return CR_FAILURE;
7859 }
7860
7862 {
7864 ulFlags);
7865 }
7867 {
7869 }
7871
7872 return ret;
7873}
7874
7875
7876/***********************************************************************
7877 * CM_Set_Class_Registry_PropertyA [SETUPAPI.@]
7878 */
7880WINAPI
7882 _In_ LPGUID ClassGuid,
7883 _In_ ULONG ulProperty,
7885 _In_ ULONG ulLength,
7886 _In_ ULONG ulFlags,
7887 _In_opt_ HMACHINE hMachine)
7888{
7890 ULONG ulType;
7891 CONFIGRET ret;
7892
7893 TRACE("CM_Set_Class_Registry_PropertyA(%p %lx %p %lu %lx %p)\n",
7894 ClassGuid, ulProperty, Buffer, ulLength, ulFlags, hMachine);
7895
7896 if (ClassGuid == NULL)
7897 return CR_INVALID_POINTER;
7898
7899 if ((Buffer == NULL) && (ulLength != 0))
7900 return CR_INVALID_POINTER;
7901
7902 if (ulFlags != 0)
7903 return CR_INVALID_FLAG;
7904
7905 if (Buffer == NULL)
7906 {
7908 ulProperty,
7909 Buffer,
7910 ulLength,
7911 ulFlags,
7912 hMachine);
7913 }
7914 else
7915 {
7916 /* Get property type */
7917 ulType = GetRegistryPropertyType(ulProperty);
7918
7919 /* Allocate buffer if needed */
7920 if ((ulType == REG_SZ) || (ulType == REG_MULTI_SZ))
7921 {
7922 lpBuffer = MyMalloc(ulLength * sizeof(WCHAR));
7923 if (lpBuffer == NULL)
7924 {
7926 }
7927 else
7928 {
7930 ulLength, lpBuffer, ulLength))
7931 {
7933 ret = CR_FAILURE;
7934 }
7935 else
7936 {
7938 ulProperty,
7939 lpBuffer,
7940 ulLength * sizeof(WCHAR),
7941 ulFlags,
7942 hMachine);
7944 }
7945 }
7946 }
7947 else
7948 {
7950 ulProperty,
7951 Buffer,
7952 ulLength,
7953 ulFlags,
7954 hMachine);
7955 }
7956
7957 }
7958
7959 return ret;
7960}
7961
7962
7963/***********************************************************************
7964 * CM_Set_Class_Registry_PropertyW [SETUPAPI.@]
7965 */
7967WINAPI
7969 _In_ LPGUID ClassGuid,
7970 _In_ ULONG ulProperty,
7972 _In_ ULONG ulLength,
7973 _In_ ULONG ulFlags,
7974 _In_opt_ HMACHINE hMachine)
7975{
7977 WCHAR szGuidString[PNP_MAX_GUID_STRING_LEN + 1];
7978 ULONG ulType = 0;
7979 PSECURITY_DESCRIPTOR pSecurityDescriptor = NULL;
7980 ULONG SecurityDescriptorSize = 0;
7981 CONFIGRET ret;
7982
7983 TRACE("CM_Set_Class_Registry_PropertyW(%p %lx %p %lu %lx %p)\n",
7984 ClassGuid, ulProperty, Buffer, ulLength, ulFlags, hMachine);
7985
7986 if (ClassGuid == NULL)
7987 return CR_INVALID_POINTER;
7988
7989 if ((Buffer == NULL) && (ulLength != 0))
7990 return CR_INVALID_POINTER;
7991
7992 if (ulFlags != 0)
7993 return CR_INVALID_FLAG;
7994
7995 if (pSetupStringFromGuid(ClassGuid,
7996 szGuidString,
7998 return CR_INVALID_DATA;
7999
8000 if ((ulProperty < CM_CRP_MIN) || (ulProperty > CM_CRP_MAX))
8001 return CR_INVALID_PROPERTY;
8002
8003 if (hMachine != NULL)
8004 {
8005 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8006 if (BindingHandle == NULL)
8007 return CR_FAILURE;
8008 }
8009 else
8010 {
8012 return CR_FAILURE;
8013 }
8014
8015 ulType = GetRegistryPropertyType(ulProperty);
8016 if ((ulType == REG_DWORD) && (ulLength != sizeof(DWORD)))
8017 return CR_INVALID_DATA;
8018
8019 if (ulProperty == CM_CRP_SECURITY_SDS)
8020 {
8021 if (ulLength != 0)
8022 {
8025 &pSecurityDescriptor,
8026 &SecurityDescriptorSize))
8027 {
8028 ERR("ConvertStringSecurityDescriptorToSecurityDescriptorW() failed (Error %lu)\n", GetLastError());
8029 return CR_INVALID_DATA;
8030 }
8031
8032 Buffer = (PCVOID)pSecurityDescriptor;
8033 ulLength = SecurityDescriptorSize;
8034 }
8035
8036 ulProperty = CM_CRP_SECURITY;
8038 }
8039
8041 {
8043 szGuidString,
8044 ulProperty,
8045 ulType,
8046 (LPBYTE)Buffer,
8047 ulLength,
8048 ulFlags);
8049 }
8051 {
8053 }
8055
8056 if (pSecurityDescriptor)
8057 LocalFree(pSecurityDescriptor);
8058
8059 return ret;
8060}
8061
8062
8063/***********************************************************************
8064 * CM_Set_DevNode_Problem [SETUPAPI.@]
8065 */
8067WINAPI
8069 _In_ DEVINST dnDevInst,
8070 _In_ ULONG ulProblem,
8071 _In_ ULONG ulFlags)
8072{
8073 TRACE("CM_Set_DevNode_Problem(%lx %lx %lx)\n",
8074 dnDevInst, ulProblem, ulFlags);
8075
8076 return CM_Set_DevNode_Problem_Ex(dnDevInst, ulProblem, ulFlags, NULL);
8077}
8078
8079
8080/***********************************************************************
8081 * CM_Set_DevNode_Problem_Ex [SETUPAPI.@]
8082 */
8084WINAPI
8086 _In_ DEVINST dnDevInst,
8087 _In_ ULONG ulProblem,
8088 _In_ ULONG ulFlags,
8089 _In_opt_ HMACHINE hMachine)
8090{
8092 HSTRING_TABLE StringTable = NULL;
8093 LPWSTR lpDevInst;
8094 CONFIGRET ret;
8095
8096 TRACE("CM_Set_DevNode_Problem_Ex(%lx %lx %lx %p)\n",
8097 dnDevInst, ulProblem, ulFlags, hMachine);
8098
8099 if (dnDevInst == 0)
8100 return CR_INVALID_DEVNODE;
8101
8102 if (ulFlags & ~CM_SET_DEVNODE_PROBLEM_BITS)
8103 return CR_INVALID_FLAG;
8104
8105 if (hMachine != NULL)
8106 {
8107 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8108 if (BindingHandle == NULL)
8109 return CR_FAILURE;
8110
8111 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
8112 if (StringTable == 0)
8113 return CR_FAILURE;
8114 }
8115 else
8116 {
8117 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
8118 return CR_FAILURE;
8119 }
8120
8121 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
8122 if (lpDevInst == NULL)
8123 return CR_INVALID_DEVNODE;
8124
8126 {
8128 lpDevInst,
8129 ulProblem,
8130 ulFlags);
8131 }
8133 {
8135 }
8137
8138 return ret;
8139}
8140
8141
8142/***********************************************************************
8143 * CM_Set_DevNode_Registry_PropertyA [SETUPAPI.@]
8144 */
8146WINAPI
8148 _In_ DEVINST dnDevInst,
8149 _In_ ULONG ulProperty,
8151 _In_ ULONG ulLength,
8152 _In_ ULONG ulFlags)
8153{
8154 TRACE("CM_Set_DevNode_Registry_PropertyA(%lx %lu %p %lx %lx)\n",
8155 dnDevInst, ulProperty, Buffer, ulLength, ulFlags);
8156
8157 return CM_Set_DevNode_Registry_Property_ExA(dnDevInst, ulProperty,
8158 Buffer, ulLength,
8159 ulFlags, NULL);
8160}
8161
8162
8163/***********************************************************************
8164 * CM_Set_DevNode_Registry_PropertyW [SETUPAPI.@]
8165 */
8167WINAPI
8169 _In_ DEVINST dnDevInst,
8170 _In_ ULONG ulProperty,
8172 _In_ ULONG ulLength,
8173 _In_ ULONG ulFlags)
8174{
8175 TRACE("CM_Set_DevNode_Registry_PropertyW(%lx %lu %p %lx %lx)\n",
8176 dnDevInst, ulProperty, Buffer, ulLength, ulFlags);
8177
8178 return CM_Set_DevNode_Registry_Property_ExW(dnDevInst, ulProperty,
8179 Buffer, ulLength,
8180 ulFlags, NULL);
8181}
8182
8183
8184/***********************************************************************
8185 * CM_Set_DevNode_Registry_Property_ExA [SETUPAPI.@]
8186 */
8188WINAPI
8190 _In_ DEVINST dnDevInst,
8191 _In_ ULONG ulProperty,
8193 _In_ ULONG ulLength,
8194 _In_ ULONG ulFlags,
8195 _In_opt_ HMACHINE hMachine)
8196{
8199 ULONG ulType;
8200
8201 FIXME("CM_Set_DevNode_Registry_Property_ExA(%lx %lu %p %lx %lx %p)\n",
8202 dnDevInst, ulProperty, Buffer, ulLength, ulFlags, hMachine);
8203
8204 if (Buffer == NULL && ulLength != 0)
8205 return CR_INVALID_POINTER;
8206
8207 if (ulProperty < CM_DRP_MIN || ulProperty > CM_DRP_MAX)
8208 return CR_INVALID_PROPERTY;
8209
8210 if (Buffer == NULL)
8211 {
8213 ulProperty,
8214 NULL,
8215 0,
8216 ulFlags,
8217 hMachine);
8218 }
8219 else
8220 {
8221 /* Get property type */
8222 ulType = GetRegistryPropertyType(ulProperty);
8223
8224 /* Allocate buffer if needed */
8225 if (ulType == REG_SZ ||
8227 {
8228 lpBuffer = MyMalloc(ulLength * sizeof(WCHAR));
8229 if (lpBuffer == NULL)
8230 {
8232 }
8233 else
8234 {
8236 ulLength, lpBuffer, ulLength))
8237 {
8239 ret = CR_FAILURE;
8240 }
8241 else
8242 {
8244 ulProperty,
8245 lpBuffer,
8246 ulLength * sizeof(WCHAR),
8247 ulFlags,
8248 hMachine);
8250 }
8251 }
8252 }
8253 else
8254 {
8256 ulProperty,
8257 Buffer,
8258 ulLength,
8259 ulFlags,
8260 hMachine);
8261 }
8262
8264 }
8265
8266 return ret;
8267}
8268
8269
8270/***********************************************************************
8271 * CM_Set_DevNode_Registry_Property_ExW [SETUPAPI.@]
8272 */
8274WINAPI
8276 _In_ DEVINST dnDevInst,
8277 _In_ ULONG ulProperty,
8279 _In_ ULONG ulLength,
8280 _In_ ULONG ulFlags,
8281 _In_opt_ HMACHINE hMachine)
8282{
8284 HSTRING_TABLE StringTable = NULL;
8285 LPWSTR lpDevInst;
8286 ULONG ulType;
8287 CONFIGRET ret;
8288
8289 TRACE("CM_Set_DevNode_Registry_Property_ExW(%lx %lu %p %lx %lx %p)\n",
8290 dnDevInst, ulProperty, Buffer, ulLength, ulFlags, hMachine);
8291
8292 if (dnDevInst == 0)
8293 return CR_INVALID_DEVNODE;
8294
8295 if (ulProperty < CM_DRP_MIN || ulProperty > CM_DRP_MAX)
8296 return CR_INVALID_PROPERTY;
8297
8298 if (Buffer != NULL && ulLength == 0)
8299 return CR_INVALID_POINTER;
8300
8301 if (ulFlags != 0)
8302 return CR_INVALID_FLAG;
8303
8304 if (hMachine != NULL)
8305 {
8306 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8307 if (BindingHandle == NULL)
8308 return CR_FAILURE;
8309
8310 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
8311 if (StringTable == 0)
8312 return CR_FAILURE;
8313 }
8314 else
8315 {
8316 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
8317 return CR_FAILURE;
8318 }
8319
8320 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
8321 if (lpDevInst == NULL)
8322 return CR_INVALID_DEVNODE;
8323
8324 /* Get property type */
8325 ulType = GetRegistryPropertyType(ulProperty);
8326
8328 {
8330 lpDevInst,
8331 ulProperty,
8332 ulType,
8333 (BYTE *)Buffer,
8334 ulLength,
8335 ulFlags);
8336 }
8338 {
8340 }
8342
8343 return ret;
8344}
8345
8346
8347/***********************************************************************
8348 * CM_Set_HW_Prof [SETUPAPI.@]
8349 */
8351WINAPI
8353 _In_ ULONG ulHardwareProfile,
8354 _In_ ULONG ulFlags)
8355{
8356 TRACE("CM_Set_HW_Prof(%lu %lx)\n",
8357 ulHardwareProfile, ulFlags);
8358
8359 return CM_Set_HW_Prof_Ex(ulHardwareProfile, ulFlags, NULL);
8360}
8361
8362
8363/***********************************************************************
8364 * CM_Set_HW_Prof_Ex [SETUPAPI.@]
8365 */
8367WINAPI
8369 _In_ ULONG ulHardwareProfile,
8370 _In_ ULONG ulFlags,
8371 _In_opt_ HMACHINE hMachine)
8372{
8374 CONFIGRET ret;
8375
8376 TRACE("CM_Set_HW_Prof_Ex(%lu %lx %p)\n",
8377 ulHardwareProfile, ulFlags, hMachine);
8378
8379 if (!pSetupIsUserAdmin())
8380 return CR_ACCESS_DENIED;
8381
8382 if (ulFlags != 0)
8383 return CR_INVALID_FLAG;
8384
8385 if (hMachine != NULL)
8386 {
8387 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8388 if (BindingHandle == NULL)
8389 return CR_FAILURE;
8390 }
8391 else
8392 {
8394 return CR_FAILURE;
8395 }
8396
8398 {
8399 ret = PNP_SetHwProf(BindingHandle, ulHardwareProfile, ulFlags);
8400 }
8402 {
8404 }
8406
8407 return ret;
8408}
8409
8410
8411/***********************************************************************
8412 * CM_Set_HW_Prof_FlagsA [SETUPAPI.@]
8413 */
8415WINAPI
8417 _In_ DEVINSTID_A szDevInstName,
8418 _In_ ULONG ulConfig,
8419 _In_ ULONG ulValue,
8420 _In_ ULONG ulFlags)
8421{
8422 TRACE("CM_Set_HW_Prof_FlagsA(%s %lu %lu %lx)\n",
8423 debugstr_a(szDevInstName), ulConfig, ulValue, ulFlags);
8424
8425 return CM_Set_HW_Prof_Flags_ExA(szDevInstName, ulConfig, ulValue,
8426 ulFlags, NULL);
8427}
8428
8429
8430/***********************************************************************
8431 * CM_Set_HW_Prof_FlagsW [SETUPAPI.@]
8432 */
8434WINAPI
8436 _In_ DEVINSTID_W szDevInstName,
8437 _In_ ULONG ulConfig,
8438 _In_ ULONG ulValue,
8439 _In_ ULONG ulFlags)
8440{
8441 TRACE("CM_Set_HW_Prof_FlagsW(%s %lu %lu %lx)\n",
8442 debugstr_w(szDevInstName), ulConfig, ulValue, ulFlags);
8443
8444 return CM_Set_HW_Prof_Flags_ExW(szDevInstName, ulConfig, ulValue,
8445 ulFlags, NULL);
8446}
8447
8448
8449/***********************************************************************
8450 * CM_Set_HW_Prof_Flags_ExA [SETUPAPI.@]
8451 */
8453WINAPI
8455 _In_ DEVINSTID_A szDevInstName,
8456 _In_ ULONG ulConfig,
8457 _In_ ULONG ulValue,
8458 _In_ ULONG ulFlags,
8459 _In_opt_ HMACHINE hMachine)
8460{
8461 DEVINSTID_W pszDevIdW = NULL;
8463
8464 TRACE("CM_Set_HW_Prof_Flags_ExA(%s %lu %lu %lx %p)\n",
8465 debugstr_a(szDevInstName), ulConfig, ulValue, ulFlags, hMachine);
8466
8467 if (szDevInstName != NULL)
8468 {
8469 if (pSetupCaptureAndConvertAnsiArg(szDevInstName, &pszDevIdW))
8470 return CR_INVALID_DEVICE_ID;
8471 }
8472
8473 ret = CM_Set_HW_Prof_Flags_ExW(pszDevIdW, ulConfig, ulValue,
8474 ulFlags, hMachine);
8475
8476 if (pszDevIdW != NULL)
8477 MyFree(pszDevIdW);
8478
8479 return ret;
8480}
8481
8482
8483/***********************************************************************
8484 * CM_Set_HW_Prof_Flags_ExW [SETUPAPI.@]
8485 */
8487WINAPI
8489 _In_ DEVINSTID_W szDevInstName,
8490 _In_ ULONG ulConfig,
8491 _In_ ULONG ulValue,
8492 _In_ ULONG ulFlags,
8493 _In_opt_ HMACHINE hMachine)
8494{
8496 CONFIGRET ret;
8497
8498 FIXME("CM_Set_HW_Prof_Flags_ExW(%s %lu %lu %lx %p)\n",
8499 debugstr_w(szDevInstName), ulConfig, ulValue, ulFlags, hMachine);
8500
8501 if (szDevInstName == NULL)
8502 return CR_INVALID_POINTER;
8503
8504 if (ulFlags & ~ CM_SET_HW_PROF_FLAGS_BITS)
8505 return CR_INVALID_FLAG;
8506
8507 /* FIXME: Check whether szDevInstName is valid */
8508
8509 if (hMachine != NULL)
8510 {
8511 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8512 if (BindingHandle == NULL)
8513 return CR_FAILURE;
8514 }
8515 else
8516 {
8518 return CR_FAILURE;
8519 }
8520
8522 {
8523 ret = PNP_HwProfFlags(BindingHandle, PNP_SET_HWPROFFLAGS, szDevInstName,
8524 ulConfig, &ulValue, NULL, NULL, 0, 0);
8525 }
8527 {
8529 }
8531
8532 return ret;
8533}
8534
8535
8536/***********************************************************************
8537 * CM_Setup_DevNode [SETUPAPI.@]
8538 */
8540WINAPI
8542 _In_ DEVINST dnDevInst,
8543 _In_ ULONG ulFlags)
8544{
8545 TRACE("CM_Setup_DevNode(%lx %lx)\n",
8546 dnDevInst, ulFlags);
8547
8548 return CM_Setup_DevNode_Ex(dnDevInst, ulFlags, NULL);
8549}
8550
8551
8552/***********************************************************************
8553 * CM_Setup_DevNode_Ex [SETUPAPI.@]
8554 */
8556WINAPI
8558 _In_ DEVINST dnDevInst,
8559 _In_ ULONG ulFlags,
8560 _In_opt_ HMACHINE hMachine)
8561{
8563 HSTRING_TABLE StringTable = NULL;
8564 LPWSTR lpDevInst;
8565 CONFIGRET ret;
8566
8567 FIXME("CM_Setup_DevNode_Ex(%lx %lx %p)\n",
8568 dnDevInst, ulFlags, hMachine);
8569
8570 if (!pSetupIsUserAdmin())
8571 return CR_ACCESS_DENIED;
8572
8573 if (dnDevInst == 0)
8574 return CR_INVALID_DEVNODE;
8575
8576 if (ulFlags & ~CM_SETUP_BITS)
8577 return CR_INVALID_FLAG;
8578
8579 if (hMachine != NULL)
8580 {
8581 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8582 if (BindingHandle == NULL)
8583 return CR_FAILURE;
8584
8585 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
8586 if (StringTable == 0)
8587 return CR_FAILURE;
8588 }
8589 else
8590 {
8591 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
8592 return CR_FAILURE;
8593 }
8594
8595 lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
8596 if (lpDevInst == NULL)
8597 return CR_INVALID_DEVNODE;
8598
8600 {
8602 PNP_DEVINST_SETUP,
8603 ulFlags,
8604 lpDevInst,
8605 NULL);
8606 }
8608 {
8610 }
8612
8613 return ret;
8614}
8615
8616
8617/***********************************************************************
8618 * CM_Test_Range_Available [SETUPAPI.@]
8619 */
8621WINAPI
8623 _In_ DWORDLONG ullStartValue,
8624 _In_ DWORDLONG ullEndValue,
8625 _In_ RANGE_LIST rlh,
8626 _In_ ULONG ulFlags)
8627{
8628 PINTERNAL_RANGE_LIST pRangeList;
8629 PINTERNAL_RANGE pRange;
8630 PLIST_ENTRY ListEntry;
8632
8633 FIXME("CM_Test_Range_Available(%I64u %I64u %p %lx)\n",
8634 ullStartValue, ullEndValue, rlh, ulFlags);
8635
8636 pRangeList = (PINTERNAL_RANGE_LIST)rlh;
8637
8638 if (!IsValidRangeList(pRangeList))
8639 return CR_INVALID_RANGE_LIST;
8640
8641 if (ulFlags != 0)
8642 return CR_INVALID_FLAG;
8643
8644 if (ullStartValue > ullEndValue)
8645 return CR_INVALID_RANGE;
8646
8647 /* Lock the range list */
8648 WaitForSingleObject(pRangeList->hMutex, INFINITE);
8649
8650 /* Check the ranges */
8651 ListEntry = &pRangeList->ListHead;
8652 while (ListEntry->Flink == &pRangeList->ListHead)
8653 {
8654 pRange = CONTAINING_RECORD(ListEntry, INTERNAL_RANGE, ListEntry);
8655
8656 /* Check if the start value is within the current range */
8657 if ((ullStartValue >= pRange->ullStart) && (ullStartValue <= pRange->ullEnd))
8658 {
8659 ret = CR_FAILURE;
8660 break;
8661 }
8662
8663 /* Check if the end value is within the current range */
8664 if ((ullEndValue >= pRange->ullStart) && (ullEndValue <= pRange->ullEnd))
8665 {
8666 ret = CR_FAILURE;
8667 break;
8668 }
8669
8670 /* Check if the current range lies inside of the start-end interval */
8671 if ((ullStartValue <= pRange->ullStart) && (ullEndValue >= pRange->ullEnd))
8672 {
8673 ret = CR_FAILURE;
8674 break;
8675 }
8676
8677 ListEntry = ListEntry->Flink;
8678 }
8679
8680 /* Unlock the range list */
8681 ReleaseMutex(pRangeList->hMutex);
8682
8683 return ret;
8684}
8685
8686
8687/***********************************************************************
8688 * CM_Uninstall_DevNode [SETUPAPI.@]
8689 */
8691WINAPI
8693 _In_ DEVINST dnPhantom,
8694 _In_ ULONG ulFlags)
8695{
8696 TRACE("CM_Uninstall_DevNode(%lx %lx)\n",
8697 dnPhantom, ulFlags);
8698
8699 return CM_Uninstall_DevNode_Ex(dnPhantom, ulFlags, NULL);
8700}
8701
8702
8703/***********************************************************************
8704 * CM_Uninstall_DevNode_Ex [SETUPAPI.@]
8705 */
8707WINAPI
8709 _In_ DEVINST dnPhantom,
8710 _In_ ULONG ulFlags,
8711 _In_opt_ HMACHINE hMachine)
8712{
8714 HSTRING_TABLE StringTable = NULL;
8715 LPWSTR lpDevInst;
8716 CONFIGRET ret;
8717
8718 TRACE("CM_Uninstall_DevNode_Ex(%lx %lx %p)\n",
8719 dnPhantom, ulFlags, hMachine);
8720
8721 if (dnPhantom == 0)
8722 return CR_INVALID_DEVNODE;
8723
8724 if (ulFlags != 0)
8725 return CR_INVALID_FLAG;
8726
8727 if (hMachine != NULL)
8728 {
8729 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8730 if (BindingHandle == NULL)
8731 return CR_FAILURE;
8732
8733 StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
8734 if (StringTable == 0)
8735 return CR_FAILURE;
8736 }
8737 else
8738 {
8739 if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
8740 return CR_FAILURE;
8741 }
8742
8743 lpDevInst = pSetupStringTableStringFromId(StringTable, dnPhantom);
8744 if (lpDevInst == NULL)
8745 return CR_INVALID_DEVNODE;
8746
8748 {
8750 lpDevInst,
8751 ulFlags);
8752 }
8754 {
8756 }
8758
8759 return ret;
8760}
8761
8762
8763/***********************************************************************
8764 * CM_Unregister_Device_InterfaceA [SETUPAPI.@]
8765 */
8767WINAPI
8769 _In_ LPCSTR pszDeviceInterface,
8770 _In_ ULONG ulFlags)
8771{
8772 TRACE("CM_Unregister_Device_InterfaceA(%s %lx)\n",
8773 debugstr_a(pszDeviceInterface), ulFlags);
8774
8775 return CM_Unregister_Device_Interface_ExA(pszDeviceInterface,
8776 ulFlags, NULL);
8777}
8778
8779
8780/***********************************************************************
8781 * CM_Unregister_Device_InterfaceW [SETUPAPI.@]
8782 */
8784WINAPI
8786 _In_ LPCWSTR pszDeviceInterface,
8787 _In_ ULONG ulFlags)
8788{
8789 TRACE("CM_Unregister_Device_InterfaceW(%s %lx)\n",
8790 debugstr_w(pszDeviceInterface), ulFlags);
8791
8792 return CM_Unregister_Device_Interface_ExW(pszDeviceInterface,
8793 ulFlags, NULL);
8794}
8795
8796
8797/***********************************************************************
8798 * CM_Unregister_Device_Interface_ExA [SETUPAPI.@]
8799 */
8801WINAPI
8803 _In_ LPCSTR pszDeviceInterface,
8804 _In_ ULONG ulFlags,
8805 _In_opt_ HMACHINE hMachine)
8806{
8807 LPWSTR pszDeviceInterfaceW = NULL;
8808 CONFIGRET ret;
8809
8810 TRACE("CM_Unregister_Device_Interface_ExA(%s %lx %p)\n",
8811 debugstr_a(pszDeviceInterface), ulFlags, hMachine);
8812
8813 if (pszDeviceInterface == NULL)
8814 return CR_INVALID_POINTER;
8815
8816 if (pSetupCaptureAndConvertAnsiArg(pszDeviceInterface, &pszDeviceInterfaceW))
8817 return CR_INVALID_DATA;
8818
8819 ret = CM_Unregister_Device_Interface_ExW(pszDeviceInterfaceW,
8820 ulFlags, hMachine);
8821
8822 if (pszDeviceInterfaceW != NULL)
8823 MyFree(pszDeviceInterfaceW);
8824
8825 return ret;
8826}
8827
8828
8829/***********************************************************************
8830 * CM_Unregister_Device_Interface_ExW [SETUPAPI.@]
8831 */
8833WINAPI
8835 _In_ LPCWSTR pszDeviceInterface,
8836 _In_ ULONG ulFlags,
8837 _In_opt_ HMACHINE hMachine)
8838{
8840 CONFIGRET ret;
8841
8842 TRACE("CM_Unregister_Device_Interface_ExW(%s %lx %p)\n",
8843 debugstr_w(pszDeviceInterface), ulFlags, hMachine);
8844
8845 if (pszDeviceInterface == NULL)
8846 return CR_INVALID_POINTER;
8847
8848 if (ulFlags != 0)
8849 return CR_INVALID_FLAG;
8850
8851 if (hMachine != NULL)
8852 {
8853 BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8854 if (BindingHandle == NULL)
8855 return CR_FAILURE;
8856 }
8857 else
8858 {
8860 return CR_FAILURE;
8861 }
8862
8864 {
8866 (LPWSTR)pszDeviceInterface,
8867 ulFlags);
8868 }
8870 {
8872 }
8874
8875 return ret;
8876}
static SERVICE_STATUS_HANDLE(WINAPI *pRegisterServiceCtrlHandlerExA)(LPCSTR
DWORD WINAPI PNP_GetVersion(handle_t hBinding, WORD *pVersion)
Definition: rpcserver.c:722
DWORD WINAPI PNP_GetInterfaceDeviceList(handle_t hBinding, GUID *InterfaceGuid, LPWSTR pszDeviceID, BYTE *Buffer, PNP_RPC_BUFFER_SIZE *pulLength, DWORD ulFlags)
Definition: rpcserver.c:2706
DWORD WINAPI PNP_SetHwProf(handle_t hBinding, DWORD ulHardwareProfile, DWORD ulFlags)
Definition: rpcserver.c:5158
DWORD WINAPI PNP_UnregisterNotification(handle_t hBinding, PNP_NOTIFY_HANDLE *pNotifyHandle)
Definition: rpcserver.c:5362
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:5140
DWORD WINAPI PNP_GetRelatedDeviceInstance(handle_t hBinding, DWORD ulRelationship, LPWSTR pDeviceID, LPWSTR pRelatedDeviceId, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
Definition: rpcserver.c:915
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:993
DWORD WINAPI PNP_UnregisterDeviceClassAssociation(handle_t hBinding, LPWSTR pszInterfaceDevice, DWORD ulFlags)
Definition: rpcserver.c:2861
DWORD WINAPI PNP_GetDeviceListSize(handle_t hBinding, LPWSTR pszFilter, PNP_RPC_BUFFER_SIZE *pulLength, DWORD ulFlags)
Definition: rpcserver.c:1785
DWORD WINAPI PNP_InitDetection(handle_t hBinding)
Definition: rpcserver.c:765
DWORD WINAPI PNP_AddEmptyLogConf(handle_t hBinding, LPWSTR pDeviceID, DWORD ulPriority, DWORD *pulLogConfTag, DWORD ulFlags)
Definition: rpcserver.c:4333
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:2899
DWORD WINAPI PNP_GetServerSideDeviceInstallFlags(handle_t hBinding, DWORD *pulSSDIFlags, DWORD ulFlags)
Definition: rpcserver.c:5519
DWORD WINAPI PNP_FreeLogConf(handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfType, DWORD ulLogConfTag, DWORD ulFlags)
Definition: rpcserver.c:4550
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:1903
DWORD WINAPI PNP_GetBlockedDriverInfo(handle_t hBinding, BYTE *Buffer, PNP_RPC_BUFFER_SIZE *pulTransferLen, PNP_RPC_BUFFER_SIZE *pulLength, DWORD ulFlags)
Definition: rpcserver.c:5504
DWORD WINAPI PNP_GetInterfaceDeviceListSize(handle_t hBinding, PNP_RPC_BUFFER_SIZE *pulLen, GUID *InterfaceGuid, LPWSTR pszDeviceID, DWORD ulFlags)
Definition: rpcserver.c:2754
DWORD WINAPI PNP_UninstallDevInst(handle_t hBinding, LPWSTR pDeviceID, DWORD ulFlags)
Definition: rpcserver.c:3744
DWORD WINAPI PNP_GetDeviceStatus(handle_t hBinding, LPWSTR pDeviceID, DWORD *pulStatus, DWORD *pulProblem, DWORD ulFlags)
Definition: rpcserver.c:3583
DWORD WINAPI PNP_GetClassInstance(handle_t hBinding, LPWSTR pDeviceId, LPWSTR pszClassInstance, PNP_RPC_STRING_LEN ulLength)
Definition: rpcserver.c:2322
DWORD WINAPI PNP_DeviceInstanceAction(handle_t hBinding, DWORD ulMajorAction, DWORD ulMinorAction, LPWSTR pszDeviceInstance1, LPWSTR pszDeviceInstance2)
Definition: rpcserver.c:3538
DWORD WINAPI PNP_RegisterDriver(handle_t hBinding, LPWSTR pszDeviceID, DWORD ulFlags)
Definition: rpcserver.c:3906
DWORD WINAPI PNP_GetDepth(handle_t hBinding, LPWSTR pszDeviceID, DWORD *pulDepth, DWORD ulFlags)
Definition: rpcserver.c:1860
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:4114
DWORD WINAPI PNP_DisableDevInst(handle_t hBinding, LPWSTR pDeviceID, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, DWORD ulNameLength, DWORD ulFlags)
Definition: rpcserver.c:3714
DWORD WINAPI PNP_GetClassName(handle_t hBinding, LPWSTR pszClassGuid, LPWSTR Buffer, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
Definition: rpcserver.c:2562
DWORD WINAPI PNP_RequestDeviceEject(handle_t hBinding, LPWSTR pszDeviceID, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, DWORD ulNameLength, DWORD ulFlags)
Definition: rpcserver.c:3978
DWORD WINAPI PNP_GetLogConfPriority(handle_t hBinding, LPWSTR pDeviceID, DWORD ulType, DWORD ulTag, DWORD *pPriority, DWORD ulFlags)
Definition: rpcserver.c:4911
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:2652
DWORD WINAPI PNP_RequestEjectPC(handle_t hBinding)
Definition: rpcserver.c:4082
DWORD WINAPI PNP_CreateDevInst(handle_t hBinding, LPWSTR pszDeviceID, LPWSTR pszParentDeviceID, PNP_RPC_STRING_LEN ulLength, DWORD ulFlags)
Definition: rpcserver.c:3298
DWORD WINAPI PNP_SetDeviceRegProp(handle_t hBinding, LPWSTR pDeviceId, DWORD ulProperty, DWORD ulDataType, BYTE *Buffer, PNP_PROP_SIZE ulLength, DWORD ulFlags)
Definition: rpcserver.c:2180
DWORD WINAPI PNP_AddID(handle_t hBinding, LPWSTR pszDeviceID, LPWSTR pszID, DWORD ulFlags)
Definition: rpcserver.c:3799
DWORD WINAPI PNP_QueryRemove(handle_t hBinding, LPWSTR pszDeviceID, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName, DWORD ulNameLength, DWORD ulFlags)
Definition: rpcserver.c:3929
DWORD WINAPI PNP_GetFirstLogConf(handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfType, DWORD *pulLogConfTag, DWORD ulFlags)
Definition: rpcserver.c:4691
DWORD WINAPI PNP_SetClassRegProp(handle_t hBinding, LPWSTR pszClassGuid, DWORD ulProperty, DWORD ulDataType, BYTE *Buffer, PNP_PROP_SIZE ulLength, DWORD ulFlags)
Definition: rpcserver.c:3025
DWORD WINAPI PNP_GetNextLogConf(handle_t hBinding, LPWSTR pDeviceID, DWORD ulLogConfType, DWORD ulCurrentTag, DWORD *pulNextTag, DWORD ulFlags)
Definition: rpcserver.c:4792
DWORD WINAPI PNP_GetGlobalState(handle_t hBinding, DWORD *pulState, DWORD ulFlags)
Definition: rpcserver.c:740
CONFIGRET WINAPI PNP_IsDockStationPresent(handle_t hBinding, BOOL *Present)
Definition: rpcserver.c:4026
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:5213
DWORD WINAPI PNP_GetHwProfInfo(handle_t hBinding, DWORD ulIndex, HWPROFILEINFO *pHWProfileInfo, DWORD ulProfileInfoSize, DWORD ulFlags)
Definition: rpcserver.c:4198
DWORD WINAPI PNP_SetDeviceProblem(handle_t hBinding, LPWSTR pDeviceID, DWORD ulProblem, DWORD ulFlags)
Definition: rpcserver.c:3661
CONFIGRET WINAPI PNP_RunDetection(handle_t hBinding, DWORD ulFlags)
Definition: rpcserver.c:5202
DWORD WINAPI PNP_GetRootDeviceInstance(handle_t hBinding, LPWSTR pDeviceID, PNP_RPC_STRING_LEN ulLength)
Definition: rpcserver.c:878
DWORD WINAPI PNP_GetDeviceList(handle_t hBinding, LPWSTR pszFilter, LPWSTR Buffer, PNP_RPC_STRING_LEN *pulLength, DWORD ulFlags)
Definition: rpcserver.c:1414
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:5391
DWORD WINAPI PNP_DeleteRegistryKey(handle_t hBinding, LPWSTR pszDeviceID, LPWSTR pszParentKey, LPWSTR pszChildKey, DWORD ulFlags)
Definition: rpcserver.c:2502
DWORD WINAPI PNP_QueryArbitratorFreeData(handle_t hBinding, BYTE *pData, DWORD DataLen, LPWSTR pDeviceID, RESOURCEID ResourceID, DWORD ulFlags)
Definition: rpcserver.c:5170
DWORD WINAPI PNP_ReportLogOn(handle_t hBinding, BOOL Admin, DWORD ProcessId)
Definition: rpcserver.c:780
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:4965
DWORD WINAPI PNP_ValidateDeviceInstance(handle_t hBinding, LPWSTR pDeviceID, DWORD ulFlags)
Definition: rpcserver.c:835
DWORD WINAPI PNP_QueryArbitratorFreeSize(handle_t hBinding, DWORD *pulSize, LPWSTR pDeviceID, RESOURCEID ResourceID, DWORD ulFlags)
Definition: rpcserver.c:5185
DWORD WINAPI PNP_DeleteClassKey(handle_t hBinding, LPWSTR pszClassGuid, DWORD ulFlags)
Definition: rpcserver.c:2620
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:2801
#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:4918
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:7623
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:5868
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:8802
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:8692
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:7292
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:7833
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:4731
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:7603
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:5150
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:6417
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:8189
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:7097
CONFIGRET WINAPI CM_Get_Global_State_Ex(_Out_ PULONG pulState, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:4832
CONFIGRET WINAPI CM_Register_Device_Driver_Ex(_In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7308
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:6905
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:8834
#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:7391
#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:7780
CONFIGRET WINAPI CM_Unregister_Device_InterfaceW(_In_ LPCWSTR pszDeviceInterface, _In_ ULONG ulFlags)
Definition: cfgmgr.c:8785
CONFIGRET WINAPI CM_Set_HW_Prof_FlagsA(_In_ DEVINSTID_A szDevInstName, _In_ ULONG ulConfig, _In_ ULONG ulValue, _In_ ULONG ulFlags)
Definition: cfgmgr.c:8416
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:6164
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:7568
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:4619
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:8435
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:4412
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:4714
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:7230
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:5005
CONFIGRET WINAPI CM_Intersect_Range_List(_In_ RANGE_LIST rlhOld1, _In_ RANGE_LIST rlhOld2, _In_ RANGE_LIST rlhNew, _In_ ULONG ulFlags)
Definition: cfgmgr.c:5850
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:8168
CONFIGRET WINAPI CM_Get_Sibling_Ex(_Out_ PDEVINST pdnDevInst, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:5712
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:6579
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:5794
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:6204
CONFIGRET WINAPI CM_Query_Arbitrator_Free_Size(_Out_ PULONG pulSize, _In_ DEVINST dnDevInst, _In_ RESOURCEID ResourceID, _In_ ULONG ulFlags)
Definition: cfgmgr.c:6974
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:4454
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:7062
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:4658
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:4880
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:7414
CONFIGRET WINAPI CM_Test_Range_Available(_In_ DWORDLONG ullStartValue, _In_ DWORDLONG ullEndValue, _In_ RANGE_LIST rlh, _In_ ULONG ulFlags)
Definition: cfgmgr.c:8622
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:6885
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:5901
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:6454
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:4600
CONFIGRET WINAPI CM_Set_DevNode_Problem_Ex(_In_ DEVINST dnDevInst, _In_ ULONG ulProblem, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:8085
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:6993
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:6558
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:8541
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:5041
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:8147
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:6767
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:5963
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:6011
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:7693
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:4816
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:8368
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:5344
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:6045
CONFIGRET WINAPI CM_Get_Parent(_Out_ PDEVINST pdnDevInst, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
Definition: cfgmgr.c:5463
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:4433
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:5661
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:7368
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:6182
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:5133
CONFIGRET WINAPI CM_Reenumerate_DevNode(_In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
Definition: cfgmgr.c:7215
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:7881
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:5480
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:8768
CONFIGRET WINAPI CM_Set_DevNode_Problem(_In_ DEVINST dnDevInst, _In_ ULONG ulProblem, _In_ ULONG ulFlags)
Definition: cfgmgr.c:8068
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:7488
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:4581
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:8557
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:4348
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:8352
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:7968
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:8275
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:5324
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:7767
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:5562
BOOL WINAPI CM_Is_Version_Available(_In_ WORD wVersion)
Definition: cfgmgr.c:5948
CONFIGRET WINAPI CM_Get_Res_Des_Data_Size(_Out_ PULONG pulSize, _In_ RES_DES rdResDes, _In_ ULONG ulFlags)
Definition: cfgmgr.c:5599
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:5023
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:6314
CONFIGRET WINAPI CM_Get_Sibling(_Out_ PDEVINST pdnDevInst, _In_ DEVINST dnDevInst, _In_ ULONG ulFlags)
Definition: cfgmgr.c:5695
CONFIGRET WINAPI CM_Query_Remove_SubTree_Ex(_In_ DEVINST dnAncestor, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:7080
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:4899
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:6395
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:6243
#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:5219
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:6747
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:8708
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:7586
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:5236
CONFIGRET WINAPI CM_Locate_DevNode_ExW(_Out_ PDEVINST pdnDevInst, _In_opt_ DEVINSTID_W pDeviceID, _In_ ULONG ulFlags, _In_opt_ HMACHINE hMachine)
Definition: cfgmgr.c:6077
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:5083
struct _MACHINE_INFO * PMACHINE_INFO
CONFIGRET WINAPI CM_Get_Resource_Conflict_Count(_In_ CONFLICT_LIST clConflictList, _Out_ PULONG pulCount)
Definition: cfgmgr.c:5634
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:5580
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:6373
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:4952
BOOL IsValidRangeList(_In_opt_ PINTERNAL_RANGE_LIST pRangeList)
Definition: cfgmgr.c:395
CONFIGRET WINAPI CM_Run_Detection(_In_ ULONG ulFlags)
Definition: cfgmgr.c:7819
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:6727
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:7643
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:6815
CONFIGRET WINAPI CM_Locate_DevNodeW(_Out_ PDEVINST pdnDevInst, _In_opt_ DEVINSTID_W pDeviceID, _In_ ULONG ulFlags)
Definition: cfgmgr.c:6028
CONFIGRET WINAPI CM_Move_DevNode(_In_ DEVINST dnFromDevInst, _In_ DEVINST dnToDevInst, _In_ ULONG ulFlags)
Definition: cfgmgr.c:6226
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:5886
CONFIGRET WINAPI CM_Get_Resource_Conflict_DetailsW(_In_ CONFLICT_LIST clConflictList, _In_ ULONG ulIndex, _Inout_ PCONFLICT_DETAILS_W pConflictDetails)
Definition: cfgmgr.c:5678
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:5807
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:4519
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:5616
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:8454
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:8488
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
return ret
Definition: mutex.c:146
#define L(x)
Definition: resources.c:13
#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
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:888
#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
_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:1753
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
#define CreateMutex
Definition: winbase.h:3797
DWORD WINAPI GetCurrentProcessId(void)
Definition: proc.c:1158
#define WAIT_FAILED
Definition: winbase.h:446
WINBASEAPI _In_ DWORD nLength
Definition: wincon.h:682
_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:3022
_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