reactos/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 = pSetupIsUserAdmin();
 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  * CMP_WaitServicesAvailable [SETUPAPI.@]
 184  */
 185 CONFIGRET
 186 WINAPI
 187 CMP_WaitServicesAvailable(HMACHINE hMachine)
 188 {
 189     RPC_BINDING_HANDLE BindingHandle = NULL;
 190     CONFIGRET ret = CR_SUCCESS;
 191     WORD Version;
 192
 193     if (!PnpGetLocalHandles(&BindingHandle, NULL))
 194         return CR_FAILURE;
 195
 196     RpcTryExcept
 197     {
 198         ret = PNP_GetVersion(BindingHandle, &Version);
 199     }
 200     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 201     {
 202         ret = RpcStatusToCmStatus(RpcExceptionCode());
 203     }
 204     RpcEndExcept;
 205
 206     return ret;
 207 }
 208
 209
 210 /***********************************************************************
 211  * CM_Add_Empty_Log_Conf [SETUPAPI.@]
 212  */
 213 CONFIGRET WINAPI CM_Add_Empty_Log_Conf(
 214     PLOG_CONF plcLogConf, DEVINST dnDevInst, PRIORITY Priority,
 215     ULONG ulFlags)
 216 {
 217     TRACE("%p %p %lu %lx\n", plcLogConf, dnDevInst, Priority, ulFlags);
 218     return CM_Add_Empty_Log_Conf_Ex(plcLogConf, dnDevInst, Priority,
 219                                     ulFlags, NULL);
 220 }
 221
 222
 223 /***********************************************************************
 224  * CM_Add_Empty_Log_Conf_Ex [SETUPAPI.@]
 225  */
 226 CONFIGRET WINAPI CM_Add_Empty_Log_Conf_Ex(
 227     PLOG_CONF plcLogConf, DEVINST dnDevInst, PRIORITY Priority,
 228     ULONG ulFlags, HMACHINE hMachine)
 229 {
 230     RPC_BINDING_HANDLE BindingHandle = NULL;
 231     HSTRING_TABLE StringTable = NULL;
 232     ULONG ulLogConfTag = 0;
 233     LPWSTR lpDevInst;
 234     PLOG_CONF_INFO pLogConfInfo;
 235     CONFIGRET ret = CR_SUCCESS;
 236
 237     FIXME("%p %p %lu %lx %p\n",
 238           plcLogConf, dnDevInst, Priority, ulFlags, hMachine);
 239
 240     if (!pSetupIsUserAdmin())
 241         return CR_ACCESS_DENIED;
 242
 243     if (plcLogConf == NULL)
 244         return CR_INVALID_POINTER;
 245
 246     if (dnDevInst == 0)
 247         return CR_INVALID_DEVINST;
 248
 249     if (Priority > 0xFFFF)
 250         return CR_INVALID_PRIORITY;
 251
 252     if (ulFlags & ~(LOG_CONF_BITS | PRIORITY_BIT))
 253         return CR_INVALID_FLAG;
 254
 255     if (hMachine != NULL)
 256     {
 257         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
 258         if (BindingHandle == NULL)
 259             return CR_FAILURE;
 260
 261         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
 262         if (StringTable == 0)
 263             return CR_FAILURE;
 264     }
 265     else
 266     {
 267         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
 268             return CR_FAILURE;
 269     }
 270
 271     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
 272     if (lpDevInst == NULL)
 273         return CR_INVALID_DEVNODE;
 274
 275     RpcTryExcept
 276     {
 277         ret = PNP_AddEmptyLogConf(BindingHandle, lpDevInst, Priority,
 278                                   &ulLogConfTag, ulFlags);
 279     }
 280     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 281     {
 282         ret = RpcStatusToCmStatus(RpcExceptionCode());
 283     }
 284     RpcEndExcept;
 285
 286     if (ret == CR_SUCCESS)
 287     {
 288         pLogConfInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(LOG_CONF_INFO));
 289         if (pLogConfInfo == NULL)
 290         {
 291             ret = CR_OUT_OF_MEMORY;
 292         }
 293         else
 294         {
 295             pLogConfInfo->ulMagic = LOG_CONF_MAGIC;
 296             pLogConfInfo->dnDevInst = dnDevInst;
 297             pLogConfInfo->ulFlags = ulFlags;
 298             pLogConfInfo->ulTag = ulLogConfTag;
 299
 300             *plcLogConf = (LOG_CONF)pLogConfInfo;
 301
 302             ret = CR_SUCCESS;
 303         }
 304     }
 305
 306     return ret;
 307 }
 308
 309
 310 /***********************************************************************
 311  * CM_Add_IDA [SETUPAPI.@]
 312  */
 313 CONFIGRET WINAPI CM_Add_IDA(
 314     DEVINST dnDevInst, PSTR pszID, ULONG ulFlags)
 315 {
 316     TRACE("%p %s %lx\n", dnDevInst, pszID, ulFlags);
 317     return CM_Add_ID_ExA(dnDevInst, pszID, ulFlags, NULL);
 318 }
 319
 320
 321 /***********************************************************************
 322  * CM_Add_IDW [SETUPAPI.@]
 323  */
 324 CONFIGRET WINAPI CM_Add_IDW(
 325     DEVINST dnDevInst, PWSTR pszID, ULONG ulFlags)
 326 {
 327     TRACE("%p %s %lx\n", dnDevInst, debugstr_w(pszID), ulFlags);
 328     return CM_Add_ID_ExW(dnDevInst, pszID, ulFlags, NULL);
 329 }
 330
 331
 332 /***********************************************************************
 333  * CM_Add_ID_ExA [SETUPAPI.@]
 334  */
 335 CONFIGRET WINAPI CM_Add_ID_ExA(
 336     DEVINST dnDevInst, PSTR pszID, ULONG ulFlags, HMACHINE hMachine)
 337 {
 338     PWSTR pszIDW;
 339     CONFIGRET ret;
 340
 341     TRACE("%p %s %lx %p\n", dnDevInst, pszID, ulFlags, hMachine);
 342
 343     if (pSetupCaptureAndConvertAnsiArg(pszID, &pszIDW))
 344         return CR_INVALID_DATA;
 345
 346     ret = CM_Add_ID_ExW(dnDevInst, pszIDW, ulFlags, hMachine);
 347
 348     MyFree(pszIDW);
 349
 350     return ret;
 351 }
 352
 353
 354 /***********************************************************************
 355  * CM_Add_ID_ExW [SETUPAPI.@]
 356  */
 357 CONFIGRET WINAPI CM_Add_ID_ExW(
 358     DEVINST dnDevInst, PWSTR pszID, ULONG ulFlags, HMACHINE hMachine)
 359 {
 360     RPC_BINDING_HANDLE BindingHandle = NULL;
 361     HSTRING_TABLE StringTable = NULL;
 362     LPWSTR lpDevInst;
 363     CONFIGRET ret;
 364
 365     TRACE("%p %s %lx %p\n", dnDevInst, debugstr_w(pszID), ulFlags, hMachine);
 366
 367     if (!pSetupIsUserAdmin())
 368         return CR_ACCESS_DENIED;
 369
 370     if (dnDevInst == 0)
 371         return CR_INVALID_DEVINST;
 372
 373     if (pszID == NULL)
 374         return CR_INVALID_POINTER;
 375
 376     if (ulFlags & ~CM_ADD_ID_BITS)
 377         return CR_INVALID_FLAG;
 378
 379     if (hMachine != NULL)
 380     {
 381         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
 382         if (BindingHandle == NULL)
 383             return CR_FAILURE;
 384
 385         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
 386         if (StringTable == 0)
 387             return CR_FAILURE;
 388     }
 389     else
 390     {
 391         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
 392             return CR_FAILURE;
 393     }
 394
 395     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
 396     if (lpDevInst == NULL)
 397         return CR_INVALID_DEVNODE;
 398
 399     RpcTryExcept
 400     {
 401         ret = PNP_AddID(BindingHandle,
 402                         lpDevInst,
 403                         pszID,
 404                         ulFlags);
 405     }
 406     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 407     {
 408         ret = RpcStatusToCmStatus(RpcExceptionCode());
 409     }
 410     RpcEndExcept;
 411
 412     return ret;
 413 }
 414
 415
 416 /***********************************************************************
 417  * CM_Add_Res_Des [SETUPAPI.@]
 418  */
 419 CONFIGRET WINAPI CM_Add_Res_Des(
 420     PRES_DES prdResDes, LOG_CONF lcLogConf, RESOURCEID ResourceID,
 421     PCVOID ResourceData, ULONG ResourceLen, ULONG ulFlags)
 422 {
 423     TRACE("%p %p %lu %p %lu %lx\n", prdResDes, lcLogConf, ResourceID,
 424           ResourceData, ResourceLen, ulFlags);
 425     return CM_Add_Res_Des_Ex(prdResDes, lcLogConf, ResourceID, ResourceData,
 426                              ResourceLen, ulFlags, NULL);
 427 }
 428
 429
 430 /***********************************************************************
 431  * CM_Add_Res_Des_Ex [SETUPAPI.@]
 432  */
 433 CONFIGRET WINAPI CM_Add_Res_Des_Ex(
 434     PRES_DES prdResDes, LOG_CONF lcLogConf, RESOURCEID ResourceID,
 435     PCVOID ResourceData, ULONG ResourceLen, ULONG ulFlags, HMACHINE hMachine)
 436 {
 437     FIXME("%p %p %lu %p %lu %lx %p\n", prdResDes, lcLogConf, ResourceID,
 438           ResourceData, ResourceLen, ulFlags, hMachine);
 439
 440     return CR_CALL_NOT_IMPLEMENTED;
 441 }
 442
 443
 444 /***********************************************************************
 445  * CM_Connect_MachineA [SETUPAPI.@]
 446  */
 447 CONFIGRET WINAPI CM_Connect_MachineA(
 448     PCSTR UNCServerName, PHMACHINE phMachine)
 449 {
 450     PWSTR pServerNameW;
 451     CONFIGRET ret;
 452
 453     TRACE("%s %p\n", UNCServerName, phMachine);
 454
 455     if (UNCServerName == NULL || *UNCServerName == 0)
 456         return CM_Connect_MachineW(NULL, phMachine);
 457
 458     if (pSetupCaptureAndConvertAnsiArg(UNCServerName, &pServerNameW))
 459         return CR_INVALID_DATA;
 460
 461     ret = CM_Connect_MachineW(pServerNameW, phMachine);
 462
 463     MyFree(pServerNameW);
 464
 465     return ret;
 466 }
 467
 468
 469 /***********************************************************************
 470  * CM_Connect_MachineW [SETUPAPI.@]
 471  */
 472 CONFIGRET WINAPI CM_Connect_MachineW(
 473     PCWSTR UNCServerName, PHMACHINE phMachine)
 474 {
 475     PMACHINE_INFO pMachine;
 476
 477     TRACE("%s %p\n", debugstr_w(UNCServerName), phMachine);
 478
 479     if (phMachine == NULL)
 480         return CR_INVALID_POINTER;
 481
 482     *phMachine = NULL;
 483
 484     pMachine = HeapAlloc(GetProcessHeap(), 0, sizeof(MACHINE_INFO));
 485     if (pMachine == NULL)
 486         return CR_OUT_OF_MEMORY;
 487
 488     if (UNCServerName == NULL || *UNCServerName == 0)
 489     {
 490         pMachine->bLocal = TRUE;
 491
 492         /* FIXME: store the computers name in pMachine->szMachineName */
 493
 494         if (!PnpGetLocalHandles(&pMachine->BindingHandle,
 495                                 &pMachine->StringTable))
 496         {
 497             HeapFree(GetProcessHeap(), 0, pMachine);
 498             return CR_FAILURE;
 499         }
 500     }
 501     else
 502     {
 503         pMachine->bLocal = FALSE;
 504         if (wcslen(UNCServerName) >= SP_MAX_MACHINENAME_LENGTH - 1)
 505         {
 506             HeapFree(GetProcessHeap(), 0, pMachine);
 507             return CR_INVALID_MACHINENAME;
 508         }
 509         lstrcpyW(pMachine->szMachineName, UNCServerName);
 510
 511         pMachine->StringTable = pSetupStringTableInitialize();
 512         if (pMachine->StringTable == NULL)
 513         {
 514             HeapFree(GetProcessHeap(), 0, pMachine);
 515             return CR_FAILURE;
 516         }
 517
 518         pSetupStringTableAddString(pMachine->StringTable, L"PLT", 1);
 519
 520         if (!PnpBindRpc(UNCServerName, &pMachine->BindingHandle))
 521         {
 522             pSetupStringTableDestroy(pMachine->StringTable);
 523             HeapFree(GetProcessHeap(), 0, pMachine);
 524             return CR_INVALID_MACHINENAME;
 525         }
 526     }
 527
 528     phMachine = (PHMACHINE)pMachine;
 529
 530     return CR_SUCCESS;
 531 }
 532
 533
 534 /***********************************************************************
 535  * CM_Create_DevNodeA [SETUPAPI.@]
 536  */
 537 CONFIGRET WINAPI CM_Create_DevNodeA(
 538     PDEVINST pdnDevInst, DEVINSTID_A pDeviceID, DEVINST dnParent,
 539     ULONG ulFlags)
 540 {
 541     TRACE("%p %s %p %lx\n",
 542           pdnDevInst, debugstr_a(pDeviceID), dnParent, ulFlags);
 543     return CM_Create_DevNode_ExA(pdnDevInst, pDeviceID, dnParent,
 544                                  ulFlags, NULL);
 545 }
 546
 547
 548 /***********************************************************************
 549  * CM_Create_DevNodeW [SETUPAPI.@]
 550  */
 551 CONFIGRET WINAPI CM_Create_DevNodeW(
 552     PDEVINST pdnDevInst, DEVINSTID_W pDeviceID, DEVINST dnParent,
 553     ULONG ulFlags)
 554 {
 555     TRACE("%p %s %p %lx\n",
 556           pdnDevInst, debugstr_w(pDeviceID), dnParent, ulFlags);
 557     return CM_Create_DevNode_ExW(pdnDevInst, pDeviceID, dnParent,
 558                                  ulFlags, NULL);
 559 }
 560
 561
 562 /***********************************************************************
 563  * CM_Create_DevNode_ExA [SETUPAPI.@]
 564  */
 565 CONFIGRET WINAPI CM_Create_DevNode_ExA(
 566     PDEVINST pdnDevInst, DEVINSTID_A pDeviceID, DEVINST dnParent,
 567     ULONG ulFlags, HANDLE hMachine)
 568 {
 569     DEVINSTID_W pDeviceIDW;
 570     CONFIGRET ret;
 571
 572     TRACE("%p %s %p %lx %p\n",
 573           pdnDevInst, debugstr_a(pDeviceID), dnParent, ulFlags, hMachine);
 574
 575     if (pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDeviceIDW))
 576         return CR_INVALID_DATA;
 577
 578     ret = CM_Create_DevNode_ExW(pdnDevInst, pDeviceIDW, dnParent, ulFlags,
 579                                 hMachine);
 580
 581     MyFree(pDeviceIDW);
 582
 583     return ret;
 584 }
 585
 586
 587 /***********************************************************************
 588  * CM_Create_DevNode_ExW [SETUPAPI.@]
 589  */
 590 CONFIGRET WINAPI CM_Create_DevNode_ExW(
 591     PDEVINST pdnDevInst, DEVINSTID_W pDeviceID, DEVINST dnParent,
 592     ULONG ulFlags, HANDLE hMachine)
 593 {
 594     RPC_BINDING_HANDLE BindingHandle = NULL;
 595     HSTRING_TABLE StringTable = NULL;
 596     LPWSTR lpParentDevInst;
 597     CONFIGRET ret = CR_SUCCESS;
 598
 599     FIXME("%p %s %p %lx %p\n",
 600           pdnDevInst, debugstr_w(pDeviceID), dnParent, ulFlags, hMachine);
 601
 602     if (!pSetupIsUserAdmin())
 603         return CR_ACCESS_DENIED;
 604
 605     if (pdnDevInst == NULL)
 606         return CR_INVALID_POINTER;
 607
 608     if (pDeviceID == NULL || wcslen(pDeviceID) == 0)
 609         return CR_INVALID_DEVICE_ID;
 610
 611     if (dnParent == 0)
 612         return CR_INVALID_DEVNODE;
 613
 614     if (ulFlags & ~CM_CREATE_DEVNODE_BITS)
 615         return CR_INVALID_FLAG;
 616
 617     if (hMachine != NULL)
 618     {
 619         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
 620         if (BindingHandle == NULL)
 621             return CR_FAILURE;
 622
 623         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
 624         if (StringTable == 0)
 625             return CR_FAILURE;
 626     }
 627     else
 628     {
 629         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
 630             return CR_FAILURE;
 631     }
 632
 633     lpParentDevInst = pSetupStringTableStringFromId(StringTable, dnParent);
 634     if (lpParentDevInst == NULL)
 635         return CR_INVALID_DEVNODE;
 636
 637     RpcTryExcept
 638     {
 639         ret = PNP_CreateDevInst(BindingHandle,
 640                                 pDeviceID,
 641                                 lpParentDevInst,
 642                                 MAX_DEVICE_ID_LEN,
 643                                 ulFlags);
 644     }
 645     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 646     {
 647         ret = RpcStatusToCmStatus(RpcExceptionCode());
 648     }
 649     RpcEndExcept;
 650
 651     if (ret == CR_SUCCESS)
 652     {
 653         *pdnDevInst = pSetupStringTableAddString(StringTable, pDeviceID, 1);
 654         if (*pdnDevInst == 0)
 655             ret = CR_NO_SUCH_DEVNODE;
 656     }
 657
 658     return ret;
 659 }
 660
 661
 662 /***********************************************************************
 663  * CM_Delete_Class_Key [SETUPAPI.@]
 664  */
 665 CONFIGRET WINAPI CM_Delete_Class_Key(
 666     LPGUID ClassGuid, ULONG ulFlags)
 667 {
 668     TRACE("%p %lx\n", ClassGuid, ulFlags);
 669     return CM_Delete_Class_Key_Ex(ClassGuid, ulFlags, NULL);
 670 }
 671
 672
 673 /***********************************************************************
 674  * CM_Delete_Class_Key_Ex [SETUPAPI.@]
 675  */
 676 CONFIGRET WINAPI CM_Delete_Class_Key_Ex(
 677     LPGUID ClassGuid, ULONG ulFlags, HANDLE hMachine)
 678 {
 679     WCHAR szGuidString[MAX_GUID_STRING_LEN];
 680     RPC_BINDING_HANDLE BindingHandle = NULL;
 681     CONFIGRET ret;
 682
 683     TRACE("%p %lx %lx\n", ClassGuid, ulFlags, hMachine);
 684
 685     if (ClassGuid == NULL)
 686         return CR_INVALID_POINTER;
 687
 688     if (ulFlags & ~CM_DELETE_CLASS_BITS)
 689         return CR_INVALID_FLAG;
 690
 691     if (!GuidToString(ClassGuid, szGuidString))
 692         return CR_INVALID_DATA;
 693
 694     if (hMachine != NULL)
 695     {
 696         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
 697         if (BindingHandle == NULL)
 698             return CR_FAILURE;
 699     }
 700     else
 701     {
 702         if (!PnpGetLocalHandles(&BindingHandle, NULL))
 703             return CR_FAILURE;
 704     }
 705
 706     RpcTryExcept
 707     {
 708         ret = PNP_DeleteClassKey(BindingHandle,
 709                                  szGuidString,
 710                                  ulFlags);
 711     }
 712     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 713     {
 714         ret = RpcStatusToCmStatus(RpcExceptionCode());
 715     }
 716     RpcEndExcept;
 717
 718     return ret;
 719 }
 720
 721
 722 /***********************************************************************
 723  * CM_Delete_DevNode_Key [SETUPAPI.@]
 724  */
 725 CONFIGRET WINAPI CM_Delete_DevNode_Key(
 726     DEVNODE dnDevNode, ULONG ulHardwareProfile, ULONG ulFlags)
 727 {
 728     TRACE("%p %lu %lx\n", dnDevNode, ulHardwareProfile, ulFlags);
 729     return CM_Delete_DevNode_Key_Ex(dnDevNode, ulHardwareProfile, ulFlags,
 730                                     NULL);
 731 }
 732
 733
 734 /***********************************************************************
 735  * CM_Delete_DevNode_Key_Ex [SETUPAPI.@]
 736  */
 737 CONFIGRET WINAPI CM_Delete_DevNode_Key_Ex(
 738     DEVNODE dnDevNode, ULONG ulHardwareProfile, ULONG ulFlags,
 739     HANDLE hMachine)
 740 {
 741     FIXME("%p %lu %lx %p\n",
 742           dnDevNode, ulHardwareProfile, ulFlags, hMachine);
 743
 744     return CR_CALL_NOT_IMPLEMENTED;
 745 }
 746
 747
 748 /***********************************************************************
 749  * CM_Disable_DevNode [SETUPAPI.@]
 750  */
 751 CONFIGRET WINAPI CM_Disable_DevNode(
 752     DEVINST dnDevInst, ULONG ulFlags)
 753 {
 754     TRACE("%p %lx\n", dnDevInst, ulFlags);
 755     return CM_Disable_DevNode_Ex(dnDevInst, ulFlags, NULL);
 756 }
 757
 758
 759 /***********************************************************************
 760  * CM_Disable_DevNode_Ex [SETUPAPI.@]
 761  */
 762 CONFIGRET WINAPI CM_Disable_DevNode_Ex(
 763     DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
 764 {
 765     RPC_BINDING_HANDLE BindingHandle = NULL;
 766     HSTRING_TABLE StringTable = NULL;
 767     LPWSTR lpDevInst;
 768     CONFIGRET ret;
 769
 770     FIXME("%p %lx %p\n", dnDevInst, ulFlags, hMachine);
 771
 772     if (!pSetupIsUserAdmin())
 773         return CR_ACCESS_DENIED;
 774
 775     if (dnDevInst == 0)
 776         return CR_INVALID_DEVINST;
 777
 778     if (ulFlags != 0)
 779         return CR_INVALID_FLAG;
 780
 781     if (hMachine != NULL)
 782     {
 783         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
 784         if (BindingHandle == NULL)
 785             return CR_FAILURE;
 786
 787         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
 788         if (StringTable == 0)
 789             return CR_FAILURE;
 790     }
 791     else
 792     {
 793         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
 794             return CR_FAILURE;
 795     }
 796
 797     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
 798     if (lpDevInst == NULL)
 799         return CR_INVALID_DEVNODE;
 800
 801     RpcTryExcept
 802     {
 803         ret = PNP_DeviceInstanceAction(BindingHandle,
 804                                        PNP_DEVINST_DISABLE,
 805                                        ulFlags,
 806                                        lpDevInst,
 807                                        NULL);
 808     }
 809     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 810     {
 811         ret = RpcStatusToCmStatus(RpcExceptionCode());
 812     }
 813     RpcEndExcept;
 814
 815     return ret;
 816 }
 817
 818
 819 /***********************************************************************
 820  * CM_Disconnect_Machine [SETUPAPI.@]
 821  */
 822 CONFIGRET WINAPI CM_Disconnect_Machine(HMACHINE hMachine)
 823 {
 824     PMACHINE_INFO pMachine;
 825
 826     TRACE("%lx\n", hMachine);
 827
 828     pMachine = (PMACHINE_INFO)hMachine;
 829     if (pMachine == NULL)
 830         return CR_SUCCESS;
 831
 832     if (pMachine->bLocal == FALSE)
 833     {
 834         if (pMachine->StringTable != NULL)
 835             pSetupStringTableDestroy(pMachine->StringTable);
 836
 837         if (!PnpUnbindRpc(pMachine->BindingHandle))
 838             return CR_ACCESS_DENIED;
 839     }
 840
 841     HeapFree(GetProcessHeap(), 0, pMachine);
 842
 843     return CR_SUCCESS;
 844 }
 845
 846
 847 /***********************************************************************
 848  * CM_Enable_DevNode [SETUPAPI.@]
 849  */
 850 CONFIGRET WINAPI CM_Enable_DevNode(
 851     DEVINST dnDevInst, ULONG ulFlags)
 852 {
 853     TRACE("%p %lx\n", dnDevInst, ulFlags);
 854     return CM_Enable_DevNode_Ex(dnDevInst, ulFlags, NULL);
 855 }
 856
 857
 858 /***********************************************************************
 859  * CM_Enable_DevNode_Ex [SETUPAPI.@]
 860  */
 861 CONFIGRET WINAPI CM_Enable_DevNode_Ex(
 862     DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
 863 {
 864     RPC_BINDING_HANDLE BindingHandle = NULL;
 865     HSTRING_TABLE StringTable = NULL;
 866     LPWSTR lpDevInst;
 867     CONFIGRET ret;
 868
 869     TRACE("%p %lx %p\n", dnDevInst, ulFlags, hMachine);
 870
 871     if (!pSetupIsUserAdmin())
 872         return CR_ACCESS_DENIED;
 873
 874     if (dnDevInst == 0)
 875         return CR_INVALID_DEVINST;
 876
 877     if (ulFlags != 0)
 878         return CR_INVALID_FLAG;
 879
 880     if (hMachine != NULL)
 881     {
 882         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
 883         if (BindingHandle == NULL)
 884             return CR_FAILURE;
 885
 886         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
 887         if (StringTable == 0)
 888             return CR_FAILURE;
 889     }
 890     else
 891     {
 892         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
 893             return CR_FAILURE;
 894     }
 895
 896     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
 897     if (lpDevInst == NULL)
 898         return CR_INVALID_DEVNODE;
 899
 900     RpcTryExcept
 901     {
 902         ret = PNP_DeviceInstanceAction(BindingHandle,
 903                                        PNP_DEVINST_ENABLE,
 904                                        ulFlags,
 905                                        lpDevInst,
 906                                        NULL);
 907     }
 908     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 909     {
 910         ret = RpcStatusToCmStatus(RpcExceptionCode());
 911     }
 912     RpcEndExcept;
 913
 914     return ret;
 915 }
 916
 917
 918 /***********************************************************************
 919  * CM_Enumerate_Classes [SETUPAPI.@]
 920  */
 921 CONFIGRET WINAPI CM_Enumerate_Classes(
 922     ULONG ulClassIndex, LPGUID ClassGuid, ULONG ulFlags)
 923 {
 924     TRACE("%lx %p %lx\n", ulClassIndex, ClassGuid, ulFlags);
 925     return CM_Enumerate_Classes_Ex(ulClassIndex, ClassGuid, ulFlags, NULL);
 926 }
 927
 928
 929 /***********************************************************************
 930  * CM_Enumerate_Classes_Ex [SETUPAPI.@]
 931  */
 932 CONFIGRET WINAPI CM_Enumerate_Classes_Ex(
 933     ULONG ulClassIndex, LPGUID ClassGuid, ULONG ulFlags, HMACHINE hMachine)
 934 {
 935     WCHAR szBuffer[MAX_GUID_STRING_LEN];
 936     RPC_BINDING_HANDLE BindingHandle = NULL;
 937     CONFIGRET ret = CR_SUCCESS;
 938     ULONG ulLength = MAX_GUID_STRING_LEN;
 939
 940     TRACE("%lx %p %lx %p\n", ulClassIndex, ClassGuid, ulFlags, hMachine);
 941
 942     if (ClassGuid == NULL)
 943         return CR_INVALID_POINTER;
 944
 945     if (ulFlags != 0)
 946         return CR_INVALID_FLAG;
 947
 948     if (hMachine != NULL)
 949     {
 950         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
 951         if (BindingHandle == NULL)
 952             return CR_FAILURE;
 953     }
 954     else
 955     {
 956         if (!PnpGetLocalHandles(&BindingHandle, NULL))
 957             return CR_FAILURE;
 958     }
 959
 960     RpcTryExcept
 961     {
 962         ret = PNP_EnumerateSubKeys(BindingHandle,
 963                                    PNP_CLASS_SUBKEYS,
 964                                    ulClassIndex,
 965                                    szBuffer,
 966                                    MAX_GUID_STRING_LEN,
 967                                    &ulLength,
 968                                    ulFlags);
 969     }
 970     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 971     {
 972         ret = RpcStatusToCmStatus(RpcExceptionCode());
 973     }
 974     RpcEndExcept;
 975
 976     if (ret == CR_SUCCESS)
 977     {
 978         /* Remove the {} */
 979         szBuffer[MAX_GUID_STRING_LEN - 2] = UNICODE_NULL;
 980
 981         /* Convert the buffer to a GUID */
 982         if (UuidFromStringW(&szBuffer[1], ClassGuid) != RPC_S_OK)
 983             return CR_FAILURE;
 984     }
 985
 986     return ret;
 987 }
 988
 989
 990 /***********************************************************************
 991  * CM_Enumerate_EnumeratorsA [SETUPAPI.@]
 992  */
 993 CONFIGRET WINAPI CM_Enumerate_EnumeratorsA(
 994     ULONG ulEnumIndex, PCHAR Buffer, PULONG pulLength, ULONG ulFlags)
 995 {
 996     TRACE("%lu %p %p %lx\n", ulEnumIndex, Buffer, pulLength, ulFlags);
 997     return CM_Enumerate_Enumerators_ExA(ulEnumIndex, Buffer, pulLength,
 998                                         ulFlags, NULL);
 999 }
1000
1001
1002 /***********************************************************************
1003  * CM_Enumerate_EnumeratorsW [SETUPAPI.@]
1004  */
1005 CONFIGRET WINAPI CM_Enumerate_EnumeratorsW(
1006     ULONG ulEnumIndex, PWCHAR Buffer, PULONG pulLength, ULONG ulFlags)
1007 {
1008     TRACE("%lu %p %p %lx\n", ulEnumIndex, Buffer, pulLength, ulFlags);
1009     return CM_Enumerate_Enumerators_ExW(ulEnumIndex, Buffer, pulLength,
1010                                         ulFlags, NULL);
1011 }
1012
1013
1014 /***********************************************************************
1015  * CM_Enumerate_Enumerators_ExA [SETUPAPI.@]
1016  */
1017 CONFIGRET WINAPI CM_Enumerate_Enumerators_ExA(
1018     ULONG ulEnumIndex, PCHAR Buffer, PULONG pulLength, ULONG ulFlags,
1019     HMACHINE hMachine)
1020 {
1021     WCHAR szBuffer[MAX_DEVICE_ID_LEN];
1022     ULONG ulOrigLength;
1023     ULONG ulLength;
1024     CONFIGRET ret = CR_SUCCESS;
1025
1026     TRACE("%lu %p %p %lx %lx\n", ulEnumIndex, Buffer, pulLength, ulFlags,
1027           hMachine);
1028
1029     if (Buffer == NULL || pulLength == NULL)
1030         return CR_INVALID_POINTER;
1031
1032     if (ulFlags != 0)
1033         return CR_INVALID_FLAG;
1034
1035     ulOrigLength = *pulLength;
1036     *pulLength = 0;
1037
1038     ulLength = MAX_DEVICE_ID_LEN;
1039     ret = CM_Enumerate_Enumerators_ExW(ulEnumIndex, szBuffer, &ulLength,
1040                                        ulFlags, hMachine);
1041     if (ret == CR_SUCCESS)
1042     {
1043         if (WideCharToMultiByte(CP_ACP,
1044                                 0,
1045                                 szBuffer,
1046                                 ulLength,
1047                                 Buffer,
1048                                 ulOrigLength,
1049                                 NULL,
1050                                 NULL) == 0)
1051             ret = CR_FAILURE;
1052         else
1053             *pulLength = lstrlenA(Buffer) + 1;
1054     }
1055
1056     return ret;
1057 }
1058
1059
1060 /***********************************************************************
1061  * CM_Enumerate_Enumerators_ExW [SETUPAPI.@]
1062  */
1063 CONFIGRET WINAPI CM_Enumerate_Enumerators_ExW(
1064     ULONG ulEnumIndex, PWCHAR Buffer, PULONG pulLength, ULONG ulFlags,
1065     HMACHINE hMachine)
1066 {
1067     RPC_BINDING_HANDLE BindingHandle = NULL;
1068     CONFIGRET ret;
1069
1070     TRACE("%lu %p %p %lx %lx\n", ulEnumIndex, Buffer, pulLength, ulFlags,
1071           hMachine);
1072
1073     if (Buffer == NULL || pulLength == NULL)
1074         return CR_INVALID_POINTER;
1075
1076     if (ulFlags != 0)
1077         return CR_INVALID_FLAG;
1078
1079     *Buffer = UNICODE_NULL;
1080
1081     if (hMachine != NULL)
1082     {
1083         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1084         if (BindingHandle == NULL)
1085             return CR_FAILURE;
1086     }
1087     else
1088     {
1089         if (!PnpGetLocalHandles(&BindingHandle, NULL))
1090             return CR_FAILURE;
1091     }
1092
1093     RpcTryExcept
1094     {
1095         ret = PNP_EnumerateSubKeys(BindingHandle,
1096                                    PNP_ENUMERATOR_SUBKEYS,
1097                                    ulEnumIndex,
1098                                    Buffer,
1099                                    *pulLength,
1100                                    pulLength,
1101                                    ulFlags);
1102     }
1103     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1104     {
1105         ret = RpcStatusToCmStatus(RpcExceptionCode());
1106     }
1107     RpcEndExcept;
1108
1109     return ret;
1110 }
1111
1112
1113 /***********************************************************************
1114  * CM_Free_Log_Conf [SETUPAPI.@]
1115  */
1116 CONFIGRET WINAPI CM_Free_Log_Conf(
1117     LOG_CONF lcLogConfToBeFreed, ULONG ulFlags)
1118 {
1119     TRACE("%lx %lx\n", lcLogConfToBeFreed, ulFlags);
1120     return CM_Free_Log_Conf_Ex(lcLogConfToBeFreed, ulFlags, NULL);
1121 }
1122
1123
1124 /***********************************************************************
1125  * CM_Free_Log_Conf_Ex [SETUPAPI.@]
1126  */
1127 CONFIGRET WINAPI CM_Free_Log_Conf_Ex(
1128     LOG_CONF lcLogConfToBeFreed, ULONG ulFlags, HMACHINE hMachine)
1129 {
1130     RPC_BINDING_HANDLE BindingHandle = NULL;
1131     HSTRING_TABLE StringTable = NULL;
1132     LPWSTR lpDevInst;
1133     PLOG_CONF_INFO pLogConfInfo;
1134     CONFIGRET ret;
1135
1136     TRACE("%lx %lx %lx\n", lcLogConfToBeFreed, ulFlags, hMachine);
1137
1138     if (!pSetupIsUserAdmin())
1139         return CR_ACCESS_DENIED;
1140
1141     pLogConfInfo = (PLOG_CONF_INFO)lcLogConfToBeFreed;
1142     if (pLogConfInfo == NULL || pLogConfInfo->ulMagic != LOG_CONF_MAGIC)
1143         return CR_INVALID_LOG_CONF;
1144
1145     if (ulFlags != 0)
1146         return CR_INVALID_FLAG;
1147
1148     if (hMachine != NULL)
1149     {
1150         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1151         if (BindingHandle == NULL)
1152             return CR_FAILURE;
1153
1154         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1155         if (StringTable == 0)
1156             return CR_FAILURE;
1157     }
1158     else
1159     {
1160         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
1161             return CR_FAILURE;
1162     }
1163
1164     lpDevInst = pSetupStringTableStringFromId(StringTable, pLogConfInfo->dnDevInst);
1165     if (lpDevInst == NULL)
1166         return CR_INVALID_DEVNODE;
1167
1168     RpcTryExcept
1169     {
1170         ret = PNP_FreeLogConf(BindingHandle, lpDevInst, pLogConfInfo->ulFlags,
1171                               pLogConfInfo->ulTag, 0);
1172     }
1173     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1174     {
1175         ret = RpcStatusToCmStatus(RpcExceptionCode());
1176     }
1177     RpcEndExcept;
1178
1179     return ret;
1180 }
1181
1182
1183 /***********************************************************************
1184  * CM_Free_Log_Conf_Handle [SETUPAPI.@]
1185  */
1186 CONFIGRET WINAPI CM_Free_Log_Conf_Handle(
1187     LOG_CONF lcLogConf)
1188 {
1189     PLOG_CONF_INFO pLogConfInfo;
1190
1191     TRACE("%lx\n", lcLogConf);
1192
1193     pLogConfInfo = (PLOG_CONF_INFO)lcLogConf;
1194     if (pLogConfInfo == NULL || pLogConfInfo->ulMagic != LOG_CONF_MAGIC)
1195         return CR_INVALID_LOG_CONF;
1196
1197     HeapFree(GetProcessHeap(), 0, pLogConfInfo);
1198
1199     return CR_SUCCESS;
1200 }
1201
1202
1203 /***********************************************************************
1204  * CM_Free_Res_Des [SETUPAPI.@]
1205  */
1206 CONFIGRET WINAPI CM_Free_Res_Des(
1207    PRES_DES prdResDes, RES_DES rdResDes, ULONG ulFlags)
1208 {
1209     TRACE("%p %p %lx\n", prdResDes, rdResDes, ulFlags);
1210     return CM_Free_Res_Des_Ex(prdResDes, rdResDes, ulFlags, NULL);
1211 }
1212
1213
1214 /***********************************************************************
1215  * CM_Free_Res_Des_Ex [SETUPAPI.@]
1216  */
1217 CONFIGRET WINAPI CM_Free_Res_Des_Ex(
1218     PRES_DES prdResDes, RES_DES rdResDes, ULONG ulFlags,
1219     HMACHINE hMachine)
1220 {
1221     FIXME("%p %p %lx %lx\n", prdResDes, rdResDes, ulFlags, hMachine);
1222
1223     return CR_CALL_NOT_IMPLEMENTED;
1224 }
1225
1226
1227 /***********************************************************************
1228  * CM_Free_Res_Des_Handle [SETUPAPI.@]
1229  */
1230 CONFIGRET WINAPI CM_Free_Res_Des_Handle(
1231     RES_DES rdResDes)
1232 {
1233     FIXME("%p\n", rdResDes);
1234
1235     return CR_CALL_NOT_IMPLEMENTED;
1236 }
1237
1238
1239 /***********************************************************************
1240  * CM_Get_Child [SETUPAPI.@]
1241  */
1242 CONFIGRET WINAPI CM_Get_Child(
1243     PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags)
1244 {
1245     TRACE("%p %p %lx\n", pdnDevInst, dnDevInst, ulFlags);
1246     return CM_Get_Child_Ex(pdnDevInst, dnDevInst, ulFlags, NULL);
1247 }
1248
1249
1250 /***********************************************************************
1251  * CM_Get_Child_Ex [SETUPAPI.@]
1252  */
1253 CONFIGRET WINAPI CM_Get_Child_Ex(
1254     PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
1255 {
1256     WCHAR szRelatedDevInst[MAX_DEVICE_ID_LEN];
1257     RPC_BINDING_HANDLE BindingHandle = NULL;
1258     HSTRING_TABLE StringTable = NULL;
1259     LPWSTR lpDevInst;
1260     DWORD dwIndex, dwLength = MAX_DEVICE_ID_LEN;
1261     CONFIGRET ret;
1262
1263     TRACE("%p %lx %lx %lx\n", pdnDevInst, dnDevInst, ulFlags, hMachine);
1264
1265     if (pdnDevInst == NULL)
1266         return CR_INVALID_POINTER;
1267
1268     if (dnDevInst == 0)
1269         return CR_INVALID_DEVINST;
1270
1271     if (ulFlags != 0)
1272         return CR_INVALID_FLAG;
1273
1274     *pdnDevInst = -1;
1275
1276     if (hMachine != NULL)
1277     {
1278         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1279         if (BindingHandle == NULL)
1280             return CR_FAILURE;
1281
1282         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1283         if (StringTable == 0)
1284             return CR_FAILURE;
1285     }
1286     else
1287     {
1288         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
1289             return CR_FAILURE;
1290     }
1291
1292     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
1293     if (lpDevInst == NULL)
1294         return CR_INVALID_DEVNODE;
1295
1296     RpcTryExcept
1297     {
1298         ret = PNP_GetRelatedDeviceInstance(BindingHandle,
1299                                            PNP_GET_CHILD_DEVICE_INSTANCE,
1300                                            lpDevInst,
1301                                            szRelatedDevInst,
1302                                            &dwLength,
1303                                            0);
1304     }
1305     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1306     {
1307         ret = RpcStatusToCmStatus(RpcExceptionCode());
1308     }
1309     RpcEndExcept;
1310
1311     if (ret != CR_SUCCESS)
1312         return ret;
1313
1314     TRACE("szRelatedDevInst: %s\n", debugstr_w(szRelatedDevInst));
1315
1316     dwIndex = pSetupStringTableAddString(StringTable, szRelatedDevInst, 1);
1317     if (dwIndex == -1)
1318         return CR_FAILURE;
1319
1320     *pdnDevInst = dwIndex;
1321
1322     return CR_SUCCESS;
1323 }
1324
1325
1326 /***********************************************************************
1327  * CM_Get_Class_Key_NameA [SETUPAPI.@]
1328  */
1329 CONFIGRET WINAPI CM_Get_Class_Key_NameA(
1330     LPGUID ClassGuid, LPSTR pszKeyName, PULONG pulLength, ULONG ulFlags)
1331 {
1332     TRACE("%p %p %p %lx\n",
1333           ClassGuid, pszKeyName, pulLength, ulFlags);
1334     return CM_Get_Class_Key_Name_ExA(ClassGuid, pszKeyName, pulLength,
1335                                      ulFlags, NULL);
1336 }
1337
1338
1339 /***********************************************************************
1340  * CM_Get_Class_Key_NameW [SETUPAPI.@]
1341  */
1342 CONFIGRET WINAPI CM_Get_Class_Key_NameW(
1343     LPGUID ClassGuid, LPWSTR pszKeyName, PULONG pulLength, ULONG ulFlags)
1344 {
1345     TRACE("%p %p %p %lx\n",
1346           ClassGuid, pszKeyName, pulLength, ulFlags);
1347     return CM_Get_Class_Key_Name_ExW(ClassGuid, pszKeyName, pulLength,
1348                                      ulFlags, NULL);
1349 }
1350
1351
1352 /***********************************************************************
1353  * CM_Get_Class_Key_Name_ExA [SETUPAPI.@]
1354  */
1355 CONFIGRET WINAPI CM_Get_Class_Key_Name_ExA(
1356     LPGUID ClassGuid, LPSTR pszKeyName, PULONG pulLength, ULONG ulFlags,
1357     HMACHINE hMachine)
1358 {
1359     WCHAR szBuffer[MAX_GUID_STRING_LEN];
1360     CONFIGRET ret = CR_SUCCESS;
1361     ULONG ulLength;
1362     ULONG ulOrigLength;
1363
1364     TRACE("%p %p %p %lx %lx\n",
1365           ClassGuid, pszKeyName, pulLength, ulFlags, hMachine);
1366
1367     if (ClassGuid == NULL || pszKeyName == NULL || pulLength == NULL)
1368         return CR_INVALID_POINTER;
1369
1370     ulOrigLength = *pulLength;
1371     *pulLength = 0;
1372
1373     ulLength = MAX_GUID_STRING_LEN;
1374     ret = CM_Get_Class_Key_Name_ExW(ClassGuid, szBuffer, &ulLength,
1375                                     ulFlags, hMachine);
1376     if (ret == CR_SUCCESS)
1377     {
1378         if (WideCharToMultiByte(CP_ACP,
1379                                 0,
1380                                 szBuffer,
1381                                 ulLength,
1382                                 pszKeyName,
1383                                 ulOrigLength,
1384                                 NULL,
1385                                 NULL) == 0)
1386             ret = CR_FAILURE;
1387         else
1388             *pulLength = lstrlenA(pszKeyName) + 1;
1389     }
1390
1391     return CR_SUCCESS;
1392 }
1393
1394
1395 /***********************************************************************
1396  * CM_Get_Class_Key_Name_ExW [SETUPAPI.@]
1397  */
1398 CONFIGRET WINAPI CM_Get_Class_Key_Name_ExW(
1399     LPGUID ClassGuid, LPWSTR pszKeyName, PULONG pulLength, ULONG ulFlags,
1400     HMACHINE hMachine)
1401 {
1402     TRACE("%p %p %p %lx %lx\n",
1403           ClassGuid, pszKeyName, pulLength, ulFlags, hMachine);
1404
1405     if (ClassGuid == NULL || pszKeyName == NULL || pulLength == NULL)
1406         return CR_INVALID_POINTER;
1407
1408     if (ulFlags != 0)
1409         return CR_INVALID_FLAG;
1410
1411     if (*pulLength < MAX_GUID_STRING_LEN)
1412     {
1413         *pulLength = 0;
1414         return CR_BUFFER_SMALL;
1415     }
1416
1417     if (!GuidToString(ClassGuid, pszKeyName))
1418         return CR_INVALID_DATA;
1419
1420     *pulLength = MAX_GUID_STRING_LEN;
1421
1422     return CR_SUCCESS;
1423 }
1424
1425
1426 /***********************************************************************
1427  * CM_Get_Class_NameA [SETUPAPI.@]
1428  */
1429 CONFIGRET WINAPI CM_Get_Class_NameA(
1430     LPGUID ClassGuid, PCHAR Buffer, PULONG pulLength, ULONG ulFlags)
1431 {
1432     TRACE("%p %p %p %lx\n", ClassGuid, Buffer, pulLength, ulFlags);
1433     return CM_Get_Class_Name_ExA(ClassGuid, Buffer, pulLength, ulFlags,
1434                                  NULL);
1435 }
1436
1437
1438 /***********************************************************************
1439  * CM_Get_Class_NameW [SETUPAPI.@]
1440  */
1441 CONFIGRET WINAPI CM_Get_Class_NameW(
1442     LPGUID ClassGuid, PWCHAR Buffer, PULONG pulLength, ULONG ulFlags)
1443 {
1444     TRACE("%p %p %p %lx\n", ClassGuid, Buffer, pulLength, ulFlags);
1445     return CM_Get_Class_Name_ExW(ClassGuid, Buffer, pulLength, ulFlags,
1446                                  NULL);
1447 }
1448
1449
1450 /***********************************************************************
1451  * CM_Get_Class_Name_ExA [SETUPAPI.@]
1452  */
1453 CONFIGRET WINAPI CM_Get_Class_Name_ExA(
1454     LPGUID ClassGuid, PCHAR Buffer, PULONG pulLength, ULONG ulFlags,
1455     HMACHINE hMachine)
1456 {
1457     WCHAR szBuffer[MAX_CLASS_NAME_LEN];
1458     CONFIGRET ret = CR_SUCCESS;
1459     ULONG ulLength;
1460     ULONG ulOrigLength;
1461
1462     TRACE("%p %p %p %lx %lx\n",
1463           ClassGuid, Buffer, pulLength, ulFlags, hMachine);
1464
1465     if (ClassGuid == NULL || Buffer == NULL || pulLength == NULL)
1466         return CR_INVALID_POINTER;
1467
1468     ulOrigLength = *pulLength;
1469     *pulLength = 0;
1470
1471     ulLength = MAX_CLASS_NAME_LEN;
1472     ret = CM_Get_Class_Name_ExW(ClassGuid, szBuffer, &ulLength,
1473                                 ulFlags, hMachine);
1474     if (ret == CR_SUCCESS)
1475     {
1476         if (WideCharToMultiByte(CP_ACP,
1477                                 0,
1478                                 szBuffer,
1479                                 ulLength,
1480                                 Buffer,
1481                                 ulOrigLength,
1482                                 NULL,
1483                                 NULL) == 0)
1484             ret = CR_FAILURE;
1485         else
1486             *pulLength = lstrlenA(Buffer) + 1;
1487     }
1488
1489     return ret;
1490 }
1491
1492
1493 /***********************************************************************
1494  * CM_Get_Class_Name_ExW [SETUPAPI.@]
1495  */
1496 CONFIGRET WINAPI
1497 CM_Get_Class_Name_ExW(
1498     LPGUID ClassGuid, PWCHAR Buffer, PULONG pulLength, ULONG ulFlags,
1499     HMACHINE hMachine)
1500 {
1501     WCHAR szGuidString[MAX_GUID_STRING_LEN];
1502     RPC_BINDING_HANDLE BindingHandle = NULL;
1503     CONFIGRET ret;
1504
1505     TRACE("%p %p %p %lx %lx\n",
1506           ClassGuid, Buffer, pulLength, ulFlags, hMachine);
1507
1508     if (ClassGuid == NULL || Buffer == NULL || pulLength == NULL)
1509         return CR_INVALID_POINTER;
1510
1511     if (ulFlags != 0)
1512         return CR_INVALID_FLAG;
1513
1514     if (!GuidToString(ClassGuid, szGuidString))
1515         return CR_INVALID_DATA;
1516
1517     TRACE("Guid %s\n", debugstr_w(szGuidString));
1518
1519     if (hMachine != NULL)
1520     {
1521         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1522         if (BindingHandle == NULL)
1523             return CR_FAILURE;
1524     }
1525     else
1526     {
1527         if (!PnpGetLocalHandles(&BindingHandle, NULL))
1528             return CR_FAILURE;
1529     }
1530
1531     RpcTryExcept
1532     {
1533         ret = PNP_GetClassName(BindingHandle,
1534                                szGuidString,
1535                                Buffer,
1536                                pulLength,
1537                                ulFlags);
1538     }
1539     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1540     {
1541         ret = RpcStatusToCmStatus(RpcExceptionCode());
1542     }
1543     RpcEndExcept;
1544
1545     return ret;
1546 }
1547
1548
1549 /***********************************************************************
1550  * CM_Get_Depth [SETUPAPI.@]
1551  */
1552 CONFIGRET WINAPI CM_Get_Depth(
1553     PULONG pulDepth, DEVINST dnDevInst, ULONG ulFlags)
1554 {
1555     TRACE("%p %lx %lx\n", pulDepth, dnDevInst, ulFlags);
1556     return CM_Get_Depth_Ex(pulDepth, dnDevInst, ulFlags, NULL);
1557 }
1558
1559
1560 /***********************************************************************
1561  * CM_Get_Depth_Ex [SETUPAPI.@]
1562  */
1563 CONFIGRET WINAPI CM_Get_Depth_Ex(
1564     PULONG pulDepth, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
1565 {
1566     RPC_BINDING_HANDLE BindingHandle = NULL;
1567     HSTRING_TABLE StringTable = NULL;
1568     LPWSTR lpDevInst;
1569     CONFIGRET ret;
1570
1571     TRACE("%p %lx %lx %lx\n",
1572           pulDepth, dnDevInst, ulFlags, hMachine);
1573
1574     if (pulDepth == NULL)
1575         return CR_INVALID_POINTER;
1576
1577     if (dnDevInst == 0)
1578         return CR_INVALID_DEVINST;
1579
1580     if (ulFlags != 0)
1581         return CR_INVALID_FLAG;
1582
1583     if (hMachine != NULL)
1584     {
1585         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1586         if (BindingHandle == NULL)
1587             return CR_FAILURE;
1588
1589         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1590         if (StringTable == 0)
1591             return CR_FAILURE;
1592     }
1593     else
1594     {
1595         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
1596             return CR_FAILURE;
1597     }
1598
1599     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
1600     if (lpDevInst == NULL)
1601         return CR_INVALID_DEVNODE;
1602
1603     RpcTryExcept
1604     {
1605         ret = PNP_GetDepth(BindingHandle,
1606                            lpDevInst,
1607                            pulDepth,
1608                            ulFlags);
1609     }
1610     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1611     {
1612         ret = RpcStatusToCmStatus(RpcExceptionCode());
1613     }
1614     RpcEndExcept;
1615
1616     return ret;
1617 }
1618
1619
1620 /***********************************************************************
1621  * CM_Get_DevNode_Registry_PropertyA [SETUPAPI.@]
1622  */
1623 CONFIGRET WINAPI CM_Get_DevNode_Registry_PropertyA(
1624     DEVINST dnDevInst, ULONG ulProperty, PULONG pulRegDataType,
1625     PVOID Buffer, PULONG pulLength, ULONG ulFlags)
1626 {
1627     TRACE("%lx %lu %p %p %p %lx\n",
1628           dnDevInst, ulProperty, pulRegDataType, Buffer, pulLength, ulFlags);
1629
1630     return CM_Get_DevNode_Registry_Property_ExA(dnDevInst, ulProperty,
1631                                                 pulRegDataType, Buffer,
1632                                                 pulLength, ulFlags, NULL);
1633 }
1634
1635
1636 /***********************************************************************
1637  * CM_Get_DevNode_Registry_PropertyW [SETUPAPI.@]
1638  */
1639 CONFIGRET WINAPI CM_Get_DevNode_Registry_PropertyW(
1640     DEVINST dnDevInst, ULONG ulProperty, PULONG pulRegDataType,
1641     PVOID Buffer, PULONG pulLength, ULONG ulFlags)
1642 {
1643     TRACE("%lx %lu %p %p %p %lx\n",
1644           dnDevInst, ulProperty, pulRegDataType, Buffer, pulLength, ulFlags);
1645
1646     return CM_Get_DevNode_Registry_Property_ExW(dnDevInst, ulProperty,
1647                                                 pulRegDataType, Buffer,
1648                                                 pulLength, ulFlags, NULL);
1649 }
1650
1651
1652 /***********************************************************************
1653  * CM_Get_DevNode_Registry_Property_ExA [SETUPAPI.@]
1654  */
1655 CONFIGRET WINAPI CM_Get_DevNode_Registry_Property_ExA(
1656     DEVINST dnDevInst, ULONG ulProperty, PULONG pulRegDataType,
1657     PVOID Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine)
1658 {
1659     PVOID BufferW;
1660     ULONG LengthW;
1661     ULONG RegDataType = REG_NONE;
1662     CONFIGRET ret;
1663
1664     TRACE("%lx %lu %p %p %p %lx %lx\n",
1665           dnDevInst, ulProperty, pulRegDataType, Buffer, pulLength,
1666           ulFlags, hMachine);
1667
1668     if (!pulLength)
1669         return CR_INVALID_POINTER;
1670
1671     LengthW = *pulLength * sizeof(WCHAR);
1672     BufferW = HeapAlloc(GetProcessHeap(), 0, LengthW);
1673
1674     if (!BufferW)
1675         return CR_OUT_OF_MEMORY;
1676
1677     ret = CM_Get_DevNode_Registry_Property_ExW(dnDevInst,
1678                                                ulProperty,
1679                                                &RegDataType,
1680                                                BufferW,
1681                                                &LengthW,
1682                                                ulFlags,
1683                                                hMachine);
1684
1685     if (ret == CR_SUCCESS)
1686     {
1687         if (RegDataType == REG_SZ || RegDataType == REG_EXPAND_SZ)
1688         {
1689             /* Do W->A conversion */
1690             *pulLength = WideCharToMultiByte(CP_ACP,
1691                                              0,
1692                                              BufferW,
1693                                              lstrlenW(BufferW) + 1,
1694                                              Buffer,
1695                                              *pulLength,
1696                                              NULL,
1697                                              NULL);
1698             if (*pulLength == 0)
1699                 ret = CR_FAILURE;
1700         }
1701         else
1702         {
1703             /* Directly copy the value */
1704             if (LengthW <= *pulLength)
1705                 memcpy(Buffer, BufferW, LengthW);
1706             else
1707             {
1708                 *pulLength = LengthW;
1709                 ret = CR_BUFFER_SMALL;
1710             }
1711         }
1712     }
1713
1714     if (pulRegDataType)
1715         *pulRegDataType = RegDataType;
1716
1717     HeapFree(GetProcessHeap(), 0, BufferW);
1718
1719     return ret;
1720 }
1721
1722
1723 /***********************************************************************
1724  * CM_Get_DevNode_Registry_Property_ExW [SETUPAPI.@]
1725  */
1726 CONFIGRET WINAPI CM_Get_DevNode_Registry_Property_ExW(
1727     DEVINST dnDevInst, ULONG ulProperty, PULONG pulRegDataType,
1728     PVOID Buffer, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine)
1729 {
1730     RPC_BINDING_HANDLE BindingHandle = NULL;
1731     HSTRING_TABLE StringTable = NULL;
1732     CONFIGRET ret = CR_SUCCESS;
1733     LPWSTR lpDevInst;
1734     ULONG ulDataType = 0;
1735     ULONG ulTransferLength = 0;
1736
1737     TRACE("%lx %lu %p %p %p %lx %lx\n",
1738           dnDevInst, ulProperty, pulRegDataType, Buffer, pulLength,
1739           ulFlags, hMachine);
1740
1741     if (dnDevInst == 0)
1742         return CR_INVALID_DEVNODE;
1743
1744     if (ulProperty < CM_DRP_MIN || ulProperty > CM_DRP_MAX)
1745         return CR_INVALID_PROPERTY;
1746
1747     /* pulRegDataType is optional */
1748
1749     /* Buffer is optional */
1750
1751     if (pulLength == NULL)
1752         return CR_INVALID_POINTER;
1753
1754     if (*pulLength == 0)
1755         return CR_INVALID_POINTER;
1756
1757     if (ulFlags != 0)
1758         return CR_INVALID_FLAG;
1759
1760     if (hMachine != NULL)
1761     {
1762         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1763         if (BindingHandle == NULL)
1764             return CR_FAILURE;
1765
1766         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1767         if (StringTable == 0)
1768             return CR_FAILURE;
1769     }
1770     else
1771     {
1772         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
1773             return CR_FAILURE;
1774     }
1775
1776     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
1777     if (lpDevInst == NULL)
1778         return CR_INVALID_DEVNODE;
1779
1780     ulTransferLength = *pulLength;
1781
1782     RpcTryExcept
1783     {
1784         ret = PNP_GetDeviceRegProp(BindingHandle,
1785                                    lpDevInst,
1786                                    ulProperty,
1787                                    &ulDataType,
1788                                    Buffer,
1789                                    &ulTransferLength,
1790                                    pulLength,
1791                                    ulFlags);
1792     }
1793     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1794     {
1795         ret = RpcStatusToCmStatus(RpcExceptionCode());
1796     }
1797     RpcEndExcept;
1798
1799     if (ret == CR_SUCCESS)
1800     {
1801         if (pulRegDataType != NULL)
1802             *pulRegDataType = ulDataType;
1803     }
1804
1805     return ret;
1806 }
1807
1808
1809 /***********************************************************************
1810  * CM_Get_DevNode_Status [SETUPAPI.@]
1811  */
1812 CONFIGRET WINAPI CM_Get_DevNode_Status(
1813     PULONG pulStatus, PULONG pulProblemNumber, DEVINST dnDevInst,
1814     ULONG ulFlags)
1815 {
1816     TRACE("%p %p %lx %lx\n",
1817           pulStatus, pulProblemNumber, dnDevInst, ulFlags);
1818     return CM_Get_DevNode_Status_Ex(pulStatus, pulProblemNumber, dnDevInst,
1819                                     ulFlags, NULL);
1820 }
1821
1822
1823 /***********************************************************************
1824  * CM_Get_DevNode_Status_Ex [SETUPAPI.@]
1825  */
1826 CONFIGRET WINAPI
1827 CM_Get_DevNode_Status_Ex(
1828     PULONG pulStatus, PULONG pulProblemNumber, DEVINST dnDevInst,
1829     ULONG ulFlags, HMACHINE hMachine)
1830 {
1831     RPC_BINDING_HANDLE BindingHandle = NULL;
1832     HSTRING_TABLE StringTable = NULL;
1833     LPWSTR lpDevInst;
1834     CONFIGRET ret;
1835
1836     TRACE("%p %p %lx %lx %lx\n",
1837           pulStatus, pulProblemNumber, dnDevInst, ulFlags, hMachine);
1838
1839     if (pulStatus == NULL || pulProblemNumber == NULL)
1840         return CR_INVALID_POINTER;
1841
1842     if (dnDevInst == 0)
1843         return CR_INVALID_DEVINST;
1844
1845     if (ulFlags != 0)
1846         return CR_INVALID_FLAG;
1847
1848     if (hMachine != NULL)
1849     {
1850         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
1851         if (BindingHandle == NULL)
1852             return CR_FAILURE;
1853
1854         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1855         if (StringTable == 0)
1856             return CR_FAILURE;
1857     }
1858     else
1859     {
1860         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
1861             return CR_FAILURE;
1862     }
1863
1864     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
1865     if (lpDevInst == NULL)
1866         return CR_INVALID_DEVNODE;
1867
1868     RpcTryExcept
1869     {
1870         ret = PNP_GetDeviceStatus(BindingHandle,
1871                                   lpDevInst,
1872                                   pulStatus,
1873                                   pulProblemNumber,
1874                                   ulFlags);
1875     }
1876     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1877     {
1878         ret = RpcStatusToCmStatus(RpcExceptionCode());
1879     }
1880     RpcEndExcept;
1881
1882     return ret;
1883 }
1884
1885
1886 /***********************************************************************
1887  * CM_Get_Device_IDA [SETUPAPI.@]
1888  */
1889 CONFIGRET WINAPI CM_Get_Device_IDA(
1890     DEVINST dnDevInst, PCHAR Buffer, ULONG BufferLen, ULONG ulFlags)
1891 {
1892     TRACE("%lx %p %ld %ld\n",
1893           dnDevInst, Buffer, BufferLen, ulFlags);
1894     return CM_Get_Device_ID_ExA(dnDevInst, Buffer, BufferLen, ulFlags, NULL);
1895 }
1896
1897
1898 /***********************************************************************
1899  * CM_Get_Device_IDW [SETUPAPI.@]
1900  */
1901 CONFIGRET WINAPI CM_Get_Device_IDW(
1902     DEVINST dnDevInst, PWCHAR Buffer, ULONG BufferLen, ULONG ulFlags)
1903 {
1904     TRACE("%lx %p %ld %ld\n",
1905           dnDevInst, Buffer, BufferLen, ulFlags);
1906     return CM_Get_Device_ID_ExW(dnDevInst, Buffer, BufferLen, ulFlags, NULL);
1907 }
1908
1909
1910 /***********************************************************************
1911  * CM_Get_Device_ID_ExA [SETUPAPI.@]
1912  */
1913 CONFIGRET WINAPI CM_Get_Device_ID_ExA(
1914     DEVINST dnDevInst, PCHAR Buffer, ULONG BufferLen, ULONG ulFlags,
1915     HMACHINE hMachine)
1916 {
1917     WCHAR szBufferW[MAX_DEVICE_ID_LEN];
1918     CONFIGRET ret = CR_SUCCESS;
1919
1920     TRACE("%lx %p %ld %ld %lx\n",
1921           dnDevInst, Buffer, BufferLen, ulFlags, hMachine);
1922
1923     if (Buffer == NULL)
1924         return CR_INVALID_POINTER;
1925
1926     ret = CM_Get_Device_ID_ExW(dnDevInst,
1927                                szBufferW,
1928                                MAX_DEVICE_ID_LEN,
1929                                ulFlags,
1930                                hMachine);
1931     if (ret == CR_SUCCESS)
1932     {
1933         if (WideCharToMultiByte(CP_ACP,
1934                                 0,
1935                                 szBufferW,
1936                                 lstrlenW(szBufferW) + 1,
1937                                 Buffer,
1938                                 BufferLen,
1939                                 NULL,
1940                                 NULL) == 0)
1941             ret = CR_FAILURE;
1942     }
1943
1944     return ret;
1945 }
1946
1947
1948 /***********************************************************************
1949  * CM_Get_Device_ID_ExW [SETUPAPI.@]
1950  */
1951 CONFIGRET WINAPI CM_Get_Device_ID_ExW(
1952     DEVINST dnDevInst, PWCHAR Buffer, ULONG BufferLen, ULONG ulFlags,
1953     HMACHINE hMachine)
1954 {
1955     HSTRING_TABLE StringTable = NULL;
1956
1957     TRACE("%lx %p %ld %ld %lx\n",
1958           dnDevInst, Buffer, BufferLen, ulFlags, hMachine);
1959
1960     if (dnDevInst == 0)
1961         return CR_INVALID_DEVINST;
1962
1963     if (Buffer == NULL)
1964         return CR_INVALID_POINTER;
1965
1966     if (ulFlags != 0)
1967         return CR_INVALID_FLAG;
1968
1969     if (hMachine != NULL)
1970     {
1971         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
1972         if (StringTable == NULL)
1973             return CR_FAILURE;
1974     }
1975     else
1976     {
1977         if (!PnpGetLocalHandles(NULL, &StringTable))
1978             return CR_FAILURE;
1979     }
1980
1981     if (!pSetupStringTableStringFromIdEx(StringTable,
1982                                          dnDevInst,
1983                                          Buffer,
1984                                          &BufferLen))
1985         return CR_FAILURE;
1986
1987     return CR_SUCCESS;
1988 }
1989
1990
1991 /***********************************************************************
1992  * CM_Get_Device_ID_ListA [SETUPAPI.@]
1993  */
1994 CONFIGRET WINAPI CM_Get_Device_ID_ListA(
1995     PCSTR pszFilter, PCHAR Buffer, ULONG BufferLen, ULONG ulFlags)
1996 {
1997     TRACE("%p %p %ld %ld\n", pszFilter, Buffer, BufferLen, ulFlags);
1998     return CM_Get_Device_ID_List_ExA(pszFilter, Buffer, BufferLen,
1999                                      ulFlags, NULL);
2000 }
2001
2002
2003 /***********************************************************************
2004  * CM_Get_Device_ID_ListW [SETUPAPI.@]
2005  */
2006 CONFIGRET WINAPI CM_Get_Device_ID_ListW(
2007     PCWSTR pszFilter, PWCHAR Buffer, ULONG BufferLen, ULONG ulFlags)
2008 {
2009     TRACE("%p %p %ld %ld\n", pszFilter, Buffer, BufferLen, ulFlags);
2010     return CM_Get_Device_ID_List_ExW(pszFilter, Buffer, BufferLen,
2011                                      ulFlags, NULL);
2012 }
2013
2014
2015 /***********************************************************************
2016  * CM_Get_Device_ID_List_ExA [SETUPAPI.@]
2017  */
2018 CONFIGRET WINAPI CM_Get_Device_ID_List_ExA(
2019     PCSTR pszFilter, PCHAR Buffer, ULONG BufferLen, ULONG ulFlags,
2020     HMACHINE hMachine)
2021 {
2022     LPWSTR BufferW = NULL;
2023     LPWSTR pszFilterW = NULL;
2024     CONFIGRET ret = CR_SUCCESS;
2025
2026     TRACE("%p %p %ld %ld %lx\n",
2027           pszFilter, Buffer, BufferLen, ulFlags, hMachine);
2028
2029     BufferW = MyMalloc(BufferLen * sizeof(WCHAR));
2030     if (BufferW == NULL)
2031         return CR_OUT_OF_MEMORY;
2032
2033     if (pszFilter == NULL)
2034     {
2035         ret = CM_Get_Device_ID_List_ExW(NULL,
2036                                         BufferW,
2037                                         BufferLen,
2038                                         ulFlags,
2039                                         hMachine);
2040     }
2041     else
2042     {
2043         if (pSetupCaptureAndConvertAnsiArg(pszFilter, &pszFilterW))
2044         {
2045             ret = CR_INVALID_DEVICE_ID;
2046             goto Done;
2047         }
2048
2049         ret = CM_Get_Device_ID_List_ExW(pszFilterW,
2050                                         BufferW,
2051                                         BufferLen,
2052                                         ulFlags,
2053                                         hMachine);
2054
2055         MyFree(pszFilterW);
2056     }
2057
2058     if (WideCharToMultiByte(CP_ACP,
2059                             0,
2060                             BufferW,
2061                             lstrlenW(BufferW) + 1,
2062                             Buffer,
2063                             BufferLen,
2064                             NULL,
2065                             NULL) == 0)
2066         ret = CR_FAILURE;
2067
2068 Done:
2069     MyFree(BufferW);
2070
2071     return ret;
2072 }
2073
2074
2075 /***********************************************************************
2076  * CM_Get_Device_ID_List_ExW [SETUPAPI.@]
2077  */
2078 CONFIGRET WINAPI CM_Get_Device_ID_List_ExW(
2079     PCWSTR pszFilter, PWCHAR Buffer, ULONG BufferLen, ULONG ulFlags,
2080     HMACHINE hMachine)
2081 {
2082     RPC_BINDING_HANDLE BindingHandle = NULL;
2083     CONFIGRET ret;
2084
2085     TRACE("%p %p %ld %ld %lx\n",
2086           pszFilter, Buffer, BufferLen, ulFlags, hMachine);
2087
2088     if (Buffer == NULL || BufferLen == 0)
2089         return CR_INVALID_POINTER;
2090
2091     if (ulFlags & ~CM_GETIDLIST_FILTER_BITS)
2092         return CR_INVALID_FLAG;
2093
2094     if (hMachine != NULL)
2095     {
2096         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2097         if (BindingHandle == NULL)
2098             return CR_FAILURE;
2099     }
2100     else
2101     {
2102         if (!PnpGetLocalHandles(&BindingHandle, NULL))
2103             return CR_FAILURE;
2104     }
2105
2106     *Buffer = 0;
2107
2108     RpcTryExcept
2109     {
2110         ret = PNP_GetDeviceList(BindingHandle,
2111                                 (LPWSTR)pszFilter,
2112                                 Buffer,
2113                                 &BufferLen,
2114                                 ulFlags);
2115     }
2116     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2117     {
2118         ret = RpcStatusToCmStatus(RpcExceptionCode());
2119     }
2120     RpcEndExcept;
2121
2122     return ret;
2123 }
2124
2125
2126 /***********************************************************************
2127  * CM_Get_Device_ID_List_SizeA [SETUPAPI.@]
2128  */
2129 CONFIGRET WINAPI CM_Get_Device_ID_List_SizeA(
2130     PULONG pulLen, PCSTR pszFilter, ULONG ulFlags)
2131 {
2132     TRACE("%p %s %ld\n", pulLen, pszFilter, ulFlags);
2133     return CM_Get_Device_ID_List_Size_ExA(pulLen, pszFilter, ulFlags, NULL);
2134 }
2135
2136
2137 /***********************************************************************
2138  * CM_Get_Device_ID_List_SizeW [SETUPAPI.@]
2139  */
2140 CONFIGRET WINAPI CM_Get_Device_ID_List_SizeW(
2141     PULONG pulLen, PCWSTR pszFilter, ULONG ulFlags)
2142 {
2143     TRACE("%p %s %ld\n", pulLen, debugstr_w(pszFilter), ulFlags);
2144     return CM_Get_Device_ID_List_Size_ExW(pulLen, pszFilter, ulFlags, NULL);
2145 }
2146
2147
2148 /***********************************************************************
2149  * CM_Get_Device_ID_List_Size_ExA [SETUPAPI.@]
2150  */
2151 CONFIGRET WINAPI CM_Get_Device_ID_List_Size_ExA(
2152     PULONG pulLen, PCSTR pszFilter, ULONG ulFlags, HMACHINE hMachine)
2153 {
2154     LPWSTR pszFilterW = NULL;
2155     CONFIGRET ret = CR_SUCCESS;
2156
2157     FIXME("%p %s %lx %lx\n", pulLen, pszFilter, ulFlags, hMachine);
2158
2159     if (pszFilter == NULL)
2160     {
2161         ret = CM_Get_Device_ID_List_Size_ExW(pulLen,
2162                                              NULL,
2163                                              ulFlags,
2164                                              hMachine);
2165     }
2166     else
2167     {
2168         if (pSetupCaptureAndConvertAnsiArg(pszFilter, &pszFilterW))
2169             return CR_INVALID_DEVICE_ID;
2170
2171         ret = CM_Get_Device_ID_List_Size_ExW(pulLen,
2172                                              pszFilterW,
2173                                              ulFlags,
2174                                              hMachine);
2175
2176         MyFree(pszFilterW);
2177     }
2178
2179     return ret;
2180 }
2181
2182
2183 /***********************************************************************
2184  * CM_Get_Device_ID_List_Size_ExW [SETUPAPI.@]
2185  */
2186 CONFIGRET WINAPI CM_Get_Device_ID_List_Size_ExW(
2187     PULONG pulLen, PCWSTR pszFilter, ULONG ulFlags, HMACHINE hMachine)
2188 {
2189     RPC_BINDING_HANDLE BindingHandle = NULL;
2190     CONFIGRET ret;
2191
2192     FIXME("%p %s %ld %lx\n", pulLen, debugstr_w(pszFilter), ulFlags, hMachine);
2193
2194     if (pulLen == NULL)
2195         return CR_INVALID_POINTER;
2196
2197     if (ulFlags & ~CM_GETIDLIST_FILTER_BITS)
2198         return CR_INVALID_FLAG;
2199
2200     if (hMachine != NULL)
2201     {
2202         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2203         if (BindingHandle == NULL)
2204             return CR_FAILURE;
2205     }
2206     else
2207     {
2208         if (!PnpGetLocalHandles(&BindingHandle, NULL))
2209             return CR_FAILURE;
2210     }
2211
2212     *pulLen = 0;
2213
2214     RpcTryExcept
2215     {
2216         ret = PNP_GetDeviceListSize(BindingHandle,
2217                                     (LPWSTR)pszFilter,
2218                                     pulLen,
2219                                     ulFlags);
2220     }
2221     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2222     {
2223         ret = RpcStatusToCmStatus(RpcExceptionCode());
2224     }
2225     RpcEndExcept;
2226
2227     return ret;
2228 }
2229
2230
2231 /***********************************************************************
2232  * CM_Get_Device_ID_Size [SETUPAPI.@]
2233  */
2234 CONFIGRET WINAPI CM_Get_Device_ID_Size(
2235     PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags)
2236 {
2237     TRACE("%p %lx %lx\n", pulLen, dnDevInst, ulFlags);
2238     return CM_Get_Device_ID_Size_Ex(pulLen, dnDevInst, ulFlags, NULL);
2239 }
2240
2241
2242 /***********************************************************************
2243  * CM_Get_Device_ID_Size_Ex [SETUPAPI.@]
2244  */
2245 CONFIGRET WINAPI CM_Get_Device_ID_Size_Ex(
2246     PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
2247 {
2248     HSTRING_TABLE StringTable = NULL;
2249     LPWSTR DeviceId;
2250
2251     TRACE("%p %lx %lx %lx\n", pulLen, dnDevInst, ulFlags, hMachine);
2252
2253     if (pulLen == NULL)
2254         return CR_INVALID_POINTER;
2255
2256     if (dnDevInst == 0)
2257         return CR_INVALID_DEVINST;
2258
2259     if (ulFlags != 0)
2260         return CR_INVALID_FLAG;
2261
2262     if (hMachine != NULL)
2263     {
2264         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
2265         if (StringTable == NULL)
2266             return CR_FAILURE;
2267     }
2268     else
2269     {
2270         if (!PnpGetLocalHandles(NULL, &StringTable))
2271             return CR_FAILURE;
2272     }
2273
2274     DeviceId = pSetupStringTableStringFromId(StringTable, dnDevInst);
2275     if (DeviceId == NULL)
2276     {
2277         *pulLen = 0;
2278         return CR_SUCCESS;
2279     }
2280
2281     *pulLen = lstrlenW(DeviceId);
2282
2283     return CR_SUCCESS;
2284 }
2285
2286
2287 /***********************************************************************
2288  * CM_Get_Device_Interface_AliasA [SETUPAPI.@]
2289  */
2290 CONFIGRET WINAPI CM_Get_Device_Interface_AliasA(
2291     LPCSTR pszDeviceInterface, LPGUID AliasInterfaceGuid,
2292     LPSTR pszAliasDeviceInterface, PULONG pulLength, ULONG ulFlags)
2293 {
2294     TRACE("%p %p %p %p %lu\n", pszDeviceInterface, AliasInterfaceGuid,
2295           pszAliasDeviceInterface, pulLength, ulFlags);
2296
2297     return CM_Get_Device_Interface_Alias_ExA(pszDeviceInterface,
2298         AliasInterfaceGuid, pszAliasDeviceInterface, pulLength,
2299         ulFlags, NULL);
2300 }
2301
2302
2303 /***********************************************************************
2304  * CM_Get_Device_Interface_AliasW [SETUPAPI.@]
2305  */
2306 CONFIGRET WINAPI CM_Get_Device_Interface_AliasW(
2307     LPCWSTR pszDeviceInterface, LPGUID AliasInterfaceGuid,
2308     LPWSTR pszAliasDeviceInterface, PULONG pulLength, ULONG ulFlags)
2309 {
2310     TRACE("%p %p %p %p %lu\n", pszDeviceInterface, AliasInterfaceGuid,
2311           pszAliasDeviceInterface, pulLength, ulFlags);
2312
2313     return CM_Get_Device_Interface_Alias_ExW(pszDeviceInterface,
2314         AliasInterfaceGuid, pszAliasDeviceInterface, pulLength,
2315         ulFlags, NULL);
2316 }
2317
2318
2319 /***********************************************************************
2320  * CM_Get_Device_Interface_Alias_ExA [SETUPAPI.@]
2321  */
2322 CONFIGRET WINAPI CM_Get_Device_Interface_Alias_ExA(
2323     LPCSTR pszDeviceInterface, LPGUID AliasInterfaceGuid, LPSTR pszAliasDeviceInterface,
2324     PULONG pulLength, ULONG ulFlags, HMACHINE hMachine)
2325 {
2326     FIXME("%p %p %p %p %lu %lx\n", pszDeviceInterface, AliasInterfaceGuid,
2327           pszAliasDeviceInterface, pulLength, ulFlags, hMachine);
2328
2329     return CR_CALL_NOT_IMPLEMENTED;
2330 }
2331
2332
2333 /***********************************************************************
2334  * CM_Get_Device_Interface_Alias_ExW [SETUPAPI.@]
2335  */
2336 CONFIGRET WINAPI CM_Get_Device_Interface_Alias_ExW(
2337     LPCWSTR pszDeviceInterface, LPGUID AliasInterfaceGuid, LPWSTR pszAliasDeviceInterface,
2338     PULONG pulLength, ULONG ulFlags, HMACHINE hMachine)
2339 {
2340     RPC_BINDING_HANDLE BindingHandle = NULL;
2341     ULONG ulTransferLength;
2342     CONFIGRET ret = CR_SUCCESS;
2343
2344     TRACE("%p %p %p %p %lu %lx\n", pszDeviceInterface, AliasInterfaceGuid,
2345           pszAliasDeviceInterface, pulLength, ulFlags, hMachine);
2346
2347     if (pszDeviceInterface == NULL ||
2348         AliasInterfaceGuid == NULL ||
2349         pszAliasDeviceInterface == NULL ||
2350         pulLength == NULL)
2351         return CR_INVALID_POINTER;
2352
2353     if (ulFlags != 0)
2354         return CR_INVALID_FLAG;
2355
2356     if (hMachine != NULL)
2357     {
2358         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2359         if (BindingHandle == NULL)
2360             return CR_FAILURE;
2361     }
2362     else
2363     {
2364         if (!PnpGetLocalHandles(&BindingHandle, NULL))
2365             return CR_FAILURE;
2366     }
2367
2368     ulTransferLength = *pulLength;
2369
2370     RpcTryExcept
2371     {
2372         ret = PNP_GetInterfaceDeviceAlias(BindingHandle,
2373                                           (LPWSTR)pszDeviceInterface,
2374                                           AliasInterfaceGuid,
2375                                           pszAliasDeviceInterface,
2376                                           pulLength,
2377                                           &ulTransferLength,
2378                                           0);
2379     }
2380     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2381     {
2382         ret = RpcStatusToCmStatus(RpcExceptionCode());
2383     }
2384     RpcEndExcept;
2385
2386     return ret;
2387 }
2388
2389
2390 /***********************************************************************
2391  *      CM_Get_Device_Interface_ListA (SETUPAPI.@)
2392  */
2393 CONFIGRET WINAPI CM_Get_Device_Interface_ListA(
2394     LPGUID InterfaceClassGuid, DEVINSTID_A pDeviceID, PCHAR Buffer,
2395     ULONG BufferLen, ULONG ulFlags)
2396 {
2397     TRACE("%s %s %p %lu 0x%08lx\n", debugstr_guid(InterfaceClassGuid),
2398           pDeviceID, Buffer, BufferLen, ulFlags);
2399
2400     return CM_Get_Device_Interface_List_ExA(InterfaceClassGuid, pDeviceID,
2401                                             Buffer, BufferLen, ulFlags, NULL);
2402 }
2403
2404
2405 /***********************************************************************
2406  *      CM_Get_Device_Interface_ListW (SETUPAPI.@)
2407  */
2408 CONFIGRET WINAPI CM_Get_Device_Interface_ListW(
2409     LPGUID InterfaceClassGuid, DEVINSTID_W pDeviceID, PWCHAR Buffer,
2410     ULONG BufferLen, ULONG ulFlags)
2411 {
2412     TRACE("%s %s %p %lu 0x%08lx\n", debugstr_guid(InterfaceClassGuid),
2413           debugstr_w(pDeviceID), Buffer, BufferLen, ulFlags);
2414
2415     return CM_Get_Device_Interface_List_ExW(InterfaceClassGuid, pDeviceID,
2416                                             Buffer, BufferLen, ulFlags, NULL);
2417 }
2418
2419
2420 /***********************************************************************
2421  *      CM_Get_Device_Interface_List_ExA (SETUPAPI.@)
2422  */
2423 CONFIGRET WINAPI CM_Get_Device_Interface_List_ExA(
2424     LPGUID InterfaceClassGuid, DEVINSTID_A pDeviceID, PCHAR Buffer,
2425     ULONG BufferLen, ULONG ulFlags, HMACHINE hMachine)
2426 {
2427     DEVINSTID_W pDeviceIdW = NULL;
2428     PWCHAR BufferW = NULL;
2429     CONFIGRET ret = CR_SUCCESS;
2430
2431     TRACE("%s %s %p %lu 0x%08lx %p\n", debugstr_guid(InterfaceClassGuid),
2432           pDeviceID, Buffer, BufferLen, ulFlags, hMachine);
2433
2434     if (Buffer == NULL ||
2435         BufferLen == 0)
2436         return CR_INVALID_POINTER;
2437
2438     if (pDeviceID != NULL)
2439     {
2440         if (!pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDeviceIdW))
2441             return CR_INVALID_DEVICE_ID;
2442     }
2443
2444     BufferW = MyMalloc(BufferLen * sizeof(WCHAR));
2445     if (BufferW == NULL)
2446     {
2447         ret = CR_OUT_OF_MEMORY;
2448         goto Done;
2449     }
2450
2451     ret = CM_Get_Device_Interface_List_ExW(InterfaceClassGuid, pDeviceIdW,
2452                                            BufferW, BufferLen, ulFlags,
2453                                            hMachine);
2454     if (ret != CR_SUCCESS)
2455         goto Done;
2456
2457     if (WideCharToMultiByte(CP_ACP,
2458                             0,
2459                             BufferW,
2460                             lstrlenW(BufferW) + 1,
2461                             Buffer,
2462                             BufferLen,
2463                             NULL,
2464                             NULL) == 0)
2465         ret = CR_FAILURE;
2466
2467 Done:
2468     if (BufferW != NULL)
2469         MyFree(BufferW);
2470
2471     if (pDeviceIdW != NULL)
2472         MyFree(pDeviceIdW);
2473
2474     return ret;
2475 }
2476
2477
2478 /***********************************************************************
2479  *      CM_Get_Device_Interface_List_ExW (SETUPAPI.@)
2480  */
2481 CONFIGRET WINAPI CM_Get_Device_Interface_List_ExW(
2482     LPGUID InterfaceClassGuid, DEVINSTID_W pDeviceID, PWCHAR Buffer,
2483     ULONG BufferLen, ULONG ulFlags, HMACHINE hMachine)
2484 {
2485     RPC_BINDING_HANDLE BindingHandle = NULL;
2486     PNP_RPC_BUFFER_SIZE BufferSize = 0;
2487     CONFIGRET ret = CR_SUCCESS;
2488
2489     TRACE("%s %s %p %lu 0x%08lx %p\n", debugstr_guid(InterfaceClassGuid),
2490           debugstr_w(pDeviceID), Buffer, BufferLen, ulFlags, hMachine);
2491
2492     if (Buffer == NULL ||
2493         BufferLen == 0)
2494         return CR_INVALID_POINTER;
2495
2496     if (ulFlags & ~CM_GET_DEVICE_INTERFACE_LIST_BITS)
2497         return CR_INVALID_FLAG;
2498
2499     if (hMachine != NULL)
2500     {
2501         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2502         if (BindingHandle == NULL)
2503             return CR_FAILURE;
2504     }
2505     else
2506     {
2507         if (!PnpGetLocalHandles(&BindingHandle, NULL))
2508             return CR_FAILURE;
2509     }
2510
2511     *Buffer = 0;
2512     BufferSize = BufferLen;
2513
2514     RpcTryExcept
2515     {
2516         ret = PNP_GetInterfaceDeviceList(BindingHandle,
2517                                          InterfaceClassGuid,
2518                                          pDeviceID,
2519                                          (LPBYTE)Buffer,
2520                                          &BufferSize,
2521                                          ulFlags);
2522     }
2523     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2524     {
2525         ret = RpcStatusToCmStatus(RpcExceptionCode());
2526     }
2527     RpcEndExcept;
2528
2529     return ret;
2530 }
2531
2532
2533 /***********************************************************************
2534  *      CM_Get_Device_Interface_List_SizeA (SETUPAPI.@)
2535  */
2536 CONFIGRET WINAPI CM_Get_Device_Interface_List_SizeA(
2537     PULONG pulLen, LPGUID InterfaceClassGuid, DEVINSTID_A pDeviceId,
2538     ULONG ulFlags)
2539 {
2540     TRACE("%p %p %s 0x%08lx\n", pulLen, InterfaceClassGuid,
2541           pDeviceId, ulFlags);
2542
2543     return CM_Get_Device_Interface_List_Size_ExA(pulLen, InterfaceClassGuid,
2544                                                  pDeviceId, ulFlags, NULL);
2545 }
2546
2547
2548 /***********************************************************************
2549  *      CM_Get_Device_Interface_List_SizeW (SETUPAPI.@)
2550  */
2551 CONFIGRET WINAPI CM_Get_Device_Interface_List_SizeW(
2552     PULONG pulLen, LPGUID InterfaceClassGuid, DEVINSTID_W pDeviceId,
2553     ULONG ulFlags)
2554 {
2555     TRACE("%p %p %s 0x%08lx\n", pulLen, InterfaceClassGuid,
2556           debugstr_w(pDeviceId), ulFlags);
2557
2558     return CM_Get_Device_Interface_List_Size_ExW(pulLen, InterfaceClassGuid,
2559                                                  pDeviceId, ulFlags, NULL);
2560 }
2561
2562
2563 /***********************************************************************
2564  *      CM_Get_Device_Interface_List_Size_ExA (SETUPAPI.@)
2565  */
2566 CONFIGRET WINAPI CM_Get_Device_Interface_List_Size_ExA(
2567     PULONG pulLen, LPGUID InterfaceClassGuid, DEVINSTID_A pDeviceId,
2568     ULONG ulFlags, HMACHINE hMachine)
2569 {
2570     DEVINSTID_W pDeviceIdW = NULL;
2571     CONFIGRET ret = CR_SUCCESS;
2572
2573     TRACE("%p %p %s 0x%08lx %p\n", pulLen, InterfaceClassGuid,
2574           pDeviceId, ulFlags, hMachine);
2575
2576     if (pulLen == NULL)
2577         return CR_INVALID_POINTER;
2578
2579     if (pDeviceId != NULL)
2580     {
2581         if (!pSetupCaptureAndConvertAnsiArg(pDeviceId, &pDeviceIdW))
2582             return CR_INVALID_DEVICE_ID;
2583     }
2584
2585     *pulLen = 0;
2586
2587     ret = CM_Get_Device_Interface_List_Size_ExW(pulLen, InterfaceClassGuid,
2588                                                 pDeviceIdW, ulFlags, hMachine);
2589
2590     if (pDeviceIdW != NULL)
2591         MyFree(pDeviceIdW);
2592
2593     return ret;
2594 }
2595
2596
2597 /***********************************************************************
2598  *      CM_Get_Device_Interface_List_Size_ExW (SETUPAPI.@)
2599  */
2600 CONFIGRET WINAPI CM_Get_Device_Interface_List_Size_ExW(
2601     PULONG pulLen, LPGUID InterfaceClassGuid, DEVINSTID_W pDeviceId,
2602     ULONG ulFlags, HMACHINE hMachine)
2603 {
2604     RPC_BINDING_HANDLE BindingHandle = NULL;
2605     CONFIGRET ret = CR_SUCCESS;
2606
2607     TRACE("%p %p %s 0x%08lx %p\n", pulLen, InterfaceClassGuid,
2608           debugstr_w(pDeviceId), ulFlags, hMachine);
2609
2610     if (pulLen == NULL)
2611         return CR_INVALID_POINTER;
2612
2613     if (ulFlags & ~CM_GET_DEVICE_INTERFACE_LIST_BITS)
2614         return CR_INVALID_FLAG;
2615
2616     if (hMachine != NULL)
2617     {
2618         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2619         if (BindingHandle == NULL)
2620             return CR_FAILURE;
2621     }
2622     else
2623     {
2624         if (!PnpGetLocalHandles(&BindingHandle, NULL))
2625             return CR_FAILURE;
2626     }
2627
2628     *pulLen = 0;
2629
2630     RpcTryExcept
2631     {
2632         ret = PNP_GetInterfaceDeviceListSize(BindingHandle,
2633                                              pulLen,
2634                                              InterfaceClassGuid,
2635                                              pDeviceId,
2636                                              ulFlags);
2637     }
2638     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2639     {
2640         ret = RpcStatusToCmStatus(RpcExceptionCode());
2641     }
2642     RpcEndExcept;
2643
2644     return ret;
2645 }
2646
2647
2648 /***********************************************************************
2649  * CM_Get_First_Log_Conf [SETUPAPI.@]
2650  */
2651 CONFIGRET WINAPI CM_Get_First_Log_Conf(
2652     PLOG_CONF plcLogConf, DEVINST dnDevInst, ULONG ulFlags)
2653 {
2654     TRACE("%p %lx %lx\n", plcLogConf, dnDevInst, ulFlags);
2655     return CM_Get_First_Log_Conf_Ex(plcLogConf, dnDevInst, ulFlags, NULL);
2656 }
2657
2658
2659 /***********************************************************************
2660  * CM_Get_First_Log_Conf_Ex [SETUPAPI.@]
2661  */
2662 CONFIGRET WINAPI CM_Get_First_Log_Conf_Ex(
2663     PLOG_CONF plcLogConf, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
2664 {
2665     RPC_BINDING_HANDLE BindingHandle = NULL;
2666     HSTRING_TABLE StringTable = NULL;
2667     LPWSTR lpDevInst = NULL;
2668     CONFIGRET ret = CR_SUCCESS;
2669     ULONG ulTag;
2670     PLOG_CONF_INFO pLogConfInfo;
2671
2672     FIXME("%p %lx %lx %lx\n", plcLogConf, dnDevInst, ulFlags, hMachine);
2673
2674     if (dnDevInst == 0)
2675         return CR_INVALID_DEVINST;
2676
2677     if (ulFlags & ~LOG_CONF_BITS)
2678         return CR_INVALID_FLAG;
2679
2680     if (plcLogConf)
2681         *plcLogConf = 0;
2682
2683     if (hMachine != NULL)
2684     {
2685         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2686         if (BindingHandle == NULL)
2687             return CR_FAILURE;
2688
2689         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
2690         if (StringTable == 0)
2691             return CR_FAILURE;
2692     }
2693     else
2694     {
2695         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
2696             return CR_FAILURE;
2697     }
2698
2699     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
2700     if (lpDevInst == NULL)
2701         return CR_INVALID_DEVNODE;
2702
2703     RpcTryExcept
2704     {
2705         ret = PNP_GetFirstLogConf(BindingHandle,
2706                                   lpDevInst,
2707                                   ulFlags,
2708                                   &ulTag,
2709                                   ulFlags);
2710     }
2711     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2712     {
2713         ret = RpcStatusToCmStatus(RpcExceptionCode());
2714     }
2715     RpcEndExcept;
2716
2717     if (ret != CR_SUCCESS)
2718         return ret;
2719
2720     if (plcLogConf)
2721     {
2722         pLogConfInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(LOG_CONF_INFO));
2723         if (pLogConfInfo == NULL)
2724             return CR_OUT_OF_MEMORY;
2725
2726         pLogConfInfo->ulMagic = LOG_CONF_MAGIC;
2727         pLogConfInfo->dnDevInst = dnDevInst;
2728         pLogConfInfo->ulFlags = ulFlags;
2729         pLogConfInfo->ulTag = ulTag;
2730
2731         *plcLogConf = (LOG_CONF)pLogConfInfo;
2732     }
2733
2734     return CR_SUCCESS;
2735 }
2736
2737
2738 /***********************************************************************
2739  * CM_Get_Global_State [SETUPAPI.@]
2740  */
2741 CONFIGRET WINAPI CM_Get_Global_State(
2742     PULONG pulState, ULONG ulFlags)
2743 {
2744     TRACE("%p %lx\n", pulState, ulFlags);
2745     return CM_Get_Global_State_Ex(pulState, ulFlags, NULL);
2746 }
2747
2748
2749 /***********************************************************************
2750  * CM_Get_Global_State_Ex [SETUPAPI.@]
2751  */
2752 CONFIGRET WINAPI CM_Get_Global_State_Ex(
2753     PULONG pulState, ULONG ulFlags, HMACHINE hMachine)
2754 {
2755     RPC_BINDING_HANDLE BindingHandle = NULL;
2756     CONFIGRET ret;
2757
2758     TRACE("%p %lx %lx\n", pulState, ulFlags, hMachine);
2759
2760     if (pulState == NULL)
2761         return CR_INVALID_POINTER;
2762
2763     if (ulFlags != 0)
2764         return CR_INVALID_FLAG;
2765
2766     if (hMachine != NULL)
2767     {
2768         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2769         if (BindingHandle == NULL)
2770             return CR_FAILURE;
2771     }
2772     else
2773     {
2774         if (!PnpGetLocalHandles(&BindingHandle, NULL))
2775             return CR_FAILURE;
2776     }
2777
2778     RpcTryExcept
2779     {
2780         ret = PNP_GetGlobalState(BindingHandle, pulState, ulFlags);
2781     }
2782     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2783     {
2784         ret = RpcStatusToCmStatus(RpcExceptionCode());
2785     }
2786     RpcEndExcept;
2787
2788     return ret;
2789 }
2790
2791
2792 /***********************************************************************
2793  * CM_Get_HW_Prof_FlagsA [SETUPAPI.@]
2794  */
2795 CONFIGRET WINAPI CM_Get_HW_Prof_FlagsA(
2796     DEVINSTID_A szDevInstName, ULONG ulHardwareProfile, PULONG pulValue,
2797     ULONG ulFlags)
2798 {
2799     TRACE("%s %lu %p %lx\n", szDevInstName,
2800           ulHardwareProfile, pulValue, ulFlags);
2801
2802     return CM_Get_HW_Prof_Flags_ExA(szDevInstName, ulHardwareProfile,
2803                                     pulValue, ulFlags, NULL);
2804 }
2805
2806
2807 /***********************************************************************
2808  * CM_Get_HW_Prof_FlagsW [SETUPAPI.@]
2809  */
2810 CONFIGRET WINAPI CM_Get_HW_Prof_FlagsW(
2811     DEVINSTID_W szDevInstName, ULONG ulHardwareProfile, PULONG pulValue,
2812     ULONG ulFlags)
2813 {
2814     TRACE("%s %lu %p %lx\n", debugstr_w(szDevInstName),
2815           ulHardwareProfile, pulValue, ulFlags);
2816
2817     return CM_Get_HW_Prof_Flags_ExW(szDevInstName, ulHardwareProfile,
2818                                     pulValue, ulFlags, NULL);
2819 }
2820
2821
2822 /***********************************************************************
2823  * CM_Get_HW_Prof_Flags_ExA [SETUPAPI.@]
2824  */
2825 CONFIGRET WINAPI CM_Get_HW_Prof_Flags_ExA(
2826     DEVINSTID_A szDevInstName, ULONG ulHardwareProfile, PULONG pulValue,
2827     ULONG ulFlags, HMACHINE hMachine)
2828 {
2829     DEVINSTID_W pszDevIdW = NULL;
2830     CONFIGRET ret = CR_SUCCESS;
2831
2832     TRACE("%s %lu %p %lx %lx\n", szDevInstName,
2833           ulHardwareProfile, pulValue, ulFlags, hMachine);
2834
2835     if (szDevInstName != NULL)
2836     {
2837        if (pSetupCaptureAndConvertAnsiArg(szDevInstName, &pszDevIdW))
2838          return CR_INVALID_DEVICE_ID;
2839     }
2840
2841     ret = CM_Get_HW_Prof_Flags_ExW(pszDevIdW, ulHardwareProfile,
2842                                    pulValue, ulFlags, hMachine);
2843
2844     if (pszDevIdW != NULL)
2845         MyFree(pszDevIdW);
2846
2847     return ret;
2848 }
2849
2850
2851 /***********************************************************************
2852  * CM_Get_HW_Prof_Flags_ExW [SETUPAPI.@]
2853  */
2854 CONFIGRET WINAPI CM_Get_HW_Prof_Flags_ExW(
2855     DEVINSTID_W szDevInstName, ULONG ulHardwareProfile, PULONG pulValue,
2856     ULONG ulFlags, HMACHINE hMachine)
2857 {
2858     RPC_BINDING_HANDLE BindingHandle = NULL;
2859     CONFIGRET ret;
2860
2861     FIXME("%s %lu %p %lx %lx\n", debugstr_w(szDevInstName),
2862           ulHardwareProfile, pulValue, ulFlags, hMachine);
2863
2864     if ((szDevInstName == NULL) || (pulValue == NULL))
2865         return CR_INVALID_POINTER;
2866
2867     if (ulFlags != 0)
2868         return CR_INVALID_FLAG;
2869
2870     /* FIXME: Check whether szDevInstName is valid */
2871
2872     if (hMachine != NULL)
2873     {
2874         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2875         if (BindingHandle == NULL)
2876             return CR_FAILURE;
2877     }
2878     else
2879     {
2880         if (!PnpGetLocalHandles(&BindingHandle, NULL))
2881             return CR_FAILURE;
2882     }
2883
2884     RpcTryExcept
2885     {
2886         ret = PNP_HwProfFlags(BindingHandle, PNP_GET_HWPROFFLAGS, szDevInstName,
2887                               ulHardwareProfile, pulValue, NULL, NULL, 0, 0);
2888     }
2889     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2890     {
2891         ret = RpcStatusToCmStatus(RpcExceptionCode());
2892     }
2893     RpcEndExcept;
2894
2895     return ret;
2896 }
2897
2898
2899 /***********************************************************************
2900  * CM_Get_Hardware_Profile_InfoA [SETUPAPI.@]
2901  */
2902 CONFIGRET WINAPI CM_Get_Hardware_Profile_InfoA(
2903     ULONG ulIndex, PHWPROFILEINFO_A pHWProfileInfo, ULONG ulFlags)
2904 {
2905     TRACE("%lu %p %lx\n", ulIndex, pHWProfileInfo, ulFlags);
2906
2907     return CM_Get_Hardware_Profile_Info_ExA(ulIndex, pHWProfileInfo,
2908                                             ulFlags, NULL);
2909 }
2910
2911
2912 /***********************************************************************
2913  * CM_Get_Hardware_Profile_InfoW [SETUPAPI.@]
2914  */
2915 CONFIGRET WINAPI CM_Get_Hardware_Profile_InfoW(
2916     ULONG ulIndex, PHWPROFILEINFO_W pHWProfileInfo, ULONG ulFlags)
2917 {
2918     TRACE("%lu %p %lx\n", ulIndex, pHWProfileInfo, ulFlags);
2919
2920     return CM_Get_Hardware_Profile_Info_ExW(ulIndex, pHWProfileInfo,
2921                                             ulFlags, NULL);
2922 }
2923
2924
2925 /***********************************************************************
2926  * CM_Get_Hardware_Profile_Info_ExA [SETUPAPI.@]
2927  */
2928 CONFIGRET WINAPI CM_Get_Hardware_Profile_Info_ExA(
2929     ULONG ulIndex, PHWPROFILEINFO_A pHWProfileInfo, ULONG ulFlags,
2930     HMACHINE hMachine)
2931 {
2932     HWPROFILEINFO_W LocalProfileInfo;
2933     CONFIGRET ret;
2934
2935     TRACE("%lu %p %lx %lx\n", ulIndex, pHWProfileInfo, ulFlags, hMachine);
2936
2937     if (pHWProfileInfo == NULL)
2938         return CR_INVALID_POINTER;
2939
2940     ret = CM_Get_Hardware_Profile_Info_ExW(ulIndex, &LocalProfileInfo,
2941                                            ulFlags, hMachine);
2942     if (ret == CR_SUCCESS)
2943     {
2944         pHWProfileInfo->HWPI_ulHWProfile = LocalProfileInfo.HWPI_ulHWProfile;
2945         pHWProfileInfo->HWPI_dwFlags = LocalProfileInfo.HWPI_dwFlags;
2946
2947         if (WideCharToMultiByte(CP_ACP,
2948                                 0,
2949                                 LocalProfileInfo.HWPI_szFriendlyName,
2950                                 lstrlenW(LocalProfileInfo.HWPI_szFriendlyName) + 1,
2951                                 pHWProfileInfo->HWPI_szFriendlyName,
2952                                 MAX_PROFILE_LEN,
2953                                 NULL,
2954                                 NULL) == 0)
2955             ret = CR_FAILURE;
2956     }
2957
2958     return ret;
2959 }
2960
2961
2962 /***********************************************************************
2963  * CM_Get_Hardware_Profile_Info_ExW [SETUPAPI.@]
2964  */
2965 CONFIGRET WINAPI CM_Get_Hardware_Profile_Info_ExW(
2966     ULONG ulIndex, PHWPROFILEINFO_W pHWProfileInfo, ULONG ulFlags,
2967     HMACHINE hMachine)
2968 {
2969     RPC_BINDING_HANDLE BindingHandle = NULL;
2970     CONFIGRET ret;
2971
2972     TRACE("%lu %p %lx %lx\n", ulIndex, pHWProfileInfo, ulFlags, hMachine);
2973
2974     if (pHWProfileInfo == NULL)
2975         return CR_INVALID_POINTER;
2976
2977     if (ulFlags != 0)
2978         return CR_INVALID_FLAG;
2979
2980     if (hMachine != NULL)
2981     {
2982         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
2983         if (BindingHandle == NULL)
2984             return CR_FAILURE;
2985     }
2986     else
2987     {
2988         if (!PnpGetLocalHandles(&BindingHandle, NULL))
2989             return CR_FAILURE;
2990     }
2991
2992     RpcTryExcept
2993     {
2994         ret = PNP_GetHwProfInfo(BindingHandle, ulIndex, pHWProfileInfo,
2995                                 sizeof(HWPROFILEINFO_W), 0);
2996     }
2997     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2998     {
2999         ret = RpcStatusToCmStatus(RpcExceptionCode());
3000     }
3001     RpcEndExcept;
3002
3003     return ret;
3004 }
3005
3006
3007 /***********************************************************************
3008  * CM_Get_Log_Conf_Priority [SETUPAPI.@]
3009  */
3010 CONFIGRET WINAPI CM_Get_Log_Conf_Priority(
3011     LOG_CONF lcLogConf, PPRIORITY pPriority, ULONG ulFlags)
3012 {
3013     TRACE("%p %p %lx\n", lcLogConf, pPriority, ulFlags);
3014     return CM_Get_Log_Conf_Priority_Ex(lcLogConf, pPriority, ulFlags, NULL);
3015 }
3016
3017
3018 /***********************************************************************
3019  * CM_Get_Log_Conf_Priority_Ex [SETUPAPI.@]
3020  */
3021 CONFIGRET WINAPI CM_Get_Log_Conf_Priority_Ex(
3022     LOG_CONF lcLogConf, PPRIORITY pPriority, ULONG ulFlags,
3023     HMACHINE hMachine)
3024 {
3025     RPC_BINDING_HANDLE BindingHandle = NULL;
3026     HSTRING_TABLE StringTable = NULL;
3027     PLOG_CONF_INFO pLogConfInfo;
3028     LPWSTR lpDevInst;
3029     CONFIGRET ret;
3030
3031     FIXME("%p %p %lx %lx\n", lcLogConf, pPriority, ulFlags, hMachine);
3032
3033     pLogConfInfo = (PLOG_CONF_INFO)lcLogConf;
3034     if (pLogConfInfo == NULL || pLogConfInfo->ulMagic != LOG_CONF_MAGIC)
3035         return CR_INVALID_LOG_CONF;
3036
3037     if (pPriority == NULL)
3038         return CR_INVALID_POINTER;
3039
3040     if (ulFlags != 0)
3041         return CR_INVALID_FLAG;
3042
3043     if (hMachine != NULL)
3044     {
3045         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3046         if (BindingHandle == NULL)
3047             return CR_FAILURE;
3048
3049         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3050         if (StringTable == 0)
3051             return CR_FAILURE;
3052     }
3053     else
3054     {
3055         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
3056             return CR_FAILURE;
3057     }
3058
3059     lpDevInst = pSetupStringTableStringFromId(StringTable, pLogConfInfo->dnDevInst);
3060     if (lpDevInst == NULL)
3061         return CR_INVALID_DEVNODE;
3062
3063     RpcTryExcept
3064     {
3065         ret = PNP_GetLogConfPriority(BindingHandle,
3066                                      lpDevInst,
3067                                      pLogConfInfo->ulFlags,
3068                                      pLogConfInfo->ulTag,
3069                                      pPriority,
3070                                      0);
3071     }
3072     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3073     {
3074         ret = RpcStatusToCmStatus(RpcExceptionCode());
3075     }
3076     RpcEndExcept;
3077
3078     return ret;
3079 }
3080
3081
3082 /***********************************************************************
3083  * CM_Get_Next_Log_Conf [SETUPAPI.@]
3084  */
3085 CONFIGRET WINAPI CM_Get_Next_Log_Conf(
3086     PLOG_CONF plcLogConf, LOG_CONF lcLogConf, ULONG ulFlags)
3087 {
3088     TRACE("%p %p %lx\n", plcLogConf, lcLogConf, ulFlags);
3089     return CM_Get_Next_Log_Conf_Ex(plcLogConf, lcLogConf, ulFlags, NULL);
3090 }
3091
3092
3093 /***********************************************************************
3094  * CM_Get_Next_Log_Conf_Ex [SETUPAPI.@]
3095  */
3096 CONFIGRET WINAPI CM_Get_Next_Log_Conf_Ex(
3097     PLOG_CONF plcLogConf, LOG_CONF lcLogConf, ULONG ulFlags,
3098     HMACHINE hMachine)
3099 {
3100     RPC_BINDING_HANDLE BindingHandle = NULL;
3101     HSTRING_TABLE StringTable = NULL;
3102     PLOG_CONF_INFO pLogConfInfo;
3103     PLOG_CONF_INFO pNewLogConfInfo;
3104     ULONG ulNewTag;
3105     LPWSTR lpDevInst;
3106     CONFIGRET ret;
3107
3108     FIXME("%p %p %lx %lx\n", plcLogConf, lcLogConf, ulFlags, hMachine);
3109
3110     if (plcLogConf)
3111         *plcLogConf = 0;
3112
3113     pLogConfInfo = (PLOG_CONF_INFO)lcLogConf;
3114     if (pLogConfInfo == NULL || pLogConfInfo->ulMagic != LOG_CONF_MAGIC)
3115         return CR_INVALID_LOG_CONF;
3116
3117     if (ulFlags != 0)
3118         return CR_INVALID_FLAG;
3119
3120     if (hMachine != NULL)
3121     {
3122         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3123         if (BindingHandle == NULL)
3124             return CR_FAILURE;
3125
3126         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3127         if (StringTable == 0)
3128             return CR_FAILURE;
3129     }
3130     else
3131     {
3132         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
3133             return CR_FAILURE;
3134     }
3135
3136     lpDevInst = pSetupStringTableStringFromId(StringTable, pLogConfInfo->dnDevInst);
3137     if (lpDevInst == NULL)
3138         return CR_INVALID_DEVNODE;
3139
3140     RpcTryExcept
3141     {
3142         ret = PNP_GetNextLogConf(BindingHandle,
3143                                  lpDevInst,
3144                                  pLogConfInfo->ulFlags,
3145                                  pLogConfInfo->ulTag,
3146                                  &ulNewTag,
3147                                  0);
3148     }
3149     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3150     {
3151         ret = RpcStatusToCmStatus(RpcExceptionCode());
3152     }
3153     RpcEndExcept;
3154
3155     if (ret != CR_SUCCESS)
3156         return ret;
3157
3158     if (plcLogConf)
3159     {
3160         pNewLogConfInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(LOG_CONF_INFO));
3161         if (pNewLogConfInfo == NULL)
3162             return CR_OUT_OF_MEMORY;
3163
3164         pNewLogConfInfo->ulMagic = LOG_CONF_MAGIC;
3165         pNewLogConfInfo->dnDevInst = pLogConfInfo->dnDevInst;
3166         pNewLogConfInfo->ulFlags = pLogConfInfo->ulFlags;
3167         pNewLogConfInfo->ulTag = ulNewTag;
3168
3169         *plcLogConf = (LOG_CONF)pNewLogConfInfo;
3170     }
3171
3172     return CR_SUCCESS;
3173 }
3174
3175
3176 /***********************************************************************
3177  * CM_Get_Next_Re_Des [SETUPAPI.@]
3178  */
3179 CONFIGRET WINAPI CM_Get_Next_Res_Des(
3180     PRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ForResource,
3181     PRESOURCEID pResourceID, ULONG ulFlags)
3182 {
3183     TRACE("%p %p %lu %p %lx\n", prdResDes, rdResDes, ForResource,
3184           pResourceID, ulFlags);
3185     return CM_Get_Next_Res_Des_Ex(prdResDes, rdResDes, ForResource,
3186                                   pResourceID, ulFlags, NULL);
3187 }
3188
3189
3190 /***********************************************************************
3191  * CM_Get_Next_Re_Des_Ex [SETUPAPI.@]
3192  */
3193 CONFIGRET WINAPI CM_Get_Next_Res_Des_Ex(
3194     PRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ForResource,
3195     PRESOURCEID pResourceID, ULONG ulFlags, HMACHINE hMachine)
3196 {
3197     FIXME("%p %p %lu %p %lx %lx\n", prdResDes, rdResDes, ForResource,
3198           pResourceID, ulFlags, hMachine);
3199
3200     return CR_CALL_NOT_IMPLEMENTED;
3201 }
3202
3203
3204 /***********************************************************************
3205  * CM_Get_Parent [SETUPAPI.@]
3206  */
3207 CONFIGRET WINAPI CM_Get_Parent(
3208     PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags)
3209 {
3210     TRACE("%p %p %lx\n", pdnDevInst, dnDevInst, ulFlags);
3211     return CM_Get_Parent_Ex(pdnDevInst, dnDevInst, ulFlags, NULL);
3212 }
3213
3214
3215 /***********************************************************************
3216  * CM_Get_Parent_Ex [SETUPAPI.@]
3217  */
3218 CONFIGRET WINAPI CM_Get_Parent_Ex(
3219     PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
3220 {
3221     WCHAR szRelatedDevInst[MAX_DEVICE_ID_LEN];
3222     RPC_BINDING_HANDLE BindingHandle = NULL;
3223     HSTRING_TABLE StringTable = NULL;
3224     LPWSTR lpDevInst;
3225     DWORD dwIndex, dwLength = MAX_DEVICE_ID_LEN;
3226     CONFIGRET ret;
3227
3228     TRACE("%p %lx %lx %lx\n", pdnDevInst, dnDevInst, ulFlags, hMachine);
3229
3230     if (pdnDevInst == NULL)
3231         return CR_INVALID_POINTER;
3232
3233     if (dnDevInst == 0)
3234         return CR_INVALID_DEVINST;
3235
3236     if (ulFlags != 0)
3237         return CR_INVALID_FLAG;
3238
3239     *pdnDevInst = -1;
3240
3241     if (hMachine != NULL)
3242     {
3243         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3244         if (BindingHandle == NULL)
3245             return CR_FAILURE;
3246
3247         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3248         if (StringTable == 0)
3249             return CR_FAILURE;
3250     }
3251     else
3252     {
3253         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
3254             return CR_FAILURE;
3255     }
3256
3257     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
3258     if (lpDevInst == NULL)
3259         return CR_INVALID_DEVNODE;
3260
3261     RpcTryExcept
3262     {
3263         ret = PNP_GetRelatedDeviceInstance(BindingHandle,
3264                                            PNP_GET_PARENT_DEVICE_INSTANCE,
3265                                            lpDevInst,
3266                                            szRelatedDevInst,
3267                                            &dwLength,
3268                                            0);
3269     }
3270     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3271     {
3272         ret = RpcStatusToCmStatus(RpcExceptionCode());
3273     }
3274     RpcEndExcept;
3275
3276     if (ret != CR_SUCCESS)
3277         return ret;
3278
3279     TRACE("szRelatedDevInst: %s\n", debugstr_w(szRelatedDevInst));
3280
3281     dwIndex = pSetupStringTableAddString(StringTable, szRelatedDevInst, 1);
3282     if (dwIndex == -1)
3283         return CR_FAILURE;
3284
3285     *pdnDevInst = dwIndex;
3286
3287     return CR_SUCCESS;
3288 }
3289
3290
3291 /***********************************************************************
3292  * CM_Get_Res_Des_Data [SETUPAPI.@]
3293  */
3294 CONFIGRET WINAPI CM_Get_Res_Des_Data(
3295     RES_DES rdResDes, PVOID Buffer, ULONG BufferLen, ULONG ulFlags)
3296 {
3297     TRACE("%p %p %l %lx\n", rdResDes, Buffer, BufferLen, ulFlags);
3298     return CM_Get_Res_Des_Data_Ex(rdResDes, Buffer, BufferLen, ulFlags, NULL);
3299 }
3300
3301
3302 /***********************************************************************
3303  * CM_Get_Res_Des_Data_Ex [SETUPAPI.@]
3304  */
3305 CONFIGRET WINAPI CM_Get_Res_Des_Data_Ex(
3306     RES_DES rdResDes, PVOID Buffer, ULONG BufferLen, ULONG ulFlags,
3307     HMACHINE hMachine)
3308 {
3309     FIXME("%p %p %l %lx %lx\n", rdResDes, Buffer, BufferLen, ulFlags, hMachine);
3310     return CR_CALL_NOT_IMPLEMENTED;
3311 }
3312
3313
3314 /***********************************************************************
3315  * CM_Get_Res_Des_Size [SETUPAPI.@]
3316  */
3317 CONFIGRET WINAPI CM_Get_Res_Des_Data_Size(
3318     PULONG pulSize, RES_DES rdResDes, ULONG ulFlags)
3319 {
3320     TRACE("%p %p %lx\n", pulSize, rdResDes, ulFlags);
3321     return CM_Get_Res_Des_Data_Size_Ex(pulSize, rdResDes, ulFlags, NULL);
3322 }
3323
3324
3325 /***********************************************************************
3326  * CM_Get_Res_Des_Size_Ex [SETUPAPI.@]
3327  */
3328 CONFIGRET WINAPI CM_Get_Res_Des_Data_Size_Ex(
3329     PULONG pulSize, RES_DES rdResDes, ULONG ulFlags, HMACHINE hMachine)
3330 {
3331     TRACE("%p %p %lx %lx\n", pulSize, rdResDes, ulFlags, hMachine);
3332     return CR_CALL_NOT_IMPLEMENTED;
3333 }
3334
3335
3336 /***********************************************************************
3337  * CM_Get_Sibling [SETUPAPI.@]
3338  */
3339 CONFIGRET WINAPI CM_Get_Sibling(
3340     PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags)
3341 {
3342     TRACE("%p %p %lx\n", pdnDevInst, dnDevInst, ulFlags);
3343     return CM_Get_Sibling_Ex(pdnDevInst, dnDevInst, ulFlags, NULL);
3344 }
3345
3346
3347 /***********************************************************************
3348  * CM_Get_Sibling_Ex [SETUPAPI.@]
3349  */
3350 CONFIGRET WINAPI CM_Get_Sibling_Ex(
3351     PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
3352 {
3353     WCHAR szRelatedDevInst[MAX_DEVICE_ID_LEN];
3354     RPC_BINDING_HANDLE BindingHandle = NULL;
3355     HSTRING_TABLE StringTable = NULL;
3356     LPWSTR lpDevInst;
3357     DWORD dwIndex, dwLength = MAX_DEVICE_ID_LEN;
3358     CONFIGRET ret;
3359
3360     TRACE("%p %lx %lx %lx\n", pdnDevInst, dnDevInst, ulFlags, hMachine);
3361
3362     if (pdnDevInst == NULL)
3363         return CR_INVALID_POINTER;
3364
3365     if (dnDevInst == 0)
3366         return CR_INVALID_DEVINST;
3367
3368     if (ulFlags != 0)
3369         return CR_INVALID_FLAG;
3370
3371     *pdnDevInst = -1;
3372
3373     if (hMachine != NULL)
3374     {
3375         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3376         if (BindingHandle == NULL)
3377             return CR_FAILURE;
3378
3379         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3380         if (StringTable == 0)
3381             return CR_FAILURE;
3382     }
3383     else
3384     {
3385         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
3386             return CR_FAILURE;
3387     }
3388
3389     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
3390     if (lpDevInst == NULL)
3391         return CR_INVALID_DEVNODE;
3392
3393     RpcTryExcept
3394     {
3395         ret = PNP_GetRelatedDeviceInstance(BindingHandle,
3396                                            PNP_GET_SIBLING_DEVICE_INSTANCE,
3397                                            lpDevInst,
3398                                            szRelatedDevInst,
3399                                            &dwLength,
3400                                            0);
3401     }
3402     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3403     {
3404         ret = RpcStatusToCmStatus(RpcExceptionCode());
3405     }
3406     RpcEndExcept;
3407
3408     if (ret != CR_SUCCESS)
3409         return ret;
3410
3411     TRACE("szRelatedDevInst: %s\n", debugstr_w(szRelatedDevInst));
3412
3413     dwIndex = pSetupStringTableAddString(StringTable, szRelatedDevInst, 1);
3414     if (dwIndex == -1)
3415         return CR_FAILURE;
3416
3417     *pdnDevInst = dwIndex;
3418
3419     return CR_SUCCESS;
3420 }
3421
3422
3423 /***********************************************************************
3424  * CM_Get_Version [SETUPAPI.@]
3425  */
3426 WORD WINAPI CM_Get_Version(VOID)
3427 {
3428     TRACE("\n");
3429     return CM_Get_Version_Ex(NULL);
3430 }
3431
3432
3433 /***********************************************************************
3434  * CM_Get_Version_Ex [SETUPAPI.@]
3435  */
3436 WORD WINAPI CM_Get_Version_Ex(HMACHINE hMachine)
3437 {
3438     RPC_BINDING_HANDLE BindingHandle = NULL;
3439     WORD Version = 0;
3440     CONFIGRET ret;
3441
3442     TRACE("%lx\n", hMachine);
3443
3444     if (hMachine != NULL)
3445     {
3446         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3447         if (BindingHandle == NULL)
3448             return 0;
3449     }
3450     else
3451     {
3452         if (!PnpGetLocalHandles(&BindingHandle, NULL))
3453             return CR_FAILURE;
3454     }
3455
3456     RpcTryExcept
3457     {
3458         ret = PNP_GetVersion(BindingHandle, &Version);
3459     }
3460     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3461     {
3462         ret = RpcStatusToCmStatus(RpcExceptionCode());
3463     }
3464     RpcEndExcept;
3465
3466     if (ret != CR_SUCCESS)
3467         return 0;
3468
3469     return Version;
3470 }
3471
3472
3473 /***********************************************************************
3474  * CM_Is_Dock_Station_Present [SETUPAPI.@]
3475  */
3476 CONFIGRET WINAPI CM_Is_Dock_Station_Present(
3477     PBOOL pbPresent)
3478 {
3479     TRACE("%p\n", pbPresent);
3480     return CM_Is_Dock_Station_Present_Ex(pbPresent, NULL);
3481 }
3482
3483
3484 /***********************************************************************
3485  * CM_Is_Dock_Station_Present_Ex [SETUPAPI.@]
3486  */
3487 CONFIGRET WINAPI CM_Is_Dock_Station_Present_Ex(
3488     PBOOL pbPresent, HMACHINE hMachine)
3489 {
3490     RPC_BINDING_HANDLE BindingHandle = NULL;
3491     CONFIGRET ret;
3492
3493     TRACE("%p %lx\n", pbPresent, hMachine);
3494
3495     if (pbPresent == NULL)
3496         return CR_INVALID_POINTER;
3497
3498     *pbPresent = FALSE;
3499
3500     if (hMachine != NULL)
3501     {
3502         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3503         if (BindingHandle == NULL)
3504             return CR_FAILURE;
3505     }
3506     else
3507     {
3508         if (!PnpGetLocalHandles(&BindingHandle, NULL))
3509             return CR_FAILURE;
3510     }
3511
3512     RpcTryExcept
3513     {
3514         ret = PNP_IsDockStationPresent(BindingHandle,
3515                                        pbPresent);
3516     }
3517     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3518     {
3519         ret = RpcStatusToCmStatus(RpcExceptionCode());
3520     }
3521     RpcEndExcept;
3522
3523     return ret;
3524 }
3525
3526
3527 /***********************************************************************
3528  * CM_Is_Version_Available_Ex [SETUPAPI.@]
3529  */
3530 BOOL WINAPI CM_Is_Version_Available(
3531      WORD wVersion)
3532 {
3533     TRACE("%hu\n", wVersion);
3534     return CM_Is_Version_Available_Ex(wVersion, NULL);
3535 }
3536
3537
3538 /***********************************************************************
3539  * CM_Is_Version_Available_Ex [SETUPAPI.@]
3540  */
3541 BOOL WINAPI CM_Is_Version_Available_Ex(
3542     WORD wVersion, HMACHINE hMachine)
3543 {
3544     RPC_BINDING_HANDLE BindingHandle = NULL;
3545     WORD wServerVersion;
3546     CONFIGRET ret;
3547
3548     TRACE("%hu %lx\n", wVersion, hMachine);
3549
3550     if (wVersion <= 0x400)
3551         return TRUE;
3552
3553     if (hMachine != NULL)
3554     {
3555         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3556         if (BindingHandle == NULL)
3557             return FALSE;
3558     }
3559     else
3560     {
3561         if (!PnpGetLocalHandles(&BindingHandle, NULL))
3562             return FALSE;
3563     }
3564
3565     RpcTryExcept
3566     {
3567         ret = PNP_GetVersion(BindingHandle, &wServerVersion);
3568     }
3569     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3570     {
3571         ret = RpcStatusToCmStatus(RpcExceptionCode());
3572     }
3573     RpcEndExcept;
3574
3575     if (ret != CR_SUCCESS)
3576         return FALSE;
3577
3578     return (wServerVersion >= wVersion);
3579 }
3580
3581
3582 /***********************************************************************
3583  * CM_Locate_DevNodeA [SETUPAPI.@]
3584  */
3585 CONFIGRET WINAPI CM_Locate_DevNodeA(
3586     PDEVINST pdnDevInst, DEVINSTID_A pDeviceID, ULONG ulFlags)
3587 {
3588     TRACE("%p %s %lu\n", pdnDevInst, pDeviceID, ulFlags);
3589     return CM_Locate_DevNode_ExA(pdnDevInst, pDeviceID, ulFlags, NULL);
3590 }
3591
3592
3593 /***********************************************************************
3594  * CM_Locate_DevNodeW [SETUPAPI.@]
3595  */
3596 CONFIGRET WINAPI CM_Locate_DevNodeW(
3597     PDEVINST pdnDevInst, DEVINSTID_W pDeviceID, ULONG ulFlags)
3598 {
3599     TRACE("%p %s %lu\n", pdnDevInst, debugstr_w(pDeviceID), ulFlags);
3600     return CM_Locate_DevNode_ExW(pdnDevInst, pDeviceID, ulFlags, NULL);
3601 }
3602
3603
3604 /***********************************************************************
3605  * CM_Locate_DevNode_ExA [SETUPAPI.@]
3606  */
3607 CONFIGRET WINAPI CM_Locate_DevNode_ExA(
3608     PDEVINST pdnDevInst, DEVINSTID_A pDeviceID, ULONG ulFlags, HMACHINE hMachine)
3609 {
3610     DEVINSTID_W pDevIdW = NULL;
3611     CONFIGRET ret = CR_SUCCESS;
3612
3613     TRACE("%p %s %lu %lx\n", pdnDevInst, pDeviceID, ulFlags, hMachine);
3614
3615     if (pDeviceID != NULL)
3616     {
3617        if (pSetupCaptureAndConvertAnsiArg(pDeviceID, &pDevIdW))
3618          return CR_INVALID_DEVICE_ID;
3619     }
3620
3621     ret = CM_Locate_DevNode_ExW(pdnDevInst, pDevIdW, ulFlags, hMachine);
3622
3623     if (pDevIdW != NULL)
3624         MyFree(pDevIdW);
3625
3626     return ret;
3627 }
3628
3629
3630 /***********************************************************************
3631  * CM_Locate_DevNode_ExW [SETUPAPI.@]
3632  */
3633 CONFIGRET WINAPI CM_Locate_DevNode_ExW(
3634     PDEVINST pdnDevInst, DEVINSTID_W pDeviceID, ULONG ulFlags, HMACHINE hMachine)
3635 {
3636     WCHAR DeviceIdBuffer[MAX_DEVICE_ID_LEN];
3637     RPC_BINDING_HANDLE BindingHandle = NULL;
3638     HSTRING_TABLE StringTable = NULL;
3639     CONFIGRET ret = CR_SUCCESS;
3640
3641     TRACE("%p %s %lu %lx\n", pdnDevInst, debugstr_w(pDeviceID), ulFlags, hMachine);
3642
3643     if (pdnDevInst == NULL)
3644         return CR_INVALID_POINTER;
3645
3646     if (ulFlags & ~CM_LOCATE_DEVNODE_BITS)
3647         return CR_INVALID_FLAG;
3648
3649     if (hMachine != NULL)
3650     {
3651         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3652         if (BindingHandle == NULL)
3653             return CR_FAILURE;
3654
3655         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3656         if (StringTable == 0)
3657             return CR_FAILURE;
3658     }
3659     else
3660     {
3661         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
3662             return CR_FAILURE;
3663     }
3664
3665     if (pDeviceID != NULL && lstrlenW(pDeviceID) != 0)
3666     {
3667         lstrcpyW(DeviceIdBuffer, pDeviceID);
3668     }
3669     else
3670     {
3671         RpcTryExcept
3672         {
3673             /* Get the root device ID */
3674             ret = PNP_GetRootDeviceInstance(BindingHandle,
3675                                             DeviceIdBuffer,
3676                                             MAX_DEVICE_ID_LEN);
3677         }
3678         RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3679         {
3680             ret = RpcStatusToCmStatus(RpcExceptionCode());
3681         }
3682         RpcEndExcept;
3683
3684         if (ret != CR_SUCCESS)
3685             return CR_FAILURE;
3686     }
3687     TRACE("DeviceIdBuffer: %s\n", debugstr_w(DeviceIdBuffer));
3688
3689     RpcTryExcept
3690     {
3691         /* Validate the device ID */
3692         ret = PNP_ValidateDeviceInstance(BindingHandle,
3693                                          DeviceIdBuffer,
3694                                          ulFlags);
3695     }
3696     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3697     {
3698         ret = RpcStatusToCmStatus(RpcExceptionCode());
3699     }
3700     RpcEndExcept;
3701
3702     if (ret == CR_SUCCESS)
3703     {
3704         *pdnDevInst = pSetupStringTableAddString(StringTable, DeviceIdBuffer, 1);
3705         if (*pdnDevInst == -1)
3706             ret = CR_FAILURE;
3707     }
3708
3709     return ret;
3710 }
3711
3712
3713 /***********************************************************************
3714  * CM_Modify_Res_Des [SETUPAPI.@]
3715  */
3716 CONFIGRET WINAPI CM_Modify_Res_Des(
3717     PRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ResourceID,
3718     PCVOID ResourceData, ULONG ResourceLen, ULONG ulFlags)
3719 {
3720     TRACE("%p %p %lx %p %lu %lx", prdResDes, rdResDes, ResourceID, ResourceData,
3721           ResourceLen, ulFlags);
3722     return CM_Modify_Res_Des_Ex(prdResDes, rdResDes, ResourceID, ResourceData,
3723                                 ResourceLen, ulFlags, NULL);
3724 }
3725
3726
3727 /***********************************************************************
3728  * CM_Modify_Res_Des_Ex [SETUPAPI.@]
3729  */
3730 CONFIGRET WINAPI CM_Modify_Res_Des_Ex(
3731     PRES_DES prdResDes, RES_DES rdResDes, RESOURCEID ResourceID, PCVOID ResourceData,
3732     ULONG ResourceLen, ULONG ulFlags, HMACHINE hMachine)
3733 {
3734     FIXME("%p %p %lx %p %lu %lx %lx", prdResDes, rdResDes, ResourceID, ResourceData,
3735           ResourceLen, ulFlags, hMachine);
3736     return CR_CALL_NOT_IMPLEMENTED;
3737 }
3738
3739
3740 /***********************************************************************
3741  * CM_Move_DevNode [SETUPAPI.@]
3742  */
3743 CONFIGRET WINAPI CM_Move_DevNode(
3744     DEVINST dnFromDevInst, DEVINST dnToDevInst, ULONG ulFlags)
3745 {
3746     TRACE("%lx %lx %lx\n", dnFromDevInst, dnToDevInst, ulFlags);
3747     return CM_Move_DevNode_Ex(dnFromDevInst, dnToDevInst, ulFlags, NULL);
3748 }
3749
3750
3751 /***********************************************************************
3752  * CM_Move_DevNode_Ex [SETUPAPI.@]
3753  */
3754 CONFIGRET WINAPI CM_Move_DevNode_Ex(
3755     DEVINST dnFromDevInst, DEVINST dnToDevInst, ULONG ulFlags,
3756     HMACHINE hMachine)
3757 {
3758     RPC_BINDING_HANDLE BindingHandle = NULL;
3759     HSTRING_TABLE StringTable = NULL;
3760     LPWSTR lpFromDevInst;
3761     LPWSTR lpToDevInst;
3762     CONFIGRET ret;
3763
3764     FIXME("%lx %lx %lx %lx\n",
3765           dnFromDevInst, dnToDevInst, ulFlags, hMachine);
3766
3767     if (!pSetupIsUserAdmin())
3768         return CR_ACCESS_DENIED;
3769
3770     if (dnFromDevInst == 0 || dnToDevInst == 0)
3771         return CR_INVALID_DEVNODE;
3772
3773     if (ulFlags != 0)
3774         return CR_INVALID_FLAG;
3775
3776     if (hMachine != NULL)
3777     {
3778         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
3779         if (BindingHandle == NULL)
3780             return CR_FAILURE;
3781
3782         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
3783         if (StringTable == 0)
3784             return CR_FAILURE;
3785     }
3786     else
3787     {
3788         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
3789             return CR_FAILURE;
3790     }
3791
3792     lpFromDevInst = pSetupStringTableStringFromId(StringTable, dnFromDevInst);
3793     if (lpFromDevInst == NULL)
3794         return CR_INVALID_DEVNODE;
3795
3796     lpToDevInst = pSetupStringTableStringFromId(StringTable, dnToDevInst);
3797     if (lpToDevInst == NULL)
3798         return CR_INVALID_DEVNODE;
3799
3800     RpcTryExcept
3801     {
3802         ret = PNP_DeviceInstanceAction(BindingHandle,
3803                                        PNP_DEVINST_MOVE,
3804                                        ulFlags,
3805                                        lpFromDevInst,
3806                                        lpToDevInst);
3807     }
3808     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
3809     {
3810         ret = RpcStatusToCmStatus(RpcExceptionCode());
3811     }
3812     RpcEndExcept;
3813
3814     return ret;
3815 }
3816
3817
3818 /***********************************************************************
3819  * CM_Open_Class_KeyA [SETUPAPI.@]
3820  */
3821 CONFIGRET WINAPI CM_Open_Class_KeyA(
3822     LPGUID pClassGuid, LPCSTR pszClassName, REGSAM samDesired,
3823     REGDISPOSITION Disposition, PHKEY phkClass, ULONG ulFlags)
3824 {
3825     TRACE("%p %s %lx %lx %p %lx\n",
3826           debugstr_guid(pClassGuid), pszClassName,
3827           samDesired, Disposition, phkClass, ulFlags);
3828
3829     return CM_Open_Class_Key_ExA(pClassGuid, pszClassName, samDesired,
3830                                  Disposition, phkClass, ulFlags, NULL);
3831 }
3832
3833
3834 /***********************************************************************
3835  * CM_Open_Class_KeyW [SETUPAPI.@]
3836  */
3837 CONFIGRET WINAPI CM_Open_Class_KeyW(
3838     LPGUID pClassGuid, LPCWSTR pszClassName, REGSAM samDesired,
3839     REGDISPOSITION Disposition, PHKEY phkClass, ULONG ulFlags)
3840 {
3841     TRACE("%p %s %lx %lx %p %lx\n",
3842           debugstr_guid(pClassGuid), debugstr_w(pszClassName),
3843           samDesired, Disposition, phkClass, ulFlags);
3844
3845     return CM_Open_Class_Key_ExW(pClassGuid, pszClassName, samDesired,
3846                                  Disposition, phkClass, ulFlags, NULL);
3847 }
3848
3849
3850 /***********************************************************************
3851  * CM_Open_Class_Key_ExA [SETUPAPI.@]
3852  */
3853 CONFIGRET WINAPI CM_Open_Class_Key_ExA(
3854     LPGUID pClassGuid, LPCSTR pszClassName, REGSAM samDesired,
3855     REGDISPOSITION Disposition, PHKEY phkClass, ULONG ulFlags,
3856     HMACHINE hMachine)
3857 {
3858     CONFIGRET rc = CR_SUCCESS;
3859     LPWSTR pszClassNameW = NULL;
3860
3861     TRACE("%p %s %lx %lx %p %lx %lx\n",
3862           debugstr_guid(pClassGuid), pszClassName,
3863           samDesired, Disposition, phkClass, ulFlags, hMachine);
3864
3865     if (pszClassName != NULL)
3866     {
3867        if (pSetupCaptureAndConvertAnsiArg(pszClassName, &pszClassNameW))
3868          return CR_INVALID_DATA;
3869     }
3870
3871     rc = CM_Open_Class_Key_ExW(pClassGuid, pszClassNameW, samDesired,
3872                                Disposition, phkClass, ulFlags, hMachine);
3873
3874     if (pszClassNameW != NULL)
3875         MyFree(pszClassNameW);
3876
3877     return CR_SUCCESS;
3878 }
3879
3880
3881 /***********************************************************************
3882  * CM_Open_Class_Key_ExW [SETUPAPI.@]
3883  */
3884 CONFIGRET WINAPI CM_Open_Class_Key_ExW(
3885     LPGUID pClassGuid, LPCWSTR pszClassName, REGSAM samDesired,
3886     REGDISPOSITION Disposition, PHKEY phkClass, ULONG ulFlags,
3887     HMACHINE hMachine)
3888 {
3889     WCHAR szKeyName[MAX_PATH];
3890     LPWSTR lpGuidString;
3891     DWORD dwDisposition;
3892     DWORD dwError;
3893     HKEY hKey;
3894
3895     TRACE("%p %s %lx %lx %p %lx %lx\n",
3896           debugstr_guid(pClassGuid), debugstr_w(pszClassName),
3897           samDesired, Disposition, phkClass, ulFlags, hMachine);
3898
3899     /* Check Disposition and ulFlags */
3900     if ((Disposition & ~RegDisposition_Bits) ||
3901         (ulFlags & ~CM_OPEN_CLASS_KEY_BITS))
3902         return CR_INVALID_FLAG;
3903
3904     /* Check phkClass */
3905     if (phkClass == NULL)
3906         return CR_INVALID_POINTER;
3907
3908     *phkClass = NULL;
3909
3910     if (ulFlags == CM_OPEN_CLASS_KEY_INTERFACE &&
3911         pszClassName != NULL)
3912         return CR_INVALID_DATA;
3913
3914     if (hMachine == NULL)
3915     {
3916         hKey = HKEY_LOCAL_MACHINE;
3917     }
3918     else
3919     {
3920        if (RegConnectRegistryW(((PMACHINE_INFO)hMachine)->szMachineName,
3921                                HKEY_LOCAL_MACHINE, &hKey))
3922            return CR_REGISTRY_ERROR;
3923     }
3924
3925     if (ulFlags & CM_OPEN_CLASS_KEY_INTERFACE)
3926     {
3927         lstrcpyW(szKeyName, DeviceClasses);
3928     }
3929     else
3930     {
3931         lstrcpyW(szKeyName, ControlClass);
3932     }
3933
3934     if (pClassGuid != NULL)
3935     {
3936         if (UuidToStringW((UUID*)pClassGuid, &lpGuidString) != RPC_S_OK)
3937         {
3938             RegCloseKey(hKey);
3939             return CR_INVALID_DATA;
3940         }
3941
3942         lstrcatW(szKeyName, Backslash);
3943         lstrcatW(szKeyName, lpGuidString);
3944     }
3945
3946     if (Disposition == RegDisposition_OpenAlways)
3947     {
3948         dwError = RegCreateKeyExW(hKey, szKeyName, 0, NULL, 0, samDesired,
3949                                   NULL, phkClass, &dwDisposition);
3950     }
3951     else
3952     {
3953         dwError = RegOpenKeyExW(hKey, szKeyName, 0, samDesired, phkClass);
3954     }
3955
3956     RegCloseKey(hKey);
3957
3958     if (pClassGuid != NULL)
3959         RpcStringFreeW(&lpGuidString);
3960
3961     if (dwError != ERROR_SUCCESS)
3962     {
3963         *phkClass = NULL;
3964         return CR_NO_SUCH_REGISTRY_KEY;
3965     }
3966
3967     if (pszClassName != NULL)
3968     {
3969         RegSetValueExW(*phkClass, Class, 0, REG_SZ, (LPBYTE)pszClassName,
3970                        (lstrlenW(pszClassName) + 1) * sizeof(WCHAR));
3971     }
3972
3973     return CR_SUCCESS;
3974 }
3975
3976
3977 /***********************************************************************
3978  * CM_Open_DevNode_Key [SETUPAPI.@]
3979  */
3980 CONFIGRET WINAPI CM_Open_DevNode_Key(
3981     DEVINST dnDevNode, REGSAM samDesired, ULONG ulHardwareProfile,
3982     REGDISPOSITION Disposition, PHKEY phkDevice, ULONG ulFlags)
3983 {
3984     TRACE("%lx %lx %lu %lx %p %lx\n", dnDevNode, samDesired,
3985           ulHardwareProfile, Disposition, phkDevice, ulFlags);
3986     return CM_Open_DevNode_Key_Ex(dnDevNode, samDesired, ulHardwareProfile,
3987                                   Disposition, phkDevice, ulFlags, NULL);
3988 }
3989
3990
3991 /***********************************************************************
3992  * CM_Open_DevNode_Key_Ex [SETUPAPI.@]
3993  */
3994 CONFIGRET WINAPI CM_Open_DevNode_Key_Ex(
3995     DEVINST dnDevNode, REGSAM samDesired, ULONG ulHardwareProfile,
3996     REGDISPOSITION Disposition, PHKEY phkDevice, ULONG ulFlags,
3997     HMACHINE hMachine)
3998 {
3999     FIXME("%lx %lx %lu %lx %p %lx %lx\n", dnDevNode, samDesired,
4000           ulHardwareProfile, Disposition, phkDevice, ulFlags, hMachine);
4001
4002     return CR_CALL_NOT_IMPLEMENTED;
4003 }
4004
4005
4006 /***********************************************************************
4007  * CM_Query_And_Remove_SubTreeA [SETUPAPI.@]
4008  */
4009 CONFIGRET WINAPI CM_Query_And_Remove_SubTreeA(
4010     DEVINST dnAncestor, PPNP_VETO_TYPE pVetoType, LPSTR pszVetoName,
4011     ULONG ulNameLength, ULONG ulFlags)
4012 {
4013     TRACE("%lx %p %s %lu %lx\n", dnAncestor, pVetoType, pszVetoName,
4014           ulNameLength, ulFlags);
4015
4016     return CM_Query_And_Remove_SubTree_ExA(dnAncestor, pVetoType, pszVetoName,
4017                                            ulNameLength, ulFlags, NULL);
4018 }
4019
4020
4021 /***********************************************************************
4022  * CM_Query_And_Remove_SubTreeW [SETUPAPI.@]
4023  */
4024 CONFIGRET WINAPI CM_Query_And_Remove_SubTreeW(
4025     DEVINST dnAncestor, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName,
4026     ULONG ulNameLength, ULONG ulFlags)
4027 {
4028     TRACE("%lx %p %s %lu %lx\n", dnAncestor, pVetoType,
4029           debugstr_w(pszVetoName), ulNameLength, ulFlags);
4030
4031     return CM_Query_And_Remove_SubTree_ExW(dnAncestor, pVetoType, pszVetoName,
4032                                            ulNameLength, ulFlags, NULL);
4033 }
4034
4035
4036 /***********************************************************************
4037  * CM_Query_And_Remove_SubTree_ExA [SETUPAPI.@]
4038  */
4039 CONFIGRET WINAPI CM_Query_And_Remove_SubTree_ExA(
4040     DEVINST dnAncestor, PPNP_VETO_TYPE pVetoType, LPSTR pszVetoName,
4041     ULONG ulNameLength, ULONG ulFlags, HMACHINE hMachine)
4042 {
4043     LPWSTR lpLocalVetoName;
4044     CONFIGRET ret;
4045
4046     TRACE("%lx %p %s %lu %lx %lx\n", dnAncestor, pVetoType, pszVetoName,
4047           ulNameLength, ulFlags, hMachine);
4048
4049     if (pszVetoName == NULL && ulNameLength == 0)
4050         return CR_INVALID_POINTER;
4051
4052     lpLocalVetoName = HeapAlloc(GetProcessHeap(), 0, ulNameLength * sizeof(WCHAR));
4053     if (lpLocalVetoName == NULL)
4054         return CR_OUT_OF_MEMORY;
4055
4056     ret = CM_Query_And_Remove_SubTree_ExW(dnAncestor, pVetoType, lpLocalVetoName,
4057                                           ulNameLength, ulFlags, hMachine);
4058     if (ret == CR_REMOVE_VETOED)
4059     {
4060         if (WideCharToMultiByte(CP_ACP,
4061                                 0,
4062                                 lpLocalVetoName,
4063                                 ulNameLength,
4064                                 pszVetoName,
4065                                 ulNameLength,
4066                                 NULL,
4067                                 NULL) == 0)
4068             ret = CR_FAILURE;
4069     }
4070
4071     HeapFree(GetProcessHeap(), 0, lpLocalVetoName);
4072
4073     return ret;
4074 }
4075
4076
4077 /***********************************************************************
4078  * CM_Query_And_Remove_SubTree_ExW [SETUPAPI.@]
4079  */
4080 CONFIGRET WINAPI CM_Query_And_Remove_SubTree_ExW(
4081     DEVINST dnAncestor, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName,
4082     ULONG ulNameLength, ULONG ulFlags, HMACHINE hMachine)
4083 {
4084     RPC_BINDING_HANDLE BindingHandle = NULL;
4085     HSTRING_TABLE StringTable = NULL;
4086     LPWSTR lpDevInst;
4087     CONFIGRET ret;
4088
4089     TRACE("%lx %p %s %lu %lx %lx\n", dnAncestor, pVetoType,
4090           debugstr_w(pszVetoName), ulNameLength, ulFlags, hMachine);
4091
4092     if (dnAncestor == 0)
4093         return CR_INVALID_DEVNODE;
4094
4095     if (ulFlags & ~CM_REMOVE_BITS)
4096         return CR_INVALID_FLAG;
4097
4098     if (pszVetoName == NULL && ulNameLength == 0)
4099         return CR_INVALID_POINTER;
4100
4101     if (hMachine != NULL)
4102     {
4103         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4104         if (BindingHandle == NULL)
4105             return CR_FAILURE;
4106
4107         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4108         if (StringTable == 0)
4109             return CR_FAILURE;
4110     }
4111     else
4112     {
4113         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
4114             return CR_FAILURE;
4115     }
4116
4117     lpDevInst = pSetupStringTableStringFromId(StringTable, dnAncestor);
4118     if (lpDevInst == NULL)
4119         return CR_INVALID_DEVNODE;
4120
4121     RpcTryExcept
4122     {
4123         ret = PNP_QueryRemove(BindingHandle,
4124                               lpDevInst,
4125                               pVetoType,
4126                               pszVetoName,
4127                               ulNameLength,
4128                               ulFlags);
4129     }
4130     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
4131     {
4132         ret = RpcStatusToCmStatus(RpcExceptionCode());
4133     }
4134     RpcEndExcept;
4135
4136     return ret;
4137 }
4138
4139
4140 /***********************************************************************
4141  * CM_Query_Remove_SubTree [SETUPAPI.@]
4142  *
4143  * This function is obsolete in Windows XP and above.
4144  */
4145 CONFIGRET WINAPI CM_Query_Remove_SubTree(
4146     DEVINST dnAncestor, ULONG ulFlags)
4147 {
4148     TRACE("%lx %lx\n", dnAncestor, ulFlags);
4149     return CR_CALL_NOT_IMPLEMENTED;
4150 }
4151
4152
4153 /***********************************************************************
4154  * CM_Query_Remove_SubTree_Ex [SETUPAPI.@]
4155  *
4156  * This function is obsolete in Windows XP and above.
4157  */
4158 CONFIGRET WINAPI CM_Query_Remove_SubTree_Ex(
4159     DEVINST dnAncestor, ULONG ulFlags, HMACHINE hMachine)
4160 {
4161     TRACE("%lx %lx %lx\n", dnAncestor, ulFlags, hMachine);
4162     return CR_CALL_NOT_IMPLEMENTED;
4163 }
4164
4165
4166 /***********************************************************************
4167  * CM_Reenumerate_DevNode [SETUPAPI.@]
4168  */
4169 CONFIGRET WINAPI CM_Reenumerate_DevNode(
4170     DEVINST dnDevInst, ULONG ulFlags)
4171 {
4172     TRACE("%lx %lx\n", dnDevInst, ulFlags);
4173     return CM_Reenumerate_DevNode_Ex(dnDevInst, ulFlags, NULL);
4174 }
4175
4176
4177 /***********************************************************************
4178  * CM_Reenumerate_DevNode_Ex [SETUPAPI.@]
4179  */
4180 CONFIGRET WINAPI
4181 CM_Reenumerate_DevNode_Ex(
4182     DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
4183 {
4184     RPC_BINDING_HANDLE BindingHandle = NULL;
4185     HSTRING_TABLE StringTable = NULL;
4186     LPWSTR lpDevInst;
4187     CONFIGRET ret;
4188
4189     FIXME("%lx %lx %lx\n", dnDevInst, ulFlags, hMachine);
4190
4191     if (dnDevInst == 0)
4192         return CR_INVALID_DEVNODE;
4193
4194     if (ulFlags & ~CM_REENUMERATE_BITS)
4195         return CR_INVALID_FLAG;
4196
4197     if (hMachine != NULL)
4198     {
4199         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4200         if (BindingHandle == NULL)
4201             return CR_FAILURE;
4202
4203         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4204         if (StringTable == 0)
4205             return CR_FAILURE;
4206     }
4207     else
4208     {
4209         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
4210             return CR_FAILURE;
4211     }
4212
4213     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
4214     if (lpDevInst == NULL)
4215         return CR_INVALID_DEVNODE;
4216
4217     RpcTryExcept
4218     {
4219         ret = PNP_DeviceInstanceAction(BindingHandle,
4220                                        PNP_DEVINST_REENUMERATE,
4221                                        ulFlags,
4222                                        lpDevInst,
4223                                        NULL);
4224     }
4225     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
4226     {
4227         ret = RpcStatusToCmStatus(RpcExceptionCode());
4228     }
4229     RpcEndExcept;
4230
4231     return ret;
4232 }
4233
4234
4235 /***********************************************************************
4236  * CM_Register_Device_InterfaceA [SETUPAPI.@]
4237  */
4238 CONFIGRET WINAPI CM_Register_Device_InterfaceA(
4239     DEVINST dnDevInst, LPGUID InterfaceClassGuid, LPCSTR pszReference,
4240     LPSTR pszDeviceInterface, PULONG pulLength, ULONG ulFlags)
4241 {
4242     TRACE("%lx %s %s %p %p %lx\n", dnDevInst, debugstr_guid(InterfaceClassGuid),
4243           pszReference, pszDeviceInterface, pulLength, ulFlags);
4244
4245     return CM_Register_Device_Interface_ExA(dnDevInst, InterfaceClassGuid,
4246                                             pszReference, pszDeviceInterface,
4247                                             pulLength, ulFlags, NULL);
4248 }
4249
4250
4251 /***********************************************************************
4252  * CM_Register_Device_InterfaceW [SETUPAPI.@]
4253  */
4254 CONFIGRET WINAPI CM_Register_Device_InterfaceW(
4255     DEVINST dnDevInst, LPGUID InterfaceClassGuid, LPCWSTR pszReference,
4256     LPWSTR pszDeviceInterface, PULONG pulLength, ULONG ulFlags)
4257 {
4258     TRACE("%lx %s %s %p %p %lx\n", dnDevInst, debugstr_guid(InterfaceClassGuid),
4259           debugstr_w(pszReference), pszDeviceInterface, pulLength, ulFlags);
4260
4261     return CM_Register_Device_Interface_ExW(dnDevInst, InterfaceClassGuid,
4262                                             pszReference, pszDeviceInterface,
4263                                             pulLength, ulFlags, NULL);
4264 }
4265
4266
4267 /***********************************************************************
4268  * CM_Register_Device_Interface_ExA [SETUPAPI.@]
4269  */
4270 CONFIGRET WINAPI CM_Register_Device_Interface_ExA(
4271     DEVINST dnDevInst, LPGUID InterfaceClassGuid, LPCSTR pszReference,
4272     LPSTR pszDeviceInterface, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine)
4273 {
4274     LPWSTR pszReferenceW = NULL;
4275     LPWSTR pszDeviceInterfaceW = NULL;
4276     ULONG ulLength;
4277     CONFIGRET ret;
4278
4279     TRACE("%lx %s %s %p %p %lx %lx\n", dnDevInst, debugstr_guid(InterfaceClassGuid),
4280           pszReference, pszDeviceInterface, pulLength, ulFlags, hMachine);
4281
4282     if (pulLength == NULL || pszDeviceInterface == NULL)
4283         return CR_INVALID_POINTER;
4284
4285     if (pszReference != NULL)
4286     {
4287         if (pSetupCaptureAndConvertAnsiArg(pszReference, &pszReferenceW))
4288             return CR_INVALID_DATA;
4289     }
4290
4291     ulLength = *pulLength;
4292
4293     pszDeviceInterfaceW = HeapAlloc(GetProcessHeap(), 0, ulLength * sizeof(WCHAR));
4294     if (pszDeviceInterfaceW == NULL)
4295     {
4296         ret = CR_OUT_OF_MEMORY;
4297         goto Done;
4298     }
4299
4300     ret = CM_Register_Device_Interface_ExW(dnDevInst,
4301                                            InterfaceClassGuid,
4302                                            pszReferenceW,
4303                                            pszDeviceInterfaceW,
4304                                            &ulLength,
4305                                            ulFlags,
4306                                            hMachine);
4307     if (ret == CR_SUCCESS)
4308     {
4309         if (WideCharToMultiByte(CP_ACP,
4310                                 0,
4311                                 pszDeviceInterfaceW,
4312                                 ulLength,
4313                                 pszDeviceInterface,
4314                                 *pulLength,
4315                                 NULL,
4316                                 NULL) == 0)
4317             ret = CR_FAILURE;
4318     }
4319
4320     *pulLength = ulLength;
4321
4322 Done:
4323     if (pszDeviceInterfaceW != NULL)
4324         HeapFree(GetProcessHeap(), 0, pszDeviceInterfaceW);
4325
4326     if (pszReferenceW != NULL)
4327         MyFree(pszReferenceW);
4328
4329     return ret;
4330 }
4331
4332
4333 /***********************************************************************
4334  * CM_Register_Device_Interface_ExW [SETUPAPI.@]
4335  */
4336 CONFIGRET WINAPI CM_Register_Device_Interface_ExW(
4337     DEVINST dnDevInst, LPGUID InterfaceClassGuid, LPCWSTR pszReference,
4338     LPWSTR pszDeviceInterface, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine)
4339 {
4340     RPC_BINDING_HANDLE BindingHandle = NULL;
4341     HSTRING_TABLE StringTable = NULL;
4342     LPWSTR lpDevInst;
4343     ULONG ulTransferLength;
4344     CONFIGRET ret;
4345
4346     TRACE("%lx %s %s %p %p %lx %lx\n", dnDevInst, debugstr_guid(InterfaceClassGuid),
4347           debugstr_w(pszReference), pszDeviceInterface, pulLength, ulFlags, hMachine);
4348
4349     if (dnDevInst == 0)
4350         return CR_INVALID_DEVNODE;
4351
4352     if (InterfaceClassGuid == NULL ||
4353         pszDeviceInterface == NULL ||
4354         pulLength == NULL)
4355         return CR_INVALID_POINTER;
4356
4357     if (ulFlags != 0)
4358         return CR_INVALID_FLAG;
4359
4360     if (hMachine != NULL)
4361     {
4362         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4363         if (BindingHandle == NULL)
4364             return CR_FAILURE;
4365
4366         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4367         if (StringTable == 0)
4368             return CR_FAILURE;
4369     }
4370     else
4371     {
4372         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
4373             return CR_FAILURE;
4374     }
4375
4376     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
4377     if (lpDevInst == NULL)
4378         return CR_INVALID_DEVNODE;
4379
4380     ulTransferLength = *pulLength;
4381
4382     RpcTryExcept
4383     {
4384         ret = PNP_RegisterDeviceClassAssociation(BindingHandle,
4385                                                  lpDevInst,
4386                                                  InterfaceClassGuid,
4387                                                  (LPWSTR)pszReference,
4388                                                  pszDeviceInterface,
4389                                                  pulLength,
4390                                                  &ulTransferLength,
4391                                                  0);
4392     }
4393     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
4394     {
4395         ret = RpcStatusToCmStatus(RpcExceptionCode());
4396     }
4397     RpcEndExcept;
4398
4399     return ret;
4400 }
4401
4402
4403 /***********************************************************************
4404  * CM_Remove_SubTree [SETUPAPI.@]
4405  *
4406  * This function is obsolete in Windows XP and above.
4407  */
4408 CONFIGRET WINAPI CM_Remove_SubTree(
4409     DEVINST dnAncestor, ULONG ulFlags)
4410 {
4411     TRACE("%lx %lx\n", dnAncestor, ulFlags);
4412     return CR_CALL_NOT_IMPLEMENTED;
4413 }
4414
4415
4416 /***********************************************************************
4417  * CM_Remove_SubTree_Ex [SETUPAPI.@]
4418  *
4419  * This function is obsolete in Windows XP and above.
4420  */
4421 CONFIGRET WINAPI CM_Remove_SubTree_Ex(
4422     DEVINST dnAncestor, ULONG ulFlags, HMACHINE hMachine)
4423 {
4424     TRACE("%lx %lx %lx\n", dnAncestor, ulFlags, hMachine);
4425     return CR_CALL_NOT_IMPLEMENTED;
4426 }
4427
4428
4429 /***********************************************************************
4430  * CM_Request_Device_EjectA [SETUPAPI.@]
4431  */
4432 CONFIGRET WINAPI CM_Request_Device_EjectA(
4433     DEVINST dnDevInst, PPNP_VETO_TYPE pVetoType, LPSTR pszVetoName,
4434     ULONG ulNameLength, ULONG ulFlags)
4435 {
4436     TRACE("%lx %p %s %lu %lx\n", dnDevInst, pVetoType, pszVetoName,
4437           ulNameLength, ulFlags);
4438     return CM_Request_Device_Eject_ExA(dnDevInst, pVetoType, pszVetoName,
4439                                        ulNameLength, ulFlags, NULL);
4440 }
4441
4442
4443 /***********************************************************************
4444  * CM_Request_Device_EjectW [SETUPAPI.@]
4445  */
4446 CONFIGRET WINAPI CM_Request_Device_EjectW(
4447     DEVINST dnDevInst, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName,
4448     ULONG ulNameLength, ULONG ulFlags)
4449 {
4450     TRACE("%lx %p %s %lu %lx\n", dnDevInst, pVetoType, debugstr_w(pszVetoName),
4451           ulNameLength, ulFlags);
4452     return CM_Request_Device_Eject_ExW(dnDevInst, pVetoType, pszVetoName,
4453                                        ulNameLength, ulFlags, NULL);
4454 }
4455
4456
4457 /***********************************************************************
4458  * CM_Request_Device_Eject_ExA [SETUPAPI.@]
4459  */
4460 CONFIGRET WINAPI CM_Request_Device_Eject_ExA(
4461     DEVINST dnDevInst, PPNP_VETO_TYPE pVetoType, LPSTR pszVetoName,
4462     ULONG ulNameLength, ULONG ulFlags, HMACHINE hMachine)
4463 {
4464     LPWSTR lpLocalVetoName;
4465     CONFIGRET ret;
4466
4467     TRACE("%lx %p %s %lu %lx %lx\n", dnDevInst, pVetoType, pszVetoName,
4468           ulNameLength, ulFlags, hMachine);
4469
4470     if (pszVetoName == NULL && ulNameLength == 0)
4471         return CR_INVALID_POINTER;
4472
4473     lpLocalVetoName = HeapAlloc(GetProcessHeap(), 0, ulNameLength * sizeof(WCHAR));
4474     if (lpLocalVetoName == NULL)
4475         return CR_OUT_OF_MEMORY;
4476
4477     ret = CM_Request_Device_Eject_ExW(dnDevInst, pVetoType, lpLocalVetoName,
4478                                       ulNameLength, ulFlags, hMachine);
4479     if (ret == CR_REMOVE_VETOED)
4480     {
4481         if (WideCharToMultiByte(CP_ACP,
4482                                 0,
4483                                 lpLocalVetoName,
4484                                 ulNameLength,
4485                                 pszVetoName,
4486                                 ulNameLength,
4487                                 NULL,
4488                                 NULL) == 0)
4489             ret = CR_FAILURE;
4490     }
4491
4492     HeapFree(GetProcessHeap(), 0, lpLocalVetoName);
4493
4494     return ret;
4495 }
4496
4497
4498 /***********************************************************************
4499  * CM_Request_Device_Eject_ExW [SETUPAPI.@]
4500  */
4501 CONFIGRET WINAPI CM_Request_Device_Eject_ExW(
4502     DEVINST dnDevInst, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName,
4503     ULONG ulNameLength, ULONG ulFlags, HMACHINE hMachine)
4504 {
4505     RPC_BINDING_HANDLE BindingHandle = NULL;
4506     HSTRING_TABLE StringTable = NULL;
4507     LPWSTR lpDevInst;
4508     CONFIGRET ret;
4509
4510     TRACE("%lx %p %s %lu %lx %lx\n", dnDevInst, pVetoType,
4511           debugstr_w(pszVetoName), ulNameLength, ulFlags, hMachine);
4512
4513     if (dnDevInst == 0)
4514         return CR_INVALID_DEVNODE;
4515
4516     if (ulFlags != 0)
4517         return CR_INVALID_FLAG;
4518
4519     if (pszVetoName == NULL && ulNameLength == 0)
4520         return CR_INVALID_POINTER;
4521
4522     if (hMachine != NULL)
4523     {
4524         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4525         if (BindingHandle == NULL)
4526             return CR_FAILURE;
4527
4528         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4529         if (StringTable == 0)
4530             return CR_FAILURE;
4531     }
4532     else
4533     {
4534         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
4535             return CR_FAILURE;
4536     }
4537
4538     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
4539     if (lpDevInst == NULL)
4540         return CR_INVALID_DEVNODE;
4541
4542     RpcTryExcept
4543     {
4544         ret = PNP_RequestDeviceEject(BindingHandle,
4545                                      lpDevInst,
4546                                      pVetoType,
4547                                      pszVetoName,
4548                                      ulNameLength,
4549                                      ulFlags);
4550     }
4551     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
4552     {
4553         ret = RpcStatusToCmStatus(RpcExceptionCode());
4554     }
4555     RpcEndExcept;
4556
4557     return ret;
4558 }
4559
4560
4561 /***********************************************************************
4562  * CM_Request_Eject_PC [SETUPAPI.@]
4563  */
4564 CONFIGRET WINAPI CM_Request_Eject_PC(VOID)
4565 {
4566     TRACE("\n");
4567     return CM_Request_Eject_PC_Ex(NULL);
4568 }
4569
4570
4571 /***********************************************************************
4572  * CM_Request_Eject_PC_Ex [SETUPAPI.@]
4573  */
4574 CONFIGRET WINAPI CM_Request_Eject_PC_Ex(
4575     HMACHINE hMachine)
4576 {
4577     RPC_BINDING_HANDLE BindingHandle = NULL;
4578     CONFIGRET ret;
4579
4580     TRACE("%lx\n", hMachine);
4581
4582     if (hMachine != NULL)
4583     {
4584         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4585         if (BindingHandle == NULL)
4586             return CR_FAILURE;
4587     }
4588     else
4589     {
4590         if (!PnpGetLocalHandles(&BindingHandle, NULL))
4591             return CR_FAILURE;
4592     }
4593
4594     RpcTryExcept
4595     {
4596         ret = PNP_RequestEjectPC(BindingHandle);
4597     }
4598     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
4599     {
4600         ret = RpcStatusToCmStatus(RpcExceptionCode());
4601     }
4602     RpcEndExcept;
4603
4604     return ret;
4605 }
4606
4607
4608 /***********************************************************************
4609  * CM_Run_Detection [SETUPAPI.@]
4610  */
4611 CONFIGRET WINAPI CM_Run_Detection(
4612     ULONG ulFlags)
4613 {
4614     TRACE("%lx\n", ulFlags);
4615     return CM_Run_Detection_Ex(ulFlags, NULL);
4616 }
4617
4618
4619 /***********************************************************************
4620  * CM_Run_Detection_Ex [SETUPAPI.@]
4621  */
4622 CONFIGRET WINAPI CM_Run_Detection_Ex(
4623     ULONG ulFlags, HMACHINE hMachine)
4624 {
4625     RPC_BINDING_HANDLE BindingHandle = NULL;
4626     CONFIGRET ret;
4627
4628     TRACE("%lx %lx\n", ulFlags, hMachine);
4629
4630     if (!pSetupIsUserAdmin())
4631         return CR_ACCESS_DENIED;
4632
4633     if (ulFlags & ~CM_DETECT_BITS)
4634         return CR_INVALID_FLAG;
4635
4636     if (hMachine != NULL)
4637     {
4638         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4639         if (BindingHandle == NULL)
4640             return CR_FAILURE;
4641     }
4642     else
4643     {
4644         if (!PnpGetLocalHandles(&BindingHandle, NULL))
4645             return CR_FAILURE;
4646     }
4647
4648     RpcTryExcept
4649     {
4650         ret = PNP_RunDetection(BindingHandle,
4651                                ulFlags);
4652     }
4653     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
4654     {
4655         ret = RpcStatusToCmStatus(RpcExceptionCode());
4656     }
4657     RpcEndExcept;
4658
4659     return ret;
4660 }
4661
4662
4663 /***********************************************************************
4664  * CM_Set_DevNode_Problem [SETUPAPI.@]
4665  */
4666 CONFIGRET WINAPI CM_Set_DevNode_Problem(
4667     DEVINST dnDevInst, ULONG ulProblem, ULONG ulFlags)
4668 {
4669     TRACE("%lx %lx %lx\n", dnDevInst, ulProblem, ulFlags);
4670     return CM_Set_DevNode_Problem_Ex(dnDevInst, ulProblem, ulFlags, NULL);
4671 }
4672
4673
4674 /***********************************************************************
4675  * CM_Set_DevNode_Problem_Ex [SETUPAPI.@]
4676  */
4677 CONFIGRET WINAPI CM_Set_DevNode_Problem_Ex(
4678     DEVINST dnDevInst, ULONG ulProblem, ULONG ulFlags, HMACHINE hMachine)
4679 {
4680     RPC_BINDING_HANDLE BindingHandle = NULL;
4681     HSTRING_TABLE StringTable = NULL;
4682     LPWSTR lpDevInst;
4683     CONFIGRET ret;
4684
4685     TRACE("%lx %lx %lx %lx\n", dnDevInst, ulProblem, ulFlags, hMachine);
4686
4687     if (dnDevInst == 0)
4688         return CR_INVALID_DEVNODE;
4689
4690     if (ulFlags & ~CM_SET_DEVNODE_PROBLEM_BITS)
4691         return CR_INVALID_FLAG;
4692
4693     if (hMachine != NULL)
4694     {
4695         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4696         if (BindingHandle == NULL)
4697             return CR_FAILURE;
4698
4699         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4700         if (StringTable == 0)
4701             return CR_FAILURE;
4702     }
4703     else
4704     {
4705         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
4706             return CR_FAILURE;
4707     }
4708
4709     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
4710     if (lpDevInst == NULL)
4711         return CR_INVALID_DEVNODE;
4712
4713     RpcTryExcept
4714     {
4715         ret = PNP_SetDeviceProblem(BindingHandle,
4716                                    lpDevInst,
4717                                    ulProblem,
4718                                    ulFlags);
4719     }
4720     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
4721     {
4722         ret = RpcStatusToCmStatus(RpcExceptionCode());
4723     }
4724     RpcEndExcept;
4725
4726     return ret;
4727 }
4728
4729
4730 /***********************************************************************
4731  * CM_Set_DevNode_Registry_PropertyA [SETUPAPI.@]
4732  */
4733 CONFIGRET WINAPI CM_Set_DevNode_Registry_PropertyA(
4734     DEVINST dnDevInst, ULONG ulProperty, PCVOID Buffer, ULONG ulLength,
4735     ULONG ulFlags)
4736 {
4737     TRACE("%lx %lu %p %lx %lx\n",
4738           dnDevInst, ulProperty, Buffer, ulLength, ulFlags);
4739     return CM_Set_DevNode_Registry_Property_ExA(dnDevInst, ulProperty,
4740                                                 Buffer, ulLength,
4741                                                 ulFlags, NULL);
4742 }
4743
4744
4745 /***********************************************************************
4746  * CM_Set_DevNode_Registry_PropertyW [SETUPAPI.@]
4747  */
4748 CONFIGRET WINAPI CM_Set_DevNode_Registry_PropertyW(
4749     DEVINST dnDevInst, ULONG ulProperty, PCVOID Buffer, ULONG ulLength,
4750     ULONG ulFlags)
4751 {
4752     TRACE("%lx %lu %p %lx %lx\n",
4753           dnDevInst, ulProperty, Buffer, ulLength, ulFlags);
4754     return CM_Set_DevNode_Registry_Property_ExW(dnDevInst, ulProperty,
4755                                                 Buffer, ulLength,
4756                                                 ulFlags, NULL);
4757 }
4758
4759
4760 /***********************************************************************
4761  * CM_Set_DevNode_Registry_Property_ExA [SETUPAPI.@]
4762  */
4763 CONFIGRET WINAPI CM_Set_DevNode_Registry_Property_ExA(
4764     DEVINST dnDevInst, ULONG ulProperty, PCVOID Buffer, ULONG ulLength,
4765     ULONG ulFlags, HMACHINE hMachine)
4766 {
4767     CONFIGRET ret = CR_SUCCESS;
4768     LPWSTR lpBuffer;
4769     ULONG ulType;
4770
4771     FIXME("%lx %lu %p %lx %lx %lx\n",
4772           dnDevInst, ulProperty, Buffer, ulLength, ulFlags, hMachine);
4773
4774     if (Buffer == NULL && ulLength != 0)
4775         return CR_INVALID_POINTER;
4776
4777     if (Buffer == NULL)
4778     {
4779         ret = CM_Set_DevNode_Registry_Property_ExW(dnDevInst,
4780                                                    ulProperty,
4781                                                    NULL,
4782                                                    0,
4783                                                    ulFlags,
4784                                                    hMachine);
4785     }
4786     else
4787     {
4788         /* Get property type */
4789         switch (ulProperty)
4790         {
4791             case CM_DRP_DEVICEDESC:
4792                 ulType = REG_SZ;
4793                 break;
4794
4795             case CM_DRP_HARDWAREID:
4796                 ulType = REG_MULTI_SZ;
4797                 break;
4798
4799             case CM_DRP_COMPATIBLEIDS:
4800                 ulType = REG_MULTI_SZ;
4801                 break;
4802
4803             case CM_DRP_SERVICE:
4804                 ulType = REG_SZ;
4805                 break;
4806
4807             case CM_DRP_CLASS:
4808                 ulType = REG_SZ;
4809                 break;
4810
4811             case CM_DRP_CLASSGUID:
4812                 ulType = REG_SZ;
4813                 break;
4814
4815             case CM_DRP_DRIVER:
4816                 ulType = REG_SZ;
4817                 break;
4818
4819             case CM_DRP_CONFIGFLAGS:
4820                 ulType = REG_DWORD;
4821                 break;
4822
4823             case CM_DRP_MFG:
4824                 ulType = REG_SZ;
4825                 break;
4826
4827             case CM_DRP_FRIENDLYNAME:
4828                 ulType = REG_SZ;
4829                 break;
4830
4831             case CM_DRP_LOCATION_INFORMATION:
4832                 ulType = REG_SZ;
4833                 break;
4834
4835             case CM_DRP_UPPERFILTERS:
4836                 ulType = REG_MULTI_SZ;
4837                 break;
4838
4839             case CM_DRP_LOWERFILTERS:
4840                 ulType = REG_MULTI_SZ;
4841                 break;
4842
4843             default:
4844                 return CR_INVALID_PROPERTY;
4845         }
4846
4847         /* Allocate buffer if needed */
4848         if (ulType == REG_SZ ||
4849             ulType == REG_MULTI_SZ)
4850         {
4851             lpBuffer = MyMalloc(ulLength * sizeof(WCHAR));
4852             if (lpBuffer == NULL)
4853             {
4854                 ret = CR_OUT_OF_MEMORY;
4855             }
4856             else
4857             {
4858                 if (!MultiByteToWideChar(CP_ACP, 0, Buffer,
4859                                          ulLength, lpBuffer, ulLength))
4860                 {
4861                     MyFree(lpBuffer);
4862                     ret = CR_FAILURE;
4863                 }
4864                 else
4865                 {
4866                     ret = CM_Set_DevNode_Registry_Property_ExW(dnDevInst,
4867                                                                ulProperty,
4868                                                                lpBuffer,
4869                                                                ulLength * sizeof(WCHAR),
4870                                                                ulFlags,
4871                                                                hMachine);
4872                     MyFree(lpBuffer);
4873                 }
4874             }
4875         }
4876         else
4877         {
4878             ret = CM_Set_DevNode_Registry_Property_ExW(dnDevInst,
4879                                                        ulProperty,
4880                                                        Buffer,
4881                                                        ulLength,
4882                                                        ulFlags,
4883                                                        hMachine);
4884         }
4885
4886         ret = CR_CALL_NOT_IMPLEMENTED;
4887     }
4888
4889     return ret;
4890 }
4891
4892
4893 /***********************************************************************
4894  * CM_Set_DevNode_Registry_Property_ExW [SETUPAPI.@]
4895  */
4896 CONFIGRET WINAPI CM_Set_DevNode_Registry_Property_ExW(
4897     DEVINST dnDevInst, ULONG ulProperty, PCVOID Buffer, ULONG ulLength,
4898     ULONG ulFlags, HMACHINE hMachine)
4899 {
4900     RPC_BINDING_HANDLE BindingHandle = NULL;
4901     HSTRING_TABLE StringTable = NULL;
4902     LPWSTR lpDevInst;
4903     ULONG ulType;
4904     CONFIGRET ret;
4905
4906     TRACE("%lx %lu %p %lx %lx %lx\n",
4907           dnDevInst, ulProperty, Buffer, ulLength, ulFlags, hMachine);
4908
4909     if (dnDevInst == 0)
4910         return CR_INVALID_DEVNODE;
4911
4912     if (ulProperty <  CM_DRP_MIN || ulProperty > CM_DRP_MAX)
4913         return CR_INVALID_PROPERTY;
4914
4915     if (Buffer != NULL && ulLength == 0)
4916         return CR_INVALID_POINTER;
4917
4918     if (ulFlags != 0)
4919         return CR_INVALID_FLAG;
4920
4921     if (hMachine != NULL)
4922     {
4923         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4924         if (BindingHandle == NULL)
4925             return CR_FAILURE;
4926
4927         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4928         if (StringTable == 0)
4929             return CR_FAILURE;
4930     }
4931     else
4932     {
4933         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
4934             return CR_FAILURE;
4935     }
4936
4937     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
4938     if (lpDevInst == NULL)
4939         return CR_INVALID_DEVNODE;
4940
4941     switch (ulProperty)
4942     {
4943         case CM_DRP_DEVICEDESC:
4944             ulType = REG_SZ;
4945             break;
4946
4947         case CM_DRP_HARDWAREID:
4948             ulType = REG_MULTI_SZ;
4949             break;
4950
4951         case CM_DRP_COMPATIBLEIDS:
4952             ulType = REG_MULTI_SZ;
4953             break;
4954
4955         case CM_DRP_SERVICE:
4956             ulType = REG_SZ;
4957             break;
4958
4959         case CM_DRP_CLASS:
4960             ulType = REG_SZ;
4961             break;
4962
4963         case CM_DRP_CLASSGUID:
4964             ulType = REG_SZ;
4965             break;
4966
4967         case CM_DRP_DRIVER:
4968             ulType = REG_SZ;
4969             break;
4970
4971         case CM_DRP_CONFIGFLAGS:
4972             ulType = REG_DWORD;
4973             break;
4974
4975         case CM_DRP_MFG:
4976             ulType = REG_SZ;
4977             break;
4978
4979         case CM_DRP_FRIENDLYNAME:
4980             ulType = REG_SZ;
4981             break;
4982
4983         case CM_DRP_LOCATION_INFORMATION:
4984             ulType = REG_SZ;
4985             break;
4986
4987         case CM_DRP_UPPERFILTERS:
4988             ulType = REG_MULTI_SZ;
4989             break;
4990
4991         case CM_DRP_LOWERFILTERS:
4992             ulType = REG_MULTI_SZ;
4993             break;
4994
4995         default:
4996             return CR_INVALID_PROPERTY;
4997     }
4998
4999     RpcTryExcept
5000     {
5001         ret = PNP_SetDeviceRegProp(BindingHandle,
5002                                    lpDevInst,
5003                                    ulProperty,
5004                                    ulType,
5005                                    (BYTE *)Buffer,
5006                                    ulLength,
5007                                    ulFlags);
5008     }
5009     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5010     {
5011         ret = RpcStatusToCmStatus(RpcExceptionCode());
5012     }
5013     RpcEndExcept;
5014
5015     return ret;
5016 }
5017
5018
5019 /***********************************************************************
5020  * CM_Set_HW_Prof [SETUPAPI.@]
5021  */
5022 CONFIGRET WINAPI CM_Set_HW_Prof(
5023     ULONG ulHardwareProfile, ULONG ulFlags)
5024 {
5025     TRACE("%lu %lu\n", ulHardwareProfile, ulFlags);
5026     return CM_Set_HW_Prof_Ex(ulHardwareProfile, ulFlags, NULL);
5027 }
5028
5029
5030 /***********************************************************************
5031  * CM_Set_HW_Prof_Ex [SETUPAPI.@]
5032  */
5033 CONFIGRET WINAPI CM_Set_HW_Prof_Ex(
5034     ULONG ulHardwareProfile, ULONG ulFlags, HMACHINE hMachine)
5035 {
5036     RPC_BINDING_HANDLE BindingHandle = NULL;
5037     CONFIGRET ret;
5038
5039     TRACE("%lu %lu %lx\n", ulHardwareProfile, ulFlags, hMachine);
5040
5041     if (!pSetupIsUserAdmin())
5042         return CR_ACCESS_DENIED;
5043
5044     if (ulFlags != 0)
5045         return CR_INVALID_FLAG;
5046
5047     if (hMachine != NULL)
5048     {
5049         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5050         if (BindingHandle == NULL)
5051             return CR_FAILURE;
5052     }
5053     else
5054     {
5055         if (!PnpGetLocalHandles(&BindingHandle, NULL))
5056             return CR_FAILURE;
5057     }
5058
5059     RpcTryExcept
5060     {
5061         ret = PNP_SetHwProf(BindingHandle, ulHardwareProfile, ulFlags);
5062     }
5063     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5064     {
5065         ret = RpcStatusToCmStatus(RpcExceptionCode());
5066     }
5067     RpcEndExcept;
5068
5069     return ret;
5070 }
5071
5072
5073 /***********************************************************************
5074  * CM_Set_HW_Prof_FlagsA [SETUPAPI.@]
5075  */
5076 CONFIGRET WINAPI CM_Set_HW_Prof_FlagsA(
5077     DEVINSTID_A szDevInstName, ULONG ulConfig, ULONG ulValue,
5078     ULONG ulFlags)
5079 {
5080     TRACE("%s %lu %lu %lx\n", szDevInstName,
5081           ulConfig, ulValue, ulFlags);
5082     return CM_Set_HW_Prof_Flags_ExA(szDevInstName, ulConfig, ulValue,
5083                                     ulFlags, NULL);
5084 }
5085
5086
5087 /***********************************************************************
5088  * CM_Set_HW_Prof_FlagsW [SETUPAPI.@]
5089  */
5090 CONFIGRET WINAPI CM_Set_HW_Prof_FlagsW(
5091     DEVINSTID_W szDevInstName, ULONG ulConfig, ULONG ulValue,
5092     ULONG ulFlags)
5093 {
5094     TRACE("%s %lu %lu %lx\n", debugstr_w(szDevInstName),
5095           ulConfig, ulValue, ulFlags);
5096     return CM_Set_HW_Prof_Flags_ExW(szDevInstName, ulConfig, ulValue,
5097                                     ulFlags, NULL);
5098 }
5099
5100
5101 /***********************************************************************
5102  * CM_Set_HW_Prof_Flags_ExA [SETUPAPI.@]
5103  */
5104 CONFIGRET WINAPI CM_Set_HW_Prof_Flags_ExA(
5105     DEVINSTID_A szDevInstName, ULONG ulConfig, ULONG ulValue,
5106     ULONG ulFlags, HMACHINE hMachine)
5107 {
5108     DEVINSTID_W pszDevIdW = NULL;
5109     CONFIGRET ret = CR_SUCCESS;
5110
5111     TRACE("%s %lu %lu %lx %lx\n", szDevInstName,
5112           ulConfig, ulValue, ulFlags, hMachine);
5113
5114     if (szDevInstName != NULL)
5115     {
5116        if (pSetupCaptureAndConvertAnsiArg(szDevInstName, &pszDevIdW))
5117          return CR_INVALID_DEVICE_ID;
5118     }
5119
5120     ret = CM_Set_HW_Prof_Flags_ExW(pszDevIdW, ulConfig, ulValue,
5121                                    ulFlags, hMachine);
5122
5123     if (pszDevIdW != NULL)
5124         MyFree(pszDevIdW);
5125
5126     return ret;
5127 }
5128
5129
5130 /***********************************************************************
5131  * CM_Set_HW_Prof_Flags_ExW [SETUPAPI.@]
5132  */
5133 CONFIGRET WINAPI CM_Set_HW_Prof_Flags_ExW(
5134     DEVINSTID_W szDevInstName, ULONG ulConfig, ULONG ulValue,
5135     ULONG ulFlags, HMACHINE hMachine)
5136 {
5137     RPC_BINDING_HANDLE BindingHandle = NULL;
5138     CONFIGRET ret;
5139
5140     FIXME("%s %lu %lu %lx %lx\n", debugstr_w(szDevInstName),
5141           ulConfig, ulValue, ulFlags, hMachine);
5142
5143     if (szDevInstName == NULL)
5144         return CR_INVALID_POINTER;
5145
5146     if (ulFlags & ~ CM_SET_HW_PROF_FLAGS_BITS)
5147         return CR_INVALID_FLAG;
5148
5149     /* FIXME: Check whether szDevInstName is valid */
5150
5151     if (hMachine != NULL)
5152     {
5153         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5154         if (BindingHandle == NULL)
5155             return CR_FAILURE;
5156     }
5157     else
5158     {
5159         if (!PnpGetLocalHandles(&BindingHandle, NULL))
5160             return CR_FAILURE;
5161     }
5162
5163     RpcTryExcept
5164     {
5165         ret = PNP_HwProfFlags(BindingHandle, PNP_SET_HWPROFFLAGS, szDevInstName,
5166                               ulConfig, &ulValue, NULL, NULL, 0, 0);
5167     }
5168     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5169     {
5170         ret = RpcStatusToCmStatus(RpcExceptionCode());
5171     }
5172     RpcEndExcept;
5173
5174     return ret;
5175 }
5176
5177
5178 /***********************************************************************
5179  * CM_Setup_DevNode [SETUPAPI.@]
5180  */
5181 CONFIGRET WINAPI CM_Setup_DevNode(
5182     DEVINST dnDevInst, ULONG ulFlags)
5183 {
5184     TRACE("%lx %lx\n", dnDevInst, ulFlags);
5185     return CM_Setup_DevNode_Ex(dnDevInst, ulFlags, NULL);
5186 }
5187
5188
5189 /***********************************************************************
5190  * CM_Setup_DevNode_Ex [SETUPAPI.@]
5191  */
5192 CONFIGRET WINAPI CM_Setup_DevNode_Ex(
5193     DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
5194 {
5195     RPC_BINDING_HANDLE BindingHandle = NULL;
5196     HSTRING_TABLE StringTable = NULL;
5197     LPWSTR lpDevInst;
5198     CONFIGRET ret;
5199
5200     FIXME("%lx %lx %lx\n", dnDevInst, ulFlags, hMachine);
5201
5202     if (!pSetupIsUserAdmin())
5203         return CR_ACCESS_DENIED;
5204
5205     if (dnDevInst == 0)
5206         return CR_INVALID_DEVNODE;
5207
5208     if (ulFlags & ~CM_SETUP_BITS)
5209         return CR_INVALID_FLAG;
5210
5211     if (hMachine != NULL)
5212     {
5213         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5214         if (BindingHandle == NULL)
5215             return CR_FAILURE;
5216
5217         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5218         if (StringTable == 0)
5219             return CR_FAILURE;
5220     }
5221     else
5222     {
5223         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5224             return CR_FAILURE;
5225     }
5226
5227     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
5228     if (lpDevInst == NULL)
5229         return CR_INVALID_DEVNODE;
5230
5231     RpcTryExcept
5232     {
5233         ret = PNP_DeviceInstanceAction(BindingHandle,
5234                                        PNP_DEVINST_SETUP,
5235                                        ulFlags,
5236                                        lpDevInst,
5237                                        NULL);
5238     }
5239     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5240     {
5241         ret = RpcStatusToCmStatus(RpcExceptionCode());
5242     }
5243     RpcEndExcept;
5244
5245     return ret;
5246 }
5247
5248
5249 /***********************************************************************
5250  * CM_Uninstall_DevNode [SETUPAPI.@]
5251  */
5252 CONFIGRET WINAPI CM_Uninstall_DevNode(
5253     DEVINST dnPhantom, ULONG ulFlags)
5254 {
5255     TRACE("%lx %lx\n", dnPhantom, ulFlags);
5256     return CM_Uninstall_DevNode_Ex(dnPhantom, ulFlags, NULL);
5257 }
5258
5259
5260 /***********************************************************************
5261  * CM_Uninstall_DevNode_Ex [SETUPAPI.@]
5262  */
5263 CONFIGRET WINAPI CM_Uninstall_DevNode_Ex(
5264     DEVINST dnPhantom, ULONG ulFlags, HMACHINE hMachine)
5265 {
5266     RPC_BINDING_HANDLE BindingHandle = NULL;
5267     HSTRING_TABLE StringTable = NULL;
5268     LPWSTR lpDevInst;
5269     CONFIGRET ret;
5270
5271     TRACE("%lx %lx %lx\n", dnPhantom, ulFlags, hMachine);
5272
5273     if (dnPhantom == 0)
5274         return CR_INVALID_DEVNODE;
5275
5276     if (ulFlags != 0)
5277         return CR_INVALID_FLAG;
5278
5279     if (hMachine != NULL)
5280     {
5281         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5282         if (BindingHandle == NULL)
5283             return CR_FAILURE;
5284
5285         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5286         if (StringTable == 0)
5287             return CR_FAILURE;
5288     }
5289     else
5290     {
5291         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5292             return CR_FAILURE;
5293     }
5294
5295     lpDevInst = pSetupStringTableStringFromId(StringTable, dnPhantom);
5296     if (lpDevInst == NULL)
5297         return CR_INVALID_DEVNODE;
5298
5299     RpcTryExcept
5300     {
5301         ret = PNP_UninstallDevInst(BindingHandle,
5302                                    lpDevInst,
5303                                    ulFlags);
5304     }
5305     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5306     {
5307         ret = RpcStatusToCmStatus(RpcExceptionCode());
5308     }
5309     RpcEndExcept;
5310
5311     return ret;
5312 }
5313
5314
5315 /***********************************************************************
5316  * CM_Unregister_Device_InterfaceA [SETUPAPI.@]
5317  */
5318 CONFIGRET WINAPI CM_Unregister_Device_InterfaceA(
5319     LPCSTR pszDeviceInterface, ULONG ulFlags)
5320 {
5321     TRACE("%s %lx\n", pszDeviceInterface, ulFlags);
5322
5323     return CM_Unregister_Device_Interface_ExA(pszDeviceInterface,
5324                                               ulFlags, NULL);
5325 }
5326
5327
5328 /***********************************************************************
5329  * CM_Unregister_Device_InterfaceW [SETUPAPI.@]
5330  */
5331 CONFIGRET WINAPI CM_Unregister_Device_InterfaceW(
5332     LPCWSTR pszDeviceInterface, ULONG ulFlags)
5333 {
5334     TRACE("%s %lx\n", debugstr_w(pszDeviceInterface), ulFlags);
5335
5336     return CM_Unregister_Device_Interface_ExW(pszDeviceInterface,
5337                                               ulFlags, NULL);
5338 }
5339
5340
5341 /***********************************************************************
5342  * CM_Unregister_Device_Interface_ExA [SETUPAPI.@]
5343  */
5344 CONFIGRET WINAPI CM_Unregister_Device_Interface_ExA(
5345     LPCSTR pszDeviceInterface, ULONG ulFlags, HMACHINE hMachine)
5346 {
5347     LPWSTR pszDeviceInterfaceW = NULL;
5348     CONFIGRET ret;
5349
5350     TRACE("%s %lx %lx\n", pszDeviceInterface, ulFlags, hMachine);
5351
5352     if (pszDeviceInterface == NULL)
5353         return CR_INVALID_POINTER;
5354
5355     if (pSetupCaptureAndConvertAnsiArg(pszDeviceInterface, &pszDeviceInterfaceW))
5356         return CR_INVALID_DATA;
5357
5358     ret = CM_Unregister_Device_Interface_ExW(pszDeviceInterfaceW,
5359                                              ulFlags, hMachine);
5360
5361     if (pszDeviceInterfaceW != NULL)
5362         MyFree(pszDeviceInterfaceW);
5363
5364     return ret;
5365 }
5366
5367
5368 /***********************************************************************
5369  * CM_Unregister_Device_Interface_ExW [SETUPAPI.@]
5370  */
5371 CONFIGRET WINAPI CM_Unregister_Device_Interface_ExW(
5372     LPCWSTR pszDeviceInterface, ULONG ulFlags, HMACHINE hMachine)
5373 {
5374     RPC_BINDING_HANDLE BindingHandle = NULL;
5375     CONFIGRET ret;
5376
5377     TRACE("%s %lx %lx\n", debugstr_w(pszDeviceInterface), ulFlags, hMachine);
5378
5379     if (pszDeviceInterface == NULL)
5380         return CR_INVALID_POINTER;
5381
5382     if (ulFlags != 0)
5383         return CR_INVALID_FLAG;
5384
5385     if (hMachine != NULL)
5386     {
5387         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5388         if (BindingHandle == NULL)
5389             return CR_FAILURE;
5390     }
5391     else
5392     {
5393         if (!PnpGetLocalHandles(&BindingHandle, NULL))
5394             return CR_FAILURE;
5395     }
5396
5397     RpcTryExcept
5398     {
5399         ret = PNP_UnregisterDeviceClassAssociation(BindingHandle,
5400                                                    (LPWSTR)pszDeviceInterface,
5401                                                    ulFlags);
5402     }
5403     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5404     {
5405         ret = RpcStatusToCmStatus(RpcExceptionCode());
5406     }
5407     RpcEndExcept;
5408
5409     return ret;
5410 }