dll/win32/setupapi/cfgmgr.c

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