dll/win32/setupapi/cfgmgr.c

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