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