dll/win32/setupapi/cfgmgr.c

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