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