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_Sibling [SETUPAPI.@]
5162  */
5163 CONFIGRET
5164 WINAPI
5165 CM_Get_Sibling(
5166     _Out_ PDEVINST pdnDevInst,
5167     _In_ DEVINST dnDevInst,
5168     _In_ ULONG ulFlags)
5169 {
5170     TRACE("CM_Get_Sibling(%p %p %lx)\n",
5171           pdnDevInst, dnDevInst, ulFlags);
5172
5173     return CM_Get_Sibling_Ex(pdnDevInst, dnDevInst, ulFlags, NULL);
5174 }
5175
5176
5177 /***********************************************************************
5178  * CM_Get_Sibling_Ex [SETUPAPI.@]
5179  */
5180 CONFIGRET
5181 WINAPI
5182 CM_Get_Sibling_Ex(
5183     _Out_ PDEVINST pdnDevInst,
5184     _In_ DEVINST dnDevInst,
5185     _In_ ULONG ulFlags,
5186     _In_opt_ HMACHINE hMachine)
5187 {
5188     WCHAR szRelatedDevInst[MAX_DEVICE_ID_LEN];
5189     RPC_BINDING_HANDLE BindingHandle = NULL;
5190     HSTRING_TABLE StringTable = NULL;
5191     LPWSTR lpDevInst;
5192     DWORD dwIndex, dwLength = MAX_DEVICE_ID_LEN;
5193     CONFIGRET ret;
5194
5195     TRACE("CM_Get_Sibling_Ex(%p %lx %lx %p)\n",
5196           pdnDevInst, dnDevInst, ulFlags, hMachine);
5197
5198     if (pdnDevInst == NULL)
5199         return CR_INVALID_POINTER;
5200
5201     if (dnDevInst == 0)
5202         return CR_INVALID_DEVINST;
5203
5204     if (ulFlags != 0)
5205         return CR_INVALID_FLAG;
5206
5207     *pdnDevInst = -1;
5208
5209     if (hMachine != NULL)
5210     {
5211         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5212         if (BindingHandle == NULL)
5213             return CR_FAILURE;
5214
5215         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5216         if (StringTable == 0)
5217             return CR_FAILURE;
5218     }
5219     else
5220     {
5221         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5222             return CR_FAILURE;
5223     }
5224
5225     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
5226     if (lpDevInst == NULL)
5227         return CR_INVALID_DEVNODE;
5228
5229     RpcTryExcept
5230     {
5231         ret = PNP_GetRelatedDeviceInstance(BindingHandle,
5232                                            PNP_GET_SIBLING_DEVICE_INSTANCE,
5233                                            lpDevInst,
5234                                            szRelatedDevInst,
5235                                            &dwLength,
5236                                            0);
5237     }
5238     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5239     {
5240         ret = RpcStatusToCmStatus(RpcExceptionCode());
5241     }
5242     RpcEndExcept;
5243
5244     if (ret != CR_SUCCESS)
5245         return ret;
5246
5247     TRACE("szRelatedDevInst: %s\n", debugstr_w(szRelatedDevInst));
5248
5249     dwIndex = pSetupStringTableAddString(StringTable, szRelatedDevInst, 1);
5250     if (dwIndex == -1)
5251         return CR_FAILURE;
5252
5253     *pdnDevInst = dwIndex;
5254
5255     return CR_SUCCESS;
5256 }
5257
5258
5259 /***********************************************************************
5260  * CM_Get_Version [SETUPAPI.@]
5261  */
5262 WORD
5263 WINAPI
5264 CM_Get_Version(VOID)
5265 {
5266     TRACE("CM_Get_Version()\n");
5267
5268     return CM_Get_Version_Ex(NULL);
5269 }
5270
5271
5272 /***********************************************************************
5273  * CM_Get_Version_Ex [SETUPAPI.@]
5274  */
5275 WORD
5276 WINAPI
5277 CM_Get_Version_Ex(
5278     _In_opt_ HMACHINE hMachine)
5279 {
5280     RPC_BINDING_HANDLE BindingHandle = NULL;
5281     WORD Version = 0;
5282     CONFIGRET ret;
5283
5284     TRACE("CM_Get_Version_Ex(%p)\n", hMachine);
5285
5286     if (hMachine != NULL)
5287     {
5288         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5289         if (BindingHandle == NULL)
5290             return 0;
5291     }
5292     else
5293     {
5294         if (!PnpGetLocalHandles(&BindingHandle, NULL))
5295             return CR_FAILURE;
5296     }
5297
5298     RpcTryExcept
5299     {
5300         ret = PNP_GetVersion(BindingHandle, &Version);
5301     }
5302     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5303     {
5304         ret = RpcStatusToCmStatus(RpcExceptionCode());
5305     }
5306     RpcEndExcept;
5307
5308     if (ret != CR_SUCCESS)
5309         return 0;
5310
5311     return Version;
5312 }
5313
5314
5315 /***********************************************************************
5316  * CM_Intersect_Range_List [SETUPAPI.@]
5317  */
5318 CONFIGRET
5319 WINAPI
5320 CM_Intersect_Range_List(
5321     _In_ RANGE_LIST rlhOld1,
5322     _In_ RANGE_LIST rlhOld2,
5323     _In_ RANGE_LIST rlhNew,
5324     _In_ ULONG ulFlags)
5325 {
5326     FIXME("CM_Intersect_Range_List(%p %p %p %lx)\n",
5327           rlhOld1, rlhOld2, rlhNew, ulFlags);
5328
5329     return CR_CALL_NOT_IMPLEMENTED;
5330 }
5331
5332
5333 /***********************************************************************
5334  * CM_Invert_Range_List [SETUPAPI.@]
5335  */
5336 CONFIGRET
5337 WINAPI
5338 CM_Invert_Range_List(
5339     _In_ RANGE_LIST rlhOld,
5340     _In_ RANGE_LIST rlhNew,
5341     _In_ DWORDLONG ullMaxValue,
5342     _In_ ULONG ulFlags)
5343 {
5344     FIXME("CM_Invert_Range_List(%p %p %I64u %lx)\n",
5345           rlhOld, rlhNew, ullMaxValue, ulFlags);
5346
5347     return CR_CALL_NOT_IMPLEMENTED;
5348 }
5349
5350
5351 /***********************************************************************
5352  * CM_Is_Dock_Station_Present [SETUPAPI.@]
5353  */
5354 CONFIGRET
5355 WINAPI
5356 CM_Is_Dock_Station_Present(
5357     _Out_ PBOOL pbPresent)
5358 {
5359     TRACE("CM_Is_Dock_Station_Present(%p)\n",
5360           pbPresent);
5361
5362     return CM_Is_Dock_Station_Present_Ex(pbPresent, NULL);
5363 }
5364
5365
5366 /***********************************************************************
5367  * CM_Is_Dock_Station_Present_Ex [SETUPAPI.@]
5368  */
5369 CONFIGRET
5370 WINAPI
5371 CM_Is_Dock_Station_Present_Ex(
5372     _Out_ PBOOL pbPresent,
5373     _In_opt_ HMACHINE hMachine)
5374 {
5375     RPC_BINDING_HANDLE BindingHandle = NULL;
5376     CONFIGRET ret;
5377
5378     TRACE("CM_Is_Dock_Station_Present_Ex(%p %p)\n",
5379           pbPresent, hMachine);
5380
5381     if (pbPresent == NULL)
5382         return CR_INVALID_POINTER;
5383
5384     *pbPresent = FALSE;
5385
5386     if (hMachine != NULL)
5387     {
5388         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5389         if (BindingHandle == NULL)
5390             return CR_FAILURE;
5391     }
5392     else
5393     {
5394         if (!PnpGetLocalHandles(&BindingHandle, NULL))
5395             return CR_FAILURE;
5396     }
5397
5398     RpcTryExcept
5399     {
5400         ret = PNP_IsDockStationPresent(BindingHandle,
5401                                        pbPresent);
5402     }
5403     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5404     {
5405         ret = RpcStatusToCmStatus(RpcExceptionCode());
5406     }
5407     RpcEndExcept;
5408
5409     return ret;
5410 }
5411
5412
5413 /***********************************************************************
5414  * CM_Is_Version_Available_Ex [SETUPAPI.@]
5415  */
5416 BOOL
5417 WINAPI
5418 CM_Is_Version_Available(
5419      _In_ WORD wVersion)
5420 {
5421     TRACE("CM_Is_Version_Available(%hu)\n",
5422           wVersion);
5423
5424     return CM_Is_Version_Available_Ex(wVersion, NULL);
5425 }
5426
5427
5428 /***********************************************************************
5429  * CM_Is_Version_Available_Ex [SETUPAPI.@]
5430  */
5431 BOOL
5432 WINAPI
5433 CM_Is_Version_Available_Ex(
5434     _In_ WORD wVersion,
5435     _In_opt_ HMACHINE hMachine)
5436 {
5437     RPC_BINDING_HANDLE BindingHandle = NULL;
5438     WORD wServerVersion;
5439     CONFIGRET ret;
5440
5441     TRACE("CM_Is_Version_Available_Ex(%hu %p)\n",
5442           wVersion, hMachine);
5443
5444     if (wVersion <= 0x400)
5445         return TRUE;
5446
5447     if (hMachine != NULL)
5448     {
5449         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5450         if (BindingHandle == NULL)
5451             return FALSE;
5452     }
5453     else
5454     {
5455         if (!PnpGetLocalHandles(&BindingHandle, NULL))
5456             return FALSE;
5457     }
5458
5459     RpcTryExcept
5460     {
5461         ret = PNP_GetVersion(BindingHandle, &wServerVersion);
5462     }
5463     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5464     {
5465         ret = RpcStatusToCmStatus(RpcExceptionCode());
5466     }
5467     RpcEndExcept;
5468
5469     if (ret != CR_SUCCESS)
5470         return FALSE;
5471
5472     return (wServerVersion >= wVersion);
5473 }
5474
5475
5476 /***********************************************************************
5477  * CM_Locate_DevNodeA [SETUPAPI.@]
5478  */
5479 CONFIGRET
5480 WINAPI
5481 CM_Locate_DevNodeA(
5482     _Out_ PDEVINST pdnDevInst,
5483     _In_opt_ DEVINSTID_A pDeviceID,
5484     _In_ ULONG ulFlags)
5485 {
5486     TRACE("CM_Locate_DevNodeA(%p %s %lx)\n",
5487           pdnDevInst, debugstr_a(pDeviceID), ulFlags);
5488
5489     return CM_Locate_DevNode_ExA(pdnDevInst, pDeviceID, ulFlags, NULL);
5490 }
5491
5492
5493 /***********************************************************************
5494  * CM_Locate_DevNodeW [SETUPAPI.@]
5495  */
5496 CONFIGRET
5497 WINAPI
5498 CM_Locate_DevNodeW(
5499     _Out_ PDEVINST pdnDevInst,
5500     _In_opt_ DEVINSTID_W pDeviceID,
5501     _In_ ULONG ulFlags)
5502 {
5503     TRACE("CM_Locate_DevNodeW(%p %s %lx)\n",
5504           pdnDevInst, debugstr_w(pDeviceID), ulFlags);
5505
5506     return CM_Locate_DevNode_ExW(pdnDevInst, pDeviceID, ulFlags, NULL);
5507 }
5508
5509
5510 /***********************************************************************
5511  * CM_Locate_DevNode_ExA [SETUPAPI.@]
5512  */
5513 CONFIGRET
5514 WINAPI
5515 CM_Locate_DevNode_ExA(
5516     _Out_ PDEVINST pdnDevInst,
5517     _In_opt_ DEVINSTID_A pDeviceID,
5518     _In_ ULONG ulFlags,
5519     _In_opt_ HMACHINE hMachine)
5520 {
5521     DEVINSTID_W pDevIdW = NULL;
5522     CONFIGRET ret = CR_SUCCESS;
5523
5524     TRACE("CM_Locate_DevNode_ExA(%p %s %lx %p)\n",
5525           pdnDevInst, debugstr_a(pDeviceID), ulFlags, hMachine);
5526
5527     if (pDeviceID != NULL)
5528     {
5529        if (pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDevIdW))
5530          return CR_INVALID_DEVICE_ID;
5531     }
5532
5533     ret = CM_Locate_DevNode_ExW(pdnDevInst, pDevIdW, ulFlags, hMachine);
5534
5535     if (pDevIdW != NULL)
5536         MyFree(pDevIdW);
5537
5538     return ret;
5539 }
5540
5541
5542 /***********************************************************************
5543  * CM_Locate_DevNode_ExW [SETUPAPI.@]
5544  */
5545 CONFIGRET
5546 WINAPI
5547 CM_Locate_DevNode_ExW(
5548     _Out_ PDEVINST pdnDevInst,
5549     _In_opt_ DEVINSTID_W pDeviceID,
5550     _In_ ULONG ulFlags,
5551     _In_opt_ HMACHINE hMachine)
5552 {
5553     WCHAR DeviceIdBuffer[MAX_DEVICE_ID_LEN];
5554     RPC_BINDING_HANDLE BindingHandle = NULL;
5555     HSTRING_TABLE StringTable = NULL;
5556     CONFIGRET ret = CR_SUCCESS;
5557
5558     TRACE("CM_Locate_DevNode_ExW(%p %s %lx %p)\n",
5559           pdnDevInst, debugstr_w(pDeviceID), ulFlags, hMachine);
5560
5561     if (pdnDevInst == NULL)
5562         return CR_INVALID_POINTER;
5563
5564     if (ulFlags & ~CM_LOCATE_DEVNODE_BITS)
5565         return CR_INVALID_FLAG;
5566
5567     if (hMachine != NULL)
5568     {
5569         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5570         if (BindingHandle == NULL)
5571             return CR_FAILURE;
5572
5573         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5574         if (StringTable == 0)
5575             return CR_FAILURE;
5576     }
5577     else
5578     {
5579         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5580             return CR_FAILURE;
5581     }
5582
5583     if (pDeviceID != NULL && lstrlenW(pDeviceID) != 0)
5584     {
5585         lstrcpyW(DeviceIdBuffer, pDeviceID);
5586     }
5587     else
5588     {
5589         RpcTryExcept
5590         {
5591             /* Get the root device ID */
5592             ret = PNP_GetRootDeviceInstance(BindingHandle,
5593                                             DeviceIdBuffer,
5594                                             MAX_DEVICE_ID_LEN);
5595         }
5596         RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5597         {
5598             ret = RpcStatusToCmStatus(RpcExceptionCode());
5599         }
5600         RpcEndExcept;
5601
5602         if (ret != CR_SUCCESS)
5603             return CR_FAILURE;
5604     }
5605     TRACE("DeviceIdBuffer: %s\n", debugstr_w(DeviceIdBuffer));
5606
5607     RpcTryExcept
5608     {
5609         /* Validate the device ID */
5610         ret = PNP_ValidateDeviceInstance(BindingHandle,
5611                                          DeviceIdBuffer,
5612                                          ulFlags);
5613     }
5614     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5615     {
5616         ret = RpcStatusToCmStatus(RpcExceptionCode());
5617     }
5618     RpcEndExcept;
5619
5620     if (ret == CR_SUCCESS)
5621     {
5622         *pdnDevInst = pSetupStringTableAddString(StringTable, DeviceIdBuffer, 1);
5623         if (*pdnDevInst == -1)
5624             ret = CR_FAILURE;
5625     }
5626
5627     return ret;
5628 }
5629
5630
5631 /***********************************************************************
5632  * CM_Merge_Range_List [SETUPAPI.@]
5633  */
5634 CONFIGRET
5635 WINAPI
5636 CM_Merge_Range_List(
5637     _In_ RANGE_LIST rlhOld1,
5638     _In_ RANGE_LIST rlhOld2,
5639     _In_ RANGE_LIST rlhNew,
5640     _In_ ULONG ulFlags)
5641 {
5642     FIXME("CM_Merge_Range_List(%p %p %p %lx)\n",
5643           rlhOld1, rlhOld2, rlhNew, ulFlags);
5644
5645     return CR_CALL_NOT_IMPLEMENTED;
5646 }
5647
5648
5649 /***********************************************************************
5650  * CM_Modify_Res_Des [SETUPAPI.@]
5651  */
5652 CONFIGRET
5653 WINAPI
5654 CM_Modify_Res_Des(
5655     _Out_ PRES_DES prdResDes,
5656     _In_ RES_DES rdResDes,
5657     _In_ RESOURCEID ResourceID,
5658     _In_reads_bytes_(ResourceLen) PCVOID ResourceData,
5659     _In_ ULONG ResourceLen,
5660     _In_ ULONG ulFlags)
5661 {
5662     TRACE("CM_Modify_Res_Des(%p %p %lx %p %lu %lx)\n",
5663           prdResDes, rdResDes, ResourceID, ResourceData,
5664           ResourceLen, ulFlags);
5665
5666     return CM_Modify_Res_Des_Ex(prdResDes, rdResDes, ResourceID, ResourceData,
5667                                 ResourceLen, ulFlags, NULL);
5668 }
5669
5670
5671 /***********************************************************************
5672  * CM_Modify_Res_Des_Ex [SETUPAPI.@]
5673  */
5674 CONFIGRET
5675 WINAPI
5676 CM_Modify_Res_Des_Ex(
5677     _Out_ PRES_DES prdResDes,
5678     _In_ RES_DES rdResDes,
5679     _In_ RESOURCEID ResourceID,
5680     _In_reads_bytes_(ResourceLen) PCVOID ResourceData,
5681     _In_ ULONG ResourceLen,
5682     _In_ ULONG ulFlags,
5683     _In_opt_ HMACHINE hMachine)
5684 {
5685     FIXME("CM_Modify_Res_Des_Ex(%p %p %lx %p %lu %lx %p)\n",
5686           prdResDes, rdResDes, ResourceID, ResourceData,
5687           ResourceLen, ulFlags, hMachine);
5688
5689     return CR_CALL_NOT_IMPLEMENTED;
5690 }
5691
5692
5693 /***********************************************************************
5694  * CM_Move_DevNode [SETUPAPI.@]
5695  */
5696 CONFIGRET
5697 WINAPI
5698 CM_Move_DevNode(
5699     _In_ DEVINST dnFromDevInst,
5700     _In_ DEVINST dnToDevInst,
5701     _In_ ULONG ulFlags)
5702 {
5703     TRACE("CM_Move_DevNode(%lx %lx %lx)\n",
5704           dnFromDevInst, dnToDevInst, ulFlags);
5705
5706     return CM_Move_DevNode_Ex(dnFromDevInst, dnToDevInst, ulFlags, NULL);
5707 }
5708
5709
5710 /***********************************************************************
5711  * CM_Move_DevNode_Ex [SETUPAPI.@]
5712  */
5713 CONFIGRET
5714 WINAPI
5715 CM_Move_DevNode_Ex(
5716     _In_ DEVINST dnFromDevInst,
5717     _In_ DEVINST dnToDevInst,
5718     _In_ ULONG ulFlags,
5719     _In_opt_ HMACHINE hMachine)
5720 {
5721     RPC_BINDING_HANDLE BindingHandle = NULL;
5722     HSTRING_TABLE StringTable = NULL;
5723     LPWSTR lpFromDevInst;
5724     LPWSTR lpToDevInst;
5725     CONFIGRET ret;
5726
5727     FIXME("CM_Move_DevNode_Ex(%lx %lx %lx %p)\n",
5728           dnFromDevInst, dnToDevInst, ulFlags, hMachine);
5729
5730     if (!pSetupIsUserAdmin())
5731         return CR_ACCESS_DENIED;
5732
5733     if (dnFromDevInst == 0 || dnToDevInst == 0)
5734         return CR_INVALID_DEVNODE;
5735
5736     if (ulFlags != 0)
5737         return CR_INVALID_FLAG;
5738
5739     if (hMachine != NULL)
5740     {
5741         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5742         if (BindingHandle == NULL)
5743             return CR_FAILURE;
5744
5745         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5746         if (StringTable == 0)
5747             return CR_FAILURE;
5748     }
5749     else
5750     {
5751         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5752             return CR_FAILURE;
5753     }
5754
5755     lpFromDevInst = pSetupStringTableStringFromId(StringTable, dnFromDevInst);
5756     if (lpFromDevInst == NULL)
5757         return CR_INVALID_DEVNODE;
5758
5759     lpToDevInst = pSetupStringTableStringFromId(StringTable, dnToDevInst);
5760     if (lpToDevInst == NULL)
5761         return CR_INVALID_DEVNODE;
5762
5763     RpcTryExcept
5764     {
5765         ret = PNP_DeviceInstanceAction(BindingHandle,
5766                                        PNP_DEVINST_MOVE,
5767                                        ulFlags,
5768                                        lpFromDevInst,
5769                                        lpToDevInst);
5770     }
5771     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5772     {
5773         ret = RpcStatusToCmStatus(RpcExceptionCode());
5774     }
5775     RpcEndExcept;
5776
5777     return ret;
5778 }
5779
5780
5781 /***********************************************************************
5782  * CM_Next_Range [SETUPAPI.@]
5783  */
5784 CONFIGRET
5785 WINAPI
5786 CM_Next_Range(
5787     _Inout_ PRANGE_ELEMENT preElement,
5788     _Out_ PDWORDLONG pullStart,
5789     _Out_ PDWORDLONG pullEnd,
5790     _In_ ULONG ulFlags)
5791 {
5792     FIXME("CM_Next_Range(%p %p %p %lx)\n",
5793           preElement, pullStart, pullEnd, ulFlags);
5794
5795     return CR_CALL_NOT_IMPLEMENTED;
5796 }
5797
5798
5799 /***********************************************************************
5800  * CM_Open_Class_KeyA [SETUPAPI.@]
5801  */
5802 CONFIGRET
5803 WINAPI
5804 CM_Open_Class_KeyA(
5805     _In_opt_ LPGUID pClassGuid,
5806     _In_opt_ LPCSTR pszClassName,
5807     _In_ REGSAM samDesired,
5808     _In_ REGDISPOSITION Disposition,
5809     _Out_ PHKEY phkClass,
5810     _In_ ULONG ulFlags)
5811 {
5812     TRACE("CM_Open_Class_KeyA(%p %s %lx %lx %p %lx)\n",
5813           debugstr_guid(pClassGuid), debugstr_a(pszClassName),
5814           samDesired, Disposition, phkClass, ulFlags);
5815
5816     return CM_Open_Class_Key_ExA(pClassGuid, pszClassName, samDesired,
5817                                  Disposition, phkClass, ulFlags, NULL);
5818 }
5819
5820
5821 /***********************************************************************
5822  * CM_Open_Class_KeyW [SETUPAPI.@]
5823  */
5824 CONFIGRET
5825 WINAPI
5826 CM_Open_Class_KeyW(
5827     _In_opt_ LPGUID pClassGuid,
5828     _In_opt_ LPCWSTR pszClassName,
5829     _In_ REGSAM samDesired,
5830     _In_ REGDISPOSITION Disposition,
5831     _Out_ PHKEY phkClass,
5832     _In_ ULONG ulFlags)
5833 {
5834     TRACE("CM_Open_Class_KeyW%p %s %lx %lx %p %lx)\n",
5835           debugstr_guid(pClassGuid), debugstr_w(pszClassName),
5836           samDesired, Disposition, phkClass, ulFlags);
5837
5838     return CM_Open_Class_Key_ExW(pClassGuid, pszClassName, samDesired,
5839                                  Disposition, phkClass, ulFlags, NULL);
5840 }
5841
5842
5843 /***********************************************************************
5844  * CM_Open_Class_Key_ExA [SETUPAPI.@]
5845  */
5846 CONFIGRET
5847 WINAPI
5848 CM_Open_Class_Key_ExA(
5849     _In_opt_ LPGUID pClassGuid,
5850     _In_opt_ LPCSTR pszClassName,
5851     _In_ REGSAM samDesired,
5852     _In_ REGDISPOSITION Disposition,
5853     _Out_ PHKEY phkClass,
5854     _In_ ULONG ulFlags,
5855     _In_opt_ HMACHINE hMachine)
5856 {
5857     LPWSTR pszClassNameW = NULL;
5858     CONFIGRET ret;
5859
5860     TRACE("CM_Open_Class_Key_ExA(%p %s %lx %lx %p %lx %p)\n",
5861           debugstr_guid(pClassGuid), debugstr_a(pszClassName),
5862           samDesired, Disposition, phkClass, ulFlags, hMachine);
5863
5864     if (pszClassName != NULL)
5865     {
5866        if (pSetupCaptureAndConvertAnsiArg(pszClassName, &pszClassNameW))
5867          return CR_INVALID_DATA;
5868     }
5869
5870     ret = CM_Open_Class_Key_ExW(pClassGuid, pszClassNameW, samDesired,
5871                                 Disposition, phkClass, ulFlags, hMachine);
5872
5873     if (pszClassNameW != NULL)
5874         MyFree(pszClassNameW);
5875
5876     return ret;
5877 }
5878
5879
5880 /***********************************************************************
5881  * CM_Open_Class_Key_ExW [SETUPAPI.@]
5882  */
5883 CONFIGRET
5884 WINAPI
5885 CM_Open_Class_Key_ExW(
5886     _In_opt_ LPGUID pClassGuid,
5887     _In_opt_ LPCWSTR pszClassName,
5888     _In_ REGSAM samDesired,
5889     _In_ REGDISPOSITION Disposition,
5890     _Out_ PHKEY phkClass,
5891     _In_ ULONG ulFlags,
5892     _In_opt_ HMACHINE hMachine)
5893 {
5894     WCHAR szKeyName[MAX_PATH];
5895     LPWSTR lpGuidString;
5896     DWORD dwDisposition;
5897     DWORD dwError;
5898     HKEY hKey;
5899
5900     TRACE("CM_Open_Class_Key_ExW(%p %s %lx %lx %p %lx %p)\n",
5901           debugstr_guid(pClassGuid), debugstr_w(pszClassName),
5902           samDesired, Disposition, phkClass, ulFlags, hMachine);
5903
5904     /* Check Disposition and ulFlags */
5905     if ((Disposition & ~RegDisposition_Bits) ||
5906         (ulFlags & ~CM_OPEN_CLASS_KEY_BITS))
5907         return CR_INVALID_FLAG;
5908
5909     /* Check phkClass */
5910     if (phkClass == NULL)
5911         return CR_INVALID_POINTER;
5912
5913     *phkClass = NULL;
5914
5915     if (ulFlags == CM_OPEN_CLASS_KEY_INTERFACE &&
5916         pszClassName != NULL)
5917         return CR_INVALID_DATA;
5918
5919     if (hMachine == NULL)
5920     {
5921         hKey = HKEY_LOCAL_MACHINE;
5922     }
5923     else
5924     {
5925         if (RegConnectRegistryW(((PMACHINE_INFO)hMachine)->szMachineName,
5926                                 HKEY_LOCAL_MACHINE,
5927                                 &hKey))
5928             return CR_REGISTRY_ERROR;
5929     }
5930
5931     if (ulFlags & CM_OPEN_CLASS_KEY_INTERFACE)
5932     {
5933         lstrcpyW(szKeyName, DeviceClasses);
5934     }
5935     else
5936     {
5937         lstrcpyW(szKeyName, ControlClass);
5938     }
5939
5940     if (pClassGuid != NULL)
5941     {
5942         if (UuidToStringW((UUID*)pClassGuid, &lpGuidString) != RPC_S_OK)
5943         {
5944             RegCloseKey(hKey);
5945             return CR_INVALID_DATA;
5946         }
5947
5948         lstrcatW(szKeyName, Backslash);
5949         lstrcatW(szKeyName, lpGuidString);
5950     }
5951
5952     if (Disposition == RegDisposition_OpenAlways)
5953     {
5954         dwError = RegCreateKeyExW(hKey, szKeyName, 0, NULL, 0, samDesired,
5955                                   NULL, phkClass, &dwDisposition);
5956     }
5957     else
5958     {
5959         dwError = RegOpenKeyExW(hKey, szKeyName, 0, samDesired, phkClass);
5960     }
5961
5962     RegCloseKey(hKey);
5963
5964     if (pClassGuid != NULL)
5965         RpcStringFreeW(&lpGuidString);
5966
5967     if (dwError != ERROR_SUCCESS)
5968     {
5969         *phkClass = NULL;
5970         return CR_NO_SUCH_REGISTRY_KEY;
5971     }
5972
5973     if (pszClassName != NULL)
5974     {
5975         RegSetValueExW(*phkClass, Class, 0, REG_SZ, (LPBYTE)pszClassName,
5976                        (lstrlenW(pszClassName) + 1) * sizeof(WCHAR));
5977     }
5978
5979     return CR_SUCCESS;
5980 }
5981
5982
5983 /***********************************************************************
5984  * CM_Open_DevNode_Key [SETUPAPI.@]
5985  */
5986 CONFIGRET
5987 WINAPI
5988 CM_Open_DevNode_Key(
5989     _In_ DEVINST dnDevNode,
5990     _In_ REGSAM samDesired,
5991     _In_ ULONG ulHardwareProfile,
5992     _In_ REGDISPOSITION Disposition,
5993     _Out_ PHKEY phkDevice,
5994     _In_ ULONG ulFlags)
5995 {
5996     TRACE("CM_Open_DevNode_Key(%lx %lx %lu %lx %p %lx)\n",
5997           dnDevNode, samDesired, ulHardwareProfile, Disposition, phkDevice, ulFlags);
5998
5999     return CM_Open_DevNode_Key_Ex(dnDevNode, samDesired, ulHardwareProfile,
6000                                   Disposition, phkDevice, ulFlags, NULL);
6001 }
6002
6003
6004 /***********************************************************************
6005  * CM_Open_DevNode_Key_Ex [SETUPAPI.@]
6006  */
6007 CONFIGRET
6008 WINAPI
6009 CM_Open_DevNode_Key_Ex(
6010     _In_ DEVINST dnDevNode,
6011     _In_ REGSAM samDesired,
6012     _In_ ULONG ulHardwareProfile,
6013     _In_ REGDISPOSITION Disposition,
6014     _Out_ PHKEY phkDevice,
6015     _In_ ULONG ulFlags,
6016     _In_opt_ HMACHINE hMachine)
6017 {
6018     RPC_BINDING_HANDLE BindingHandle = NULL;
6019     HSTRING_TABLE StringTable = NULL;
6020     LPWSTR pszDevInst, pszKeyPath = NULL, pszInstancePath = NULL;
6021     LONG lError;
6022     DWORD dwDisposition;
6023     HKEY hRootKey = NULL;
6024     CONFIGRET ret = CR_CALL_NOT_IMPLEMENTED;
6025
6026     TRACE("CM_Open_DevNode_Key_Ex(%lx %lx %lu %lx %p %lx %p)\n",
6027           dnDevNode, samDesired, ulHardwareProfile, Disposition, phkDevice, ulFlags, hMachine);
6028
6029     if (phkDevice == NULL)
6030         return CR_INVALID_POINTER;
6031
6032     *phkDevice = NULL;
6033
6034     if (dnDevNode == 0)
6035         return CR_INVALID_DEVNODE;
6036
6037     if (ulFlags & ~CM_REGISTRY_BITS)
6038         return CR_INVALID_FLAG;
6039
6040     if (Disposition & ~RegDisposition_Bits)
6041         return CR_INVALID_DATA;
6042
6043     if (hMachine != NULL)
6044     {
6045         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6046         if (BindingHandle == NULL)
6047             return CR_FAILURE;
6048
6049         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6050         if (StringTable == 0)
6051             return CR_FAILURE;
6052     }
6053     else
6054     {
6055         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6056             return CR_FAILURE;
6057     }
6058
6059     pszDevInst = pSetupStringTableStringFromId(StringTable, dnDevNode);
6060     if (pszDevInst == NULL)
6061         return CR_INVALID_DEVNODE;
6062
6063     TRACE("pszDevInst: %S\n", pszDevInst);
6064
6065     pszKeyPath = MyMalloc(512 * sizeof(WCHAR));
6066     if (pszKeyPath == NULL)
6067     {
6068         ret = CR_OUT_OF_MEMORY;
6069         goto done;
6070     }
6071
6072     pszInstancePath = MyMalloc(512 * sizeof(WCHAR));
6073     if (pszInstancePath == NULL)
6074     {
6075         ret = CR_OUT_OF_MEMORY;
6076         goto done;
6077     }
6078
6079     ret = GetDeviceInstanceKeyPath(BindingHandle,
6080                                    pszDevInst,
6081                                    pszKeyPath,
6082                                    pszInstancePath,
6083                                    ulHardwareProfile,
6084                                    ulFlags);
6085     if (ret != CR_SUCCESS)
6086         goto done;
6087
6088     TRACE("pszKeyPath: %S\n", pszKeyPath);
6089     TRACE("pszInstancePath: %S\n", pszInstancePath);
6090
6091     wcscat(pszKeyPath, L"\\");
6092     wcscat(pszKeyPath, pszInstancePath);
6093
6094     TRACE("pszKeyPath: %S\n", pszKeyPath);
6095
6096     if (hMachine == NULL)
6097     {
6098         hRootKey = HKEY_LOCAL_MACHINE;
6099     }
6100     else
6101     {
6102         if (RegConnectRegistryW(((PMACHINE_INFO)hMachine)->szMachineName,
6103                                 HKEY_LOCAL_MACHINE,
6104                                 &hRootKey))
6105         {
6106             ret = CR_REGISTRY_ERROR;
6107             goto done;
6108         }
6109     }
6110
6111     if (Disposition == RegDisposition_OpenAlways)
6112     {
6113         lError = RegCreateKeyExW(hRootKey,
6114                                  pszKeyPath,
6115                                  0,
6116                                  NULL,
6117                                  0,
6118                                  samDesired,
6119                                  NULL,
6120                                  phkDevice,
6121                                  &dwDisposition);
6122     }
6123     else
6124     {
6125         lError = RegOpenKeyExW(hRootKey,
6126                                pszKeyPath,
6127                                0,
6128                                samDesired,
6129                                phkDevice);
6130     }
6131
6132     if (lError != ERROR_SUCCESS)
6133     {
6134         *phkDevice = NULL;
6135         ret = CR_NO_SUCH_REGISTRY_KEY;
6136     }
6137
6138 done:
6139     if ((hRootKey != NULL) && (hRootKey != HKEY_LOCAL_MACHINE))
6140         RegCloseKey(hRootKey);
6141
6142     if (pszInstancePath != NULL)
6143         MyFree(pszInstancePath);
6144
6145     if (pszKeyPath != NULL)
6146         MyFree(pszKeyPath);
6147
6148     return ret;
6149 }
6150
6151
6152 /***********************************************************************
6153  * CM_Query_And_Remove_SubTreeA [SETUPAPI.@]
6154  */
6155 CONFIGRET
6156 WINAPI
6157 CM_Query_And_Remove_SubTreeA(
6158     _In_ DEVINST dnAncestor,
6159     _Out_opt_ PPNP_VETO_TYPE pVetoType,
6160     _Out_writes_opt_(ulNameLength) LPSTR pszVetoName,
6161     _In_ ULONG ulNameLength,
6162     _In_ ULONG ulFlags)
6163 {
6164     TRACE("CM_Query_And_Remove_SubTreeA(%lx %p %s %lu %lx)\n",
6165           dnAncestor, pVetoType, pszVetoName, ulNameLength, ulFlags);
6166
6167     return CM_Query_And_Remove_SubTree_ExA(dnAncestor, pVetoType, pszVetoName,
6168                                            ulNameLength, ulFlags, NULL);
6169 }
6170
6171
6172 /***********************************************************************
6173  * CM_Query_And_Remove_SubTreeW [SETUPAPI.@]
6174  */
6175 CONFIGRET
6176 WINAPI
6177 CM_Query_And_Remove_SubTreeW(
6178     _In_ DEVINST dnAncestor,
6179     _Out_opt_ PPNP_VETO_TYPE pVetoType,
6180     _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName,
6181     _In_ ULONG ulNameLength,
6182     _In_ ULONG ulFlags)
6183 {
6184     TRACE("CM_Query_And_Remove_SubTreeW(%lx %p %s %lu %lx)\n",
6185           dnAncestor, pVetoType, debugstr_w(pszVetoName), ulNameLength, ulFlags);
6186
6187     return CM_Query_And_Remove_SubTree_ExW(dnAncestor, pVetoType, pszVetoName,
6188                                            ulNameLength, ulFlags, NULL);
6189 }
6190
6191
6192 /***********************************************************************
6193  * CM_Query_And_Remove_SubTree_ExA [SETUPAPI.@]
6194  */
6195 CONFIGRET
6196 WINAPI
6197 CM_Query_And_Remove_SubTree_ExA(
6198     _In_ DEVINST dnAncestor,
6199     _Out_opt_ PPNP_VETO_TYPE pVetoType,
6200     _Out_writes_opt_(ulNameLength) LPSTR pszVetoName,
6201     _In_ ULONG ulNameLength,
6202     _In_ ULONG ulFlags,
6203     _In_opt_ HMACHINE hMachine)
6204 {
6205     LPWSTR lpLocalVetoName;
6206     CONFIGRET ret;
6207
6208     TRACE("CM_Query_And_Remove_SubTree_ExA(%lx %p %s %lu %lx %p)\n",
6209           dnAncestor, pVetoType, debugstr_a(pszVetoName), ulNameLength,
6210           ulFlags, hMachine);
6211
6212     if (pszVetoName == NULL && ulNameLength == 0)
6213         return CR_INVALID_POINTER;
6214
6215     lpLocalVetoName = HeapAlloc(GetProcessHeap(), 0, ulNameLength * sizeof(WCHAR));
6216     if (lpLocalVetoName == NULL)
6217         return CR_OUT_OF_MEMORY;
6218
6219     ret = CM_Query_And_Remove_SubTree_ExW(dnAncestor, pVetoType, lpLocalVetoName,
6220                                           ulNameLength, ulFlags, hMachine);
6221     if (ret == CR_REMOVE_VETOED)
6222     {
6223         if (WideCharToMultiByte(CP_ACP,
6224                                 0,
6225                                 lpLocalVetoName,
6226                                 ulNameLength,
6227                                 pszVetoName,
6228                                 ulNameLength,
6229                                 NULL,
6230                                 NULL) == 0)
6231             ret = CR_FAILURE;
6232     }
6233
6234     HeapFree(GetProcessHeap(), 0, lpLocalVetoName);
6235
6236     return ret;
6237 }
6238
6239
6240 /***********************************************************************
6241  * CM_Query_And_Remove_SubTree_ExW [SETUPAPI.@]
6242  */
6243 CONFIGRET
6244 WINAPI
6245 CM_Query_And_Remove_SubTree_ExW(
6246     _In_ DEVINST dnAncestor,
6247     _Out_opt_ PPNP_VETO_TYPE pVetoType,
6248     _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName,
6249     _In_ ULONG ulNameLength,
6250     _In_ ULONG ulFlags,
6251     _In_opt_ HMACHINE hMachine)
6252 {
6253     RPC_BINDING_HANDLE BindingHandle = NULL;
6254     HSTRING_TABLE StringTable = NULL;
6255     LPWSTR lpDevInst;
6256     CONFIGRET ret;
6257
6258     TRACE("CM_Query_And_Remove_SubTree_ExW(%lx %p %s %lu %lx %p)\n",
6259           dnAncestor, pVetoType, debugstr_w(pszVetoName), ulNameLength,
6260           ulFlags, hMachine);
6261
6262     if (dnAncestor == 0)
6263         return CR_INVALID_DEVNODE;
6264
6265     if (ulFlags & ~CM_REMOVE_BITS)
6266         return CR_INVALID_FLAG;
6267
6268     if (pszVetoName == NULL && ulNameLength == 0)
6269         return CR_INVALID_POINTER;
6270
6271     if (hMachine != NULL)
6272     {
6273         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6274         if (BindingHandle == NULL)
6275             return CR_FAILURE;
6276
6277         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6278         if (StringTable == 0)
6279             return CR_FAILURE;
6280     }
6281     else
6282     {
6283         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6284             return CR_FAILURE;
6285     }
6286
6287     lpDevInst = pSetupStringTableStringFromId(StringTable, dnAncestor);
6288     if (lpDevInst == NULL)
6289         return CR_INVALID_DEVNODE;
6290
6291     RpcTryExcept
6292     {
6293         ret = PNP_QueryRemove(BindingHandle,
6294                               lpDevInst,
6295                               pVetoType,
6296                               pszVetoName,
6297                               ulNameLength,
6298                               ulFlags);
6299     }
6300     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
6301     {
6302         ret = RpcStatusToCmStatus(RpcExceptionCode());
6303     }
6304     RpcEndExcept;
6305
6306     return ret;
6307 }
6308
6309
6310 /***********************************************************************
6311  * CM_Query_Arbitrator_Free_Data [SETUPAPI.@]
6312  */
6313 CONFIGRET
6314 WINAPI
6315 CM_Query_Arbitrator_Free_Data(
6316     _Out_writes_bytes_(DataLen) PVOID pData,
6317     _In_ ULONG DataLen,
6318     _In_ DEVINST dnDevInst,
6319     _In_ RESOURCEID ResourceID,
6320     _In_ ULONG ulFlags)
6321 {
6322     TRACE("CM_Query_Arbitrator_Free_Data(%p %lu %lx %lu 0x%08lx)\n",
6323           pData, DataLen, dnDevInst, ResourceID, ulFlags);
6324
6325     return CM_Query_Arbitrator_Free_Data_Ex(pData, DataLen, dnDevInst,
6326                                             ResourceID, ulFlags, NULL);
6327 }
6328
6329
6330 /***********************************************************************
6331  * CM_Query_Arbitrator_Free_Data_Ex [SETUPAPI.@]
6332  */
6333 CONFIGRET
6334 WINAPI
6335 CM_Query_Arbitrator_Free_Data_Ex(
6336     _Out_writes_bytes_(DataLen) PVOID pData,
6337     _In_ ULONG DataLen,
6338     _In_ DEVINST dnDevInst,
6339     _In_ RESOURCEID ResourceID,
6340     _In_ ULONG ulFlags,
6341     _In_opt_ HMACHINE hMachine)
6342 {
6343     RPC_BINDING_HANDLE BindingHandle = NULL;
6344     HSTRING_TABLE StringTable = NULL;
6345     LPWSTR lpDevInst;
6346     CONFIGRET ret;
6347
6348     TRACE("CM_Query_Arbitrator_Free_Data_Ex(%p %lu %lx %lu 0x%08lx %p)\n",
6349           pData, DataLen, dnDevInst, ResourceID, ulFlags, hMachine);
6350
6351     if (pData == NULL || DataLen == 0)
6352         return CR_INVALID_POINTER;
6353
6354     if (dnDevInst == 0)
6355         return CR_INVALID_DEVINST;
6356
6357     if (ulFlags & ~CM_QUERY_ARBITRATOR_BITS)
6358         return CR_INVALID_FLAG;
6359
6360     if (hMachine != NULL)
6361     {
6362         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6363         if (BindingHandle == NULL)
6364             return CR_FAILURE;
6365
6366         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6367         if (StringTable == 0)
6368             return CR_FAILURE;
6369     }
6370     else
6371     {
6372         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6373             return CR_FAILURE;
6374     }
6375
6376     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
6377     if (lpDevInst == NULL)
6378         return CR_INVALID_DEVNODE;
6379
6380     RpcTryExcept
6381     {
6382         ret = PNP_QueryArbitratorFreeData(BindingHandle,
6383                                           pData,
6384                                           DataLen,
6385                                           lpDevInst,
6386                                           ResourceID,
6387                                           ulFlags);
6388     }
6389     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
6390     {
6391         ret = RpcStatusToCmStatus(RpcExceptionCode());
6392     }
6393     RpcEndExcept;
6394
6395     return ret;
6396 }
6397
6398
6399 /***********************************************************************
6400  * CM_Query_Arbitrator_Free_Size [SETUPAPI.@]
6401  */
6402 CONFIGRET
6403 WINAPI
6404 CM_Query_Arbitrator_Free_Size(
6405     _Out_ PULONG pulSize,
6406     _In_ DEVINST dnDevInst,
6407     _In_ RESOURCEID ResourceID,
6408     _In_ ULONG ulFlags)
6409 {
6410     TRACE("CM_Query_Arbitrator_Free_Size(%p %lu %lx 0x%08lx)\n",
6411           pulSize, dnDevInst,ResourceID, ulFlags);
6412
6413     return CM_Query_Arbitrator_Free_Size_Ex(pulSize, dnDevInst, ResourceID,
6414                                             ulFlags, NULL);
6415 }
6416
6417
6418 /***********************************************************************
6419  * CM_Query_Arbitrator_Free_Size_Ex [SETUPAPI.@]
6420  */
6421 CONFIGRET
6422 WINAPI
6423 CM_Query_Arbitrator_Free_Size_Ex(
6424     _Out_ PULONG pulSize,
6425     _In_ DEVINST dnDevInst,
6426     _In_ RESOURCEID ResourceID,
6427     _In_ ULONG ulFlags,
6428     _In_opt_ HMACHINE hMachine)
6429 {
6430     RPC_BINDING_HANDLE BindingHandle = NULL;
6431     HSTRING_TABLE StringTable = NULL;
6432     LPWSTR lpDevInst;
6433     CONFIGRET ret;
6434
6435     TRACE("CM_Query_Arbitrator_Free_Size_Ex(%p %lu %lx 0x%08lx %p)\n",
6436           pulSize, dnDevInst,ResourceID, ulFlags, hMachine);
6437
6438     if (pulSize == NULL)
6439         return CR_INVALID_POINTER;
6440
6441     if (dnDevInst == 0)
6442         return CR_INVALID_DEVINST;
6443
6444     if (ulFlags & ~CM_QUERY_ARBITRATOR_BITS)
6445         return CR_INVALID_FLAG;
6446
6447     if (hMachine != NULL)
6448     {
6449         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6450         if (BindingHandle == NULL)
6451             return CR_FAILURE;
6452
6453         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6454         if (StringTable == 0)
6455             return CR_FAILURE;
6456     }
6457     else
6458     {
6459         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6460             return CR_FAILURE;
6461     }
6462
6463     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
6464     if (lpDevInst == NULL)
6465         return CR_INVALID_DEVNODE;
6466
6467     RpcTryExcept
6468     {
6469         ret = PNP_QueryArbitratorFreeSize(BindingHandle,
6470                                           pulSize,
6471                                           lpDevInst,
6472                                           ResourceID,
6473                                           ulFlags);
6474     }
6475     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
6476     {
6477         ret = RpcStatusToCmStatus(RpcExceptionCode());
6478     }
6479     RpcEndExcept;
6480
6481     return ret;
6482 }
6483
6484
6485 /***********************************************************************
6486  * CM_Query_Remove_SubTree [SETUPAPI.@]
6487  *
6488  * This function is obsolete in Windows XP and above.
6489  */
6490 CONFIGRET
6491 WINAPI
6492 CM_Query_Remove_SubTree(
6493     _In_ DEVINST dnAncestor,
6494     _In_ ULONG ulFlags)
6495 {
6496     TRACE("CM_Query_Remove_SubTree(%lx %lx)\n",
6497           dnAncestor, ulFlags);
6498
6499     return CR_CALL_NOT_IMPLEMENTED;
6500 }
6501
6502
6503 /***********************************************************************
6504  * CM_Query_Remove_SubTree_Ex [SETUPAPI.@]
6505  *
6506  * This function is obsolete in Windows XP and above.
6507  */
6508 CONFIGRET
6509 WINAPI
6510 CM_Query_Remove_SubTree_Ex(
6511     _In_ DEVINST dnAncestor,
6512     _In_ ULONG ulFlags,
6513     _In_opt_ HMACHINE hMachine)
6514 {
6515     TRACE("CM_Query_Remove_SubTree_Ex(%lx %lx %p)\n",
6516           dnAncestor, ulFlags, hMachine);
6517
6518     return CR_CALL_NOT_IMPLEMENTED;
6519 }
6520
6521
6522 /***********************************************************************
6523  * CM_Query_Resource_Conflict_List [SETUPAPI.@]
6524  */
6525 CONFIGRET
6526 WINAPI
6527 CM_Query_Resource_Conflict_List(
6528     _Out_ PCONFLICT_LIST pclConflictList,
6529     _In_ DEVINST dnDevInst,
6530     _In_ RESOURCEID ResourceID,
6531     _In_ PCVOID ResourceData,
6532     _In_ ULONG ResourceLen,
6533     _In_ ULONG ulFlags,
6534     _In_opt_ HMACHINE hMachine)
6535 {
6536     RPC_BINDING_HANDLE BindingHandle = NULL;
6537     HSTRING_TABLE StringTable = NULL;
6538     PPNP_CONFLICT_LIST pConflictBuffer = NULL;
6539     PCONFLICT_DATA pConflictData = NULL;
6540     ULONG ulBufferLength;
6541     LPWSTR lpDevInst;
6542     CONFIGRET ret;
6543
6544     FIXME("CM_Query_Resource_Conflict_List(%p %lx %lu %p %lu %lx %p)\n",
6545           pclConflictList, dnDevInst, ResourceID, ResourceData,
6546           ResourceLen, ulFlags, hMachine);
6547
6548     if (dnDevInst == 0)
6549         return CR_INVALID_DEVNODE;
6550
6551     if (ulFlags & ~CM_RESDES_WIDTH_BITS)
6552         return CR_INVALID_FLAG;
6553
6554     if (pclConflictList == NULL ||
6555         ResourceData == NULL ||
6556         ResourceLen == 0)
6557         return CR_INVALID_POINTER;
6558
6559     if (ResourceID == 0)
6560         return CR_INVALID_RESOURCEID;
6561
6562     *pclConflictList = 0;
6563
6564     if (hMachine != NULL)
6565     {
6566         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6567         if (BindingHandle == NULL)
6568             return CR_FAILURE;
6569
6570         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6571         if (StringTable == 0)
6572             return CR_FAILURE;
6573     }
6574     else
6575     {
6576         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6577             return CR_FAILURE;
6578     }
6579
6580     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
6581     if (lpDevInst == NULL)
6582         return CR_INVALID_DEVNODE;
6583
6584     pConflictData = MyMalloc(sizeof(PCONFLICT_DATA));
6585     if (pConflictData == NULL)
6586     {
6587         ret = CR_OUT_OF_MEMORY;
6588         goto done;
6589     }
6590
6591     ulBufferLength = sizeof(PNP_CONFLICT_LIST) +
6592                      sizeof(PNP_CONFLICT_STRINGS) +
6593                      (sizeof(wchar_t) * 200);
6594     pConflictBuffer = MyMalloc(ulBufferLength);
6595     if (pConflictBuffer == NULL)
6596     {
6597         ret = CR_OUT_OF_MEMORY;
6598         goto done;
6599     }
6600
6601     RpcTryExcept
6602     {
6603         ret = PNP_QueryResConfList(BindingHandle,
6604                                    lpDevInst,
6605                                    ResourceID,
6606                                    (PBYTE)ResourceData,
6607                                    ResourceLen,
6608                                    (PBYTE)pConflictBuffer,
6609                                    ulBufferLength,
6610                                    ulFlags);
6611     }
6612     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
6613     {
6614         ret = RpcStatusToCmStatus(RpcExceptionCode());
6615     }
6616     RpcEndExcept;
6617
6618     if (ret != CR_SUCCESS)
6619         goto done;
6620
6621     pConflictData->ulMagic = CONFLICT_MAGIC;
6622     pConflictData->pConflictList = pConflictBuffer;
6623
6624     *pclConflictList = (CONFLICT_LIST)pConflictData;
6625
6626 done:
6627     if (ret != CR_SUCCESS)
6628     {
6629         if (pConflictBuffer != NULL)
6630             MyFree(pConflictBuffer);
6631
6632         if (pConflictData != NULL)
6633             MyFree(pConflictData);
6634     }
6635
6636     return ret;
6637 }
6638
6639
6640 /***********************************************************************
6641  * CM_Reenumerate_DevNode [SETUPAPI.@]
6642  */
6643 CONFIGRET
6644 WINAPI
6645 CM_Reenumerate_DevNode(
6646     _In_ DEVINST dnDevInst,
6647     _In_ ULONG ulFlags)
6648 {
6649     TRACE("CM_Reenumerate_DevNode(%lx %lx)\n",
6650           dnDevInst, ulFlags);
6651
6652     return CM_Reenumerate_DevNode_Ex(dnDevInst, ulFlags, NULL);
6653 }
6654
6655
6656 /***********************************************************************
6657  * CM_Reenumerate_DevNode_Ex [SETUPAPI.@]
6658  */
6659 CONFIGRET WINAPI
6660 CM_Reenumerate_DevNode_Ex(
6661     _In_ DEVINST dnDevInst,
6662     _In_ ULONG ulFlags,
6663     _In_opt_ HMACHINE hMachine)
6664 {
6665     RPC_BINDING_HANDLE BindingHandle = NULL;
6666     HSTRING_TABLE StringTable = NULL;
6667     LPWSTR lpDevInst;
6668     CONFIGRET ret;
6669
6670     FIXME("CM_Reenumerate_DevNode_Ex(%lx %lx %p)\n",
6671           dnDevInst, ulFlags, hMachine);
6672
6673     if (dnDevInst == 0)
6674         return CR_INVALID_DEVNODE;
6675
6676     if (ulFlags & ~CM_REENUMERATE_BITS)
6677         return CR_INVALID_FLAG;
6678
6679     if (hMachine != NULL)
6680     {
6681         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6682         if (BindingHandle == NULL)
6683             return CR_FAILURE;
6684
6685         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6686         if (StringTable == 0)
6687             return CR_FAILURE;
6688     }
6689     else
6690     {
6691         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6692             return CR_FAILURE;
6693     }
6694
6695     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
6696     if (lpDevInst == NULL)
6697         return CR_INVALID_DEVNODE;
6698
6699     RpcTryExcept
6700     {
6701         ret = PNP_DeviceInstanceAction(BindingHandle,
6702                                        PNP_DEVINST_REENUMERATE,
6703                                        ulFlags,
6704                                        lpDevInst,
6705                                        NULL);
6706     }
6707     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
6708     {
6709         ret = RpcStatusToCmStatus(RpcExceptionCode());
6710     }
6711     RpcEndExcept;
6712
6713     return ret;
6714 }
6715
6716
6717 /***********************************************************************
6718  * CM_Register_Device_Driver [SETUPAPI.@]
6719  */
6720 CONFIGRET
6721 WINAPI
6722 CM_Register_Device_Driver(
6723     _In_ DEVINST dnDevInst,
6724     _In_ ULONG ulFlags)
6725 {
6726     TRACE("CM_Register_Device_Driver(%lx 0x%08lx)\n",
6727           dnDevInst, ulFlags);
6728
6729     return CM_Register_Device_Driver_Ex(dnDevInst, ulFlags, NULL);
6730 }
6731
6732
6733 /***********************************************************************
6734  * CM_Register_Device_Driver_Ex [SETUPAPI.@]
6735  */
6736 CONFIGRET
6737 WINAPI
6738 CM_Register_Device_Driver_Ex(
6739     _In_ DEVINST dnDevInst,
6740     _In_ ULONG ulFlags,
6741     _In_opt_ HMACHINE hMachine)
6742 {
6743     RPC_BINDING_HANDLE BindingHandle = NULL;
6744     HSTRING_TABLE StringTable = NULL;
6745     LPWSTR lpDevInst;
6746     CONFIGRET ret;
6747
6748     TRACE("CM_Register_Device_Driver_Ex(%lx 0x%08lx %p)\n",
6749           dnDevInst, ulFlags, hMachine);
6750
6751     if (dnDevInst == 0)
6752         return CR_INVALID_DEVNODE;
6753
6754     if (ulFlags & ~CM_REGISTER_DEVICE_DRIVER_BITS)
6755         return CR_INVALID_FLAG;
6756
6757     if (hMachine != NULL)
6758     {
6759         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6760         if (BindingHandle == NULL)
6761             return CR_FAILURE;
6762
6763         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6764         if (StringTable == 0)
6765             return CR_FAILURE;
6766     }
6767     else
6768     {
6769         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6770             return CR_FAILURE;
6771     }
6772
6773     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
6774     if (lpDevInst == NULL)
6775         return CR_INVALID_DEVNODE;
6776
6777     RpcTryExcept
6778     {
6779         ret = PNP_RegisterDriver(BindingHandle,
6780                                  lpDevInst,
6781                                  ulFlags);
6782     }
6783     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
6784     {
6785         ret = RpcStatusToCmStatus(RpcExceptionCode());
6786     }
6787     RpcEndExcept;
6788
6789     return ret;
6790 }
6791
6792
6793 /***********************************************************************
6794  * CM_Register_Device_InterfaceA [SETUPAPI.@]
6795  */
6796 CONFIGRET
6797 WINAPI
6798 CM_Register_Device_InterfaceA(
6799     _In_ DEVINST dnDevInst,
6800     _In_ LPGUID InterfaceClassGuid,
6801     _In_opt_ LPCSTR pszReference,
6802     _Out_writes_(*pulLength) LPSTR pszDeviceInterface,
6803     _Inout_ PULONG pulLength,
6804     _In_ ULONG ulFlags)
6805 {
6806     TRACE("CM_Register_Device_InterfaceA(%lx %s %s %p %p %lx)\n",
6807           dnDevInst, debugstr_guid(InterfaceClassGuid),
6808           pszReference, pszDeviceInterface, pulLength, ulFlags);
6809
6810     return CM_Register_Device_Interface_ExA(dnDevInst, InterfaceClassGuid,
6811                                             pszReference, pszDeviceInterface,
6812                                             pulLength, ulFlags, NULL);
6813 }
6814
6815
6816 /***********************************************************************
6817  * CM_Register_Device_InterfaceW [SETUPAPI.@]
6818  */
6819 CONFIGRET
6820 WINAPI
6821 CM_Register_Device_InterfaceW(
6822     _In_ DEVINST dnDevInst,
6823     _In_ LPGUID InterfaceClassGuid,
6824     _In_opt_ LPCWSTR pszReference,
6825     _Out_writes_(*pulLength) LPWSTR pszDeviceInterface,
6826     _Inout_ PULONG pulLength,
6827     _In_ ULONG ulFlags)
6828 {
6829     TRACE("CM_Register_Device_InterfaceW(%lx %s %s %p %p %lx)\n",
6830           dnDevInst, debugstr_guid(InterfaceClassGuid),
6831           debugstr_w(pszReference), pszDeviceInterface, pulLength, ulFlags);
6832
6833     return CM_Register_Device_Interface_ExW(dnDevInst, InterfaceClassGuid,
6834                                             pszReference, pszDeviceInterface,
6835                                             pulLength, ulFlags, NULL);
6836 }
6837
6838
6839 /***********************************************************************
6840  * CM_Register_Device_Interface_ExA [SETUPAPI.@]
6841  */
6842 CONFIGRET
6843 WINAPI
6844 CM_Register_Device_Interface_ExA(
6845     _In_ DEVINST dnDevInst,
6846     _In_ LPGUID InterfaceClassGuid,
6847     _In_opt_ LPCSTR pszReference,
6848     _Out_writes_(*pulLength) LPSTR pszDeviceInterface,
6849     _Inout_ PULONG pulLength,
6850     _In_ ULONG ulFlags,
6851     _In_opt_ HMACHINE hMachine)
6852 {
6853     LPWSTR pszReferenceW = NULL;
6854     LPWSTR pszDeviceInterfaceW = NULL;
6855     ULONG ulLength;
6856     CONFIGRET ret;
6857
6858     TRACE("CM_Register_Device_Interface_ExA(%lx %s %s %p %p %lx %p)\n",
6859           dnDevInst, debugstr_guid(InterfaceClassGuid), debugstr_a(pszReference),
6860           pszDeviceInterface, pulLength, ulFlags, hMachine);
6861
6862     if (pulLength == NULL || pszDeviceInterface == NULL)
6863         return CR_INVALID_POINTER;
6864
6865     if (pszReference != NULL)
6866     {
6867         if (pSetupCaptureAndConvertAnsiArg(pszReference, &pszReferenceW))
6868             return CR_INVALID_DATA;
6869     }
6870
6871     ulLength = *pulLength;
6872
6873     pszDeviceInterfaceW = HeapAlloc(GetProcessHeap(), 0, ulLength * sizeof(WCHAR));
6874     if (pszDeviceInterfaceW == NULL)
6875     {
6876         ret = CR_OUT_OF_MEMORY;
6877         goto Done;
6878     }
6879
6880     ret = CM_Register_Device_Interface_ExW(dnDevInst,
6881                                            InterfaceClassGuid,
6882                                            pszReferenceW,
6883                                            pszDeviceInterfaceW,
6884                                            &ulLength,
6885                                            ulFlags,
6886                                            hMachine);
6887     if (ret == CR_SUCCESS)
6888     {
6889         if (WideCharToMultiByte(CP_ACP,
6890                                 0,
6891                                 pszDeviceInterfaceW,
6892                                 ulLength,
6893                                 pszDeviceInterface,
6894                                 *pulLength,
6895                                 NULL,
6896                                 NULL) == 0)
6897             ret = CR_FAILURE;
6898     }
6899
6900     *pulLength = ulLength;
6901
6902 Done:
6903     if (pszDeviceInterfaceW != NULL)
6904         HeapFree(GetProcessHeap(), 0, pszDeviceInterfaceW);
6905
6906     if (pszReferenceW != NULL)
6907         MyFree(pszReferenceW);
6908
6909     return ret;
6910 }
6911
6912
6913 /***********************************************************************
6914  * CM_Register_Device_Interface_ExW [SETUPAPI.@]
6915  */
6916 CONFIGRET
6917 WINAPI
6918 CM_Register_Device_Interface_ExW(
6919     _In_ DEVINST dnDevInst,
6920     _In_ LPGUID InterfaceClassGuid,
6921     _In_opt_ LPCWSTR pszReference,
6922     _Out_writes_(*pulLength) LPWSTR pszDeviceInterface,
6923     _Inout_ PULONG pulLength,
6924     _In_ ULONG ulFlags,
6925     _In_opt_ HMACHINE hMachine)
6926 {
6927     RPC_BINDING_HANDLE BindingHandle = NULL;
6928     HSTRING_TABLE StringTable = NULL;
6929     LPWSTR lpDevInst;
6930     ULONG ulTransferLength;
6931     CONFIGRET ret;
6932
6933     TRACE("CM_Register_Device_Interface_ExW(%lx %s %s %p %p %lx %p)\n",
6934           dnDevInst, debugstr_guid(InterfaceClassGuid), debugstr_w(pszReference),
6935           pszDeviceInterface, pulLength, ulFlags, hMachine);
6936
6937     if (dnDevInst == 0)
6938         return CR_INVALID_DEVNODE;
6939
6940     if (InterfaceClassGuid == NULL ||
6941         pszDeviceInterface == NULL ||
6942         pulLength == NULL)
6943         return CR_INVALID_POINTER;
6944
6945     if (ulFlags != 0)
6946         return CR_INVALID_FLAG;
6947
6948     if (hMachine != NULL)
6949     {
6950         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
6951         if (BindingHandle == NULL)
6952             return CR_FAILURE;
6953
6954         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
6955         if (StringTable == 0)
6956             return CR_FAILURE;
6957     }
6958     else
6959     {
6960         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
6961             return CR_FAILURE;
6962     }
6963
6964     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
6965     if (lpDevInst == NULL)
6966         return CR_INVALID_DEVNODE;
6967
6968     ulTransferLength = *pulLength;
6969
6970     RpcTryExcept
6971     {
6972         ret = PNP_RegisterDeviceClassAssociation(BindingHandle,
6973                                                  lpDevInst,
6974                                                  InterfaceClassGuid,
6975                                                  (LPWSTR)pszReference,
6976                                                  pszDeviceInterface,
6977                                                  pulLength,
6978                                                  &ulTransferLength,
6979                                                  0);
6980     }
6981     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
6982     {
6983         ret = RpcStatusToCmStatus(RpcExceptionCode());
6984     }
6985     RpcEndExcept;
6986
6987     return ret;
6988 }
6989
6990
6991 /***********************************************************************
6992  * CM_Remove_SubTree [SETUPAPI.@]
6993  *
6994  * This function is obsolete in Windows XP and above.
6995  */
6996 CONFIGRET
6997 WINAPI
6998 CM_Remove_SubTree(
6999     _In_ DEVINST dnAncestor,
7000     _In_ ULONG ulFlags)
7001 {
7002     TRACE("CM_Remove_SubTree(%lx %lx)\n",
7003           dnAncestor, ulFlags);
7004
7005     return CR_CALL_NOT_IMPLEMENTED;
7006 }
7007
7008
7009 /***********************************************************************
7010  * CM_Remove_SubTree_Ex [SETUPAPI.@]
7011  *
7012  * This function is obsolete in Windows XP and above.
7013  */
7014 CONFIGRET
7015 WINAPI
7016 CM_Remove_SubTree_Ex(
7017     _In_ DEVINST dnAncestor,
7018     _In_ ULONG ulFlags,
7019     _In_opt_ HMACHINE hMachine)
7020 {
7021     TRACE("CM_Remove_SubTree_Ex(%lx %lx %p)\n",
7022           dnAncestor, ulFlags, hMachine);
7023
7024     return CR_CALL_NOT_IMPLEMENTED;
7025 }
7026
7027
7028 /***********************************************************************
7029  * CM_Request_Device_EjectA [SETUPAPI.@]
7030  */
7031 CONFIGRET
7032 WINAPI
7033 CM_Request_Device_EjectA(
7034     _In_ DEVINST dnDevInst,
7035     _Out_opt_ PPNP_VETO_TYPE pVetoType,
7036     _Out_writes_opt_(ulNameLength) LPSTR pszVetoName,
7037     _In_ ULONG ulNameLength,
7038     _In_ ULONG ulFlags)
7039 {
7040     TRACE("CM_Request_Device_EjectA(%lx %p %s %lu %lx)\n",
7041           dnDevInst, pVetoType, debugstr_a(pszVetoName), ulNameLength, ulFlags);
7042
7043     return CM_Request_Device_Eject_ExA(dnDevInst, pVetoType, pszVetoName,
7044                                        ulNameLength, ulFlags, NULL);
7045 }
7046
7047
7048 /***********************************************************************
7049  * CM_Request_Device_EjectW [SETUPAPI.@]
7050  */
7051 CONFIGRET
7052 WINAPI
7053 CM_Request_Device_EjectW(
7054     _In_ DEVINST dnDevInst,
7055     _Out_opt_ PPNP_VETO_TYPE pVetoType,
7056     _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName,
7057     _In_ ULONG ulNameLength,
7058     _In_ ULONG ulFlags)
7059 {
7060     TRACE("CM_Request_Device_EjectW(%lx %p %s %lu %lx)\n",
7061           dnDevInst, pVetoType, debugstr_w(pszVetoName), ulNameLength, ulFlags);
7062
7063     return CM_Request_Device_Eject_ExW(dnDevInst, pVetoType, pszVetoName,
7064                                        ulNameLength, ulFlags, NULL);
7065 }
7066
7067
7068 /***********************************************************************
7069  * CM_Request_Device_Eject_ExA [SETUPAPI.@]
7070  */
7071 CONFIGRET
7072 WINAPI
7073 CM_Request_Device_Eject_ExA(
7074     _In_ DEVINST dnDevInst,
7075     _Out_opt_ PPNP_VETO_TYPE pVetoType,
7076     _Out_writes_opt_(ulNameLength) LPSTR pszVetoName,
7077     _In_ ULONG ulNameLength,
7078     _In_ ULONG ulFlags,
7079     _In_opt_ HMACHINE hMachine)
7080 {
7081     LPWSTR lpLocalVetoName;
7082     CONFIGRET ret;
7083
7084     TRACE("CM_Request_Device_Eject_ExA(%lx %p %s %lu %lx %p)\n",
7085           dnDevInst, pVetoType, debugstr_a(pszVetoName), ulNameLength, ulFlags, hMachine);
7086
7087     if (pszVetoName == NULL && ulNameLength == 0)
7088         return CR_INVALID_POINTER;
7089
7090     lpLocalVetoName = HeapAlloc(GetProcessHeap(), 0, ulNameLength * sizeof(WCHAR));
7091     if (lpLocalVetoName == NULL)
7092         return CR_OUT_OF_MEMORY;
7093
7094     ret = CM_Request_Device_Eject_ExW(dnDevInst, pVetoType, lpLocalVetoName,
7095                                       ulNameLength, ulFlags, hMachine);
7096     if (ret == CR_REMOVE_VETOED)
7097     {
7098         if (WideCharToMultiByte(CP_ACP,
7099                                 0,
7100                                 lpLocalVetoName,
7101                                 ulNameLength,
7102                                 pszVetoName,
7103                                 ulNameLength,
7104                                 NULL,
7105                                 NULL) == 0)
7106             ret = CR_FAILURE;
7107     }
7108
7109     HeapFree(GetProcessHeap(), 0, lpLocalVetoName);
7110
7111     return ret;
7112 }
7113
7114
7115 /***********************************************************************
7116  * CM_Request_Device_Eject_ExW [SETUPAPI.@]
7117  */
7118 CONFIGRET
7119 WINAPI
7120 CM_Request_Device_Eject_ExW(
7121     _In_ DEVINST dnDevInst,
7122     _Out_opt_ PPNP_VETO_TYPE pVetoType,
7123     _Out_writes_opt_(ulNameLength) LPWSTR pszVetoName,
7124     _In_ ULONG ulNameLength,
7125     _In_ ULONG ulFlags,
7126     _In_opt_ HMACHINE hMachine)
7127 {
7128     RPC_BINDING_HANDLE BindingHandle = NULL;
7129     HSTRING_TABLE StringTable = NULL;
7130     LPWSTR lpDevInst;
7131     CONFIGRET ret;
7132
7133     TRACE("CM_Request_Device_Eject_ExW(%lx %p %s %lu %lx %p)\n",
7134           dnDevInst, pVetoType, debugstr_w(pszVetoName), ulNameLength, ulFlags, hMachine);
7135
7136     if (dnDevInst == 0)
7137         return CR_INVALID_DEVNODE;
7138
7139     if (ulFlags != 0)
7140         return CR_INVALID_FLAG;
7141
7142     if (pszVetoName == NULL && ulNameLength == 0)
7143         return CR_INVALID_POINTER;
7144
7145     if (hMachine != NULL)
7146     {
7147         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7148         if (BindingHandle == NULL)
7149             return CR_FAILURE;
7150
7151         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7152         if (StringTable == 0)
7153             return CR_FAILURE;
7154     }
7155     else
7156     {
7157         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7158             return CR_FAILURE;
7159     }
7160
7161     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7162     if (lpDevInst == NULL)
7163         return CR_INVALID_DEVNODE;
7164
7165     RpcTryExcept
7166     {
7167         ret = PNP_RequestDeviceEject(BindingHandle,
7168                                      lpDevInst,
7169                                      pVetoType,
7170                                      pszVetoName,
7171                                      ulNameLength,
7172                                      ulFlags);
7173     }
7174     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
7175     {
7176         ret = RpcStatusToCmStatus(RpcExceptionCode());
7177     }
7178     RpcEndExcept;
7179
7180     return ret;
7181 }
7182
7183
7184 /***********************************************************************
7185  * CM_Request_Eject_PC [SETUPAPI.@]
7186  */
7187 CONFIGRET
7188 WINAPI
7189 CM_Request_Eject_PC(VOID)
7190 {
7191     TRACE("CM_Request_Eject_PC()\n");
7192
7193     return CM_Request_Eject_PC_Ex(NULL);
7194 }
7195
7196
7197 /***********************************************************************
7198  * CM_Request_Eject_PC_Ex [SETUPAPI.@]
7199  */
7200 CONFIGRET
7201 WINAPI
7202 CM_Request_Eject_PC_Ex(
7203     _In_opt_ HMACHINE hMachine)
7204 {
7205     RPC_BINDING_HANDLE BindingHandle = NULL;
7206     CONFIGRET ret;
7207
7208     TRACE("CM_Request_Eject_PC_Ex(%p)\n", hMachine);
7209
7210     if (hMachine != NULL)
7211     {
7212         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7213         if (BindingHandle == NULL)
7214             return CR_FAILURE;
7215     }
7216     else
7217     {
7218         if (!PnpGetLocalHandles(&BindingHandle, NULL))
7219             return CR_FAILURE;
7220     }
7221
7222     RpcTryExcept
7223     {
7224         ret = PNP_RequestEjectPC(BindingHandle);
7225     }
7226     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
7227     {
7228         ret = RpcStatusToCmStatus(RpcExceptionCode());
7229     }
7230     RpcEndExcept;
7231
7232     return ret;
7233 }
7234
7235
7236 /***********************************************************************
7237  * CM_Run_Detection [SETUPAPI.@]
7238  */
7239 CONFIGRET
7240 WINAPI
7241 CM_Run_Detection(
7242     _In_ ULONG ulFlags)
7243 {
7244     TRACE("CM_Run_Detection(%lx)\n", ulFlags);
7245
7246     return CM_Run_Detection_Ex(ulFlags, NULL);
7247 }
7248
7249
7250 /***********************************************************************
7251  * CM_Run_Detection_Ex [SETUPAPI.@]
7252  */
7253 CONFIGRET
7254 WINAPI
7255 CM_Run_Detection_Ex(
7256     _In_ ULONG ulFlags,
7257     _In_opt_ HMACHINE hMachine)
7258 {
7259     RPC_BINDING_HANDLE BindingHandle = NULL;
7260     CONFIGRET ret;
7261
7262     TRACE("CM_Run_Detection_Ex(%lx %p)\n",
7263           ulFlags, hMachine);
7264
7265     if (!pSetupIsUserAdmin())
7266         return CR_ACCESS_DENIED;
7267
7268     if (ulFlags & ~CM_DETECT_BITS)
7269         return CR_INVALID_FLAG;
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_RunDetection(BindingHandle,
7286                                ulFlags);
7287     }
7288     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
7289     {
7290         ret = RpcStatusToCmStatus(RpcExceptionCode());
7291     }
7292     RpcEndExcept;
7293
7294     return ret;
7295 }
7296
7297
7298 /***********************************************************************
7299  * CM_Set_Class_Registry_PropertyA [SETUPAPI.@]
7300  */
7301 CONFIGRET
7302 WINAPI
7303 CM_Set_Class_Registry_PropertyA(
7304     _In_ LPGUID ClassGuid,
7305     _In_ ULONG ulProperty,
7306     _In_reads_bytes_opt_(ulLength) PCVOID Buffer,
7307     _In_ ULONG ulLength,
7308     _In_ ULONG ulFlags,
7309     _In_opt_ HMACHINE hMachine)
7310 {
7311     FIXME("CM_Set_Class_Registry_PropertyA(%p %lx %p %lu %lx %p)\n",
7312           ClassGuid, ulProperty, Buffer, ulLength, ulFlags, hMachine);
7313
7314     return CR_CALL_NOT_IMPLEMENTED;
7315 }
7316
7317
7318 /***********************************************************************
7319  * CM_Set_Class_Registry_PropertyW [SETUPAPI.@]
7320  */
7321 CONFIGRET
7322 WINAPI
7323 CM_Set_Class_Registry_PropertyW(
7324     _In_ LPGUID ClassGuid,
7325     _In_ ULONG ulProperty,
7326     _In_reads_bytes_opt_(ulLength) PCVOID Buffer,
7327     _In_ ULONG ulLength,
7328     _In_ ULONG ulFlags,
7329     _In_opt_ HMACHINE hMachine)
7330 {
7331     FIXME("CM_Set_Class_Registry_PropertyW(%p %lx %p %lu %lx %p)\n",
7332           ClassGuid, ulProperty, Buffer, ulLength, ulFlags, hMachine);
7333
7334     return CR_CALL_NOT_IMPLEMENTED;
7335 }
7336
7337
7338 /***********************************************************************
7339  * CM_Set_DevNode_Problem [SETUPAPI.@]
7340  */
7341 CONFIGRET
7342 WINAPI
7343 CM_Set_DevNode_Problem(
7344     _In_ DEVINST dnDevInst,
7345     _In_ ULONG ulProblem,
7346     _In_ ULONG ulFlags)
7347 {
7348     TRACE("CM_Set_DevNode_Problem(%lx %lx %lx)\n",
7349           dnDevInst, ulProblem, ulFlags);
7350
7351     return CM_Set_DevNode_Problem_Ex(dnDevInst, ulProblem, ulFlags, NULL);
7352 }
7353
7354
7355 /***********************************************************************
7356  * CM_Set_DevNode_Problem_Ex [SETUPAPI.@]
7357  */
7358 CONFIGRET
7359 WINAPI
7360 CM_Set_DevNode_Problem_Ex(
7361     _In_ DEVINST dnDevInst,
7362     _In_ ULONG ulProblem,
7363     _In_ ULONG ulFlags,
7364     _In_opt_ HMACHINE hMachine)
7365 {
7366     RPC_BINDING_HANDLE BindingHandle = NULL;
7367     HSTRING_TABLE StringTable = NULL;
7368     LPWSTR lpDevInst;
7369     CONFIGRET ret;
7370
7371     TRACE("CM_Set_DevNode_Problem_Ex(%lx %lx %lx %p)\n",
7372           dnDevInst, ulProblem, ulFlags, hMachine);
7373
7374     if (dnDevInst == 0)
7375         return CR_INVALID_DEVNODE;
7376
7377     if (ulFlags & ~CM_SET_DEVNODE_PROBLEM_BITS)
7378         return CR_INVALID_FLAG;
7379
7380     if (hMachine != NULL)
7381     {
7382         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7383         if (BindingHandle == NULL)
7384             return CR_FAILURE;
7385
7386         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7387         if (StringTable == 0)
7388             return CR_FAILURE;
7389     }
7390     else
7391     {
7392         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7393             return CR_FAILURE;
7394     }
7395
7396     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7397     if (lpDevInst == NULL)
7398         return CR_INVALID_DEVNODE;
7399
7400     RpcTryExcept
7401     {
7402         ret = PNP_SetDeviceProblem(BindingHandle,
7403                                    lpDevInst,
7404                                    ulProblem,
7405                                    ulFlags);
7406     }
7407     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
7408     {
7409         ret = RpcStatusToCmStatus(RpcExceptionCode());
7410     }
7411     RpcEndExcept;
7412
7413     return ret;
7414 }
7415
7416
7417 /***********************************************************************
7418  * CM_Set_DevNode_Registry_PropertyA [SETUPAPI.@]
7419  */
7420 CONFIGRET
7421 WINAPI
7422 CM_Set_DevNode_Registry_PropertyA(
7423   _In_ DEVINST dnDevInst,
7424   _In_ ULONG ulProperty,
7425   _In_reads_bytes_opt_(ulLength) PCVOID Buffer,
7426   _In_ ULONG ulLength,
7427   _In_ ULONG ulFlags)
7428 {
7429     TRACE("CM_Set_DevNode_Registry_PropertyA(%lx %lu %p %lx %lx)\n",
7430           dnDevInst, ulProperty, Buffer, ulLength, ulFlags);
7431
7432     return CM_Set_DevNode_Registry_Property_ExA(dnDevInst, ulProperty,
7433                                                 Buffer, ulLength,
7434                                                 ulFlags, NULL);
7435 }
7436
7437
7438 /***********************************************************************
7439  * CM_Set_DevNode_Registry_PropertyW [SETUPAPI.@]
7440  */
7441 CONFIGRET
7442 WINAPI
7443 CM_Set_DevNode_Registry_PropertyW(
7444     _In_ DEVINST dnDevInst,
7445     _In_ ULONG ulProperty,
7446     _In_reads_bytes_opt_(ulLength) PCVOID Buffer,
7447     _In_ ULONG ulLength,
7448     _In_ ULONG ulFlags)
7449 {
7450     TRACE("CM_Set_DevNode_Registry_PropertyW(%lx %lu %p %lx %lx)\n",
7451           dnDevInst, ulProperty, Buffer, ulLength, ulFlags);
7452
7453     return CM_Set_DevNode_Registry_Property_ExW(dnDevInst, ulProperty,
7454                                                 Buffer, ulLength,
7455                                                 ulFlags, NULL);
7456 }
7457
7458
7459 /***********************************************************************
7460  * CM_Set_DevNode_Registry_Property_ExA [SETUPAPI.@]
7461  */
7462 CONFIGRET
7463 WINAPI
7464 CM_Set_DevNode_Registry_Property_ExA(
7465     _In_ DEVINST dnDevInst,
7466     _In_ ULONG ulProperty,
7467     _In_reads_bytes_opt_(ulLength) PCVOID Buffer,
7468     _In_ ULONG ulLength,
7469     _In_ ULONG ulFlags,
7470     _In_opt_ HMACHINE hMachine)
7471 {
7472     CONFIGRET ret = CR_SUCCESS;
7473     LPWSTR lpBuffer;
7474     ULONG ulType;
7475
7476     FIXME("CM_Set_DevNode_Registry_Property_ExA(%lx %lu %p %lx %lx %p)\n",
7477           dnDevInst, ulProperty, Buffer, ulLength, ulFlags, hMachine);
7478
7479     if (Buffer == NULL && ulLength != 0)
7480         return CR_INVALID_POINTER;
7481
7482     if (ulProperty < CM_DRP_MIN || ulProperty > CM_DRP_MAX)
7483         return CR_INVALID_PROPERTY;
7484
7485     if (Buffer == NULL)
7486     {
7487         ret = CM_Set_DevNode_Registry_Property_ExW(dnDevInst,
7488                                                    ulProperty,
7489                                                    NULL,
7490                                                    0,
7491                                                    ulFlags,
7492                                                    hMachine);
7493     }
7494     else
7495     {
7496         /* Get property type */
7497         ulType = GetRegistryPropertyType(ulProperty);
7498
7499         /* Allocate buffer if needed */
7500         if (ulType == REG_SZ ||
7501             ulType == REG_MULTI_SZ)
7502         {
7503             lpBuffer = MyMalloc(ulLength * sizeof(WCHAR));
7504             if (lpBuffer == NULL)
7505             {
7506                 ret = CR_OUT_OF_MEMORY;
7507             }
7508             else
7509             {
7510                 if (!MultiByteToWideChar(CP_ACP, 0, Buffer,
7511                                          ulLength, lpBuffer, ulLength))
7512                 {
7513                     MyFree(lpBuffer);
7514                     ret = CR_FAILURE;
7515                 }
7516                 else
7517                 {
7518                     ret = CM_Set_DevNode_Registry_Property_ExW(dnDevInst,
7519                                                                ulProperty,
7520                                                                lpBuffer,
7521                                                                ulLength * sizeof(WCHAR),
7522                                                                ulFlags,
7523                                                                hMachine);
7524                     MyFree(lpBuffer);
7525                 }
7526             }
7527         }
7528         else
7529         {
7530             ret = CM_Set_DevNode_Registry_Property_ExW(dnDevInst,
7531                                                        ulProperty,
7532                                                        Buffer,
7533                                                        ulLength,
7534                                                        ulFlags,
7535                                                        hMachine);
7536         }
7537
7538         ret = CR_CALL_NOT_IMPLEMENTED;
7539     }
7540
7541     return ret;
7542 }
7543
7544
7545 /***********************************************************************
7546  * CM_Set_DevNode_Registry_Property_ExW [SETUPAPI.@]
7547  */
7548 CONFIGRET
7549 WINAPI
7550 CM_Set_DevNode_Registry_Property_ExW(
7551     _In_ DEVINST dnDevInst,
7552     _In_ ULONG ulProperty,
7553     _In_reads_bytes_opt_(ulLength) PCVOID Buffer,
7554     _In_ ULONG ulLength,
7555     _In_ ULONG ulFlags,
7556     _In_opt_ HMACHINE hMachine)
7557 {
7558     RPC_BINDING_HANDLE BindingHandle = NULL;
7559     HSTRING_TABLE StringTable = NULL;
7560     LPWSTR lpDevInst;
7561     ULONG ulType;
7562     CONFIGRET ret;
7563
7564     TRACE("CM_Set_DevNode_Registry_Property_ExW(%lx %lu %p %lx %lx %p)\n",
7565           dnDevInst, ulProperty, Buffer, ulLength, ulFlags, hMachine);
7566
7567     if (dnDevInst == 0)
7568         return CR_INVALID_DEVNODE;
7569
7570     if (ulProperty <  CM_DRP_MIN || ulProperty > CM_DRP_MAX)
7571         return CR_INVALID_PROPERTY;
7572
7573     if (Buffer != NULL && ulLength == 0)
7574         return CR_INVALID_POINTER;
7575
7576     if (ulFlags != 0)
7577         return CR_INVALID_FLAG;
7578
7579     if (hMachine != NULL)
7580     {
7581         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7582         if (BindingHandle == NULL)
7583             return CR_FAILURE;
7584
7585         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7586         if (StringTable == 0)
7587             return CR_FAILURE;
7588     }
7589     else
7590     {
7591         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7592             return CR_FAILURE;
7593     }
7594
7595     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7596     if (lpDevInst == NULL)
7597         return CR_INVALID_DEVNODE;
7598
7599     /* Get property type */
7600     ulType = GetRegistryPropertyType(ulProperty);
7601
7602     RpcTryExcept
7603     {
7604         ret = PNP_SetDeviceRegProp(BindingHandle,
7605                                    lpDevInst,
7606                                    ulProperty,
7607                                    ulType,
7608                                    (BYTE *)Buffer,
7609                                    ulLength,
7610                                    ulFlags);
7611     }
7612     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
7613     {
7614         ret = RpcStatusToCmStatus(RpcExceptionCode());
7615     }
7616     RpcEndExcept;
7617
7618     return ret;
7619 }
7620
7621
7622 /***********************************************************************
7623  * CM_Set_HW_Prof [SETUPAPI.@]
7624  */
7625 CONFIGRET
7626 WINAPI
7627 CM_Set_HW_Prof(
7628     _In_ ULONG ulHardwareProfile,
7629     _In_ ULONG ulFlags)
7630 {
7631     TRACE("CM_Set_HW_Prof(%lu %lx)\n",
7632           ulHardwareProfile, ulFlags);
7633
7634     return CM_Set_HW_Prof_Ex(ulHardwareProfile, ulFlags, NULL);
7635 }
7636
7637
7638 /***********************************************************************
7639  * CM_Set_HW_Prof_Ex [SETUPAPI.@]
7640  */
7641 CONFIGRET
7642 WINAPI
7643 CM_Set_HW_Prof_Ex(
7644     _In_ ULONG ulHardwareProfile,
7645     _In_ ULONG ulFlags,
7646     _In_opt_ HMACHINE hMachine)
7647 {
7648     RPC_BINDING_HANDLE BindingHandle = NULL;
7649     CONFIGRET ret;
7650
7651     TRACE("CM_Set_HW_Prof_Ex(%lu %lx %p)\n",
7652           ulHardwareProfile, ulFlags, hMachine);
7653
7654     if (!pSetupIsUserAdmin())
7655         return CR_ACCESS_DENIED;
7656
7657     if (ulFlags != 0)
7658         return CR_INVALID_FLAG;
7659
7660     if (hMachine != NULL)
7661     {
7662         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7663         if (BindingHandle == NULL)
7664             return CR_FAILURE;
7665     }
7666     else
7667     {
7668         if (!PnpGetLocalHandles(&BindingHandle, NULL))
7669             return CR_FAILURE;
7670     }
7671
7672     RpcTryExcept
7673     {
7674         ret = PNP_SetHwProf(BindingHandle, ulHardwareProfile, ulFlags);
7675     }
7676     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
7677     {
7678         ret = RpcStatusToCmStatus(RpcExceptionCode());
7679     }
7680     RpcEndExcept;
7681
7682     return ret;
7683 }
7684
7685
7686 /***********************************************************************
7687  * CM_Set_HW_Prof_FlagsA [SETUPAPI.@]
7688  */
7689 CONFIGRET
7690 WINAPI
7691 CM_Set_HW_Prof_FlagsA(
7692     _In_ DEVINSTID_A szDevInstName,
7693     _In_ ULONG ulConfig,
7694     _In_ ULONG ulValue,
7695     _In_ ULONG ulFlags)
7696 {
7697     TRACE("CM_Set_HW_Prof_FlagsA(%s %lu %lu %lx)\n",
7698           debugstr_a(szDevInstName), ulConfig, ulValue, ulFlags);
7699
7700     return CM_Set_HW_Prof_Flags_ExA(szDevInstName, ulConfig, ulValue,
7701                                     ulFlags, NULL);
7702 }
7703
7704
7705 /***********************************************************************
7706  * CM_Set_HW_Prof_FlagsW [SETUPAPI.@]
7707  */
7708 CONFIGRET
7709 WINAPI
7710 CM_Set_HW_Prof_FlagsW(
7711     _In_ DEVINSTID_W szDevInstName,
7712     _In_ ULONG ulConfig,
7713     _In_ ULONG ulValue,
7714     _In_ ULONG ulFlags)
7715 {
7716     TRACE("CM_Set_HW_Prof_FlagsW(%s %lu %lu %lx)\n",
7717           debugstr_w(szDevInstName), ulConfig, ulValue, ulFlags);
7718
7719     return CM_Set_HW_Prof_Flags_ExW(szDevInstName, ulConfig, ulValue,
7720                                     ulFlags, NULL);
7721 }
7722
7723
7724 /***********************************************************************
7725  * CM_Set_HW_Prof_Flags_ExA [SETUPAPI.@]
7726  */
7727 CONFIGRET
7728 WINAPI
7729 CM_Set_HW_Prof_Flags_ExA(
7730     _In_ DEVINSTID_A szDevInstName,
7731     _In_ ULONG ulConfig,
7732     _In_ ULONG ulValue,
7733     _In_ ULONG ulFlags,
7734     _In_opt_ HMACHINE hMachine)
7735 {
7736     DEVINSTID_W pszDevIdW = NULL;
7737     CONFIGRET ret = CR_SUCCESS;
7738
7739     TRACE("CM_Set_HW_Prof_Flags_ExA(%s %lu %lu %lx %p)\n",
7740           debugstr_a(szDevInstName), ulConfig, ulValue, ulFlags, hMachine);
7741
7742     if (szDevInstName != NULL)
7743     {
7744        if (pSetupCaptureAndConvertAnsiArg(szDevInstName, &pszDevIdW))
7745          return CR_INVALID_DEVICE_ID;
7746     }
7747
7748     ret = CM_Set_HW_Prof_Flags_ExW(pszDevIdW, ulConfig, ulValue,
7749                                    ulFlags, hMachine);
7750
7751     if (pszDevIdW != NULL)
7752         MyFree(pszDevIdW);
7753
7754     return ret;
7755 }
7756
7757
7758 /***********************************************************************
7759  * CM_Set_HW_Prof_Flags_ExW [SETUPAPI.@]
7760  */
7761 CONFIGRET
7762 WINAPI
7763 CM_Set_HW_Prof_Flags_ExW(
7764     _In_ DEVINSTID_W szDevInstName,
7765     _In_ ULONG ulConfig,
7766     _In_ ULONG ulValue,
7767     _In_ ULONG ulFlags,
7768     _In_opt_ HMACHINE hMachine)
7769 {
7770     RPC_BINDING_HANDLE BindingHandle = NULL;
7771     CONFIGRET ret;
7772
7773     FIXME("CM_Set_HW_Prof_Flags_ExW(%s %lu %lu %lx %p)\n",
7774           debugstr_w(szDevInstName), ulConfig, ulValue, ulFlags, hMachine);
7775
7776     if (szDevInstName == NULL)
7777         return CR_INVALID_POINTER;
7778
7779     if (ulFlags & ~ CM_SET_HW_PROF_FLAGS_BITS)
7780         return CR_INVALID_FLAG;
7781
7782     /* FIXME: Check whether szDevInstName is valid */
7783
7784     if (hMachine != NULL)
7785     {
7786         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7787         if (BindingHandle == NULL)
7788             return CR_FAILURE;
7789     }
7790     else
7791     {
7792         if (!PnpGetLocalHandles(&BindingHandle, NULL))
7793             return CR_FAILURE;
7794     }
7795
7796     RpcTryExcept
7797     {
7798         ret = PNP_HwProfFlags(BindingHandle, PNP_SET_HWPROFFLAGS, szDevInstName,
7799                               ulConfig, &ulValue, NULL, NULL, 0, 0);
7800     }
7801     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
7802     {
7803         ret = RpcStatusToCmStatus(RpcExceptionCode());
7804     }
7805     RpcEndExcept;
7806
7807     return ret;
7808 }
7809
7810
7811 /***********************************************************************
7812  * CM_Setup_DevNode [SETUPAPI.@]
7813  */
7814 CONFIGRET
7815 WINAPI
7816 CM_Setup_DevNode(
7817     _In_ DEVINST dnDevInst,
7818     _In_ ULONG ulFlags)
7819 {
7820     TRACE("CM_Setup_DevNode(%lx %lx)\n",
7821           dnDevInst, ulFlags);
7822
7823     return CM_Setup_DevNode_Ex(dnDevInst, ulFlags, NULL);
7824 }
7825
7826
7827 /***********************************************************************
7828  * CM_Setup_DevNode_Ex [SETUPAPI.@]
7829  */
7830 CONFIGRET
7831 WINAPI
7832 CM_Setup_DevNode_Ex(
7833     _In_ DEVINST dnDevInst,
7834     _In_ ULONG ulFlags,
7835     _In_opt_ HMACHINE hMachine)
7836 {
7837     RPC_BINDING_HANDLE BindingHandle = NULL;
7838     HSTRING_TABLE StringTable = NULL;
7839     LPWSTR lpDevInst;
7840     CONFIGRET ret;
7841
7842     FIXME("CM_Setup_DevNode_Ex(%lx %lx %p)\n",
7843           dnDevInst, ulFlags, hMachine);
7844
7845     if (!pSetupIsUserAdmin())
7846         return CR_ACCESS_DENIED;
7847
7848     if (dnDevInst == 0)
7849         return CR_INVALID_DEVNODE;
7850
7851     if (ulFlags & ~CM_SETUP_BITS)
7852         return CR_INVALID_FLAG;
7853
7854     if (hMachine != NULL)
7855     {
7856         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7857         if (BindingHandle == NULL)
7858             return CR_FAILURE;
7859
7860         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7861         if (StringTable == 0)
7862             return CR_FAILURE;
7863     }
7864     else
7865     {
7866         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7867             return CR_FAILURE;
7868     }
7869
7870     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
7871     if (lpDevInst == NULL)
7872         return CR_INVALID_DEVNODE;
7873
7874     RpcTryExcept
7875     {
7876         ret = PNP_DeviceInstanceAction(BindingHandle,
7877                                        PNP_DEVINST_SETUP,
7878                                        ulFlags,
7879                                        lpDevInst,
7880                                        NULL);
7881     }
7882     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
7883     {
7884         ret = RpcStatusToCmStatus(RpcExceptionCode());
7885     }
7886     RpcEndExcept;
7887
7888     return ret;
7889 }
7890
7891
7892 /***********************************************************************
7893  * CM_Test_Range_Available [SETUPAPI.@]
7894  */
7895 CONFIGRET
7896 WINAPI
7897 CM_Test_Range_Available(
7898     _In_ DWORDLONG ullStartValue,
7899     _In_ DWORDLONG ullEndValue,
7900     _In_ RANGE_LIST rlh,
7901     _In_ ULONG ulFlags)
7902 {
7903     FIXME("CM_Test_Range_Available(%I64u %I64u %p %lx)\n",
7904           ullStartValue, ullEndValue, rlh, ulFlags);
7905     return CR_CALL_NOT_IMPLEMENTED;
7906 }
7907
7908
7909 /***********************************************************************
7910  * CM_Uninstall_DevNode [SETUPAPI.@]
7911  */
7912 CONFIGRET
7913 WINAPI
7914 CM_Uninstall_DevNode(
7915     _In_ DEVINST dnPhantom,
7916     _In_ ULONG ulFlags)
7917 {
7918     TRACE("CM_Uninstall_DevNode(%lx %lx)\n",
7919           dnPhantom, ulFlags);
7920
7921     return CM_Uninstall_DevNode_Ex(dnPhantom, ulFlags, NULL);
7922 }
7923
7924
7925 /***********************************************************************
7926  * CM_Uninstall_DevNode_Ex [SETUPAPI.@]
7927  */
7928 CONFIGRET
7929 WINAPI
7930 CM_Uninstall_DevNode_Ex(
7931     _In_ DEVINST dnPhantom,
7932     _In_ ULONG ulFlags,
7933     _In_opt_ HMACHINE hMachine)
7934 {
7935     RPC_BINDING_HANDLE BindingHandle = NULL;
7936     HSTRING_TABLE StringTable = NULL;
7937     LPWSTR lpDevInst;
7938     CONFIGRET ret;
7939
7940     TRACE("CM_Uninstall_DevNode_Ex(%lx %lx %p)\n",
7941           dnPhantom, ulFlags, hMachine);
7942
7943     if (dnPhantom == 0)
7944         return CR_INVALID_DEVNODE;
7945
7946     if (ulFlags != 0)
7947         return CR_INVALID_FLAG;
7948
7949     if (hMachine != NULL)
7950     {
7951         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
7952         if (BindingHandle == NULL)
7953             return CR_FAILURE;
7954
7955         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
7956         if (StringTable == 0)
7957             return CR_FAILURE;
7958     }
7959     else
7960     {
7961         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
7962             return CR_FAILURE;
7963     }
7964
7965     lpDevInst = pSetupStringTableStringFromId(StringTable, dnPhantom);
7966     if (lpDevInst == NULL)
7967         return CR_INVALID_DEVNODE;
7968
7969     RpcTryExcept
7970     {
7971         ret = PNP_UninstallDevInst(BindingHandle,
7972                                    lpDevInst,
7973                                    ulFlags);
7974     }
7975     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
7976     {
7977         ret = RpcStatusToCmStatus(RpcExceptionCode());
7978     }
7979     RpcEndExcept;
7980
7981     return ret;
7982 }
7983
7984
7985 /***********************************************************************
7986  * CM_Unregister_Device_InterfaceA [SETUPAPI.@]
7987  */
7988 CONFIGRET
7989 WINAPI
7990 CM_Unregister_Device_InterfaceA(
7991     _In_ LPCSTR pszDeviceInterface,
7992     _In_ ULONG ulFlags)
7993 {
7994     TRACE("CM_Unregister_Device_InterfaceA(%s %lx)\n",
7995           debugstr_a(pszDeviceInterface), ulFlags);
7996
7997     return CM_Unregister_Device_Interface_ExA(pszDeviceInterface,
7998                                               ulFlags, NULL);
7999 }
8000
8001
8002 /***********************************************************************
8003  * CM_Unregister_Device_InterfaceW [SETUPAPI.@]
8004  */
8005 CONFIGRET
8006 WINAPI
8007 CM_Unregister_Device_InterfaceW(
8008     _In_ LPCWSTR pszDeviceInterface,
8009     _In_ ULONG ulFlags)
8010 {
8011     TRACE("CM_Unregister_Device_InterfaceW(%s %lx)\n",
8012           debugstr_w(pszDeviceInterface), ulFlags);
8013
8014     return CM_Unregister_Device_Interface_ExW(pszDeviceInterface,
8015                                               ulFlags, NULL);
8016 }
8017
8018
8019 /***********************************************************************
8020  * CM_Unregister_Device_Interface_ExA [SETUPAPI.@]
8021  */
8022 CONFIGRET
8023 WINAPI
8024 CM_Unregister_Device_Interface_ExA(
8025     _In_ LPCSTR pszDeviceInterface,
8026     _In_ ULONG ulFlags,
8027     _In_opt_ HMACHINE hMachine)
8028 {
8029     LPWSTR pszDeviceInterfaceW = NULL;
8030     CONFIGRET ret;
8031
8032     TRACE("CM_Unregister_Device_Interface_ExA(%s %lx %p)\n",
8033           debugstr_a(pszDeviceInterface), ulFlags, hMachine);
8034
8035     if (pszDeviceInterface == NULL)
8036         return CR_INVALID_POINTER;
8037
8038     if (pSetupCaptureAndConvertAnsiArg(pszDeviceInterface, &pszDeviceInterfaceW))
8039         return CR_INVALID_DATA;
8040
8041     ret = CM_Unregister_Device_Interface_ExW(pszDeviceInterfaceW,
8042                                              ulFlags, hMachine);
8043
8044     if (pszDeviceInterfaceW != NULL)
8045         MyFree(pszDeviceInterfaceW);
8046
8047     return ret;
8048 }
8049
8050
8051 /***********************************************************************
8052  * CM_Unregister_Device_Interface_ExW [SETUPAPI.@]
8053  */
8054 CONFIGRET
8055 WINAPI
8056 CM_Unregister_Device_Interface_ExW(
8057     _In_ LPCWSTR pszDeviceInterface,
8058     _In_ ULONG ulFlags,
8059     _In_opt_ HMACHINE hMachine)
8060 {
8061     RPC_BINDING_HANDLE BindingHandle = NULL;
8062     CONFIGRET ret;
8063
8064     TRACE("CM_Unregister_Device_Interface_ExW(%s %lx %p)\n",
8065           debugstr_w(pszDeviceInterface), ulFlags, hMachine);
8066
8067     if (pszDeviceInterface == NULL)
8068         return CR_INVALID_POINTER;
8069
8070     if (ulFlags != 0)
8071         return CR_INVALID_FLAG;
8072
8073     if (hMachine != NULL)
8074     {
8075         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
8076         if (BindingHandle == NULL)
8077             return CR_FAILURE;
8078     }
8079     else
8080     {
8081         if (!PnpGetLocalHandles(&BindingHandle, NULL))
8082             return CR_FAILURE;
8083     }
8084
8085     RpcTryExcept
8086     {
8087         ret = PNP_UnregisterDeviceClassAssociation(BindingHandle,
8088                                                    (LPWSTR)pszDeviceInterface,
8089                                                    ulFlags);
8090     }
8091     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
8092     {
8093         ret = RpcStatusToCmStatus(RpcExceptionCode());
8094     }
8095     RpcEndExcept;
8096
8097     return ret;
8098 }