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