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 WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
  25
  26 /* Registry key and value names */
  27 static const WCHAR Backslash[] = {'\\', 0};
  28 static const WCHAR Class[]  = {'C','l','a','s','s',0};
  29
  30 static const WCHAR ControlClass[] = {'S','y','s','t','e','m','\\',
  31                                      'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
  32                                      'C','o','n','t','r','o','l','\\',
  33                                      'C','l','a','s','s',0};
  34
  35 static const WCHAR DeviceClasses[] = {'S','y','s','t','e','m','\\',
  36                                       'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
  37                                       'C','o','n','t','r','o','l','\\',
  38                                       'D','e','v','i','c','e','C','l','a','s','s','e','s',0};
  39
  40 typedef struct _MACHINE_INFO
  41 {
  42     WCHAR szMachineName[SP_MAX_MACHINENAME_LENGTH];
  43     RPC_BINDING_HANDLE BindingHandle;
  44     HSTRING_TABLE StringTable;
  45     BOOL bLocal;
  46 } MACHINE_INFO, *PMACHINE_INFO;
  47
  48
  49 typedef struct _LOG_CONF_INFO
  50 {
  51     ULONG ulMagic;
  52     DEVINST dnDevInst;
  53     ULONG ulFlags;
  54     ULONG ulTag;
  55 } LOG_CONF_INFO, *PLOG_CONF_INFO;
  56
  57 #define LOG_CONF_MAGIC 0x464E434C  /* "LCNF" */
  58
  59
  60 static BOOL GuidToString(LPGUID Guid, LPWSTR String)
  61 {
  62     LPWSTR lpString;
  63
  64     if (UuidToStringW(Guid, &lpString) != RPC_S_OK)
  65         return FALSE;
  66
  67     lstrcpyW(&String[1], lpString);
  68
  69     String[0] = '{';
  70     String[MAX_GUID_STRING_LEN - 2] = '}';
  71     String[MAX_GUID_STRING_LEN - 1] = UNICODE_NULL;
  72
  73     RpcStringFreeW(&lpString);
  74
  75     return TRUE;
  76 }
  77
  78
  79 static CONFIGRET
  80 RpcStatusToCmStatus(RPC_STATUS Status)
  81 {
  82     return CR_FAILURE;
  83 }
  84
  85
  86 /***********************************************************************
  87  * CMP_WaitNoPendingInstallEvents [SETUPAPI.@]
  88  */
  89 DWORD WINAPI CMP_WaitNoPendingInstallEvents(
  90     DWORD dwTimeout)
  91 {
  92     HANDLE hEvent;
  93     DWORD ret;
  94
  95     hEvent = OpenEventW(SYNCHRONIZE, FALSE, L"Global\\PnP_No_Pending_Install_Events");
  96     if (hEvent == NULL)
  97        return WAIT_FAILED;
  98
  99     ret = WaitForSingleObject(hEvent, dwTimeout);
 100     CloseHandle(hEvent);
 101     return ret;
 102 }
 103
 104
 105 /***********************************************************************
 106  * CMP_Init_Detection [SETUPAPI.@]
 107  */
 108 CONFIGRET WINAPI CMP_Init_Detection(
 109     DWORD dwMagic)
 110 {
 111     RPC_BINDING_HANDLE BindingHandle = NULL;
 112     CONFIGRET ret;
 113
 114     TRACE("%lu\n", dwMagic);
 115
 116     if (dwMagic != CMP_MAGIC)
 117         return CR_INVALID_DATA;
 118
 119     if (!PnpGetLocalHandles(&BindingHandle, NULL))
 120         return CR_FAILURE;
 121
 122     RpcTryExcept
 123     {
 124         ret = PNP_InitDetection(BindingHandle);
 125     }
 126     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 127     {
 128         ret = RpcStatusToCmStatus(RpcExceptionCode());
 129     }
 130     RpcEndExcept;
 131
 132     return ret;
 133 }
 134
 135
 136 /***********************************************************************
 137  * CMP_Report_LogOn [SETUPAPI.@]
 138  */
 139 CONFIGRET WINAPI CMP_Report_LogOn(
 140     DWORD dwMagic,
 141     DWORD dwProcessId)
 142 {
 143     RPC_BINDING_HANDLE BindingHandle = NULL;
 144     CONFIGRET ret = CR_SUCCESS;
 145     BOOL bAdmin;
 146     DWORD i;
 147
 148     TRACE("%lu\n", dwMagic);
 149
 150     if (dwMagic != CMP_MAGIC)
 151         return CR_INVALID_DATA;
 152
 153     if (!PnpGetLocalHandles(&BindingHandle, NULL))
 154         return CR_FAILURE;
 155
 156     bAdmin = IsUserAdmin();
 157
 158     for (i = 0; i < 30; i++)
 159     {
 160         RpcTryExcept
 161         {
 162             ret = PNP_ReportLogOn(BindingHandle,
 163                                   bAdmin,
 164                                   dwProcessId);
 165         }
 166         RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 167         {
 168             ret = RpcStatusToCmStatus(RpcExceptionCode());
 169         }
 170         RpcEndExcept;
 171
 172         if (ret == CR_SUCCESS)
 173             break;
 174
 175         Sleep(5000);
 176     }
 177
 178     return ret;
 179 }
 180
 181
 182 /***********************************************************************
 183  * CM_Add_Empty_Log_Conf [SETUPAPI.@]
 184  */
 185 CONFIGRET WINAPI CM_Add_Empty_Log_Conf(
 186     PLOG_CONF plcLogConf, DEVINST dnDevInst, PRIORITY Priority,
 187     ULONG ulFlags)
 188 {
 189     TRACE("%p %p %lu %lx\n", plcLogConf, dnDevInst, Priority, ulFlags);
 190     return CM_Add_Empty_Log_Conf_Ex(plcLogConf, dnDevInst, Priority,
 191                                     ulFlags, NULL);
 192 }
 193
 194
 195 /***********************************************************************
 196  * CM_Add_Empty_Log_Conf_Ex [SETUPAPI.@]
 197  */
 198 CONFIGRET WINAPI CM_Add_Empty_Log_Conf_Ex(
 199     PLOG_CONF plcLogConf, DEVINST dnDevInst, PRIORITY Priority,
 200     ULONG ulFlags, HMACHINE hMachine)
 201 {
 202     RPC_BINDING_HANDLE BindingHandle = NULL;
 203     HSTRING_TABLE StringTable = NULL;
 204     ULONG ulLogConfTag = 0;
 205     LPWSTR lpDevInst;
 206     PLOG_CONF_INFO pLogConfInfo;
 207     CONFIGRET ret = CR_SUCCESS;
 208
 209     FIXME("%p %p %lu %lx %p\n",
 210           plcLogConf, dnDevInst, Priority, ulFlags, hMachine);
 211
 212     if (!IsUserAdmin())
 213         return CR_ACCESS_DENIED;
 214
 215     if (plcLogConf == NULL)
 216         return CR_INVALID_POINTER;
 217
 218     if (dnDevInst == 0)
 219         return CR_INVALID_DEVINST;
 220
 221     if (Priority > 0xFFFF)
 222         return CR_INVALID_PRIORITY;
 223
 224     if (ulFlags & ~(LOG_CONF_BITS | PRIORITY_BIT))
 225         return CR_INVALID_FLAG;
 226
 227     if (hMachine != NULL)
 228     {
 229         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
 230         if (BindingHandle == NULL)
 231             return CR_FAILURE;
 232
 233         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
 234         if (StringTable == 0)
 235             return CR_FAILURE;
 236     }
 237     else
 238     {
 239         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
 240             return CR_FAILURE;
 241     }
 242
 243     lpDevInst = StringTableStringFromId(StringTable, dnDevInst);
 244     if (lpDevInst == NULL)
 245         return CR_INVALID_DEVNODE;
 246
 247     RpcTryExcept
 248     {
 249         ret = PNP_AddEmptyLogConf(BindingHandle, lpDevInst, Priority,
 250                                   &ulLogConfTag, ulFlags);
 251     }
 252     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 253     {
 254         ret = RpcStatusToCmStatus(RpcExceptionCode());
 255     }
 256     RpcEndExcept;
 257
 258     if (ret == CR_SUCCESS)
 259     {
 260         pLogConfInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(LOG_CONF_INFO));
 261         if (pLogConfInfo == NULL)
 262         {
 263             ret = CR_OUT_OF_MEMORY;
 264         }
 265         else
 266         {
 267             pLogConfInfo->ulMagic = LOG_CONF_MAGIC;
 268             pLogConfInfo->dnDevInst = dnDevInst;
 269             pLogConfInfo->ulFlags = ulFlags;
 270             pLogConfInfo->ulTag = ulLogConfTag;
 271
 272             *plcLogConf = (LOG_CONF)pLogConfInfo;
 273
 274             ret = CR_SUCCESS;
 275         }
 276     }
 277
 278     return ret;
 279 }
 280
 281
 282 /***********************************************************************
 283  * CM_Add_IDA [SETUPAPI.@]
 284  */
 285 CONFIGRET WINAPI CM_Add_IDA(
 286     DEVINST dnDevInst, PSTR pszID, ULONG ulFlags)
 287 {
 288     TRACE("%p %s %lx\n", dnDevInst, pszID, ulFlags);
 289     return CM_Add_ID_ExA(dnDevInst, pszID, ulFlags, NULL);
 290 }
 291
 292
 293 /***********************************************************************
 294  * CM_Add_IDW [SETUPAPI.@]
 295  */
 296 CONFIGRET WINAPI CM_Add_IDW(
 297     DEVINST dnDevInst, PWSTR pszID, ULONG ulFlags)
 298 {
 299     TRACE("%p %s %lx\n", dnDevInst, debugstr_w(pszID), ulFlags);
 300     return CM_Add_ID_ExW(dnDevInst, pszID, ulFlags, NULL);
 301 }
 302
 303
 304 /***********************************************************************
 305  * CM_Add_ID_ExA [SETUPAPI.@]
 306  */
 307 CONFIGRET WINAPI CM_Add_ID_ExA(
 308     DEVINST dnDevInst, PSTR pszID, ULONG ulFlags, HMACHINE hMachine)
 309 {
 310     PWSTR pszIDW;
 311     CONFIGRET ret;
 312
 313     TRACE("%p %s %lx %p\n", dnDevInst, pszID, ulFlags, hMachine);
 314
 315     if (CaptureAndConvertAnsiArg(pszID, &pszIDW))
 316         return CR_INVALID_DATA;
 317
 318     ret = CM_Add_ID_ExW(dnDevInst, pszIDW, ulFlags, hMachine);
 319
 320     MyFree(pszIDW);
 321
 322     return ret;
 323 }
 324
 325
 326 /***********************************************************************
 327  * CM_Add_ID_ExW [SETUPAPI.@]
 328  */
 329 CONFIGRET WINAPI CM_Add_ID_ExW(
 330     DEVINST dnDevInst, PWSTR pszID, ULONG ulFlags, HMACHINE hMachine)
 331 {
 332     RPC_BINDING_HANDLE BindingHandle = NULL;
 333     HSTRING_TABLE StringTable = NULL;
 334     LPWSTR lpDevInst;
 335     CONFIGRET ret;
 336
 337     TRACE("%p %s %lx %p\n", dnDevInst, debugstr_w(pszID), ulFlags, hMachine);
 338
 339     if (!IsUserAdmin())
 340         return CR_ACCESS_DENIED;
 341
 342     if (dnDevInst == 0)
 343         return CR_INVALID_DEVINST;
 344
 345     if (pszID == NULL)
 346         return CR_INVALID_POINTER;
 347
 348     if (ulFlags & ~CM_ADD_ID_BITS)
 349         return CR_INVALID_FLAG;
 350
 351     if (hMachine != NULL)
 352     {
 353         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
 354         if (BindingHandle == NULL)
 355             return CR_FAILURE;
 356
 357         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
 358         if (StringTable == 0)
 359             return CR_FAILURE;
 360     }
 361     else
 362     {
 363         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
 364             return CR_FAILURE;
 365     }
 366
 367     lpDevInst = StringTableStringFromId(StringTable, dnDevInst);
 368     if (lpDevInst == NULL)
 369         return CR_INVALID_DEVNODE;
 370
 371     RpcTryExcept
 372     {
 373         ret = PNP_AddID(BindingHandle,
 374                         lpDevInst,
 375                         pszID,
 376                         ulFlags);
 377     }
 378     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 379     {
 380         ret = RpcStatusToCmStatus(RpcExceptionCode());
 381     }
 382     RpcEndExcept;
 383
 384     return ret;
 385 }
 386
 387
 388 /***********************************************************************
 389  * CM_Connect_MachineA [SETUPAPI.@]
 390  */
 391 CONFIGRET WINAPI CM_Connect_MachineA(
 392     PCSTR UNCServerName, PHMACHINE phMachine)
 393 {
 394     PWSTR pServerNameW;
 395     CONFIGRET ret;
 396
 397     TRACE("%s %p\n", UNCServerName, phMachine);
 398
 399     if (UNCServerName == NULL || *UNCServerName == 0)
 400         return CM_Connect_MachineW(NULL, phMachine);
 401
 402     if (CaptureAndConvertAnsiArg(UNCServerName, &pServerNameW))
 403         return CR_INVALID_DATA;
 404
 405     ret = CM_Connect_MachineW(pServerNameW, phMachine);
 406
 407     MyFree(pServerNameW);
 408
 409     return ret;
 410 }
 411
 412
 413 /***********************************************************************
 414  * CM_Connect_MachineW [SETUPAPI.@]
 415  */
 416 CONFIGRET WINAPI CM_Connect_MachineW(
 417     PCWSTR UNCServerName, PHMACHINE phMachine)
 418 {
 419     PMACHINE_INFO pMachine;
 420
 421     TRACE("%s %p\n", debugstr_w(UNCServerName), phMachine);
 422
 423     if (phMachine == NULL)
 424         return CR_INVALID_POINTER;
 425
 426     *phMachine = NULL;
 427
 428     pMachine = HeapAlloc(GetProcessHeap(), 0, sizeof(MACHINE_INFO));
 429     if (pMachine == NULL)
 430         return CR_OUT_OF_MEMORY;
 431
 432     if (UNCServerName == NULL || *UNCServerName == 0)
 433     {
 434         pMachine->bLocal = TRUE;
 435
 436         /* FIXME: store the computers name in pMachine->szMachineName */
 437
 438         if (!PnpGetLocalHandles(&pMachine->BindingHandle,
 439                                 &pMachine->StringTable))
 440         {
 441             HeapFree(GetProcessHeap(), 0, pMachine);
 442             return CR_FAILURE;
 443         }
 444     }
 445     else
 446     {
 447         pMachine->bLocal = FALSE;
 448         if (wcslen(UNCServerName) >= SP_MAX_MACHINENAME_LENGTH - 1)
 449         {
 450             HeapFree(GetProcessHeap(), 0, pMachine);
 451             return CR_INVALID_MACHINENAME;
 452         }
 453         lstrcpyW(pMachine->szMachineName, UNCServerName);
 454
 455         pMachine->StringTable = StringTableInitialize();
 456         if (pMachine->StringTable == NULL)
 457         {
 458             HeapFree(GetProcessHeap(), 0, pMachine);
 459             return CR_FAILURE;
 460         }
 461
 462         StringTableAddString(pMachine->StringTable, L"PLT", 1);
 463
 464         if (!PnpBindRpc(UNCServerName, &pMachine->BindingHandle))
 465         {
 466             StringTableDestroy(pMachine->StringTable);
 467             HeapFree(GetProcessHeap(), 0, pMachine);
 468             return CR_INVALID_MACHINENAME;
 469         }
 470     }
 471
 472     phMachine = (PHMACHINE)pMachine;
 473
 474     return CR_SUCCESS;
 475 }
 476
 477
 478 /***********************************************************************
 479  * CM_Create_DevNodeA [SETUPAPI.@]
 480  */
 481 CONFIGRET WINAPI CM_Create_DevNodeA(
 482     PDEVINST pdnDevInst, DEVINSTID_A pDeviceID, DEVINST dnParent,
 483     ULONG ulFlags)
 484 {
 485     TRACE("%p %s %p %lx\n",
 486           pdnDevInst, debugstr_a(pDeviceID), dnParent, ulFlags);
 487     return CM_Create_DevNode_ExA(pdnDevInst, pDeviceID, dnParent,
 488                                  ulFlags, NULL);
 489 }
 490
 491
 492 /***********************************************************************
 493  * CM_Create_DevNodeW [SETUPAPI.@]
 494  */
 495 CONFIGRET WINAPI CM_Create_DevNodeW(
 496     PDEVINST pdnDevInst, DEVINSTID_W pDeviceID, DEVINST dnParent,
 497     ULONG ulFlags)
 498 {
 499     TRACE("%p %s %p %lx\n",
 500           pdnDevInst, debugstr_w(pDeviceID), dnParent, ulFlags);
 501     return CM_Create_DevNode_ExW(pdnDevInst, pDeviceID, dnParent,
 502                                  ulFlags, NULL);
 503 }
 504
 505
 506 /***********************************************************************
 507  * CM_Create_DevNode_ExA [SETUPAPI.@]
 508  */
 509 CONFIGRET WINAPI CM_Create_DevNode_ExA(
 510     PDEVINST pdnDevInst, DEVINSTID_A pDeviceID, DEVINST dnParent,
 511     ULONG ulFlags, HANDLE hMachine)
 512 {
 513     DEVINSTID_W pDeviceIDW;
 514     CONFIGRET ret;
 515
 516     TRACE("%p %s %p %lx %p\n",
 517           pdnDevInst, debugstr_a(pDeviceID), dnParent, ulFlags, hMachine);
 518
 519     if (CaptureAndConvertAnsiArg(pDeviceID, &pDeviceIDW))
 520         return CR_INVALID_DATA;
 521
 522     ret = CM_Create_DevNode_ExW(pdnDevInst, pDeviceIDW, dnParent, ulFlags,
 523                                 hMachine);
 524
 525     MyFree(pDeviceIDW);
 526
 527     return ret;
 528 }
 529
 530
 531 /***********************************************************************
 532  * CM_Create_DevNode_ExW [SETUPAPI.@]
 533  */
 534 CONFIGRET WINAPI CM_Create_DevNode_ExW(
 535     PDEVINST pdnDevInst, DEVINSTID_W pDeviceID, DEVINST dnParent,
 536     ULONG ulFlags, HANDLE hMachine)
 537 {
 538     RPC_BINDING_HANDLE BindingHandle = NULL;
 539     HSTRING_TABLE StringTable = NULL;
 540     LPWSTR lpParentDevInst;
 541     CONFIGRET ret = CR_SUCCESS;
 542
 543     FIXME("%p %s %p %lx %p\n",
 544           pdnDevInst, debugstr_w(pDeviceID), dnParent, ulFlags, hMachine);
 545
 546     if (!IsUserAdmin())
 547         return CR_ACCESS_DENIED;
 548
 549     if (pdnDevInst == NULL)
 550         return CR_INVALID_POINTER;
 551
 552     if (pDeviceID == NULL || wcslen(pDeviceID) == 0)
 553         return CR_INVALID_DEVICE_ID;
 554
 555     if (dnParent == 0)
 556         return CR_INVALID_DEVNODE;
 557
 558     if (ulFlags & ~CM_CREATE_DEVNODE_BITS)
 559         return CR_INVALID_FLAG;
 560
 561     if (hMachine != NULL)
 562     {
 563         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
 564         if (BindingHandle == NULL)
 565             return CR_FAILURE;
 566
 567         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
 568         if (StringTable == 0)
 569             return CR_FAILURE;
 570     }
 571     else
 572     {
 573         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
 574             return CR_FAILURE;
 575     }
 576
 577     lpParentDevInst = StringTableStringFromId(StringTable, dnParent);
 578     if (lpParentDevInst == NULL)
 579         return CR_INVALID_DEVNODE;
 580
 581     RpcTryExcept
 582     {
 583         ret = PNP_CreateDevInst(BindingHandle,
 584                                 pDeviceID,
 585                                 lpParentDevInst,
 586                                 MAX_DEVICE_ID_LEN,
 587                                 ulFlags);
 588     }
 589     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 590     {
 591         ret = RpcStatusToCmStatus(RpcExceptionCode());
 592     }
 593     RpcEndExcept;
 594
 595     if (ret == CR_SUCCESS)
 596     {
 597         *pdnDevInst = StringTableAddString(StringTable, pDeviceID, 1);
 598         if (*pdnDevInst == 0)
 599             ret = CR_NO_SUCH_DEVNODE;
 600     }
 601
 602     return ret;
 603 }
 604
 605
 606 /***********************************************************************
 607  * CM_Delete_Class_Key [SETUPAPI.@]
 608  */
 609 CONFIGRET WINAPI CM_Delete_Class_Key(
 610     LPGUID ClassGuid, ULONG ulFlags)
 611 {
 612     TRACE("%p %lx\n", ClassGuid, ulFlags);
 613     return CM_Delete_Class_Key_Ex(ClassGuid, ulFlags, NULL);
 614 }
 615
 616
 617 /***********************************************************************
 618  * CM_Delete_Class_Key_Ex [SETUPAPI.@]
 619  */
 620 CONFIGRET WINAPI CM_Delete_Class_Key_Ex(
 621     LPGUID ClassGuid, ULONG ulFlags, HANDLE hMachine)
 622 {
 623     WCHAR szGuidString[MAX_GUID_STRING_LEN];
 624     RPC_BINDING_HANDLE BindingHandle = NULL;
 625     CONFIGRET ret;
 626
 627     TRACE("%p %lx %lx\n", ClassGuid, ulFlags, hMachine);
 628
 629     if (ClassGuid == NULL)
 630         return CR_INVALID_POINTER;
 631
 632     if (ulFlags & ~CM_DELETE_CLASS_BITS)
 633         return CR_INVALID_FLAG;
 634
 635     if (!GuidToString(ClassGuid, szGuidString))
 636         return CR_INVALID_DATA;
 637
 638     if (hMachine != NULL)
 639     {
 640         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
 641         if (BindingHandle == NULL)
 642             return CR_FAILURE;
 643     }
 644     else
 645     {
 646         if (!PnpGetLocalHandles(&BindingHandle, NULL))
 647             return CR_FAILURE;
 648     }
 649
 650     RpcTryExcept
 651     {
 652         ret = PNP_DeleteClassKey(BindingHandle,
 653                                  szGuidString,
 654                                  ulFlags);
 655     }
 656     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 657     {
 658         ret = RpcStatusToCmStatus(RpcExceptionCode());
 659     }
 660     RpcEndExcept;
 661
 662     return ret;
 663 }
 664
 665
 666 /***********************************************************************
 667  * CM_Delete_DevNode_Key [SETUPAPI.@]
 668  */
 669 CONFIGRET WINAPI CM_Delete_DevNode_Key(
 670     DEVNODE dnDevNode, ULONG ulHardwareProfile, ULONG ulFlags)
 671 {
 672     TRACE("%p %lu %lx\n", dnDevNode, ulHardwareProfile, ulFlags);
 673     return CM_Delete_DevNode_Key_Ex(dnDevNode, ulHardwareProfile, ulFlags,
 674                                     NULL);
 675 }
 676
 677
 678 /***********************************************************************
 679  * CM_Delete_DevNode_Key_Ex [SETUPAPI.@]
 680  */
 681 CONFIGRET WINAPI CM_Delete_DevNode_Key_Ex(
 682     DEVNODE dnDevNode, ULONG ulHardwareProfile, ULONG ulFlags,
 683     HANDLE hMachine)
 684 {
 685     FIXME("%p %lu %lx %p\n",
 686           dnDevNode, ulHardwareProfile, ulFlags, hMachine);
 687
 688     return CR_CALL_NOT_IMPLEMENTED;
 689 }
 690
 691
 692 /***********************************************************************
 693  * CM_Disable_DevNode [SETUPAPI.@]
 694  */
 695 CONFIGRET WINAPI CM_Disable_DevNode(
 696     DEVINST dnDevInst, ULONG ulFlags)
 697 {
 698     TRACE("%p %lx\n", dnDevInst, ulFlags);
 699     return CM_Disable_DevNode_Ex(dnDevInst, ulFlags, NULL);
 700 }
 701
 702
 703 /***********************************************************************
 704  * CM_Disable_DevNode_Ex [SETUPAPI.@]
 705  */
 706 CONFIGRET WINAPI CM_Disable_DevNode_Ex(
 707     DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
 708 {
 709     RPC_BINDING_HANDLE BindingHandle = NULL;
 710     HSTRING_TABLE StringTable = NULL;
 711     LPWSTR lpDevInst;
 712     CONFIGRET ret;
 713
 714     FIXME("%p %lx %p\n", dnDevInst, ulFlags, hMachine);
 715
 716     if (!IsUserAdmin())
 717         return CR_ACCESS_DENIED;
 718
 719     if (dnDevInst == 0)
 720         return CR_INVALID_DEVINST;
 721
 722     if (ulFlags != 0)
 723         return CR_INVALID_FLAG;
 724
 725     if (hMachine != NULL)
 726     {
 727         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
 728         if (BindingHandle == NULL)
 729             return CR_FAILURE;
 730
 731         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
 732         if (StringTable == 0)
 733             return CR_FAILURE;
 734     }
 735     else
 736     {
 737         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
 738             return CR_FAILURE;
 739     }
 740
 741     lpDevInst = StringTableStringFromId(StringTable, dnDevInst);
 742     if (lpDevInst == NULL)
 743         return CR_INVALID_DEVNODE;
 744
 745     RpcTryExcept
 746     {
 747         ret = PNP_DeviceInstanceAction(BindingHandle,
 748                                        PNP_DEVINST_DISABLE,
 749                                        ulFlags,
 750                                        lpDevInst,
 751                                        NULL);
 752     }
 753     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 754     {
 755         ret = RpcStatusToCmStatus(RpcExceptionCode());
 756     }
 757     RpcEndExcept;
 758
 759     return ret;
 760 }
 761
 762
 763 /***********************************************************************
 764  * CM_Disconnect_Machine [SETUPAPI.@]
 765  */
 766 CONFIGRET WINAPI CM_Disconnect_Machine(HMACHINE hMachine)
 767 {
 768     PMACHINE_INFO pMachine;
 769
 770     TRACE("%lx\n", hMachine);
 771
 772     pMachine = (PMACHINE_INFO)hMachine;
 773     if (pMachine == NULL)
 774         return CR_SUCCESS;
 775
 776     if (pMachine->bLocal == FALSE)
 777     {
 778         if (pMachine->StringTable != NULL)
 779             StringTableDestroy(pMachine->StringTable);
 780
 781         if (!PnpUnbindRpc(pMachine->BindingHandle))
 782             return CR_ACCESS_DENIED;
 783     }
 784
 785     HeapFree(GetProcessHeap(), 0, pMachine);
 786
 787     return CR_SUCCESS;
 788 }
 789
 790
 791 /***********************************************************************
 792  * CM_Enable_DevNode [SETUPAPI.@]
 793  */
 794 CONFIGRET WINAPI CM_Enable_DevNode(
 795     DEVINST dnDevInst, ULONG ulFlags)
 796 {
 797     TRACE("%p %lx\n", dnDevInst, ulFlags);
 798     return CM_Enable_DevNode_Ex(dnDevInst, ulFlags, NULL);
 799 }
 800
 801
 802 /***********************************************************************
 803  * CM_Enable_DevNode_Ex [SETUPAPI.@]
 804  */
 805 CONFIGRET WINAPI CM_Enable_DevNode_Ex(
 806     DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
 807 {
 808     RPC_BINDING_HANDLE BindingHandle = NULL;
 809     HSTRING_TABLE StringTable = NULL;
 810     LPWSTR lpDevInst;
 811     CONFIGRET ret;
 812
 813     TRACE("%p %lx %p\n", dnDevInst, ulFlags, hMachine);
 814
 815     if (!IsUserAdmin())
 816         return CR_ACCESS_DENIED;
 817
 818     if (dnDevInst == 0)
 819         return CR_INVALID_DEVINST;
 820
 821     if (ulFlags != 0)
 822         return CR_INVALID_FLAG;
 823
 824     if (hMachine != NULL)
 825     {
 826         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
 827         if (BindingHandle == NULL)
 828             return CR_FAILURE;
 829
 830         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
 831         if (StringTable == 0)
 832             return CR_FAILURE;
 833     }
 834     else
 835     {
 836         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
 837             return CR_FAILURE;
 838     }
 839
 840     lpDevInst = StringTableStringFromId(StringTable, dnDevInst);
 841     if (lpDevInst == NULL)
 842         return CR_INVALID_DEVNODE;
 843
 844     RpcTryExcept
 845     {
 846         ret = PNP_DeviceInstanceAction(BindingHandle,
 847                                        PNP_DEVINST_ENABLE,
 848                                        ulFlags,
 849                                        lpDevInst,
 850                                        NULL);
 851     }
 852     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 853     {
 854         ret = RpcStatusToCmStatus(RpcExceptionCode());
 855     }
 856     RpcEndExcept;
 857
 858     return ret;
 859 }
 860
 861
 862 /***********************************************************************
 863  * CM_Enumerate_Classes [SETUPAPI.@]
 864  */
 865 CONFIGRET WINAPI CM_Enumerate_Classes(
 866     ULONG ulClassIndex, LPGUID ClassGuid, ULONG ulFlags)
 867 {
 868     TRACE("%lx %p %lx\n", ulClassIndex, ClassGuid, ulFlags);
 869     return CM_Enumerate_Classes_Ex(ulClassIndex, ClassGuid, ulFlags, NULL);
 870 }
 871
 872
 873 /***********************************************************************
 874  * CM_Enumerate_Classes_Ex [SETUPAPI.@]
 875  */
 876 CONFIGRET WINAPI CM_Enumerate_Classes_Ex(
 877     ULONG ulClassIndex, LPGUID ClassGuid, ULONG ulFlags, HMACHINE hMachine)
 878 {
 879     WCHAR szBuffer[MAX_GUID_STRING_LEN];
 880     RPC_BINDING_HANDLE BindingHandle = NULL;
 881     CONFIGRET ret = CR_SUCCESS;
 882     ULONG ulLength = MAX_GUID_STRING_LEN;
 883
 884     TRACE("%lx %p %lx %p\n", ulClassIndex, ClassGuid, ulFlags, hMachine);
 885
 886     if (ClassGuid == NULL)
 887         return CR_INVALID_POINTER;
 888
 889     if (ulFlags != 0)
 890         return CR_INVALID_FLAG;
 891
 892     if (hMachine != NULL)
 893     {
 894         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
 895         if (BindingHandle == NULL)
 896             return CR_FAILURE;
 897     }
 898     else
 899     {
 900         if (!PnpGetLocalHandles(&BindingHandle, NULL))
 901             return CR_FAILURE;
 902     }
 903
 904     RpcTryExcept
 905     {
 906         ret = PNP_EnumerateSubKeys(BindingHandle,
 907                                    PNP_CLASS_SUBKEYS,
 908                                    ulClassIndex,
 909                                    szBuffer,
 910                                    MAX_GUID_STRING_LEN,
 911                                    &ulLength,
 912                                    ulFlags);
 913     }
 914     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 915     {
 916         ret = RpcStatusToCmStatus(RpcExceptionCode());
 917     }
 918     RpcEndExcept;
 919
 920     if (ret == CR_SUCCESS)
 921     {
 922         /* Remove the {} */
 923         szBuffer[MAX_GUID_STRING_LEN - 2] = UNICODE_NULL;
 924
 925         /* Convert the buffer to a GUID */
 926         if (UuidFromStringW(&szBuffer[1], ClassGuid) != RPC_S_OK)
 927             return CR_FAILURE;
 928     }
 929
 930     return ret;
 931 }
 932
 933
 934 /***********************************************************************
 935  * CM_Enumerate_EnumeratorsA [SETUPAPI.@]
 936  */
 937 CONFIGRET WINAPI CM_Enumerate_EnumeratorsA(
 938     ULONG ulEnumIndex, PCHAR Buffer, PULONG pulLength, ULONG ulFlags)
 939 {
 940     TRACE("%lu %p %p %lx\n", ulEnumIndex, Buffer, pulLength, ulFlags);
 941     return CM_Enumerate_Enumerators_ExA(ulEnumIndex, Buffer, pulLength,
 942                                         ulFlags, NULL);
 943 }
 944
 945
 946 /***********************************************************************
 947  * CM_Enumerate_EnumeratorsW [SETUPAPI.@]
 948  */
 949 CONFIGRET WINAPI CM_Enumerate_EnumeratorsW(
 950     ULONG ulEnumIndex, PWCHAR Buffer, PULONG pulLength, ULONG ulFlags)
 951 {
 952     TRACE("%lu %p %p %lx\n", ulEnumIndex, Buffer, pulLength, ulFlags);
 953     return CM_Enumerate_Enumerators_ExW(ulEnumIndex, Buffer, pulLength,
 954                                         ulFlags, NULL);
 955 }
 956
 957
 958 /***********************************************************************
 959  * CM_Enumerate_Enumerators_ExA [SETUPAPI.@]
 960  */
 961 CONFIGRET WINAPI CM_Enumerate_Enumerators_ExA(
 962     ULONG ulEnumIndex, PCHAR Buffer, PULONG pulLength, ULONG ulFlags,
 963     HMACHINE hMachine)
 964 {
 965     WCHAR szBuffer[MAX_DEVICE_ID_LEN];
 966     ULONG ulOrigLength;
 967     ULONG ulLength;
 968     CONFIGRET ret = CR_SUCCESS;
 969
 970     TRACE("%lu %p %p %lx %lx\n", ulEnumIndex, Buffer, pulLength, ulFlags,
 971           hMachine);
 972
 973     if (Buffer == NULL || pulLength == NULL)
 974         return CR_INVALID_POINTER;
 975
 976     if (ulFlags != 0)
 977         return CR_INVALID_FLAG;
 978
 979     ulOrigLength = *pulLength;
 980     *pulLength = 0;
 981
 982     ulLength = MAX_DEVICE_ID_LEN;
 983     ret = CM_Enumerate_Enumerators_ExW(ulEnumIndex, szBuffer, &ulLength,
 984                                        ulFlags, hMachine);
 985     if (ret == CR_SUCCESS)
 986     {
 987         if (WideCharToMultiByte(CP_ACP,
 988                                 0,
 989                                 szBuffer,
 990                                 ulLength,
 991                                 Buffer,
 992                                 ulOrigLength,
 993                                 NULL,
 994                                 NULL) == 0)
 995             ret = CR_FAILURE;
 996         else
 997             *pulLength = lstrlenA(Buffer) + 1;
 998     }
 999
1000     return ret;
1001 }
1002
1003
1004 /***********************************************************************
1005  * CM_Enumerate_Enumerators_ExW [SETUPAPI.@]
1006  */
1007 CONFIGRET WINAPI CM_Enumerate_Enumerators_ExW(
1008     ULONG ulEnumIndex, PWCHAR Buffer, PULONG pulLength, ULONG ulFlags,
1009     HMACHINE hMachine)
1010 {
1011     RPC_BINDING_HANDLE BindingHandle = NULL;
1012     CONFIGRET ret;
1013
1014     TRACE("%lu %p %p %lx %lx\n", ulEnumIndex, Buffer, pulLength, ulFlags,
1015           hMachine);
1016
1017     if (Buffer == NULL || pulLength == NULL)
1018         return CR_INVALID_POINTER;
1019
1020     if (ulFlags != 0)
1021         return CR_INVALID_FLAG;
1022
1023     *Buffer = UNICODE_NULL;
1024
1025     if (hMachine != NULL)
1026     {
1027         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1028         if (BindingHandle == NULL)
1029             return CR_FAILURE;
1030     }
1031     else
1032     {
1033         if (!PnpGetLocalHandles(&BindingHandle, NULL))
1034             return CR_FAILURE;
1035     }
1036
1037     RpcTryExcept
1038     {
1039         ret = PNP_EnumerateSubKeys(BindingHandle,
1040                                    PNP_ENUMERATOR_SUBKEYS,
1041                                    ulEnumIndex,
1042                                    Buffer,
1043                                    *pulLength,
1044                                    pulLength,
1045                                    ulFlags);
1046     }
1047     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1048     {
1049         ret = RpcStatusToCmStatus(RpcExceptionCode());
1050     }
1051     RpcEndExcept;
1052
1053     return ret;
1054 }
1055
1056
1057 /***********************************************************************
1058  * CM_Free_Log_Conf [SETUPAPI.@]
1059  */
1060 CONFIGRET WINAPI CM_Free_Log_Conf(
1061     LOG_CONF lcLogConfToBeFreed, ULONG ulFlags)
1062 {
1063     TRACE("%lx %lx\n", lcLogConfToBeFreed, ulFlags);
1064     return CM_Free_Log_Conf_Ex(lcLogConfToBeFreed, ulFlags, NULL);
1065 }
1066
1067
1068 /***********************************************************************
1069  * CM_Free_Log_Conf_Ex [SETUPAPI.@]
1070  */
1071 CONFIGRET WINAPI CM_Free_Log_Conf_Ex(
1072     LOG_CONF lcLogConfToBeFreed, ULONG ulFlags, HMACHINE hMachine)
1073 {
1074     RPC_BINDING_HANDLE BindingHandle = NULL;
1075     HSTRING_TABLE StringTable = NULL;
1076     LPWSTR lpDevInst;
1077     PLOG_CONF_INFO pLogConfInfo;
1078     CONFIGRET ret;
1079
1080     TRACE("%lx %lx %lx\n", lcLogConfToBeFreed, ulFlags, hMachine);
1081
1082     if (!IsUserAdmin())
1083         return CR_ACCESS_DENIED;
1084
1085     pLogConfInfo = (PLOG_CONF_INFO)lcLogConfToBeFreed;
1086     if (pLogConfInfo == NULL || pLogConfInfo->ulMagic != LOG_CONF_MAGIC)
1087         return CR_INVALID_LOG_CONF;
1088
1089     if (ulFlags != 0)
1090         return CR_INVALID_FLAG;
1091
1092     if (hMachine != NULL)
1093     {
1094         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1095         if (BindingHandle == NULL)
1096             return CR_FAILURE;
1097
1098         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1099         if (StringTable == 0)
1100             return CR_FAILURE;
1101     }
1102     else
1103     {
1104         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
1105             return CR_FAILURE;
1106     }
1107
1108     lpDevInst = StringTableStringFromId(StringTable, pLogConfInfo->dnDevInst);
1109     if (lpDevInst == NULL)
1110         return CR_INVALID_DEVNODE;
1111
1112     RpcTryExcept
1113     {
1114         ret = PNP_FreeLogConf(BindingHandle, lpDevInst, pLogConfInfo->ulFlags,
1115                               pLogConfInfo->ulTag, 0);
1116     }
1117     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1118     {
1119         ret = RpcStatusToCmStatus(RpcExceptionCode());
1120     }
1121     RpcEndExcept;
1122
1123     return ret;
1124 }
1125
1126
1127 /***********************************************************************
1128  * CM_Free_Log_Conf_Handle [SETUPAPI.@]
1129  */
1130 CONFIGRET WINAPI CM_Free_Log_Conf_Handle(
1131     LOG_CONF lcLogConf)
1132 {
1133     PLOG_CONF_INFO pLogConfInfo;
1134
1135     TRACE("%lx\n", lcLogConf);
1136
1137     pLogConfInfo = (PLOG_CONF_INFO)lcLogConf;
1138     if (pLogConfInfo == NULL || pLogConfInfo->ulMagic != LOG_CONF_MAGIC)
1139         return CR_INVALID_LOG_CONF;
1140
1141     HeapFree(GetProcessHeap(), 0, pLogConfInfo);
1142
1143     return CR_SUCCESS;
1144 }
1145
1146
1147 /***********************************************************************
1148  * CM_Get_Child [SETUPAPI.@]
1149  */
1150 CONFIGRET WINAPI CM_Get_Child(
1151     PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags)
1152 {
1153     TRACE("%p %p %lx\n", pdnDevInst, dnDevInst, ulFlags);
1154     return CM_Get_Child_Ex(pdnDevInst, dnDevInst, ulFlags, NULL);
1155 }
1156
1157
1158 /***********************************************************************
1159  * CM_Get_Child_Ex [SETUPAPI.@]
1160  */
1161 CONFIGRET WINAPI CM_Get_Child_Ex(
1162     PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
1163 {
1164     WCHAR szRelatedDevInst[MAX_DEVICE_ID_LEN];
1165     RPC_BINDING_HANDLE BindingHandle = NULL;
1166     HSTRING_TABLE StringTable = NULL;
1167     LPWSTR lpDevInst;
1168     DWORD dwIndex, dwLength = MAX_DEVICE_ID_LEN;
1169     CONFIGRET ret;
1170
1171     TRACE("%p %lx %lx %lx\n", pdnDevInst, dnDevInst, ulFlags, hMachine);
1172
1173     if (pdnDevInst == NULL)
1174         return CR_INVALID_POINTER;
1175
1176     if (dnDevInst == 0)
1177         return CR_INVALID_DEVINST;
1178
1179     if (ulFlags != 0)
1180         return CR_INVALID_FLAG;
1181
1182     *pdnDevInst = -1;
1183
1184     if (hMachine != NULL)
1185     {
1186         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1187         if (BindingHandle == NULL)
1188             return CR_FAILURE;
1189
1190         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1191         if (StringTable == 0)
1192             return CR_FAILURE;
1193     }
1194     else
1195     {
1196         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
1197             return CR_FAILURE;
1198     }
1199
1200     lpDevInst = StringTableStringFromId(StringTable, dnDevInst);
1201     if (lpDevInst == NULL)
1202         return CR_INVALID_DEVNODE;
1203
1204     RpcTryExcept
1205     {
1206         ret = PNP_GetRelatedDeviceInstance(BindingHandle,
1207                                            PNP_GET_CHILD_DEVICE_INSTANCE,
1208                                            lpDevInst,
1209                                            szRelatedDevInst,
1210                                            &dwLength,
1211                                            0);
1212     }
1213     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1214     {
1215         ret = RpcStatusToCmStatus(RpcExceptionCode());
1216     }
1217     RpcEndExcept;
1218
1219     if (ret != CR_SUCCESS)
1220         return ret;
1221
1222     TRACE("szRelatedDevInst: %s\n", debugstr_w(szRelatedDevInst));
1223
1224     dwIndex = StringTableAddString(StringTable, szRelatedDevInst, 1);
1225     if (dwIndex == -1)
1226         return CR_FAILURE;
1227
1228     *pdnDevInst = dwIndex;
1229
1230     return CR_SUCCESS;
1231 }
1232
1233
1234 /***********************************************************************
1235  * CM_Get_Class_Key_NameA [SETUPAPI.@]
1236  */
1237 CONFIGRET WINAPI CM_Get_Class_Key_NameA(
1238     LPGUID ClassGuid, LPSTR pszKeyName, PULONG pulLength, ULONG ulFlags)
1239 {
1240     TRACE("%p %p %p %lx\n",
1241           ClassGuid, pszKeyName, pulLength, ulFlags);
1242     return CM_Get_Class_Key_Name_ExA(ClassGuid, pszKeyName, pulLength,
1243                                      ulFlags, NULL);
1244 }
1245
1246
1247 /***********************************************************************
1248  * CM_Get_Class_Key_NameW [SETUPAPI.@]
1249  */
1250 CONFIGRET WINAPI CM_Get_Class_Key_NameW(
1251     LPGUID ClassGuid, LPWSTR pszKeyName, PULONG pulLength, ULONG ulFlags)
1252 {
1253     TRACE("%p %p %p %lx\n",
1254           ClassGuid, pszKeyName, pulLength, ulFlags);
1255     return CM_Get_Class_Key_Name_ExW(ClassGuid, pszKeyName, pulLength,
1256                                      ulFlags, NULL);
1257 }
1258
1259
1260 /***********************************************************************
1261  * CM_Get_Class_Key_Name_ExA [SETUPAPI.@]
1262  */
1263 CONFIGRET WINAPI CM_Get_Class_Key_Name_ExA(
1264     LPGUID ClassGuid, LPSTR pszKeyName, PULONG pulLength, ULONG ulFlags,
1265     HMACHINE hMachine)
1266 {
1267     WCHAR szBuffer[MAX_GUID_STRING_LEN];
1268     CONFIGRET ret = CR_SUCCESS;
1269     ULONG ulLength;
1270     ULONG ulOrigLength;
1271
1272     TRACE("%p %p %p %lx %lx\n",
1273           ClassGuid, pszKeyName, pulLength, ulFlags, hMachine);
1274
1275     if (ClassGuid == NULL || pszKeyName == NULL || pulLength == NULL)
1276         return CR_INVALID_POINTER;
1277
1278     ulOrigLength = *pulLength;
1279     *pulLength = 0;
1280
1281     ulLength = MAX_GUID_STRING_LEN;
1282     ret = CM_Get_Class_Key_Name_ExW(ClassGuid, szBuffer, &ulLength,
1283                                     ulFlags, hMachine);
1284     if (ret == CR_SUCCESS)
1285     {
1286         if (WideCharToMultiByte(CP_ACP,
1287                                 0,
1288                                 szBuffer,
1289                                 ulLength,
1290                                 pszKeyName,
1291                                 ulOrigLength,
1292                                 NULL,
1293                                 NULL) == 0)
1294             ret = CR_FAILURE;
1295         else
1296             *pulLength = lstrlenA(pszKeyName) + 1;
1297     }
1298
1299     return CR_SUCCESS;
1300 }
1301
1302
1303 /***********************************************************************
1304  * CM_Get_Class_Key_Name_ExW [SETUPAPI.@]
1305  */
1306 CONFIGRET WINAPI CM_Get_Class_Key_Name_ExW(
1307     LPGUID ClassGuid, LPWSTR pszKeyName, PULONG pulLength, ULONG ulFlags,
1308     HMACHINE hMachine)
1309 {
1310     TRACE("%p %p %p %lx %lx\n",
1311           ClassGuid, pszKeyName, pulLength, ulFlags, hMachine);
1312
1313     if (ClassGuid == NULL || pszKeyName == NULL || pulLength == NULL)
1314         return CR_INVALID_POINTER;
1315
1316     if (ulFlags != 0)
1317         return CR_INVALID_FLAG;
1318
1319     if (*pulLength < MAX_GUID_STRING_LEN)
1320     {
1321         *pulLength = 0;
1322         return CR_BUFFER_SMALL;
1323     }
1324
1325     if (!GuidToString(ClassGuid, pszKeyName))
1326         return CR_INVALID_DATA;
1327
1328     *pulLength = MAX_GUID_STRING_LEN;
1329
1330     return CR_SUCCESS;
1331 }
1332
1333
1334 /***********************************************************************
1335  * CM_Get_Class_NameA [SETUPAPI.@]
1336  */
1337 CONFIGRET WINAPI CM_Get_Class_NameA(
1338     LPGUID ClassGuid, PCHAR Buffer, PULONG pulLength, ULONG ulFlags)
1339 {
1340     TRACE("%p %p %p %lx\n", ClassGuid, Buffer, pulLength, ulFlags);
1341     return CM_Get_Class_Name_ExA(ClassGuid, Buffer, pulLength, ulFlags,
1342                                  NULL);
1343 }
1344
1345
1346 /***********************************************************************
1347  * CM_Get_Class_NameW [SETUPAPI.@]
1348  */
1349 CONFIGRET WINAPI CM_Get_Class_NameW(
1350     LPGUID ClassGuid, PWCHAR Buffer, PULONG pulLength, ULONG ulFlags)
1351 {
1352     TRACE("%p %p %p %lx\n", ClassGuid, Buffer, pulLength, ulFlags);
1353     return CM_Get_Class_Name_ExW(ClassGuid, Buffer, pulLength, ulFlags,
1354                                  NULL);
1355 }
1356
1357
1358 /***********************************************************************
1359  * CM_Get_Class_Name_ExA [SETUPAPI.@]
1360  */
1361 CONFIGRET WINAPI CM_Get_Class_Name_ExA(
1362     LPGUID ClassGuid, PCHAR Buffer, PULONG pulLength, ULONG ulFlags,
1363     HMACHINE hMachine)
1364 {
1365     WCHAR szBuffer[MAX_CLASS_NAME_LEN];
1366     CONFIGRET ret = CR_SUCCESS;
1367     ULONG ulLength;
1368     ULONG ulOrigLength;
1369
1370     TRACE("%p %p %p %lx %lx\n",
1371           ClassGuid, Buffer, pulLength, ulFlags, hMachine);
1372
1373     if (ClassGuid == NULL || Buffer == NULL || pulLength == NULL)
1374         return CR_INVALID_POINTER;
1375
1376     ulOrigLength = *pulLength;
1377     *pulLength = 0;
1378
1379     ulLength = MAX_CLASS_NAME_LEN;
1380     ret = CM_Get_Class_Name_ExW(ClassGuid, szBuffer, &ulLength,
1381                                 ulFlags, hMachine);
1382     if (ret == CR_SUCCESS)
1383     {
1384         if (WideCharToMultiByte(CP_ACP,
1385                                 0,
1386                                 szBuffer,
1387                                 ulLength,
1388                                 Buffer,
1389                                 ulOrigLength,
1390                                 NULL,
1391                                 NULL) == 0)
1392             ret = CR_FAILURE;
1393         else
1394             *pulLength = lstrlenA(Buffer) + 1;
1395     }
1396
1397     return ret;
1398 }
1399
1400
1401 /***********************************************************************
1402  * CM_Get_Class_Name_ExW [SETUPAPI.@]
1403  */
1404 CONFIGRET WINAPI
1405 CM_Get_Class_Name_ExW(
1406     LPGUID ClassGuid, PWCHAR Buffer, PULONG pulLength, ULONG ulFlags,
1407     HMACHINE hMachine)
1408 {
1409     WCHAR szGuidString[MAX_GUID_STRING_LEN];
1410     RPC_BINDING_HANDLE BindingHandle = NULL;
1411     CONFIGRET ret;
1412
1413     TRACE("%p %p %p %lx %lx\n",
1414           ClassGuid, Buffer, pulLength, ulFlags, hMachine);
1415
1416     if (ClassGuid == NULL || Buffer == NULL || pulLength == NULL)
1417         return CR_INVALID_POINTER;
1418
1419     if (ulFlags != 0)
1420         return CR_INVALID_FLAG;
1421
1422     if (!GuidToString(ClassGuid, szGuidString))
1423         return CR_INVALID_DATA;
1424
1425     TRACE("Guid %s\n", debugstr_w(szGuidString));
1426
1427     if (hMachine != NULL)
1428     {
1429         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1430         if (BindingHandle == NULL)
1431             return CR_FAILURE;
1432     }
1433     else
1434     {
1435         if (!PnpGetLocalHandles(&BindingHandle, NULL))
1436             return CR_FAILURE;
1437     }
1438
1439     RpcTryExcept
1440     {
1441         ret = PNP_GetClassName(BindingHandle,
1442                                szGuidString,
1443                                Buffer,
1444                                pulLength,
1445                                ulFlags);
1446     }
1447     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1448     {
1449         ret = RpcStatusToCmStatus(RpcExceptionCode());
1450     }
1451     RpcEndExcept;
1452
1453     return ret;
1454 }
1455
1456
1457 /***********************************************************************
1458  * CM_Get_Depth [SETUPAPI.@]
1459  */
1460 CONFIGRET WINAPI CM_Get_Depth(
1461     PULONG pulDepth, DEVINST dnDevInst, ULONG ulFlags)
1462 {
1463     TRACE("%p %lx %lx\n", pulDepth, dnDevInst, ulFlags);
1464     return CM_Get_Depth_Ex(pulDepth, dnDevInst, ulFlags, NULL);
1465 }
1466
1467
1468 /***********************************************************************
1469  * CM_Get_Depth_Ex [SETUPAPI.@]
1470  */
1471 CONFIGRET WINAPI CM_Get_Depth_Ex(
1472     PULONG pulDepth, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
1473 {
1474     RPC_BINDING_HANDLE BindingHandle = NULL;
1475     HSTRING_TABLE StringTable = NULL;
1476     LPWSTR lpDevInst;
1477     CONFIGRET ret;
1478
1479     TRACE("%p %lx %lx %lx\n",
1480           pulDepth, dnDevInst, ulFlags, hMachine);
1481
1482     if (pulDepth == NULL)
1483         return CR_INVALID_POINTER;
1484
1485     if (dnDevInst == 0)
1486         return CR_INVALID_DEVINST;
1487
1488     if (ulFlags != 0)
1489         return CR_INVALID_FLAG;
1490
1491     if (hMachine != NULL)
1492     {
1493         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1494         if (BindingHandle == NULL)
1495             return CR_FAILURE;
1496
1497         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1498         if (StringTable == 0)
1499             return CR_FAILURE;
1500     }
1501     else
1502     {
1503         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
1504             return CR_FAILURE;
1505     }
1506
1507     lpDevInst = StringTableStringFromId(StringTable, dnDevInst);
1508     if (lpDevInst == NULL)
1509         return CR_INVALID_DEVNODE;
1510
1511     RpcTryExcept
1512     {
1513         ret = PNP_GetDepth(BindingHandle,
1514                            lpDevInst,
1515                            pulDepth,
1516                            ulFlags);
1517     }
1518     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1519     {
1520         ret = RpcStatusToCmStatus(RpcExceptionCode());
1521     }
1522     RpcEndExcept;
1523
1524     return ret;
1525 }
1526
1527
1528 /***********************************************************************
1529  * CM_Get_DevNode_Registry_PropertyA [SETUPAPI.@]
1530  */
1531 CONFIGRET WINAPI CM_Get_DevNode_Registry_PropertyA(
1532     DEVINST dnDevInst, ULONG ulProperty, PULONG pulRegDataType,
1533     PVOID Buffer, PULONG pulLength, ULONG ulFlags)
1534 {
1535     TRACE("%lx %lu %p %p %p %lx\n",
1536           dnDevInst, ulProperty, pulRegDataType, Buffer, pulLength, ulFlags);
1537
1538     return CM_Get_DevNode_Registry_Property_ExA(dnDevInst, ulProperty,
1539                                                 pulRegDataType, Buffer,
1540                                                 pulLength, ulFlags, NULL);
1541 }
1542
1543
1544 /***********************************************************************
1545  * CM_Get_DevNode_Registry_PropertyW [SETUPAPI.@]
1546  */
1547 CONFIGRET WINAPI CM_Get_DevNode_Registry_PropertyW(
1548     DEVINST dnDevInst, ULONG ulProperty, PULONG pulRegDataType,
1549     PVOID Buffer, PULONG pulLength, ULONG ulFlags)
1550 {
1551     TRACE("%lx %lu %p %p %p %lx\n",
1552           dnDevInst, ulProperty, pulRegDataType, Buffer, pulLength, ulFlags);
1553
1554     return CM_Get_DevNode_Registry_Property_ExW(dnDevInst, ulProperty,
1555                                                 pulRegDataType, Buffer,
1556                                                 pulLength, ulFlags, NULL);
1557 }
1558
1559
1560 /***********************************************************************
1561  * CM_Get_DevNode_Registry_Property_ExA [SETUPAPI.@]
1562  */
1563 CONFIGRET WINAPI CM_Get_DevNode_Registry_Property_ExA(
1564     DEVINST dnDevInst, ULONG ulProperty, PULONG pulRegDataType,
1565     PVOID Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine)
1566 {
1567     PVOID BufferW;
1568     ULONG LengthW;
1569     ULONG RegDataType = REG_NONE;
1570     CONFIGRET ret;
1571
1572     TRACE("%lx %lu %p %p %p %lx %lx\n",
1573           dnDevInst, ulProperty, pulRegDataType, Buffer, pulLength,
1574           ulFlags, hMachine);
1575
1576     if (!pulLength)
1577         return CR_INVALID_POINTER;
1578
1579     LengthW = *pulLength * sizeof(WCHAR);
1580     BufferW = HeapAlloc(GetProcessHeap(), 0, LengthW);
1581
1582     if (!BufferW)
1583         return CR_OUT_OF_MEMORY;
1584
1585     ret = CM_Get_DevNode_Registry_Property_ExW(dnDevInst,
1586                                                ulProperty,
1587                                                &RegDataType,
1588                                                BufferW,
1589                                                &LengthW,
1590                                                ulFlags,
1591                                                hMachine);
1592
1593     if (ret == CR_SUCCESS)
1594     {
1595         if (RegDataType == REG_SZ || RegDataType == REG_EXPAND_SZ)
1596         {
1597             /* Do W->A conversion */
1598             *pulLength = WideCharToMultiByte(CP_ACP,
1599                                              0,
1600                                              BufferW,
1601                                              lstrlenW(BufferW) + 1,
1602                                              Buffer,
1603                                              *pulLength,
1604                                              NULL,
1605                                              NULL);
1606             if (*pulLength == 0)
1607                 ret = CR_FAILURE;
1608         }
1609         else
1610         {
1611             /* Directly copy the value */
1612             if (LengthW <= *pulLength)
1613                 memcpy(Buffer, BufferW, LengthW);
1614             else
1615             {
1616                 *pulLength = LengthW;
1617                 ret = CR_BUFFER_SMALL;
1618             }
1619         }
1620     }
1621
1622     if (pulRegDataType)
1623         *pulRegDataType = RegDataType;
1624
1625     HeapFree(GetProcessHeap(), 0, BufferW);
1626
1627     return ret;
1628 }
1629
1630
1631 /***********************************************************************
1632  * CM_Get_DevNode_Registry_Property_ExW [SETUPAPI.@]
1633  */
1634 CONFIGRET WINAPI CM_Get_DevNode_Registry_Property_ExW(
1635     DEVINST dnDevInst, ULONG ulProperty, PULONG pulRegDataType,
1636     PVOID Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine)
1637 {
1638     RPC_BINDING_HANDLE BindingHandle = NULL;
1639     HSTRING_TABLE StringTable = NULL;
1640     CONFIGRET ret = CR_SUCCESS;
1641     LPWSTR lpDevInst;
1642     ULONG ulDataType = 0;
1643     ULONG ulTransferLength = 0;
1644
1645     TRACE("%lx %lu %p %p %p %lx %lx\n",
1646           dnDevInst, ulProperty, pulRegDataType, Buffer, pulLength,
1647           ulFlags, hMachine);
1648
1649     if (dnDevInst == 0)
1650         return CR_INVALID_DEVNODE;
1651
1652     if (ulProperty < CM_DRP_MIN || ulProperty > CM_DRP_MAX)
1653         return CR_INVALID_PROPERTY;
1654
1655     /* pulRegDataType is optional */
1656
1657     /* Buffer is optional */
1658
1659     if (pulLength == NULL)
1660         return CR_INVALID_POINTER;
1661
1662     if (*pulLength == 0)
1663         return CR_INVALID_POINTER;
1664
1665     if (ulFlags != 0)
1666         return CR_INVALID_FLAG;
1667
1668     if (hMachine != NULL)
1669     {
1670         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1671         if (BindingHandle == NULL)
1672             return CR_FAILURE;
1673
1674         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1675         if (StringTable == 0)
1676             return CR_FAILURE;
1677     }
1678     else
1679     {
1680         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
1681             return CR_FAILURE;
1682     }
1683
1684     lpDevInst = StringTableStringFromId(StringTable, dnDevInst);
1685     if (lpDevInst == NULL)
1686         return CR_INVALID_DEVNODE;
1687
1688     ulTransferLength = *pulLength;
1689
1690     RpcTryExcept
1691     {
1692         ret = PNP_GetDeviceRegProp(BindingHandle,
1693                                    lpDevInst,
1694                                    ulProperty,
1695                                    &ulDataType,
1696                                    Buffer,
1697                                    &ulTransferLength,
1698                                    pulLength,
1699                                    ulFlags);
1700     }
1701     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1702     {
1703         ret = RpcStatusToCmStatus(RpcExceptionCode());
1704     }
1705     RpcEndExcept;
1706
1707     if (ret == CR_SUCCESS)
1708     {
1709         if (pulRegDataType != NULL)
1710             *pulRegDataType = ulDataType;
1711     }
1712
1713     return ret;
1714 }
1715
1716
1717 /***********************************************************************
1718  * CM_Get_DevNode_Status [SETUPAPI.@]
1719  */
1720 CONFIGRET WINAPI CM_Get_DevNode_Status(
1721     PULONG pulStatus, PULONG pulProblemNumber, DEVINST dnDevInst,
1722     ULONG ulFlags)
1723 {
1724     TRACE("%p %p %lx %lx\n",
1725           pulStatus, pulProblemNumber, dnDevInst, ulFlags);
1726     return CM_Get_DevNode_Status_Ex(pulStatus, pulProblemNumber, dnDevInst,
1727                                     ulFlags, NULL);
1728 }
1729
1730
1731 /***********************************************************************
1732  * CM_Get_DevNode_Status_Ex [SETUPAPI.@]
1733  */
1734 CONFIGRET WINAPI
1735 CM_Get_DevNode_Status_Ex(
1736     PULONG pulStatus, PULONG pulProblemNumber, DEVINST dnDevInst,
1737     ULONG ulFlags, HMACHINE hMachine)
1738 {
1739     RPC_BINDING_HANDLE BindingHandle = NULL;
1740     HSTRING_TABLE StringTable = NULL;
1741     LPWSTR lpDevInst;
1742     CONFIGRET ret;
1743
1744     TRACE("%p %p %lx %lx %lx\n",
1745           pulStatus, pulProblemNumber, dnDevInst, ulFlags, hMachine);
1746
1747     if (pulStatus == NULL || pulProblemNumber == NULL)
1748         return CR_INVALID_POINTER;
1749
1750     if (dnDevInst == 0)
1751         return CR_INVALID_DEVINST;
1752
1753     if (ulFlags != 0)
1754         return CR_INVALID_FLAG;
1755
1756     if (hMachine != NULL)
1757     {
1758         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1759         if (BindingHandle == NULL)
1760             return CR_FAILURE;
1761
1762         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1763         if (StringTable == 0)
1764             return CR_FAILURE;
1765     }
1766     else
1767     {
1768         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
1769             return CR_FAILURE;
1770     }
1771
1772     lpDevInst = StringTableStringFromId(StringTable, dnDevInst);
1773     if (lpDevInst == NULL)
1774         return CR_INVALID_DEVNODE;
1775
1776     RpcTryExcept
1777     {
1778         ret = PNP_GetDeviceStatus(BindingHandle,
1779                                   lpDevInst,
1780                                   pulStatus,
1781                                   pulProblemNumber,
1782                                   ulFlags);
1783     }
1784     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1785     {
1786         ret = RpcStatusToCmStatus(RpcExceptionCode());
1787     }
1788     RpcEndExcept;
1789
1790     return ret;
1791 }
1792
1793
1794 /***********************************************************************
1795  * CM_Get_Device_IDA [SETUPAPI.@]
1796  */
1797 CONFIGRET WINAPI CM_Get_Device_IDA(
1798     DEVINST dnDevInst, PCHAR Buffer, ULONG BufferLen, ULONG ulFlags)
1799 {
1800     TRACE("%lx %p %ld %ld\n",
1801           dnDevInst, Buffer, BufferLen, ulFlags);
1802     return CM_Get_Device_ID_ExA(dnDevInst, Buffer, BufferLen, ulFlags, NULL);
1803 }
1804
1805
1806 /***********************************************************************
1807  * CM_Get_Device_IDW [SETUPAPI.@]
1808  */
1809 CONFIGRET WINAPI CM_Get_Device_IDW(
1810     DEVINST dnDevInst, PWCHAR Buffer, ULONG BufferLen, ULONG ulFlags)
1811 {
1812     TRACE("%lx %p %ld %ld\n",
1813           dnDevInst, Buffer, BufferLen, ulFlags);
1814     return CM_Get_Device_ID_ExW(dnDevInst, Buffer, BufferLen, ulFlags, NULL);
1815 }
1816
1817
1818 /***********************************************************************
1819  * CM_Get_Device_ID_ExA [SETUPAPI.@]
1820  */
1821 CONFIGRET WINAPI CM_Get_Device_ID_ExA(
1822     DEVINST dnDevInst, PCHAR Buffer, ULONG BufferLen, ULONG ulFlags,
1823     HMACHINE hMachine)
1824 {
1825     WCHAR szBufferW[MAX_DEVICE_ID_LEN];
1826     CONFIGRET ret = CR_SUCCESS;
1827
1828     FIXME("%lx %p %ld %ld %lx\n",
1829           dnDevInst, Buffer, BufferLen, ulFlags, hMachine);
1830
1831     if (Buffer == NULL)
1832         return CR_INVALID_POINTER;
1833
1834     ret = CM_Get_Device_ID_ExW(dnDevInst,
1835                                szBufferW,
1836                                MAX_DEVICE_ID_LEN,
1837                                ulFlags,
1838                                hMachine);
1839     if (ret == CR_SUCCESS)
1840     {
1841         if (WideCharToMultiByte(CP_ACP,
1842                                 0,
1843                                 szBufferW,
1844                                 lstrlenW(szBufferW) + 1,
1845                                 Buffer,
1846                                 BufferLen,
1847                                 NULL,
1848                                 NULL) == 0)
1849             ret = CR_FAILURE;
1850     }
1851
1852     return ret;
1853 }
1854
1855
1856 /***********************************************************************
1857  * CM_Get_Device_ID_ExW [SETUPAPI.@]
1858  */
1859 CONFIGRET WINAPI CM_Get_Device_ID_ExW(
1860     DEVINST dnDevInst, PWCHAR Buffer, ULONG BufferLen, ULONG ulFlags,
1861     HMACHINE hMachine)
1862 {
1863     HSTRING_TABLE StringTable = NULL;
1864
1865     TRACE("%lx %p %ld %ld %lx\n",
1866           dnDevInst, Buffer, BufferLen, ulFlags, hMachine);
1867
1868     if (dnDevInst == 0)
1869         return CR_INVALID_DEVINST;
1870
1871     if (Buffer == NULL)
1872         return CR_INVALID_POINTER;
1873
1874     if (ulFlags != 0)
1875         return CR_INVALID_FLAG;
1876
1877     if (hMachine != NULL)
1878     {
1879         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1880         if (StringTable == NULL)
1881             return CR_FAILURE;
1882     }
1883     else
1884     {
1885         if (!PnpGetLocalHandles(NULL, &StringTable))
1886             return CR_FAILURE;
1887     }
1888
1889     if (!StringTableStringFromIdEx(StringTable,
1890                                    dnDevInst,
1891                                    Buffer,
1892                                    &BufferLen))
1893         return CR_FAILURE;
1894
1895     return CR_SUCCESS;
1896 }
1897
1898
1899 /***********************************************************************
1900  * CM_Get_Device_ID_ListA [SETUPAPI.@]
1901  */
1902 CONFIGRET WINAPI CM_Get_Device_ID_ListA(
1903     PCSTR pszFilter, PCHAR Buffer, ULONG BufferLen, ULONG ulFlags)
1904 {
1905     TRACE("%p %p %ld %ld\n", pszFilter, Buffer, BufferLen, ulFlags);
1906     return CM_Get_Device_ID_List_ExA(pszFilter, Buffer, BufferLen,
1907                                      ulFlags, NULL);
1908 }
1909
1910
1911 /***********************************************************************
1912  * CM_Get_Device_ID_ListW [SETUPAPI.@]
1913  */
1914 CONFIGRET WINAPI CM_Get_Device_ID_ListW(
1915     PCWSTR pszFilter, PWCHAR Buffer, ULONG BufferLen, ULONG ulFlags)
1916 {
1917     TRACE("%p %p %ld %ld\n", pszFilter, Buffer, BufferLen, ulFlags);
1918     return CM_Get_Device_ID_List_ExW(pszFilter, Buffer, BufferLen,
1919                                      ulFlags, NULL);
1920 }
1921
1922
1923 /***********************************************************************
1924  * CM_Get_Device_ID_List_ExA [SETUPAPI.@]
1925  */
1926 CONFIGRET WINAPI CM_Get_Device_ID_List_ExA(
1927     PCSTR pszFilter, PCHAR Buffer, ULONG BufferLen, ULONG ulFlags,
1928     HMACHINE hMachine)
1929 {
1930     LPWSTR BufferW = NULL;
1931     LPWSTR pszFilterW = NULL;
1932     CONFIGRET ret = CR_SUCCESS;
1933
1934     FIXME("%p %p %ld %ld %lx\n",
1935           pszFilter, Buffer, BufferLen, ulFlags, hMachine);
1936
1937     BufferW = MyMalloc(BufferLen * sizeof(WCHAR));
1938     if (BufferW == NULL)
1939         return CR_OUT_OF_MEMORY;
1940
1941     if (pszFilter == NULL)
1942     {
1943         ret = CM_Get_Device_ID_List_ExW(NULL,
1944                                         BufferW,
1945                                         BufferLen,
1946                                         ulFlags,
1947                                         hMachine);
1948     }
1949     else
1950     {
1951         if (CaptureAndConvertAnsiArg(pszFilter, &pszFilterW))
1952         {
1953             ret = CR_INVALID_DEVICE_ID;
1954             goto Done;
1955         }
1956
1957         ret = CM_Get_Device_ID_List_ExW(pszFilterW,
1958                                         BufferW,
1959                                         BufferLen,
1960                                         ulFlags,
1961                                         hMachine);
1962
1963         MyFree(pszFilterW);
1964     }
1965
1966     if (WideCharToMultiByte(CP_ACP,
1967                             0,
1968                             BufferW,
1969                             lstrlenW(BufferW) + 1,
1970                             Buffer,
1971                             BufferLen,
1972                             NULL,
1973                             NULL) == 0)
1974         ret = CR_FAILURE;
1975
1976 Done:
1977     MyFree(BufferW);
1978
1979     return ret;
1980 }
1981
1982
1983 /***********************************************************************
1984  * CM_Get_Device_ID_List_ExW [SETUPAPI.@]
1985  */
1986 CONFIGRET WINAPI CM_Get_Device_ID_List_ExW(
1987     PCWSTR pszFilter, PWCHAR Buffer, ULONG BufferLen, ULONG ulFlags,
1988     HMACHINE hMachine)
1989 {
1990     RPC_BINDING_HANDLE BindingHandle = NULL;
1991     CONFIGRET ret;
1992
1993     TRACE("%p %p %ld %ld %lx\n",
1994           pszFilter, Buffer, BufferLen, ulFlags, hMachine);
1995
1996     if (Buffer == NULL || BufferLen == 0)
1997         return CR_INVALID_POINTER;
1998
1999     if (ulFlags & ~CM_GETIDLIST_FILTER_BITS)
2000         return CR_INVALID_FLAG;
2001
2002     if (hMachine != NULL)
2003     {
2004         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2005         if (BindingHandle == NULL)
2006             return CR_FAILURE;
2007     }
2008     else
2009     {
2010         if (!PnpGetLocalHandles(&BindingHandle, NULL))
2011             return CR_FAILURE;
2012     }
2013
2014     *Buffer = 0;
2015
2016     RpcTryExcept
2017     {
2018         ret = PNP_GetDeviceList(BindingHandle,
2019                                 pszFilter,
2020                                 Buffer,
2021                                 &BufferLen,
2022                                 ulFlags);
2023     }
2024     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2025     {
2026         ret = RpcStatusToCmStatus(RpcExceptionCode());
2027     }
2028     RpcEndExcept;
2029
2030     return ret;
2031 }
2032
2033
2034 /***********************************************************************
2035  * CM_Get_Device_ID_List_SizeA [SETUPAPI.@]
2036  */
2037 CONFIGRET WINAPI CM_Get_Device_ID_List_SizeA(
2038     PULONG pulLen, PCSTR pszFilter, ULONG ulFlags)
2039 {
2040     TRACE("%p %s %ld\n", pulLen, pszFilter, ulFlags);
2041     return CM_Get_Device_ID_List_Size_ExA(pulLen, pszFilter, ulFlags, NULL);
2042 }
2043
2044
2045 /***********************************************************************
2046  * CM_Get_Device_ID_List_SizeW [SETUPAPI.@]
2047  */
2048 CONFIGRET WINAPI CM_Get_Device_ID_List_SizeW(
2049     PULONG pulLen, PCWSTR pszFilter, ULONG ulFlags)
2050 {
2051     TRACE("%p %s %ld\n", pulLen, debugstr_w(pszFilter), ulFlags);
2052     return CM_Get_Device_ID_List_Size_ExW(pulLen, pszFilter, ulFlags, NULL);
2053 }
2054
2055
2056 /***********************************************************************
2057  * CM_Get_Device_ID_List_Size_ExA [SETUPAPI.@]
2058  */
2059 CONFIGRET WINAPI CM_Get_Device_ID_List_Size_ExA(
2060     PULONG pulLen, PCSTR pszFilter, ULONG ulFlags, HMACHINE hMachine)
2061 {
2062     LPWSTR pszFilterW = NULL;
2063     CONFIGRET ret = CR_SUCCESS;
2064
2065     FIXME("%p %s %lx %lx\n", pulLen, pszFilter, ulFlags, hMachine);
2066
2067     if (pszFilter == NULL)
2068     {
2069         ret = CM_Get_Device_ID_List_Size_ExW(pulLen,
2070                                              NULL,
2071                                              ulFlags,
2072                                              hMachine);
2073     }
2074     else
2075     {
2076         if (CaptureAndConvertAnsiArg(pszFilter, &pszFilterW))
2077             return CR_INVALID_DEVICE_ID;
2078
2079         ret = CM_Get_Device_ID_List_Size_ExW(pulLen,
2080                                              pszFilterW,
2081                                              ulFlags,
2082                                              hMachine);
2083
2084         MyFree(pszFilterW);
2085     }
2086
2087     return ret;
2088 }
2089
2090
2091 /***********************************************************************
2092  * CM_Get_Device_ID_List_Size_ExW [SETUPAPI.@]
2093  */
2094 CONFIGRET WINAPI CM_Get_Device_ID_List_Size_ExW(
2095     PULONG pulLen, PCWSTR pszFilter, ULONG ulFlags, HMACHINE hMachine)
2096 {
2097     RPC_BINDING_HANDLE BindingHandle = NULL;
2098     CONFIGRET ret;
2099
2100     FIXME("%p %s %ld %lx\n", pulLen, debugstr_w(pszFilter), ulFlags, hMachine);
2101
2102     if (pulLen == NULL)
2103         return CR_INVALID_POINTER;
2104
2105     if (ulFlags & ~CM_GETIDLIST_FILTER_BITS)
2106         return CR_INVALID_FLAG;
2107
2108     if (hMachine != NULL)
2109     {
2110         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2111         if (BindingHandle == NULL)
2112             return CR_FAILURE;
2113     }
2114     else
2115     {
2116         if (!PnpGetLocalHandles(&BindingHandle, NULL))
2117             return CR_FAILURE;
2118     }
2119
2120     *pulLen = 0;
2121
2122     RpcTryExcept
2123     {
2124         ret = PNP_GetDeviceListSize(BindingHandle,
2125                                     (LPWSTR)pszFilter,
2126                                     pulLen,
2127                                     ulFlags);
2128     }
2129     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2130     {
2131         ret = RpcStatusToCmStatus(RpcExceptionCode());
2132     }
2133     RpcEndExcept;
2134
2135     return ret;
2136 }
2137
2138
2139 /***********************************************************************
2140  * CM_Get_Device_ID_Size [SETUPAPI.@]
2141  */
2142 CONFIGRET WINAPI CM_Get_Device_ID_Size(
2143     PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags)
2144 {
2145     TRACE("%p %lx %lx\n", pulLen, dnDevInst, ulFlags);
2146     return CM_Get_Device_ID_Size_Ex(pulLen, dnDevInst, ulFlags, NULL);
2147 }
2148
2149
2150 /***********************************************************************
2151  * CM_Get_Device_ID_Size_Ex [SETUPAPI.@]
2152  */
2153 CONFIGRET WINAPI CM_Get_Device_ID_Size_Ex(
2154     PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
2155 {
2156     HSTRING_TABLE StringTable = NULL;
2157     LPWSTR DeviceId;
2158
2159     TRACE("%p %lx %lx %lx\n", pulLen, dnDevInst, ulFlags, hMachine);
2160
2161     if (pulLen == NULL)
2162         return CR_INVALID_POINTER;
2163
2164     if (dnDevInst == 0)
2165         return CR_INVALID_DEVINST;
2166
2167     if (ulFlags != 0)
2168         return CR_INVALID_FLAG;
2169
2170     if (hMachine != NULL)
2171     {
2172         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
2173         if (StringTable == NULL)
2174             return CR_FAILURE;
2175     }
2176     else
2177     {
2178         if (!PnpGetLocalHandles(NULL, &StringTable))
2179             return CR_FAILURE;
2180     }
2181
2182     DeviceId = StringTableStringFromId(StringTable, dnDevInst);
2183     if (DeviceId == NULL)
2184     {
2185         *pulLen = 0;
2186         return CR_SUCCESS;
2187     }
2188
2189     *pulLen = lstrlenW(DeviceId);
2190
2191     return CR_SUCCESS;
2192 }
2193
2194
2195 /***********************************************************************
2196  * CM_Get_First_Log_Conf [SETUPAPI.@]
2197  */
2198 CONFIGRET WINAPI CM_Get_First_Log_Conf(
2199     PLOG_CONF plcLogConf, DEVINST dnDevInst, ULONG ulFlags)
2200 {
2201     TRACE("%p %lx %lx\n", plcLogConf, dnDevInst, ulFlags);
2202     return CM_Get_First_Log_Conf_Ex(plcLogConf, dnDevInst, ulFlags, NULL);
2203 }
2204
2205
2206 /***********************************************************************
2207  * CM_Get_First_Log_Conf_Ex [SETUPAPI.@]
2208  */
2209 CONFIGRET WINAPI CM_Get_First_Log_Conf_Ex(
2210     PLOG_CONF plcLogConf, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
2211 {
2212     RPC_BINDING_HANDLE BindingHandle = NULL;
2213     HSTRING_TABLE StringTable = NULL;
2214     LPWSTR lpDevInst = NULL;
2215     CONFIGRET ret = CR_SUCCESS;
2216     ULONG ulTag;
2217     PLOG_CONF_INFO pLogConfInfo;
2218
2219     FIXME("%p %lx %lx %lx\n", plcLogConf, dnDevInst, ulFlags, hMachine);
2220
2221     if (dnDevInst == 0)
2222         return CR_INVALID_DEVINST;
2223
2224     if (ulFlags & ~LOG_CONF_BITS)
2225         return CR_INVALID_FLAG;
2226
2227     if (plcLogConf)
2228         *plcLogConf = 0;
2229
2230     if (hMachine != NULL)
2231     {
2232         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2233         if (BindingHandle == NULL)
2234             return CR_FAILURE;
2235
2236         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
2237         if (StringTable == 0)
2238             return CR_FAILURE;
2239     }
2240     else
2241     {
2242         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
2243             return CR_FAILURE;
2244     }
2245
2246     lpDevInst = StringTableStringFromId(StringTable, dnDevInst);
2247     if (lpDevInst == NULL)
2248         return CR_INVALID_DEVNODE;
2249
2250     RpcTryExcept
2251     {
2252         ret = PNP_GetFirstLogConf(BindingHandle,
2253                                   lpDevInst,
2254                                   ulFlags,
2255                                   &ulTag,
2256                                   ulFlags);
2257     }
2258     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2259     {
2260         ret = RpcStatusToCmStatus(RpcExceptionCode());
2261     }
2262     RpcEndExcept;
2263
2264     if (ret != CR_SUCCESS)
2265         return ret;
2266
2267     pLogConfInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(LOG_CONF_INFO));
2268     if (pLogConfInfo == NULL)
2269         return CR_OUT_OF_MEMORY;
2270
2271     pLogConfInfo->ulMagic = LOG_CONF_MAGIC;
2272     pLogConfInfo->dnDevInst = dnDevInst;
2273     pLogConfInfo->ulFlags = ulFlags;
2274     pLogConfInfo->ulTag = ulTag;
2275
2276     *plcLogConf = (LOG_CONF)pLogConfInfo;
2277
2278     return CR_SUCCESS;
2279 }
2280
2281
2282 /***********************************************************************
2283  * CM_Get_Global_State [SETUPAPI.@]
2284  */
2285 CONFIGRET WINAPI CM_Get_Global_State(
2286     PULONG pulState, ULONG ulFlags)
2287 {
2288     TRACE("%p %lx\n", pulState, ulFlags);
2289     return CM_Get_Global_State_Ex(pulState, ulFlags, NULL);
2290 }
2291
2292
2293 /***********************************************************************
2294  * CM_Get_Global_State_Ex [SETUPAPI.@]
2295  */
2296 CONFIGRET WINAPI CM_Get_Global_State_Ex(
2297     PULONG pulState, ULONG ulFlags, HMACHINE hMachine)
2298 {
2299     RPC_BINDING_HANDLE BindingHandle = NULL;
2300     CONFIGRET ret;
2301
2302     TRACE("%p %lx %lx\n", pulState, ulFlags, hMachine);
2303
2304     if (pulState == NULL)
2305         return CR_INVALID_POINTER;
2306
2307     if (ulFlags != 0)
2308         return CR_INVALID_FLAG;
2309
2310     if (hMachine != NULL)
2311     {
2312         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2313         if (BindingHandle == NULL)
2314             return CR_FAILURE;
2315     }
2316     else
2317     {
2318         if (!PnpGetLocalHandles(&BindingHandle, NULL))
2319             return CR_FAILURE;
2320     }
2321
2322     RpcTryExcept
2323     {
2324         ret = PNP_GetGlobalState(BindingHandle, pulState, ulFlags);
2325     }
2326     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2327     {
2328         ret = RpcStatusToCmStatus(RpcExceptionCode());
2329     }
2330     RpcEndExcept;
2331
2332     return ret;
2333 }
2334
2335
2336 /***********************************************************************
2337  * CM_Get_HW_Prof_FlagsA [SETUPAPI.@]
2338  */
2339 CONFIGRET WINAPI CM_Get_HW_Prof_FlagsA(
2340     DEVINSTID_A szDevInstName, ULONG ulHardwareProfile, PULONG pulValue,
2341     ULONG ulFlags)
2342 {
2343     TRACE("%s %lu %p %lx\n", szDevInstName,
2344           ulHardwareProfile, pulValue, ulFlags);
2345
2346     return CM_Get_HW_Prof_Flags_ExA(szDevInstName, ulHardwareProfile,
2347                                     pulValue, ulFlags, NULL);
2348 }
2349
2350
2351 /***********************************************************************
2352  * CM_Get_HW_Prof_FlagsW [SETUPAPI.@]
2353  */
2354 CONFIGRET WINAPI CM_Get_HW_Prof_FlagsW(
2355     DEVINSTID_W szDevInstName, ULONG ulHardwareProfile, PULONG pulValue,
2356     ULONG ulFlags)
2357 {
2358     TRACE("%s %lu %p %lx\n", debugstr_w(szDevInstName),
2359           ulHardwareProfile, pulValue, ulFlags);
2360
2361     return CM_Get_HW_Prof_Flags_ExW(szDevInstName, ulHardwareProfile,
2362                                     pulValue, ulFlags, NULL);
2363 }
2364
2365
2366 /***********************************************************************
2367  * CM_Get_HW_Prof_Flags_ExA [SETUPAPI.@]
2368  */
2369 CONFIGRET WINAPI CM_Get_HW_Prof_Flags_ExA(
2370     DEVINSTID_A szDevInstName, ULONG ulHardwareProfile, PULONG pulValue,
2371     ULONG ulFlags, HMACHINE hMachine)
2372 {
2373     DEVINSTID_W pszDevIdW = NULL;
2374     CONFIGRET ret = CR_SUCCESS;
2375
2376     TRACE("%s %lu %p %lx %lx\n", szDevInstName,
2377           ulHardwareProfile, pulValue, ulFlags, hMachine);
2378
2379     if (szDevInstName != NULL)
2380     {
2381        if (CaptureAndConvertAnsiArg(szDevInstName, &pszDevIdW))
2382          return CR_INVALID_DEVICE_ID;
2383     }
2384
2385     ret = CM_Get_HW_Prof_Flags_ExW(pszDevIdW, ulHardwareProfile,
2386                                    pulValue, ulFlags, hMachine);
2387
2388     if (pszDevIdW != NULL)
2389         MyFree(pszDevIdW);
2390
2391     return ret;
2392 }
2393
2394
2395 /***********************************************************************
2396  * CM_Get_HW_Prof_Flags_ExW [SETUPAPI.@]
2397  */
2398 CONFIGRET WINAPI CM_Get_HW_Prof_Flags_ExW(
2399     DEVINSTID_W szDevInstName, ULONG ulHardwareProfile, PULONG pulValue,
2400     ULONG ulFlags, HMACHINE hMachine)
2401 {
2402     RPC_BINDING_HANDLE BindingHandle = NULL;
2403     CONFIGRET ret;
2404
2405     FIXME("%s %lu %p %lx %lx\n", debugstr_w(szDevInstName),
2406           ulHardwareProfile, pulValue, ulFlags, hMachine);
2407
2408     if ((szDevInstName == NULL) || (pulValue == NULL))
2409         return CR_INVALID_POINTER;
2410
2411     if (ulFlags != 0)
2412         return CR_INVALID_FLAG;
2413
2414     /* FIXME: Check whether szDevInstName is valid */
2415
2416     if (hMachine != NULL)
2417     {
2418         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2419         if (BindingHandle == NULL)
2420             return CR_FAILURE;
2421     }
2422     else
2423     {
2424         if (!PnpGetLocalHandles(&BindingHandle, NULL))
2425             return CR_FAILURE;
2426     }
2427
2428     RpcTryExcept
2429     {
2430         ret = PNP_HwProfFlags(BindingHandle, PNP_GET_HWPROFFLAGS, szDevInstName,
2431                               ulHardwareProfile, pulValue, NULL, NULL, 0, 0);
2432     }
2433     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2434     {
2435         ret = RpcStatusToCmStatus(RpcExceptionCode());
2436     }
2437     RpcEndExcept;
2438
2439     return ret;
2440 }
2441
2442
2443 /***********************************************************************
2444  * CM_Get_Log_Conf_Priority [SETUPAPI.@]
2445  */
2446 CONFIGRET WINAPI CM_Get_Log_Conf_Priority(
2447     LOG_CONF lcLogConf, PPRIORITY pPriority, ULONG ulFlags)
2448 {
2449     TRACE("%p %p %lx\n", lcLogConf, pPriority, ulFlags);
2450     return CM_Get_Log_Conf_Priority_Ex(lcLogConf, pPriority, ulFlags, NULL);
2451 }
2452
2453
2454 /***********************************************************************
2455  * CM_Get_Log_Conf_Priority_Ex [SETUPAPI.@]
2456  */
2457 CONFIGRET WINAPI CM_Get_Log_Conf_Priority_Ex(
2458     LOG_CONF lcLogConf, PPRIORITY pPriority, ULONG ulFlags,
2459     HMACHINE hMachine)
2460 {
2461     RPC_BINDING_HANDLE BindingHandle = NULL;
2462     HSTRING_TABLE StringTable = NULL;
2463     PLOG_CONF_INFO pLogConfInfo;
2464     LPWSTR lpDevInst;
2465     CONFIGRET ret;
2466
2467     FIXME("%p %p %lx %lx\n", lcLogConf, pPriority, ulFlags, hMachine);
2468
2469     pLogConfInfo = (PLOG_CONF_INFO)lcLogConf;
2470     if (pLogConfInfo == NULL || pLogConfInfo->ulMagic != LOG_CONF_MAGIC)
2471         return CR_INVALID_LOG_CONF;
2472
2473     if (pPriority == NULL)
2474         return CR_INVALID_POINTER;
2475
2476     if (ulFlags != 0)
2477         return CR_INVALID_FLAG;
2478
2479     if (hMachine != NULL)
2480     {
2481         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2482         if (BindingHandle == NULL)
2483             return CR_FAILURE;
2484
2485         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
2486         if (StringTable == 0)
2487             return CR_FAILURE;
2488     }
2489     else
2490     {
2491         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
2492             return CR_FAILURE;
2493     }
2494
2495     lpDevInst = StringTableStringFromId(StringTable, pLogConfInfo->dnDevInst);
2496     if (lpDevInst == NULL)
2497         return CR_INVALID_DEVNODE;
2498
2499     RpcTryExcept
2500     {
2501         ret = PNP_GetLogConfPriority(BindingHandle,
2502                                      lpDevInst,
2503                                      pLogConfInfo->ulFlags,
2504                                      pLogConfInfo->ulTag,
2505                                      pPriority,
2506                                      0);
2507     }
2508     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2509     {
2510         ret = RpcStatusToCmStatus(RpcExceptionCode());
2511     }
2512     RpcEndExcept;
2513
2514     return ret;
2515 }
2516
2517
2518 /***********************************************************************
2519  * CM_Get_Next_Log_Conf [SETUPAPI.@]
2520  */
2521 CONFIGRET WINAPI CM_Get_Next_Log_Conf(
2522     PLOG_CONF plcLogConf, LOG_CONF lcLogConf, ULONG ulFlags)
2523 {
2524     TRACE("%p %p %lx\n", plcLogConf, lcLogConf, ulFlags);
2525     return CM_Get_Next_Log_Conf_Ex(plcLogConf, lcLogConf, ulFlags, NULL);
2526 }
2527
2528
2529 /***********************************************************************
2530  * CM_Get_Next_Log_Conf_Ex [SETUPAPI.@]
2531  */
2532 CONFIGRET WINAPI CM_Get_Next_Log_Conf_Ex(
2533     PLOG_CONF plcLogConf, LOG_CONF lcLogConf, ULONG ulFlags,
2534     HMACHINE hMachine)
2535 {
2536     RPC_BINDING_HANDLE BindingHandle = NULL;
2537     HSTRING_TABLE StringTable = NULL;
2538     PLOG_CONF_INFO pLogConfInfo;
2539     PLOG_CONF_INFO pNewLogConfInfo;
2540     ULONG ulNewTag;
2541     LPWSTR lpDevInst;
2542     CONFIGRET ret;
2543
2544     FIXME("%p %p %lx %lx\n", plcLogConf, lcLogConf, ulFlags, hMachine);
2545
2546     if (plcLogConf)
2547         *plcLogConf = 0;
2548
2549     pLogConfInfo = (PLOG_CONF_INFO)lcLogConf;
2550     if (pLogConfInfo == NULL || pLogConfInfo->ulMagic != LOG_CONF_MAGIC)
2551         return CR_INVALID_LOG_CONF;
2552
2553     if (ulFlags != 0)
2554         return CR_INVALID_FLAG;
2555
2556     if (hMachine != NULL)
2557     {
2558         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2559         if (BindingHandle == NULL)
2560             return CR_FAILURE;
2561
2562         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
2563         if (StringTable == 0)
2564             return CR_FAILURE;
2565     }
2566     else
2567     {
2568         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
2569             return CR_FAILURE;
2570     }
2571
2572     lpDevInst = StringTableStringFromId(StringTable, pLogConfInfo->dnDevInst);
2573     if (lpDevInst == NULL)
2574         return CR_INVALID_DEVNODE;
2575
2576     RpcTryExcept
2577     {
2578         ret = PNP_GetNextLogConf(BindingHandle,
2579                                  lpDevInst,
2580                                  pLogConfInfo->ulFlags,
2581                                  pLogConfInfo->ulTag,
2582                                  &ulNewTag,
2583                                  0);
2584     }
2585     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2586     {
2587         ret = RpcStatusToCmStatus(RpcExceptionCode());
2588     }
2589     RpcEndExcept;
2590
2591     if (ret != CR_SUCCESS)
2592         return ret;
2593
2594     if (plcLogConf)
2595     {
2596         pNewLogConfInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(LOG_CONF_INFO));
2597         if (pNewLogConfInfo == NULL)
2598             return CR_OUT_OF_MEMORY;
2599
2600         pNewLogConfInfo->ulMagic = LOG_CONF_MAGIC;
2601         pNewLogConfInfo->dnDevInst = pLogConfInfo->dnDevInst;
2602         pNewLogConfInfo->ulFlags = pLogConfInfo->ulFlags;
2603         pNewLogConfInfo->ulTag = ulNewTag;
2604
2605         *plcLogConf = (LOG_CONF)pNewLogConfInfo;
2606     }
2607
2608     return CR_SUCCESS;
2609 }
2610
2611
2612 /***********************************************************************
2613  * CM_Get_Parent [SETUPAPI.@]
2614  */
2615 CONFIGRET WINAPI CM_Get_Parent(
2616     PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags)
2617 {
2618     TRACE("%p %p %lx\n", pdnDevInst, dnDevInst, ulFlags);
2619     return CM_Get_Parent_Ex(pdnDevInst, dnDevInst, ulFlags, NULL);
2620 }
2621
2622
2623 /***********************************************************************
2624  * CM_Get_Parent_Ex [SETUPAPI.@]
2625  */
2626 CONFIGRET WINAPI CM_Get_Parent_Ex(
2627     PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
2628 {
2629     WCHAR szRelatedDevInst[MAX_DEVICE_ID_LEN];
2630     RPC_BINDING_HANDLE BindingHandle = NULL;
2631     HSTRING_TABLE StringTable = NULL;
2632     LPWSTR lpDevInst;
2633     DWORD dwIndex, dwLength = MAX_DEVICE_ID_LEN;
2634     CONFIGRET ret;
2635
2636     TRACE("%p %lx %lx %lx\n", pdnDevInst, dnDevInst, ulFlags, hMachine);
2637
2638     if (pdnDevInst == NULL)
2639         return CR_INVALID_POINTER;
2640
2641     if (dnDevInst == 0)
2642         return CR_INVALID_DEVINST;
2643
2644     if (ulFlags != 0)
2645         return CR_INVALID_FLAG;
2646
2647     *pdnDevInst = -1;
2648
2649     if (hMachine != NULL)
2650     {
2651         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2652         if (BindingHandle == NULL)
2653             return CR_FAILURE;
2654
2655         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
2656         if (StringTable == 0)
2657             return CR_FAILURE;
2658     }
2659     else
2660     {
2661         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
2662             return CR_FAILURE;
2663     }
2664
2665     lpDevInst = StringTableStringFromId(StringTable, dnDevInst);
2666     if (lpDevInst == NULL)
2667         return CR_INVALID_DEVNODE;
2668
2669     RpcTryExcept
2670     {
2671         ret = PNP_GetRelatedDeviceInstance(BindingHandle,
2672                                            PNP_GET_PARENT_DEVICE_INSTANCE,
2673                                            lpDevInst,
2674                                            szRelatedDevInst,
2675                                            &dwLength,
2676                                            0);
2677     }
2678     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2679     {
2680         ret = RpcStatusToCmStatus(RpcExceptionCode());
2681     }
2682     RpcEndExcept;
2683
2684     if (ret != CR_SUCCESS)
2685         return ret;
2686
2687     TRACE("szRelatedDevInst: %s\n", debugstr_w(szRelatedDevInst));
2688
2689     dwIndex = StringTableAddString(StringTable, szRelatedDevInst, 1);
2690     if (dwIndex == -1)
2691         return CR_FAILURE;
2692
2693     *pdnDevInst = dwIndex;
2694
2695     return CR_SUCCESS;
2696 }
2697
2698
2699 /***********************************************************************
2700  * CM_Get_Sibling [SETUPAPI.@]
2701  */
2702 CONFIGRET WINAPI CM_Get_Sibling(
2703     PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags)
2704 {
2705     TRACE("%p %p %lx\n", pdnDevInst, dnDevInst, ulFlags);
2706     return CM_Get_Sibling_Ex(pdnDevInst, dnDevInst, ulFlags, NULL);
2707 }
2708
2709
2710 /***********************************************************************
2711  * CM_Get_Sibling_Ex [SETUPAPI.@]
2712  */
2713 CONFIGRET WINAPI CM_Get_Sibling_Ex(
2714     PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
2715 {
2716     WCHAR szRelatedDevInst[MAX_DEVICE_ID_LEN];
2717     RPC_BINDING_HANDLE BindingHandle = NULL;
2718     HSTRING_TABLE StringTable = NULL;
2719     LPWSTR lpDevInst;
2720     DWORD dwIndex, dwLength = MAX_DEVICE_ID_LEN;
2721     CONFIGRET ret;
2722
2723     TRACE("%p %lx %lx %lx\n", pdnDevInst, dnDevInst, ulFlags, hMachine);
2724
2725     if (pdnDevInst == NULL)
2726         return CR_INVALID_POINTER;
2727
2728     if (dnDevInst == 0)
2729         return CR_INVALID_DEVINST;
2730
2731     if (ulFlags != 0)
2732         return CR_INVALID_FLAG;
2733
2734     *pdnDevInst = -1;
2735
2736     if (hMachine != NULL)
2737     {
2738         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2739         if (BindingHandle == NULL)
2740             return CR_FAILURE;
2741
2742         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
2743         if (StringTable == 0)
2744             return CR_FAILURE;
2745     }
2746     else
2747     {
2748         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
2749             return CR_FAILURE;
2750     }
2751
2752     lpDevInst = StringTableStringFromId(StringTable, dnDevInst);
2753     if (lpDevInst == NULL)
2754         return CR_INVALID_DEVNODE;
2755
2756     RpcTryExcept
2757     {
2758         ret = PNP_GetRelatedDeviceInstance(BindingHandle,
2759                                            PNP_GET_SIBLING_DEVICE_INSTANCE,
2760                                            lpDevInst,
2761                                            szRelatedDevInst,
2762                                            &dwLength,
2763                                            0);
2764     }
2765     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2766     {
2767         ret = RpcStatusToCmStatus(RpcExceptionCode());
2768     }
2769     RpcEndExcept;
2770
2771     if (ret != CR_SUCCESS)
2772         return ret;
2773
2774     TRACE("szRelatedDevInst: %s\n", debugstr_w(szRelatedDevInst));
2775
2776     dwIndex = StringTableAddString(StringTable, szRelatedDevInst, 1);
2777     if (dwIndex == -1)
2778         return CR_FAILURE;
2779
2780     *pdnDevInst = dwIndex;
2781
2782     return CR_SUCCESS;
2783 }
2784
2785
2786 /***********************************************************************
2787  * CM_Get_Version [SETUPAPI.@]
2788  */
2789 WORD WINAPI CM_Get_Version(VOID)
2790 {
2791     TRACE("\n");
2792     return CM_Get_Version_Ex(NULL);
2793 }
2794
2795
2796 /***********************************************************************
2797  * CM_Get_Version_Ex [SETUPAPI.@]
2798  */
2799 WORD WINAPI CM_Get_Version_Ex(HMACHINE hMachine)
2800 {
2801     RPC_BINDING_HANDLE BindingHandle = NULL;
2802     WORD Version = 0;
2803     CONFIGRET ret;
2804
2805     TRACE("%lx\n", hMachine);
2806
2807     if (hMachine != NULL)
2808     {
2809         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2810         if (BindingHandle == NULL)
2811             return 0;
2812     }
2813     else
2814     {
2815         if (!PnpGetLocalHandles(&BindingHandle, NULL))
2816             return CR_FAILURE;
2817     }
2818
2819     RpcTryExcept
2820     {
2821         ret = PNP_GetVersion(BindingHandle, &Version);
2822     }
2823     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2824     {
2825         ret = RpcStatusToCmStatus(RpcExceptionCode());
2826     }
2827     RpcEndExcept;
2828
2829     if (ret != CR_SUCCESS)
2830         return 0;
2831
2832     return Version;
2833 }
2834
2835
2836 /***********************************************************************
2837  * CM_Is_Dock_Station_Present [SETUPAPI.@]
2838  */
2839 CONFIGRET WINAPI CM_Is_Dock_Station_Present(
2840     PBOOL pbPresent)
2841 {
2842     TRACE("%p\n", pbPresent);
2843     return CM_Is_Dock_Station_Present_Ex(pbPresent, NULL);
2844 }
2845
2846
2847 /***********************************************************************
2848  * CM_Is_Dock_Station_Present_Ex [SETUPAPI.@]
2849  */
2850 CONFIGRET WINAPI CM_Is_Dock_Station_Present_Ex(
2851     PBOOL pbPresent, HMACHINE hMachine)
2852 {
2853     RPC_BINDING_HANDLE BindingHandle = NULL;
2854     CONFIGRET ret;
2855
2856     TRACE("%p %lx\n", pbPresent, hMachine);
2857
2858     if (pbPresent == NULL)
2859         return CR_INVALID_POINTER;
2860
2861     *pbPresent = FALSE;
2862
2863     if (hMachine != NULL)
2864     {
2865         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2866         if (BindingHandle == NULL)
2867             return CR_FAILURE;
2868     }
2869     else
2870     {
2871         if (!PnpGetLocalHandles(&BindingHandle, NULL))
2872             return CR_FAILURE;
2873     }
2874
2875     RpcTryExcept
2876     {
2877         ret = PNP_IsDockStationPresent(BindingHandle,
2878                                        pbPresent);
2879     }
2880     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2881     {
2882         ret = RpcStatusToCmStatus(RpcExceptionCode());
2883     }
2884     RpcEndExcept;
2885
2886     return ret;
2887 }
2888
2889
2890 /***********************************************************************
2891  * CM_Locate_DevNodeA [SETUPAPI.@]
2892  */
2893 CONFIGRET WINAPI CM_Locate_DevNodeA(
2894     PDEVINST pdnDevInst, DEVINSTID_A pDeviceID, ULONG ulFlags)
2895 {
2896     TRACE("%p %s %lu\n", pdnDevInst, pDeviceID, ulFlags);
2897     return CM_Locate_DevNode_ExA(pdnDevInst, pDeviceID, ulFlags, NULL);
2898 }
2899
2900
2901 /***********************************************************************
2902  * CM_Locate_DevNodeW [SETUPAPI.@]
2903  */
2904 CONFIGRET WINAPI CM_Locate_DevNodeW(
2905     PDEVINST pdnDevInst, DEVINSTID_W pDeviceID, ULONG ulFlags)
2906 {
2907     TRACE("%p %s %lu\n", pdnDevInst, debugstr_w(pDeviceID), ulFlags);
2908     return CM_Locate_DevNode_ExW(pdnDevInst, pDeviceID, ulFlags, NULL);
2909 }
2910
2911
2912 /***********************************************************************
2913  * CM_Locate_DevNode_ExA [SETUPAPI.@]
2914  */
2915 CONFIGRET WINAPI CM_Locate_DevNode_ExA(
2916     PDEVINST pdnDevInst, DEVINSTID_A pDeviceID, ULONG ulFlags, HMACHINE hMachine)
2917 {
2918     DEVINSTID_W pDevIdW = NULL;
2919     CONFIGRET ret = CR_SUCCESS;
2920
2921     TRACE("%p %s %lu %lx\n", pdnDevInst, pDeviceID, ulFlags, hMachine);
2922
2923     if (pDeviceID != NULL)
2924     {
2925        if (CaptureAndConvertAnsiArg(pDeviceID, &pDevIdW))
2926          return CR_INVALID_DEVICE_ID;
2927     }
2928
2929     ret = CM_Locate_DevNode_ExW(pdnDevInst, pDevIdW, ulFlags, hMachine);
2930
2931     if (pDevIdW != NULL)
2932         MyFree(pDevIdW);
2933
2934     return ret;
2935 }
2936
2937
2938 /***********************************************************************
2939  * CM_Locate_DevNode_ExW [SETUPAPI.@]
2940  */
2941 CONFIGRET WINAPI CM_Locate_DevNode_ExW(
2942     PDEVINST pdnDevInst, DEVINSTID_W pDeviceID, ULONG ulFlags, HMACHINE hMachine)
2943 {
2944     WCHAR DeviceIdBuffer[MAX_DEVICE_ID_LEN];
2945     RPC_BINDING_HANDLE BindingHandle = NULL;
2946     HSTRING_TABLE StringTable = NULL;
2947     CONFIGRET ret = CR_SUCCESS;
2948
2949     TRACE("%p %s %lu %lx\n", pdnDevInst, debugstr_w(pDeviceID), ulFlags, hMachine);
2950
2951     if (pdnDevInst == NULL)
2952         return CR_INVALID_POINTER;
2953
2954     if (ulFlags & ~CM_LOCATE_DEVNODE_BITS)
2955         return CR_INVALID_FLAG;
2956
2957     if (hMachine != NULL)
2958     {
2959         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2960         if (BindingHandle == NULL)
2961             return CR_FAILURE;
2962
2963         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
2964         if (StringTable == 0)
2965             return CR_FAILURE;
2966     }
2967     else
2968     {
2969         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
2970             return CR_FAILURE;
2971     }
2972
2973     if (pDeviceID != NULL && lstrlenW(pDeviceID) != 0)
2974     {
2975         lstrcpyW(DeviceIdBuffer, pDeviceID);
2976     }
2977     else
2978     {
2979         RpcTryExcept
2980         {
2981             /* Get the root device ID */
2982             ret = PNP_GetRootDeviceInstance(BindingHandle,
2983                                             DeviceIdBuffer,
2984                                             MAX_DEVICE_ID_LEN);
2985         }
2986         RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2987         {
2988             ret = RpcStatusToCmStatus(RpcExceptionCode());
2989         }
2990         RpcEndExcept;
2991
2992         if (ret != CR_SUCCESS)
2993             return CR_FAILURE;
2994     }
2995     TRACE("DeviceIdBuffer: %s\n", debugstr_w(DeviceIdBuffer));
2996
2997     RpcTryExcept
2998     {
2999         /* Validate the device ID */
3000         ret = PNP_ValidateDeviceInstance(BindingHandle,
3001                                          DeviceIdBuffer,
3002                                          ulFlags);
3003     }
3004     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3005     {
3006         ret = RpcStatusToCmStatus(RpcExceptionCode());
3007     }
3008     RpcEndExcept;
3009
3010     if (ret == CR_SUCCESS)
3011     {
3012         *pdnDevInst = StringTableAddString(StringTable, DeviceIdBuffer, 1);
3013         if (*pdnDevInst == -1)
3014             ret = CR_FAILURE;
3015     }
3016
3017     return ret;
3018 }
3019
3020
3021 /***********************************************************************
3022  * CM_Move_DevNode [SETUPAPI.@]
3023  */
3024 CONFIGRET WINAPI CM_Move_DevNode(
3025     DEVINST dnFromDevInst, DEVINST dnToDevInst, ULONG ulFlags)
3026 {
3027     TRACE("%lx %lx %lx\n", dnFromDevInst, dnToDevInst, ulFlags);
3028     return CM_Move_DevNode_Ex(dnFromDevInst, dnToDevInst, ulFlags, NULL);
3029 }
3030
3031
3032 /***********************************************************************
3033  * CM_Move_DevNode_Ex [SETUPAPI.@]
3034  */
3035 CONFIGRET WINAPI CM_Move_DevNode_Ex(
3036     DEVINST dnFromDevInst, DEVINST dnToDevInst, ULONG ulFlags,
3037     HMACHINE hMachine)
3038 {
3039     RPC_BINDING_HANDLE BindingHandle = NULL;
3040     HSTRING_TABLE StringTable = NULL;
3041     LPWSTR lpFromDevInst;
3042     LPWSTR lpToDevInst;
3043     CONFIGRET ret;
3044
3045     FIXME("%lx %lx %lx %lx\n",
3046           dnFromDevInst, dnToDevInst, ulFlags, hMachine);
3047
3048     if (!IsUserAdmin())
3049         return CR_ACCESS_DENIED;
3050
3051     if (dnFromDevInst == 0 || dnToDevInst == 0)
3052         return CR_INVALID_DEVNODE;
3053
3054     if (ulFlags != 0)
3055         return CR_INVALID_FLAG;
3056
3057     if (hMachine != NULL)
3058     {
3059         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3060         if (BindingHandle == NULL)
3061             return CR_FAILURE;
3062
3063         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3064         if (StringTable == 0)
3065             return CR_FAILURE;
3066     }
3067     else
3068     {
3069         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
3070             return CR_FAILURE;
3071     }
3072
3073     lpFromDevInst = StringTableStringFromId(StringTable, dnFromDevInst);
3074     if (lpFromDevInst == NULL)
3075         return CR_INVALID_DEVNODE;
3076
3077     lpToDevInst = StringTableStringFromId(StringTable, dnToDevInst);
3078     if (lpToDevInst == NULL)
3079         return CR_INVALID_DEVNODE;
3080
3081     RpcTryExcept
3082     {
3083         ret = PNP_DeviceInstanceAction(BindingHandle,
3084                                        PNP_DEVINST_MOVE,
3085                                        ulFlags,
3086                                        lpFromDevInst,
3087                                        lpToDevInst);
3088     }
3089     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3090     {
3091         ret = RpcStatusToCmStatus(RpcExceptionCode());
3092     }
3093     RpcEndExcept;
3094
3095     return ret;
3096 }
3097
3098
3099 /***********************************************************************
3100  * CM_Open_Class_KeyA [SETUPAPI.@]
3101  */
3102 CONFIGRET WINAPI CM_Open_Class_KeyA(
3103     LPGUID pClassGuid, LPCSTR pszClassName, REGSAM samDesired,
3104     REGDISPOSITION Disposition, PHKEY phkClass, ULONG ulFlags)
3105 {
3106     TRACE("%p %s %lx %lx %p %lx\n",
3107           debugstr_guid(pClassGuid), pszClassName,
3108           samDesired, Disposition, phkClass, ulFlags);
3109
3110     return CM_Open_Class_Key_ExA(pClassGuid, pszClassName, samDesired,
3111                                  Disposition, phkClass, ulFlags, NULL);
3112 }
3113
3114
3115 /***********************************************************************
3116  * CM_Open_Class_KeyW [SETUPAPI.@]
3117  */
3118 CONFIGRET WINAPI CM_Open_Class_KeyW(
3119     LPGUID pClassGuid, LPCWSTR pszClassName, REGSAM samDesired,
3120     REGDISPOSITION Disposition, PHKEY phkClass, ULONG ulFlags)
3121 {
3122     TRACE("%p %s %lx %lx %p %lx\n",
3123           debugstr_guid(pClassGuid), debugstr_w(pszClassName),
3124           samDesired, Disposition, phkClass, ulFlags);
3125
3126     return CM_Open_Class_Key_ExW(pClassGuid, pszClassName, samDesired,
3127                                  Disposition, phkClass, ulFlags, NULL);
3128 }
3129
3130
3131 /***********************************************************************
3132  * CM_Open_Class_Key_ExA [SETUPAPI.@]
3133  */
3134 CONFIGRET WINAPI CM_Open_Class_Key_ExA(
3135     LPGUID pClassGuid, LPCSTR pszClassName, REGSAM samDesired,
3136     REGDISPOSITION Disposition, PHKEY phkClass, ULONG ulFlags,
3137     HMACHINE hMachine)
3138 {
3139     CONFIGRET rc = CR_SUCCESS;
3140     LPWSTR pszClassNameW = NULL;
3141
3142     TRACE("%p %s %lx %lx %p %lx %lx\n",
3143           debugstr_guid(pClassGuid), pszClassName,
3144           samDesired, Disposition, phkClass, ulFlags, hMachine);
3145
3146     if (pszClassName != NULL)
3147     {
3148        if (CaptureAndConvertAnsiArg(pszClassName, &pszClassNameW))
3149          return CR_INVALID_DATA;
3150     }
3151
3152     rc = CM_Open_Class_Key_ExW(pClassGuid, pszClassNameW, samDesired,
3153                                Disposition, phkClass, ulFlags, hMachine);
3154
3155     if (pszClassNameW != NULL)
3156         MyFree(pszClassNameW);
3157
3158     return CR_SUCCESS;
3159 }
3160
3161
3162 /***********************************************************************
3163  * CM_Open_Class_Key_ExW [SETUPAPI.@]
3164  */
3165 CONFIGRET WINAPI CM_Open_Class_Key_ExW(
3166     LPGUID pClassGuid, LPCWSTR pszClassName, REGSAM samDesired,
3167     REGDISPOSITION Disposition, PHKEY phkClass, ULONG ulFlags,
3168     HMACHINE hMachine)
3169 {
3170     WCHAR szKeyName[MAX_PATH];
3171     LPWSTR lpGuidString;
3172     DWORD dwDisposition;
3173     DWORD dwError;
3174     HKEY hKey;
3175
3176     TRACE("%p %s %lx %lx %p %lx %lx\n",
3177           debugstr_guid(pClassGuid), debugstr_w(pszClassName),
3178           samDesired, Disposition, phkClass, ulFlags, hMachine);
3179
3180     /* Check Disposition and ulFlags */
3181     if ((Disposition & ~RegDisposition_Bits) ||
3182         (ulFlags & ~CM_OPEN_CLASS_KEY_BITS))
3183         return CR_INVALID_FLAG;
3184
3185     /* Check phkClass */
3186     if (phkClass == NULL)
3187         return CR_INVALID_POINTER;
3188
3189     *phkClass = NULL;
3190
3191     if (ulFlags == CM_OPEN_CLASS_KEY_INTERFACE &&
3192         pszClassName != NULL)
3193         return CR_INVALID_DATA;
3194
3195     if (hMachine == NULL)
3196     {
3197         hKey = HKEY_LOCAL_MACHINE;
3198     }
3199     else
3200     {
3201        if (RegConnectRegistryW(((PMACHINE_INFO)hMachine)->szMachineName,
3202                                HKEY_LOCAL_MACHINE, &hKey))
3203            return CR_REGISTRY_ERROR;
3204     }
3205
3206     if (ulFlags & CM_OPEN_CLASS_KEY_INTERFACE)
3207     {
3208         lstrcpyW(szKeyName, DeviceClasses);
3209     }
3210     else
3211     {
3212         lstrcpyW(szKeyName, ControlClass);
3213     }
3214
3215     if (pClassGuid != NULL)
3216     {
3217         if (UuidToStringW((UUID*)pClassGuid, &lpGuidString) != RPC_S_OK)
3218         {
3219             RegCloseKey(hKey);
3220             return CR_INVALID_DATA;
3221         }
3222
3223         lstrcatW(szKeyName, Backslash);
3224         lstrcatW(szKeyName, lpGuidString);
3225     }
3226
3227     if (Disposition == RegDisposition_OpenAlways)
3228     {
3229         dwError = RegCreateKeyExW(hKey, szKeyName, 0, NULL, 0, samDesired,
3230                                   NULL, phkClass, &dwDisposition);
3231     }
3232     else
3233     {
3234         dwError = RegOpenKeyExW(hKey, szKeyName, 0, samDesired, phkClass);
3235     }
3236
3237     RegCloseKey(hKey);
3238
3239     if (pClassGuid != NULL)
3240         RpcStringFreeW(&lpGuidString);
3241
3242     if (dwError != ERROR_SUCCESS)
3243     {
3244         *phkClass = NULL;
3245         return CR_NO_SUCH_REGISTRY_KEY;
3246     }
3247
3248     if (pszClassName != NULL)
3249     {
3250         RegSetValueExW(*phkClass, Class, 0, REG_SZ, (LPBYTE)pszClassName,
3251                        (lstrlenW(pszClassName) + 1) * sizeof(WCHAR));
3252     }
3253
3254     return CR_SUCCESS;
3255 }
3256
3257
3258 /***********************************************************************
3259  * CM_Open_DevNode_Key [SETUPAPI.@]
3260  */
3261 CONFIGRET WINAPI CM_Open_DevNode_Key(
3262     DEVINST dnDevNode, REGSAM samDesired, ULONG ulHardwareProfile,
3263     REGDISPOSITION Disposition, PHKEY phkDevice, ULONG ulFlags)
3264 {
3265     TRACE("%lx %lx %lu %lx %p %lx\n", dnDevNode, samDesired,
3266           ulHardwareProfile, Disposition, phkDevice, ulFlags);
3267     return CM_Open_DevNode_Key_Ex(dnDevNode, samDesired, ulHardwareProfile,
3268                                   Disposition, phkDevice, ulFlags, NULL);
3269 }
3270
3271
3272 /***********************************************************************
3273  * CM_Open_DevNode_Key_Ex [SETUPAPI.@]
3274  */
3275 CONFIGRET WINAPI CM_Open_DevNode_Key_Ex(
3276     DEVINST dnDevNode, REGSAM samDesired, ULONG ulHardwareProfile,
3277     REGDISPOSITION Disposition, PHKEY phkDevice, ULONG ulFlags,
3278     HMACHINE hMachine)
3279 {
3280     FIXME("%lx %lx %lu %lx %p %lx %lx\n", dnDevNode, samDesired,
3281           ulHardwareProfile, Disposition, phkDevice, ulFlags, hMachine);
3282
3283     return CR_CALL_NOT_IMPLEMENTED;
3284 }
3285
3286
3287 /***********************************************************************
3288  * CM_Reenumerate_DevNode [SETUPAPI.@]
3289  */
3290 CONFIGRET WINAPI CM_Reenumerate_DevNode(
3291     DEVINST dnDevInst, ULONG ulFlags)
3292 {
3293     TRACE("%lx %lx\n", dnDevInst, ulFlags);
3294     return CM_Reenumerate_DevNode_Ex(dnDevInst, ulFlags, NULL);
3295 }
3296
3297
3298 /***********************************************************************
3299  * CM_Reenumerate_DevNode_Ex [SETUPAPI.@]
3300  */
3301 CONFIGRET WINAPI
3302 CM_Reenumerate_DevNode_Ex(
3303     DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
3304 {
3305     RPC_BINDING_HANDLE BindingHandle = NULL;
3306     HSTRING_TABLE StringTable = NULL;
3307     LPWSTR lpDevInst;
3308     CONFIGRET ret;
3309
3310     FIXME("%lx %lx %lx\n", dnDevInst, ulFlags, hMachine);
3311
3312     if (dnDevInst == 0)
3313         return CR_INVALID_DEVNODE;
3314
3315     if (ulFlags & ~CM_REENUMERATE_BITS)
3316         return CR_INVALID_FLAG;
3317
3318     if (hMachine != NULL)
3319     {
3320         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3321         if (BindingHandle == NULL)
3322             return CR_FAILURE;
3323
3324         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3325         if (StringTable == 0)
3326             return CR_FAILURE;
3327     }
3328     else
3329     {
3330         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
3331             return CR_FAILURE;
3332     }
3333
3334     lpDevInst = StringTableStringFromId(StringTable, dnDevInst);
3335     if (lpDevInst == NULL)
3336         return CR_INVALID_DEVNODE;
3337
3338     RpcTryExcept
3339     {
3340         ret = PNP_DeviceInstanceAction(BindingHandle,
3341                                        PNP_DEVINST_REENUMERATE,
3342                                        ulFlags,
3343                                        lpDevInst,
3344                                        NULL);
3345     }
3346     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3347     {
3348         ret = RpcStatusToCmStatus(RpcExceptionCode());
3349     }
3350     RpcEndExcept;
3351
3352     return ret;
3353 }
3354
3355
3356 /***********************************************************************
3357  * CM_Request_Eject_PC [SETUPAPI.@]
3358  */
3359 CONFIGRET WINAPI CM_Request_Eject_PC(VOID)
3360 {
3361     TRACE("\n");
3362     return CM_Request_Eject_PC_Ex(NULL);
3363 }
3364
3365
3366 /***********************************************************************
3367  * CM_Request_Eject_PC_Ex [SETUPAPI.@]
3368  */
3369 CONFIGRET WINAPI CM_Request_Eject_PC_Ex(
3370     HMACHINE hMachine)
3371 {
3372     RPC_BINDING_HANDLE BindingHandle = NULL;
3373     CONFIGRET ret;
3374
3375     TRACE("%lx\n", hMachine);
3376
3377     if (hMachine != NULL)
3378     {
3379         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3380         if (BindingHandle == NULL)
3381             return CR_FAILURE;
3382     }
3383     else
3384     {
3385         if (!PnpGetLocalHandles(&BindingHandle, NULL))
3386             return CR_FAILURE;
3387     }
3388
3389     RpcTryExcept
3390     {
3391         ret = PNP_RequestEjectPC(BindingHandle);
3392     }
3393     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3394     {
3395         ret = RpcStatusToCmStatus(RpcExceptionCode());
3396     }
3397     RpcEndExcept;
3398
3399     return ret;
3400 }
3401
3402
3403 /***********************************************************************
3404  * CM_Run_Detection [SETUPAPI.@]
3405  */
3406 CONFIGRET WINAPI CM_Run_Detection(
3407     ULONG ulFlags)
3408 {
3409     TRACE("%lx\n", ulFlags);
3410     return CM_Run_Detection_Ex(ulFlags, NULL);
3411 }
3412
3413
3414 /***********************************************************************
3415  * CM_Run_Detection_Ex [SETUPAPI.@]
3416  */
3417 CONFIGRET WINAPI CM_Run_Detection_Ex(
3418     ULONG ulFlags, HMACHINE hMachine)
3419 {
3420     RPC_BINDING_HANDLE BindingHandle = NULL;
3421     CONFIGRET ret;
3422
3423     TRACE("%lx %lx\n", ulFlags, hMachine);
3424
3425     if (!IsUserAdmin())
3426         return CR_ACCESS_DENIED;
3427
3428     if (ulFlags & ~CM_DETECT_BITS)
3429         return CR_INVALID_FLAG;
3430
3431     if (hMachine != NULL)
3432     {
3433         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3434         if (BindingHandle == NULL)
3435             return CR_FAILURE;
3436     }
3437     else
3438     {
3439         if (!PnpGetLocalHandles(&BindingHandle, NULL))
3440             return CR_FAILURE;
3441     }
3442
3443     RpcTryExcept
3444     {
3445         ret = PNP_RunDetection(BindingHandle,
3446                                ulFlags);
3447     }
3448     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3449     {
3450         ret = RpcStatusToCmStatus(RpcExceptionCode());
3451     }
3452     RpcEndExcept;
3453
3454     return ret;
3455 }
3456
3457
3458 /***********************************************************************
3459  * CM_Set_DevNode_Problem [SETUPAPI.@]
3460  */
3461 CONFIGRET WINAPI CM_Set_DevNode_Problem(
3462     DEVINST dnDevInst, ULONG ulProblem, ULONG ulFlags)
3463 {
3464     TRACE("%lx %lx %lx\n", dnDevInst, ulProblem, ulFlags);
3465     return CM_Set_DevNode_Problem_Ex(dnDevInst, ulProblem, ulFlags, NULL);
3466 }
3467
3468
3469 /***********************************************************************
3470  * CM_Set_DevNode_Problem_Ex [SETUPAPI.@]
3471  */
3472 CONFIGRET WINAPI CM_Set_DevNode_Problem_Ex(
3473     DEVINST dnDevInst, ULONG ulProblem, ULONG ulFlags, HMACHINE hMachine)
3474 {
3475     RPC_BINDING_HANDLE BindingHandle = NULL;
3476     HSTRING_TABLE StringTable = NULL;
3477     LPWSTR lpDevInst;
3478     CONFIGRET ret;
3479
3480     TRACE("%lx %lx %lx %lx\n", dnDevInst, ulProblem, ulFlags, hMachine);
3481
3482     if (dnDevInst == 0)
3483         return CR_INVALID_DEVNODE;
3484
3485     if (ulFlags & ~CM_SET_DEVNODE_PROBLEM_BITS)
3486         return CR_INVALID_FLAG;
3487
3488     if (hMachine != NULL)
3489     {
3490         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3491         if (BindingHandle == NULL)
3492             return CR_FAILURE;
3493
3494         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3495         if (StringTable == 0)
3496             return CR_FAILURE;
3497     }
3498     else
3499     {
3500         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
3501             return CR_FAILURE;
3502     }
3503
3504     lpDevInst = StringTableStringFromId(StringTable, dnDevInst);
3505     if (lpDevInst == NULL)
3506         return CR_INVALID_DEVNODE;
3507
3508     RpcTryExcept
3509     {
3510         ret = PNP_SetDeviceProblem(BindingHandle,
3511                                    lpDevInst,
3512                                    ulProblem,
3513                                    ulFlags);
3514     }
3515     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3516     {
3517         ret = RpcStatusToCmStatus(RpcExceptionCode());
3518     }
3519     RpcEndExcept;
3520
3521     return ret;
3522 }
3523
3524
3525 /***********************************************************************
3526  * CM_Set_DevNode_Registry_PropertyA [SETUPAPI.@]
3527  */
3528 CONFIGRET WINAPI CM_Set_DevNode_Registry_PropertyA(
3529     DEVINST dnDevInst, ULONG ulProperty, PCVOID Buffer, ULONG ulLength,
3530     ULONG ulFlags)
3531 {
3532     TRACE("%lx %lu %p %lx %lx\n",
3533           dnDevInst, ulProperty, Buffer, ulLength, ulFlags);
3534     return CM_Set_DevNode_Registry_Property_ExA(dnDevInst, ulProperty,
3535                                                 Buffer, ulLength,
3536                                                 ulFlags, NULL);
3537 }
3538
3539
3540 /***********************************************************************
3541  * CM_Set_DevNode_Registry_PropertyW [SETUPAPI.@]
3542  */
3543 CONFIGRET WINAPI CM_Set_DevNode_Registry_PropertyW(
3544     DEVINST dnDevInst, ULONG ulProperty, PCVOID Buffer, ULONG ulLength,
3545     ULONG ulFlags)
3546 {
3547     TRACE("%lx %lu %p %lx %lx\n",
3548           dnDevInst, ulProperty, Buffer, ulLength, ulFlags);
3549     return CM_Set_DevNode_Registry_Property_ExW(dnDevInst, ulProperty,
3550                                                 Buffer, ulLength,
3551                                                 ulFlags, NULL);
3552 }
3553
3554
3555 /***********************************************************************
3556  * CM_Set_DevNode_Registry_Property_ExA [SETUPAPI.@]
3557  */
3558 CONFIGRET WINAPI CM_Set_DevNode_Registry_Property_ExA(
3559     DEVINST dnDevInst, ULONG ulProperty, PCVOID Buffer, ULONG ulLength,
3560     ULONG ulFlags, HMACHINE hMachine)
3561 {
3562     CONFIGRET ret = CR_SUCCESS;
3563     LPWSTR lpBuffer;
3564     ULONG ulType;
3565
3566     FIXME("%lx %lu %p %lx %lx %lx\n",
3567           dnDevInst, ulProperty, Buffer, ulLength, ulFlags, hMachine);
3568
3569     if (Buffer == NULL && ulLength != 0)
3570         return CR_INVALID_POINTER;
3571
3572     if (Buffer == NULL)
3573     {
3574         ret = CM_Set_DevNode_Registry_Property_ExW(dnDevInst,
3575                                                    ulProperty,
3576                                                    NULL,
3577                                                    0,
3578                                                    ulFlags,
3579                                                    hMachine);
3580     }
3581     else
3582     {
3583         /* Get property type */
3584         switch (ulProperty)
3585         {
3586             case CM_DRP_DEVICEDESC:
3587                 ulType = REG_SZ;
3588                 break;
3589
3590             case CM_DRP_HARDWAREID:
3591                 ulType = REG_MULTI_SZ;
3592                 break;
3593
3594             case CM_DRP_COMPATIBLEIDS:
3595                 ulType = REG_MULTI_SZ;
3596                 break;
3597
3598             case CM_DRP_SERVICE:
3599                 ulType = REG_SZ;
3600                 break;
3601
3602             case CM_DRP_CLASS:
3603                 ulType = REG_SZ;
3604                 break;
3605
3606             case CM_DRP_CLASSGUID:
3607                 ulType = REG_SZ;
3608                 break;
3609
3610             case CM_DRP_DRIVER:
3611                 ulType = REG_SZ;
3612                 break;
3613
3614             case CM_DRP_CONFIGFLAGS:
3615                 ulType = REG_DWORD;
3616                 break;
3617
3618             case CM_DRP_MFG:
3619                 ulType = REG_SZ;
3620                 break;
3621
3622             case CM_DRP_FRIENDLYNAME:
3623                 ulType = REG_SZ;
3624                 break;
3625
3626             case CM_DRP_LOCATION_INFORMATION:
3627                 ulType = REG_SZ;
3628                 break;
3629
3630             case CM_DRP_UPPERFILTERS:
3631                 ulType = REG_MULTI_SZ;
3632                 break;
3633
3634             case CM_DRP_LOWERFILTERS:
3635                 ulType = REG_MULTI_SZ;
3636                 break;
3637
3638             default:
3639                 return CR_INVALID_PROPERTY;
3640         }
3641
3642         /* Allocate buffer if needed */
3643         if (ulType == REG_SZ ||
3644             ulType == REG_MULTI_SZ)
3645         {
3646             lpBuffer = MyMalloc(ulLength * sizeof(WCHAR));
3647             if (lpBuffer == NULL)
3648             {
3649                 ret = CR_OUT_OF_MEMORY;
3650             }
3651             else
3652             {
3653                 if (!MultiByteToWideChar(CP_ACP, 0, Buffer,
3654                                          ulLength, lpBuffer, ulLength))
3655                 {
3656                     MyFree(lpBuffer);
3657                     ret = CR_FAILURE;
3658                 }
3659                 else
3660                 {
3661                     ret = CM_Set_DevNode_Registry_Property_ExW(dnDevInst,
3662                                                                ulProperty,
3663                                                                lpBuffer,
3664                                                                ulLength * sizeof(WCHAR),
3665                                                                ulFlags,
3666                                                                hMachine);
3667                     MyFree(lpBuffer);
3668                 }
3669             }
3670         }
3671         else
3672         {
3673             ret = CM_Set_DevNode_Registry_Property_ExW(dnDevInst,
3674                                                        ulProperty,
3675                                                        Buffer,
3676                                                        ulLength,
3677                                                        ulFlags,
3678                                                        hMachine);
3679         }
3680
3681         ret = CR_CALL_NOT_IMPLEMENTED;
3682     }
3683
3684     return ret;
3685 }
3686
3687
3688 /***********************************************************************
3689  * CM_Set_DevNode_Registry_Property_ExW [SETUPAPI.@]
3690  */
3691 CONFIGRET WINAPI CM_Set_DevNode_Registry_Property_ExW(
3692     DEVINST dnDevInst, ULONG ulProperty, PCVOID Buffer, ULONG ulLength,
3693     ULONG ulFlags, HMACHINE hMachine)
3694 {
3695     RPC_BINDING_HANDLE BindingHandle = NULL;
3696     HSTRING_TABLE StringTable = NULL;
3697     LPWSTR lpDevInst;
3698     ULONG ulType;
3699     CONFIGRET ret;
3700
3701     TRACE("%lx %lu %p %lx %lx %lx\n",
3702           dnDevInst, ulProperty, Buffer, ulLength, ulFlags, hMachine);
3703
3704     if (dnDevInst == 0)
3705         return CR_INVALID_DEVNODE;
3706
3707     if (ulProperty <  CM_DRP_MIN || ulProperty > CM_DRP_MAX)
3708         return CR_INVALID_PROPERTY;
3709
3710     if (Buffer != NULL && ulLength == 0)
3711         return CR_INVALID_POINTER;
3712
3713     if (ulFlags != 0)
3714         return CR_INVALID_FLAG;
3715
3716     if (hMachine != NULL)
3717     {
3718         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3719         if (BindingHandle == NULL)
3720             return CR_FAILURE;
3721
3722         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3723         if (StringTable == 0)
3724             return CR_FAILURE;
3725     }
3726     else
3727     {
3728         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
3729             return CR_FAILURE;
3730     }
3731
3732     lpDevInst = StringTableStringFromId(StringTable, dnDevInst);
3733     if (lpDevInst == NULL)
3734         return CR_INVALID_DEVNODE;
3735
3736     switch (ulProperty)
3737     {
3738         case CM_DRP_DEVICEDESC:
3739             ulType = REG_SZ;
3740             break;
3741
3742         case CM_DRP_HARDWAREID:
3743             ulType = REG_MULTI_SZ;
3744             break;
3745
3746         case CM_DRP_COMPATIBLEIDS:
3747             ulType = REG_MULTI_SZ;
3748             break;
3749
3750         case CM_DRP_SERVICE:
3751             ulType = REG_SZ;
3752             break;
3753
3754         case CM_DRP_CLASS:
3755             ulType = REG_SZ;
3756             break;
3757
3758         case CM_DRP_CLASSGUID:
3759             ulType = REG_SZ;
3760             break;
3761
3762         case CM_DRP_DRIVER:
3763             ulType = REG_SZ;
3764             break;
3765
3766         case CM_DRP_CONFIGFLAGS:
3767             ulType = REG_DWORD;
3768             break;
3769
3770         case CM_DRP_MFG:
3771             ulType = REG_SZ;
3772             break;
3773
3774         case CM_DRP_FRIENDLYNAME:
3775             ulType = REG_SZ;
3776             break;
3777
3778         case CM_DRP_LOCATION_INFORMATION:
3779             ulType = REG_SZ;
3780             break;
3781
3782         case CM_DRP_UPPERFILTERS:
3783             ulType = REG_MULTI_SZ;
3784             break;
3785
3786         case CM_DRP_LOWERFILTERS:
3787             ulType = REG_MULTI_SZ;
3788             break;
3789
3790         default:
3791             return CR_INVALID_PROPERTY;
3792     }
3793
3794     RpcTryExcept
3795     {
3796         ret = PNP_SetDeviceRegProp(BindingHandle,
3797                                    lpDevInst,
3798                                    ulProperty,
3799                                    ulType,
3800                                    (BYTE *)Buffer,
3801                                    ulLength,
3802                                    ulFlags);
3803     }
3804     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3805     {
3806         ret = RpcStatusToCmStatus(RpcExceptionCode());
3807     }
3808     RpcEndExcept;
3809
3810     return ret;
3811 }
3812
3813
3814 /***********************************************************************
3815  * CM_Set_HW_Prof [SETUPAPI.@]
3816  */
3817 CONFIGRET WINAPI CM_Set_HW_Prof(
3818     ULONG ulHardwareProfile, ULONG ulFlags)
3819 {
3820     TRACE("%lu %lu\n", ulHardwareProfile, ulFlags);
3821     return CM_Set_HW_Prof_Ex(ulHardwareProfile, ulFlags, NULL);
3822 }
3823
3824
3825 /***********************************************************************
3826  * CM_Set_HW_Prof_Ex [SETUPAPI.@]
3827  */
3828 CONFIGRET WINAPI CM_Set_HW_Prof_Ex(
3829     ULONG ulHardwareProfile, ULONG ulFlags, HMACHINE hMachine)
3830 {
3831     RPC_BINDING_HANDLE BindingHandle = NULL;
3832     CONFIGRET ret;
3833
3834     TRACE("%lu %lu %lx\n", ulHardwareProfile, ulFlags, hMachine);
3835
3836     if (!IsUserAdmin())
3837         return CR_ACCESS_DENIED;
3838
3839     if (ulFlags != 0)
3840         return CR_INVALID_FLAG;
3841
3842     if (hMachine != NULL)
3843     {
3844         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3845         if (BindingHandle == NULL)
3846             return CR_FAILURE;
3847     }
3848     else
3849     {
3850         if (!PnpGetLocalHandles(&BindingHandle, NULL))
3851             return CR_FAILURE;
3852     }
3853
3854     RpcTryExcept
3855     {
3856         ret = PNP_SetHwProf(BindingHandle, ulHardwareProfile, ulFlags);
3857     }
3858     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3859     {
3860         ret = RpcStatusToCmStatus(RpcExceptionCode());
3861     }
3862     RpcEndExcept;
3863
3864     return ret;
3865 }
3866
3867
3868 /***********************************************************************
3869  * CM_Set_HW_Prof_FlagsA [SETUPAPI.@]
3870  */
3871 CONFIGRET WINAPI CM_Set_HW_Prof_FlagsA(
3872     DEVINSTID_A szDevInstName, ULONG ulConfig, ULONG ulValue,
3873     ULONG ulFlags)
3874 {
3875     TRACE("%s %lu %lu %lx\n", szDevInstName,
3876           ulConfig, ulValue, ulFlags);
3877     return CM_Set_HW_Prof_Flags_ExA(szDevInstName, ulConfig, ulValue,
3878                                     ulFlags, NULL);
3879 }
3880
3881
3882 /***********************************************************************
3883  * CM_Set_HW_Prof_FlagsW [SETUPAPI.@]
3884  */
3885 CONFIGRET WINAPI CM_Set_HW_Prof_FlagsW(
3886     DEVINSTID_W szDevInstName, ULONG ulConfig, ULONG ulValue,
3887     ULONG ulFlags)
3888 {
3889     TRACE("%s %lu %lu %lx\n", debugstr_w(szDevInstName),
3890           ulConfig, ulValue, ulFlags);
3891     return CM_Set_HW_Prof_Flags_ExW(szDevInstName, ulConfig, ulValue,
3892                                     ulFlags, NULL);
3893 }
3894
3895
3896 /***********************************************************************
3897  * CM_Set_HW_Prof_Flags_ExA [SETUPAPI.@]
3898  */
3899 CONFIGRET WINAPI CM_Set_HW_Prof_Flags_ExA(
3900     DEVINSTID_A szDevInstName, ULONG ulConfig, ULONG ulValue,
3901     ULONG ulFlags, HMACHINE hMachine)
3902 {
3903     DEVINSTID_W pszDevIdW = NULL;
3904     CONFIGRET ret = CR_SUCCESS;
3905
3906     TRACE("%s %lu %lu %lx %lx\n", szDevInstName,
3907           ulConfig, ulValue, ulFlags, hMachine);
3908
3909     if (szDevInstName != NULL)
3910     {
3911        if (CaptureAndConvertAnsiArg(szDevInstName, &pszDevIdW))
3912          return CR_INVALID_DEVICE_ID;
3913     }
3914
3915     ret = CM_Set_HW_Prof_Flags_ExW(pszDevIdW, ulConfig, ulValue,
3916                                    ulFlags, hMachine);
3917
3918     if (pszDevIdW != NULL)
3919         MyFree(pszDevIdW);
3920
3921     return ret;
3922 }
3923
3924
3925 /***********************************************************************
3926  * CM_Set_HW_Prof_Flags_ExW [SETUPAPI.@]
3927  */
3928 CONFIGRET WINAPI CM_Set_HW_Prof_Flags_ExW(
3929     DEVINSTID_W szDevInstName, ULONG ulConfig, ULONG ulValue,
3930     ULONG ulFlags, HMACHINE hMachine)
3931 {
3932     RPC_BINDING_HANDLE BindingHandle = NULL;
3933     CONFIGRET ret;
3934
3935     FIXME("%s %lu %lu %lx %lx\n", debugstr_w(szDevInstName),
3936           ulConfig, ulValue, ulFlags, hMachine);
3937
3938     if (szDevInstName == NULL)
3939         return CR_INVALID_POINTER;
3940
3941     if (ulFlags & ~ CM_SET_HW_PROF_FLAGS_BITS)
3942         return CR_INVALID_FLAG;
3943
3944     /* FIXME: Check whether szDevInstName is valid */
3945
3946     if (hMachine != NULL)
3947     {
3948         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3949         if (BindingHandle == NULL)
3950             return CR_FAILURE;
3951     }
3952     else
3953     {
3954         if (!PnpGetLocalHandles(&BindingHandle, NULL))
3955             return CR_FAILURE;
3956     }
3957
3958     RpcTryExcept
3959     {
3960         ret = PNP_HwProfFlags(BindingHandle, PNP_SET_HWPROFFLAGS, szDevInstName,
3961                               ulConfig, &ulValue, NULL, NULL, 0, 0);
3962     }
3963     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3964     {
3965         ret = RpcStatusToCmStatus(RpcExceptionCode());
3966     }
3967     RpcEndExcept;
3968
3969     return ret;
3970 }
3971
3972
3973 /***********************************************************************
3974  * CM_Setup_DevNode [SETUPAPI.@]
3975  */
3976 CONFIGRET WINAPI CM_Setup_DevNode(
3977     DEVINST dnDevInst, ULONG ulFlags)
3978 {
3979     TRACE("%lx %lx\n", dnDevInst, ulFlags);
3980     return CM_Setup_DevNode_Ex(dnDevInst, ulFlags, NULL);
3981 }
3982
3983
3984 /***********************************************************************
3985  * CM_Setup_DevNode_Ex [SETUPAPI.@]
3986  */
3987 CONFIGRET WINAPI CM_Setup_DevNode_Ex(
3988     DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
3989 {
3990     RPC_BINDING_HANDLE BindingHandle = NULL;
3991     HSTRING_TABLE StringTable = NULL;
3992     LPWSTR lpDevInst;
3993     CONFIGRET ret;
3994
3995     FIXME("%lx %lx %lx\n", dnDevInst, ulFlags, hMachine);
3996
3997     if (!IsUserAdmin())
3998         return CR_ACCESS_DENIED;
3999
4000     if (dnDevInst == 0)
4001         return CR_INVALID_DEVNODE;
4002
4003     if (ulFlags & ~CM_SETUP_BITS)
4004         return CR_INVALID_FLAG;
4005
4006     if (hMachine != NULL)
4007     {
4008         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4009         if (BindingHandle == NULL)
4010             return CR_FAILURE;
4011
4012         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4013         if (StringTable == 0)
4014             return CR_FAILURE;
4015     }
4016     else
4017     {
4018         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
4019             return CR_FAILURE;
4020     }
4021
4022     lpDevInst = StringTableStringFromId(StringTable, dnDevInst);
4023     if (lpDevInst == NULL)
4024         return CR_INVALID_DEVNODE;
4025
4026     RpcTryExcept
4027     {
4028         ret = PNP_DeviceInstanceAction(BindingHandle,
4029                                        PNP_DEVINST_SETUP,
4030                                        ulFlags,
4031                                        lpDevInst,
4032                                        NULL);
4033     }
4034     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
4035     {
4036         ret = RpcStatusToCmStatus(RpcExceptionCode());
4037     }
4038     RpcEndExcept;
4039
4040     return ret;
4041 }
4042
4043
4044 /***********************************************************************
4045  * CM_Uninstall_DevNode [SETUPAPI.@]
4046  */
4047 CONFIGRET WINAPI CM_Uninstall_DevNode(
4048     DEVINST dnPhantom, ULONG ulFlags)
4049 {
4050     TRACE("%lx %lx\n", dnPhantom, ulFlags);
4051     return CM_Uninstall_DevNode_Ex(dnPhantom, ulFlags, NULL);
4052 }
4053
4054
4055 /***********************************************************************
4056  * CM_Uninstall_DevNode_Ex [SETUPAPI.@]
4057  */
4058 CONFIGRET WINAPI CM_Uninstall_DevNode_Ex(
4059     DEVINST dnPhantom, ULONG ulFlags, HMACHINE hMachine)
4060 {
4061     RPC_BINDING_HANDLE BindingHandle = NULL;
4062     HSTRING_TABLE StringTable = NULL;
4063     LPWSTR lpDevInst;
4064     CONFIGRET ret;
4065
4066     TRACE("%lx %lx %lx\n", dnPhantom, ulFlags, hMachine);
4067
4068     if (dnPhantom == 0)
4069         return CR_INVALID_DEVNODE;
4070
4071     if (ulFlags != 0)
4072         return CR_INVALID_FLAG;
4073
4074     if (hMachine != NULL)
4075     {
4076         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4077         if (BindingHandle == NULL)
4078             return CR_FAILURE;
4079
4080         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4081         if (StringTable == 0)
4082             return CR_FAILURE;
4083     }
4084     else
4085     {
4086         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
4087             return CR_FAILURE;
4088     }
4089
4090     lpDevInst = StringTableStringFromId(StringTable, dnPhantom);
4091     if (lpDevInst == NULL)
4092         return CR_INVALID_DEVNODE;
4093
4094     RpcTryExcept
4095     {
4096         ret = PNP_UninstallDevInst(BindingHandle,
4097                                    lpDevInst,
4098                                    ulFlags);
4099     }
4100     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
4101     {
4102         ret = RpcStatusToCmStatus(RpcExceptionCode());
4103     }
4104     RpcEndExcept;
4105
4106     return ret;
4107 }