dll/win32/setupapi/cfgmgr.c

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