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_Arbitrator_Free_Data [SETUPAPI.@]
4142  */
4143 CONFIGRET WINAPI CM_Query_Arbitrator_Free_Data(
4144     PVOID pData, ULONG DataLen, DEVINST dnDevInst, RESOURCEID ResourceID,
4145     ULONG ulFlags)
4146 {
4147     TRACE("%p %lu %lx %lu 0x%08lx\n", pData, DataLen, dnDevInst,
4148           ResourceID, ulFlags);
4149
4150     return CM_Query_Arbitrator_Free_Data_Ex(pData, DataLen, dnDevInst,
4151                                             ResourceID, ulFlags, NULL);
4152 }
4153
4154
4155 /***********************************************************************
4156  * CM_Query_Arbitrator_Free_Data_Ex [SETUPAPI.@]
4157  */
4158 CONFIGRET WINAPI CM_Query_Arbitrator_Free_Data_Ex(
4159   OUT PVOID pData,
4160   IN ULONG DataLen,
4161   IN DEVINST dnDevInst,
4162   IN RESOURCEID ResourceID,
4163   IN ULONG ulFlags,
4164   IN HMACHINE hMachine)
4165 {
4166     RPC_BINDING_HANDLE BindingHandle = NULL;
4167     HSTRING_TABLE StringTable = NULL;
4168     LPWSTR lpDevInst;
4169     CONFIGRET ret;
4170
4171     TRACE("%p %lu %lx %lu 0x%08lx %p\n", pData, DataLen, dnDevInst,
4172           ResourceID, ulFlags, hMachine);
4173
4174     if (pData == NULL || DataLen == 0)
4175         return CR_INVALID_POINTER;
4176
4177     if (dnDevInst == 0)
4178         return CR_INVALID_DEVINST;
4179
4180     if (ulFlags & ~CM_QUERY_ARBITRATOR_BITS)
4181         return CR_INVALID_FLAG;
4182
4183     if (hMachine != NULL)
4184     {
4185         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4186         if (BindingHandle == NULL)
4187             return CR_FAILURE;
4188
4189         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4190         if (StringTable == 0)
4191             return CR_FAILURE;
4192     }
4193     else
4194     {
4195         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
4196             return CR_FAILURE;
4197     }
4198
4199     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
4200     if (lpDevInst == NULL)
4201         return CR_INVALID_DEVNODE;
4202
4203     RpcTryExcept
4204     {
4205         ret = PNP_QueryArbitratorFreeData(BindingHandle,
4206                                           pData,
4207                                           DataLen,
4208                                           lpDevInst,
4209                                           ResourceID,
4210                                           ulFlags);
4211     }
4212     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
4213     {
4214         ret = RpcStatusToCmStatus(RpcExceptionCode());
4215     }
4216     RpcEndExcept;
4217
4218     return ret;
4219 }
4220
4221
4222 /***********************************************************************
4223  * CM_Query_Arbitrator_Free_Size [SETUPAPI.@]
4224  */
4225 CONFIGRET WINAPI CM_Query_Arbitrator_Free_Size(
4226     PULONG pulSize, DEVINST dnDevInst, RESOURCEID ResourceID, ULONG ulFlags)
4227 {
4228     TRACE("%p %lu %lx 0x%08lx\n", pulSize, dnDevInst,ResourceID, ulFlags);
4229
4230     return CM_Query_Arbitrator_Free_Size_Ex(pulSize, dnDevInst, ResourceID,
4231                                             ulFlags, NULL);
4232 }
4233
4234
4235 /***********************************************************************
4236  * CM_Query_Arbitrator_Free_Size_Ex [SETUPAPI.@]
4237  */
4238 CONFIGRET WINAPI CM_Query_Arbitrator_Free_Size_Ex(
4239       PULONG pulSize, DEVINST dnDevInst, RESOURCEID ResourceID,
4240       ULONG ulFlags, HMACHINE hMachine)
4241 {
4242     RPC_BINDING_HANDLE BindingHandle = NULL;
4243     HSTRING_TABLE StringTable = NULL;
4244     LPWSTR lpDevInst;
4245     CONFIGRET ret;
4246
4247     TRACE("%p %lu %lx 0x%08lx %p\n", pulSize, dnDevInst,ResourceID, ulFlags,
4248           hMachine);
4249
4250     if (pulSize == NULL)
4251         return CR_INVALID_POINTER;
4252
4253     if (dnDevInst == 0)
4254         return CR_INVALID_DEVINST;
4255
4256     if (ulFlags & ~CM_QUERY_ARBITRATOR_BITS)
4257         return CR_INVALID_FLAG;
4258
4259     if (hMachine != NULL)
4260     {
4261         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4262         if (BindingHandle == NULL)
4263             return CR_FAILURE;
4264
4265         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4266         if (StringTable == 0)
4267             return CR_FAILURE;
4268     }
4269     else
4270     {
4271         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
4272             return CR_FAILURE;
4273     }
4274
4275     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
4276     if (lpDevInst == NULL)
4277         return CR_INVALID_DEVNODE;
4278
4279     RpcTryExcept
4280     {
4281         ret = PNP_QueryArbitratorFreeSize(BindingHandle,
4282                                           pulSize,
4283                                           lpDevInst,
4284                                           ResourceID,
4285                                           ulFlags);
4286     }
4287     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
4288     {
4289         ret = RpcStatusToCmStatus(RpcExceptionCode());
4290     }
4291     RpcEndExcept;
4292
4293     return ret;
4294 }
4295
4296
4297 /***********************************************************************
4298  * CM_Query_Remove_SubTree [SETUPAPI.@]
4299  *
4300  * This function is obsolete in Windows XP and above.
4301  */
4302 CONFIGRET WINAPI CM_Query_Remove_SubTree(
4303     DEVINST dnAncestor, ULONG ulFlags)
4304 {
4305     TRACE("%lx %lx\n", dnAncestor, ulFlags);
4306     return CR_CALL_NOT_IMPLEMENTED;
4307 }
4308
4309
4310 /***********************************************************************
4311  * CM_Query_Remove_SubTree_Ex [SETUPAPI.@]
4312  *
4313  * This function is obsolete in Windows XP and above.
4314  */
4315 CONFIGRET WINAPI CM_Query_Remove_SubTree_Ex(
4316     DEVINST dnAncestor, ULONG ulFlags, HMACHINE hMachine)
4317 {
4318     TRACE("%lx %lx %lx\n", dnAncestor, ulFlags, hMachine);
4319     return CR_CALL_NOT_IMPLEMENTED;
4320 }
4321
4322
4323 /***********************************************************************
4324  * CM_Reenumerate_DevNode [SETUPAPI.@]
4325  */
4326 CONFIGRET WINAPI CM_Reenumerate_DevNode(
4327     DEVINST dnDevInst, ULONG ulFlags)
4328 {
4329     TRACE("%lx %lx\n", dnDevInst, ulFlags);
4330     return CM_Reenumerate_DevNode_Ex(dnDevInst, ulFlags, NULL);
4331 }
4332
4333
4334 /***********************************************************************
4335  * CM_Reenumerate_DevNode_Ex [SETUPAPI.@]
4336  */
4337 CONFIGRET WINAPI
4338 CM_Reenumerate_DevNode_Ex(
4339     DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
4340 {
4341     RPC_BINDING_HANDLE BindingHandle = NULL;
4342     HSTRING_TABLE StringTable = NULL;
4343     LPWSTR lpDevInst;
4344     CONFIGRET ret;
4345
4346     FIXME("%lx %lx %lx\n", dnDevInst, ulFlags, hMachine);
4347
4348     if (dnDevInst == 0)
4349         return CR_INVALID_DEVNODE;
4350
4351     if (ulFlags & ~CM_REENUMERATE_BITS)
4352         return CR_INVALID_FLAG;
4353
4354     if (hMachine != NULL)
4355     {
4356         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4357         if (BindingHandle == NULL)
4358             return CR_FAILURE;
4359
4360         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4361         if (StringTable == 0)
4362             return CR_FAILURE;
4363     }
4364     else
4365     {
4366         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
4367             return CR_FAILURE;
4368     }
4369
4370     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
4371     if (lpDevInst == NULL)
4372         return CR_INVALID_DEVNODE;
4373
4374     RpcTryExcept
4375     {
4376         ret = PNP_DeviceInstanceAction(BindingHandle,
4377                                        PNP_DEVINST_REENUMERATE,
4378                                        ulFlags,
4379                                        lpDevInst,
4380                                        NULL);
4381     }
4382     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
4383     {
4384         ret = RpcStatusToCmStatus(RpcExceptionCode());
4385     }
4386     RpcEndExcept;
4387
4388     return ret;
4389 }
4390
4391
4392 /***********************************************************************
4393  * CM_Register_Device_InterfaceA [SETUPAPI.@]
4394  */
4395 CONFIGRET WINAPI CM_Register_Device_InterfaceA(
4396     DEVINST dnDevInst, LPGUID InterfaceClassGuid, LPCSTR pszReference,
4397     LPSTR pszDeviceInterface, PULONG pulLength, ULONG ulFlags)
4398 {
4399     TRACE("%lx %s %s %p %p %lx\n", dnDevInst, debugstr_guid(InterfaceClassGuid),
4400           pszReference, pszDeviceInterface, pulLength, ulFlags);
4401
4402     return CM_Register_Device_Interface_ExA(dnDevInst, InterfaceClassGuid,
4403                                             pszReference, pszDeviceInterface,
4404                                             pulLength, ulFlags, NULL);
4405 }
4406
4407
4408 /***********************************************************************
4409  * CM_Register_Device_InterfaceW [SETUPAPI.@]
4410  */
4411 CONFIGRET WINAPI CM_Register_Device_InterfaceW(
4412     DEVINST dnDevInst, LPGUID InterfaceClassGuid, LPCWSTR pszReference,
4413     LPWSTR pszDeviceInterface, PULONG pulLength, ULONG ulFlags)
4414 {
4415     TRACE("%lx %s %s %p %p %lx\n", dnDevInst, debugstr_guid(InterfaceClassGuid),
4416           debugstr_w(pszReference), pszDeviceInterface, pulLength, ulFlags);
4417
4418     return CM_Register_Device_Interface_ExW(dnDevInst, InterfaceClassGuid,
4419                                             pszReference, pszDeviceInterface,
4420                                             pulLength, ulFlags, NULL);
4421 }
4422
4423
4424 /***********************************************************************
4425  * CM_Register_Device_Interface_ExA [SETUPAPI.@]
4426  */
4427 CONFIGRET WINAPI CM_Register_Device_Interface_ExA(
4428     DEVINST dnDevInst, LPGUID InterfaceClassGuid, LPCSTR pszReference,
4429     LPSTR pszDeviceInterface, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine)
4430 {
4431     LPWSTR pszReferenceW = NULL;
4432     LPWSTR pszDeviceInterfaceW = NULL;
4433     ULONG ulLength;
4434     CONFIGRET ret;
4435
4436     TRACE("%lx %s %s %p %p %lx %lx\n", dnDevInst, debugstr_guid(InterfaceClassGuid),
4437           pszReference, pszDeviceInterface, pulLength, ulFlags, hMachine);
4438
4439     if (pulLength == NULL || pszDeviceInterface == NULL)
4440         return CR_INVALID_POINTER;
4441
4442     if (pszReference != NULL)
4443     {
4444         if (pSetupCaptureAndConvertAnsiArg(pszReference, &pszReferenceW))
4445             return CR_INVALID_DATA;
4446     }
4447
4448     ulLength = *pulLength;
4449
4450     pszDeviceInterfaceW = HeapAlloc(GetProcessHeap(), 0, ulLength * sizeof(WCHAR));
4451     if (pszDeviceInterfaceW == NULL)
4452     {
4453         ret = CR_OUT_OF_MEMORY;
4454         goto Done;
4455     }
4456
4457     ret = CM_Register_Device_Interface_ExW(dnDevInst,
4458                                            InterfaceClassGuid,
4459                                            pszReferenceW,
4460                                            pszDeviceInterfaceW,
4461                                            &ulLength,
4462                                            ulFlags,
4463                                            hMachine);
4464     if (ret == CR_SUCCESS)
4465     {
4466         if (WideCharToMultiByte(CP_ACP,
4467                                 0,
4468                                 pszDeviceInterfaceW,
4469                                 ulLength,
4470                                 pszDeviceInterface,
4471                                 *pulLength,
4472                                 NULL,
4473                                 NULL) == 0)
4474             ret = CR_FAILURE;
4475     }
4476
4477     *pulLength = ulLength;
4478
4479 Done:
4480     if (pszDeviceInterfaceW != NULL)
4481         HeapFree(GetProcessHeap(), 0, pszDeviceInterfaceW);
4482
4483     if (pszReferenceW != NULL)
4484         MyFree(pszReferenceW);
4485
4486     return ret;
4487 }
4488
4489
4490 /***********************************************************************
4491  * CM_Register_Device_Interface_ExW [SETUPAPI.@]
4492  */
4493 CONFIGRET WINAPI CM_Register_Device_Interface_ExW(
4494     DEVINST dnDevInst, LPGUID InterfaceClassGuid, LPCWSTR pszReference,
4495     LPWSTR pszDeviceInterface, PULONG pulLength, ULONG ulFlags, HMACHINE hMachine)
4496 {
4497     RPC_BINDING_HANDLE BindingHandle = NULL;
4498     HSTRING_TABLE StringTable = NULL;
4499     LPWSTR lpDevInst;
4500     ULONG ulTransferLength;
4501     CONFIGRET ret;
4502
4503     TRACE("%lx %s %s %p %p %lx %lx\n", dnDevInst, debugstr_guid(InterfaceClassGuid),
4504           debugstr_w(pszReference), pszDeviceInterface, pulLength, ulFlags, hMachine);
4505
4506     if (dnDevInst == 0)
4507         return CR_INVALID_DEVNODE;
4508
4509     if (InterfaceClassGuid == NULL ||
4510         pszDeviceInterface == NULL ||
4511         pulLength == NULL)
4512         return CR_INVALID_POINTER;
4513
4514     if (ulFlags != 0)
4515         return CR_INVALID_FLAG;
4516
4517     if (hMachine != NULL)
4518     {
4519         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4520         if (BindingHandle == NULL)
4521             return CR_FAILURE;
4522
4523         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4524         if (StringTable == 0)
4525             return CR_FAILURE;
4526     }
4527     else
4528     {
4529         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
4530             return CR_FAILURE;
4531     }
4532
4533     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
4534     if (lpDevInst == NULL)
4535         return CR_INVALID_DEVNODE;
4536
4537     ulTransferLength = *pulLength;
4538
4539     RpcTryExcept
4540     {
4541         ret = PNP_RegisterDeviceClassAssociation(BindingHandle,
4542                                                  lpDevInst,
4543                                                  InterfaceClassGuid,
4544                                                  (LPWSTR)pszReference,
4545                                                  pszDeviceInterface,
4546                                                  pulLength,
4547                                                  &ulTransferLength,
4548                                                  0);
4549     }
4550     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
4551     {
4552         ret = RpcStatusToCmStatus(RpcExceptionCode());
4553     }
4554     RpcEndExcept;
4555
4556     return ret;
4557 }
4558
4559
4560 /***********************************************************************
4561  * CM_Register_Device_Driver [SETUPAPI.@]
4562  */
4563 CONFIGRET WINAPI CM_Register_Device_Driver(
4564     DEVINST dnDevInst, ULONG ulFlags)
4565 {
4566     TRACE("%lx 0x%08lx\n", dnDevInst, ulFlags);
4567     return CM_Register_Device_Driver_Ex(dnDevInst, ulFlags, NULL);
4568 }
4569
4570
4571 /***********************************************************************
4572  * CM_Register_Device_Driver [SETUPAPI.@]
4573  */
4574 CONFIGRET WINAPI CM_Register_Device_Driver_Ex(
4575     DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
4576 {
4577     RPC_BINDING_HANDLE BindingHandle = NULL;
4578     HSTRING_TABLE StringTable = NULL;
4579     LPWSTR lpDevInst;
4580     CONFIGRET ret;
4581
4582     TRACE("%lx 0x%08lx %p\n", dnDevInst, ulFlags, hMachine);
4583
4584     if (dnDevInst == 0)
4585         return CR_INVALID_DEVNODE;
4586
4587     if (ulFlags & ~CM_REGISTER_DEVICE_DRIVER_BITS)
4588         return CR_INVALID_FLAG;
4589
4590     if (hMachine != NULL)
4591     {
4592         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4593         if (BindingHandle == NULL)
4594             return CR_FAILURE;
4595
4596         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4597         if (StringTable == 0)
4598             return CR_FAILURE;
4599     }
4600     else
4601     {
4602         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
4603             return CR_FAILURE;
4604     }
4605
4606     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
4607     if (lpDevInst == NULL)
4608         return CR_INVALID_DEVNODE;
4609
4610     RpcTryExcept
4611     {
4612         ret = PNP_RegisterDriver(BindingHandle,
4613                                  lpDevInst,
4614                                  ulFlags);
4615     }
4616     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
4617     {
4618         ret = RpcStatusToCmStatus(RpcExceptionCode());
4619     }
4620     RpcEndExcept;
4621
4622     return ret;
4623 }
4624
4625
4626 /***********************************************************************
4627  * CM_Remove_SubTree [SETUPAPI.@]
4628  *
4629  * This function is obsolete in Windows XP and above.
4630  */
4631 CONFIGRET WINAPI CM_Remove_SubTree(
4632     DEVINST dnAncestor, ULONG ulFlags)
4633 {
4634     TRACE("%lx %lx\n", dnAncestor, ulFlags);
4635     return CR_CALL_NOT_IMPLEMENTED;
4636 }
4637
4638
4639 /***********************************************************************
4640  * CM_Remove_SubTree_Ex [SETUPAPI.@]
4641  *
4642  * This function is obsolete in Windows XP and above.
4643  */
4644 CONFIGRET WINAPI CM_Remove_SubTree_Ex(
4645     DEVINST dnAncestor, ULONG ulFlags, HMACHINE hMachine)
4646 {
4647     TRACE("%lx %lx %lx\n", dnAncestor, ulFlags, hMachine);
4648     return CR_CALL_NOT_IMPLEMENTED;
4649 }
4650
4651
4652 /***********************************************************************
4653  * CM_Request_Device_EjectA [SETUPAPI.@]
4654  */
4655 CONFIGRET WINAPI CM_Request_Device_EjectA(
4656     DEVINST dnDevInst, PPNP_VETO_TYPE pVetoType, LPSTR pszVetoName,
4657     ULONG ulNameLength, ULONG ulFlags)
4658 {
4659     TRACE("%lx %p %s %lu %lx\n", dnDevInst, pVetoType, pszVetoName,
4660           ulNameLength, ulFlags);
4661     return CM_Request_Device_Eject_ExA(dnDevInst, pVetoType, pszVetoName,
4662                                        ulNameLength, ulFlags, NULL);
4663 }
4664
4665
4666 /***********************************************************************
4667  * CM_Request_Device_EjectW [SETUPAPI.@]
4668  */
4669 CONFIGRET WINAPI CM_Request_Device_EjectW(
4670     DEVINST dnDevInst, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName,
4671     ULONG ulNameLength, ULONG ulFlags)
4672 {
4673     TRACE("%lx %p %s %lu %lx\n", dnDevInst, pVetoType, debugstr_w(pszVetoName),
4674           ulNameLength, ulFlags);
4675     return CM_Request_Device_Eject_ExW(dnDevInst, pVetoType, pszVetoName,
4676                                        ulNameLength, ulFlags, NULL);
4677 }
4678
4679
4680 /***********************************************************************
4681  * CM_Request_Device_Eject_ExA [SETUPAPI.@]
4682  */
4683 CONFIGRET WINAPI CM_Request_Device_Eject_ExA(
4684     DEVINST dnDevInst, PPNP_VETO_TYPE pVetoType, LPSTR pszVetoName,
4685     ULONG ulNameLength, ULONG ulFlags, HMACHINE hMachine)
4686 {
4687     LPWSTR lpLocalVetoName;
4688     CONFIGRET ret;
4689
4690     TRACE("%lx %p %s %lu %lx %lx\n", dnDevInst, pVetoType, pszVetoName,
4691           ulNameLength, ulFlags, hMachine);
4692
4693     if (pszVetoName == NULL && ulNameLength == 0)
4694         return CR_INVALID_POINTER;
4695
4696     lpLocalVetoName = HeapAlloc(GetProcessHeap(), 0, ulNameLength * sizeof(WCHAR));
4697     if (lpLocalVetoName == NULL)
4698         return CR_OUT_OF_MEMORY;
4699
4700     ret = CM_Request_Device_Eject_ExW(dnDevInst, pVetoType, lpLocalVetoName,
4701                                       ulNameLength, ulFlags, hMachine);
4702     if (ret == CR_REMOVE_VETOED)
4703     {
4704         if (WideCharToMultiByte(CP_ACP,
4705                                 0,
4706                                 lpLocalVetoName,
4707                                 ulNameLength,
4708                                 pszVetoName,
4709                                 ulNameLength,
4710                                 NULL,
4711                                 NULL) == 0)
4712             ret = CR_FAILURE;
4713     }
4714
4715     HeapFree(GetProcessHeap(), 0, lpLocalVetoName);
4716
4717     return ret;
4718 }
4719
4720
4721 /***********************************************************************
4722  * CM_Request_Device_Eject_ExW [SETUPAPI.@]
4723  */
4724 CONFIGRET WINAPI CM_Request_Device_Eject_ExW(
4725     DEVINST dnDevInst, PPNP_VETO_TYPE pVetoType, LPWSTR pszVetoName,
4726     ULONG ulNameLength, ULONG ulFlags, HMACHINE hMachine)
4727 {
4728     RPC_BINDING_HANDLE BindingHandle = NULL;
4729     HSTRING_TABLE StringTable = NULL;
4730     LPWSTR lpDevInst;
4731     CONFIGRET ret;
4732
4733     TRACE("%lx %p %s %lu %lx %lx\n", dnDevInst, pVetoType,
4734           debugstr_w(pszVetoName), ulNameLength, ulFlags, hMachine);
4735
4736     if (dnDevInst == 0)
4737         return CR_INVALID_DEVNODE;
4738
4739     if (ulFlags != 0)
4740         return CR_INVALID_FLAG;
4741
4742     if (pszVetoName == NULL && ulNameLength == 0)
4743         return CR_INVALID_POINTER;
4744
4745     if (hMachine != NULL)
4746     {
4747         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4748         if (BindingHandle == NULL)
4749             return CR_FAILURE;
4750
4751         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4752         if (StringTable == 0)
4753             return CR_FAILURE;
4754     }
4755     else
4756     {
4757         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
4758             return CR_FAILURE;
4759     }
4760
4761     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
4762     if (lpDevInst == NULL)
4763         return CR_INVALID_DEVNODE;
4764
4765     RpcTryExcept
4766     {
4767         ret = PNP_RequestDeviceEject(BindingHandle,
4768                                      lpDevInst,
4769                                      pVetoType,
4770                                      pszVetoName,
4771                                      ulNameLength,
4772                                      ulFlags);
4773     }
4774     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
4775     {
4776         ret = RpcStatusToCmStatus(RpcExceptionCode());
4777     }
4778     RpcEndExcept;
4779
4780     return ret;
4781 }
4782
4783
4784 /***********************************************************************
4785  * CM_Request_Eject_PC [SETUPAPI.@]
4786  */
4787 CONFIGRET WINAPI CM_Request_Eject_PC(VOID)
4788 {
4789     TRACE("\n");
4790     return CM_Request_Eject_PC_Ex(NULL);
4791 }
4792
4793
4794 /***********************************************************************
4795  * CM_Request_Eject_PC_Ex [SETUPAPI.@]
4796  */
4797 CONFIGRET WINAPI CM_Request_Eject_PC_Ex(
4798     HMACHINE hMachine)
4799 {
4800     RPC_BINDING_HANDLE BindingHandle = NULL;
4801     CONFIGRET ret;
4802
4803     TRACE("%lx\n", hMachine);
4804
4805     if (hMachine != NULL)
4806     {
4807         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4808         if (BindingHandle == NULL)
4809             return CR_FAILURE;
4810     }
4811     else
4812     {
4813         if (!PnpGetLocalHandles(&BindingHandle, NULL))
4814             return CR_FAILURE;
4815     }
4816
4817     RpcTryExcept
4818     {
4819         ret = PNP_RequestEjectPC(BindingHandle);
4820     }
4821     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
4822     {
4823         ret = RpcStatusToCmStatus(RpcExceptionCode());
4824     }
4825     RpcEndExcept;
4826
4827     return ret;
4828 }
4829
4830
4831 /***********************************************************************
4832  * CM_Run_Detection [SETUPAPI.@]
4833  */
4834 CONFIGRET WINAPI CM_Run_Detection(
4835     ULONG ulFlags)
4836 {
4837     TRACE("%lx\n", ulFlags);
4838     return CM_Run_Detection_Ex(ulFlags, NULL);
4839 }
4840
4841
4842 /***********************************************************************
4843  * CM_Run_Detection_Ex [SETUPAPI.@]
4844  */
4845 CONFIGRET WINAPI CM_Run_Detection_Ex(
4846     ULONG ulFlags, HMACHINE hMachine)
4847 {
4848     RPC_BINDING_HANDLE BindingHandle = NULL;
4849     CONFIGRET ret;
4850
4851     TRACE("%lx %lx\n", ulFlags, hMachine);
4852
4853     if (!pSetupIsUserAdmin())
4854         return CR_ACCESS_DENIED;
4855
4856     if (ulFlags & ~CM_DETECT_BITS)
4857         return CR_INVALID_FLAG;
4858
4859     if (hMachine != NULL)
4860     {
4861         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4862         if (BindingHandle == NULL)
4863             return CR_FAILURE;
4864     }
4865     else
4866     {
4867         if (!PnpGetLocalHandles(&BindingHandle, NULL))
4868             return CR_FAILURE;
4869     }
4870
4871     RpcTryExcept
4872     {
4873         ret = PNP_RunDetection(BindingHandle,
4874                                ulFlags);
4875     }
4876     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
4877     {
4878         ret = RpcStatusToCmStatus(RpcExceptionCode());
4879     }
4880     RpcEndExcept;
4881
4882     return ret;
4883 }
4884
4885
4886 /***********************************************************************
4887  * CM_Set_DevNode_Problem [SETUPAPI.@]
4888  */
4889 CONFIGRET WINAPI CM_Set_DevNode_Problem(
4890     DEVINST dnDevInst, ULONG ulProblem, ULONG ulFlags)
4891 {
4892     TRACE("%lx %lx %lx\n", dnDevInst, ulProblem, ulFlags);
4893     return CM_Set_DevNode_Problem_Ex(dnDevInst, ulProblem, ulFlags, NULL);
4894 }
4895
4896
4897 /***********************************************************************
4898  * CM_Set_DevNode_Problem_Ex [SETUPAPI.@]
4899  */
4900 CONFIGRET WINAPI CM_Set_DevNode_Problem_Ex(
4901     DEVINST dnDevInst, ULONG ulProblem, ULONG ulFlags, HMACHINE hMachine)
4902 {
4903     RPC_BINDING_HANDLE BindingHandle = NULL;
4904     HSTRING_TABLE StringTable = NULL;
4905     LPWSTR lpDevInst;
4906     CONFIGRET ret;
4907
4908     TRACE("%lx %lx %lx %lx\n", dnDevInst, ulProblem, ulFlags, hMachine);
4909
4910     if (dnDevInst == 0)
4911         return CR_INVALID_DEVNODE;
4912
4913     if (ulFlags & ~CM_SET_DEVNODE_PROBLEM_BITS)
4914         return CR_INVALID_FLAG;
4915
4916     if (hMachine != NULL)
4917     {
4918         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
4919         if (BindingHandle == NULL)
4920             return CR_FAILURE;
4921
4922         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
4923         if (StringTable == 0)
4924             return CR_FAILURE;
4925     }
4926     else
4927     {
4928         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
4929             return CR_FAILURE;
4930     }
4931
4932     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
4933     if (lpDevInst == NULL)
4934         return CR_INVALID_DEVNODE;
4935
4936     RpcTryExcept
4937     {
4938         ret = PNP_SetDeviceProblem(BindingHandle,
4939                                    lpDevInst,
4940                                    ulProblem,
4941                                    ulFlags);
4942     }
4943     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
4944     {
4945         ret = RpcStatusToCmStatus(RpcExceptionCode());
4946     }
4947     RpcEndExcept;
4948
4949     return ret;
4950 }
4951
4952
4953 /***********************************************************************
4954  * CM_Set_DevNode_Registry_PropertyA [SETUPAPI.@]
4955  */
4956 CONFIGRET WINAPI CM_Set_DevNode_Registry_PropertyA(
4957     DEVINST dnDevInst, ULONG ulProperty, PCVOID Buffer, ULONG ulLength,
4958     ULONG ulFlags)
4959 {
4960     TRACE("%lx %lu %p %lx %lx\n",
4961           dnDevInst, ulProperty, Buffer, ulLength, ulFlags);
4962     return CM_Set_DevNode_Registry_Property_ExA(dnDevInst, ulProperty,
4963                                                 Buffer, ulLength,
4964                                                 ulFlags, NULL);
4965 }
4966
4967
4968 /***********************************************************************
4969  * CM_Set_DevNode_Registry_PropertyW [SETUPAPI.@]
4970  */
4971 CONFIGRET WINAPI CM_Set_DevNode_Registry_PropertyW(
4972     DEVINST dnDevInst, ULONG ulProperty, PCVOID Buffer, ULONG ulLength,
4973     ULONG ulFlags)
4974 {
4975     TRACE("%lx %lu %p %lx %lx\n",
4976           dnDevInst, ulProperty, Buffer, ulLength, ulFlags);
4977     return CM_Set_DevNode_Registry_Property_ExW(dnDevInst, ulProperty,
4978                                                 Buffer, ulLength,
4979                                                 ulFlags, NULL);
4980 }
4981
4982
4983 /***********************************************************************
4984  * CM_Set_DevNode_Registry_Property_ExA [SETUPAPI.@]
4985  */
4986 CONFIGRET WINAPI CM_Set_DevNode_Registry_Property_ExA(
4987     DEVINST dnDevInst, ULONG ulProperty, PCVOID Buffer, ULONG ulLength,
4988     ULONG ulFlags, HMACHINE hMachine)
4989 {
4990     CONFIGRET ret = CR_SUCCESS;
4991     LPWSTR lpBuffer;
4992     ULONG ulType;
4993
4994     FIXME("%lx %lu %p %lx %lx %lx\n",
4995           dnDevInst, ulProperty, Buffer, ulLength, ulFlags, hMachine);
4996
4997     if (Buffer == NULL && ulLength != 0)
4998         return CR_INVALID_POINTER;
4999
5000     if (Buffer == NULL)
5001     {
5002         ret = CM_Set_DevNode_Registry_Property_ExW(dnDevInst,
5003                                                    ulProperty,
5004                                                    NULL,
5005                                                    0,
5006                                                    ulFlags,
5007                                                    hMachine);
5008     }
5009     else
5010     {
5011         /* Get property type */
5012         switch (ulProperty)
5013         {
5014             case CM_DRP_DEVICEDESC:
5015                 ulType = REG_SZ;
5016                 break;
5017
5018             case CM_DRP_HARDWAREID:
5019                 ulType = REG_MULTI_SZ;
5020                 break;
5021
5022             case CM_DRP_COMPATIBLEIDS:
5023                 ulType = REG_MULTI_SZ;
5024                 break;
5025
5026             case CM_DRP_SERVICE:
5027                 ulType = REG_SZ;
5028                 break;
5029
5030             case CM_DRP_CLASS:
5031                 ulType = REG_SZ;
5032                 break;
5033
5034             case CM_DRP_CLASSGUID:
5035                 ulType = REG_SZ;
5036                 break;
5037
5038             case CM_DRP_DRIVER:
5039                 ulType = REG_SZ;
5040                 break;
5041
5042             case CM_DRP_CONFIGFLAGS:
5043                 ulType = REG_DWORD;
5044                 break;
5045
5046             case CM_DRP_MFG:
5047                 ulType = REG_SZ;
5048                 break;
5049
5050             case CM_DRP_FRIENDLYNAME:
5051                 ulType = REG_SZ;
5052                 break;
5053
5054             case CM_DRP_LOCATION_INFORMATION:
5055                 ulType = REG_SZ;
5056                 break;
5057
5058             case CM_DRP_UPPERFILTERS:
5059                 ulType = REG_MULTI_SZ;
5060                 break;
5061
5062             case CM_DRP_LOWERFILTERS:
5063                 ulType = REG_MULTI_SZ;
5064                 break;
5065
5066             default:
5067                 return CR_INVALID_PROPERTY;
5068         }
5069
5070         /* Allocate buffer if needed */
5071         if (ulType == REG_SZ ||
5072             ulType == REG_MULTI_SZ)
5073         {
5074             lpBuffer = MyMalloc(ulLength * sizeof(WCHAR));
5075             if (lpBuffer == NULL)
5076             {
5077                 ret = CR_OUT_OF_MEMORY;
5078             }
5079             else
5080             {
5081                 if (!MultiByteToWideChar(CP_ACP, 0, Buffer,
5082                                          ulLength, lpBuffer, ulLength))
5083                 {
5084                     MyFree(lpBuffer);
5085                     ret = CR_FAILURE;
5086                 }
5087                 else
5088                 {
5089                     ret = CM_Set_DevNode_Registry_Property_ExW(dnDevInst,
5090                                                                ulProperty,
5091                                                                lpBuffer,
5092                                                                ulLength * sizeof(WCHAR),
5093                                                                ulFlags,
5094                                                                hMachine);
5095                     MyFree(lpBuffer);
5096                 }
5097             }
5098         }
5099         else
5100         {
5101             ret = CM_Set_DevNode_Registry_Property_ExW(dnDevInst,
5102                                                        ulProperty,
5103                                                        Buffer,
5104                                                        ulLength,
5105                                                        ulFlags,
5106                                                        hMachine);
5107         }
5108
5109         ret = CR_CALL_NOT_IMPLEMENTED;
5110     }
5111
5112     return ret;
5113 }
5114
5115
5116 /***********************************************************************
5117  * CM_Set_DevNode_Registry_Property_ExW [SETUPAPI.@]
5118  */
5119 CONFIGRET WINAPI CM_Set_DevNode_Registry_Property_ExW(
5120     DEVINST dnDevInst, ULONG ulProperty, PCVOID Buffer, ULONG ulLength,
5121     ULONG ulFlags, HMACHINE hMachine)
5122 {
5123     RPC_BINDING_HANDLE BindingHandle = NULL;
5124     HSTRING_TABLE StringTable = NULL;
5125     LPWSTR lpDevInst;
5126     ULONG ulType;
5127     CONFIGRET ret;
5128
5129     TRACE("%lx %lu %p %lx %lx %lx\n",
5130           dnDevInst, ulProperty, Buffer, ulLength, ulFlags, hMachine);
5131
5132     if (dnDevInst == 0)
5133         return CR_INVALID_DEVNODE;
5134
5135     if (ulProperty <  CM_DRP_MIN || ulProperty > CM_DRP_MAX)
5136         return CR_INVALID_PROPERTY;
5137
5138     if (Buffer != NULL && ulLength == 0)
5139         return CR_INVALID_POINTER;
5140
5141     if (ulFlags != 0)
5142         return CR_INVALID_FLAG;
5143
5144     if (hMachine != NULL)
5145     {
5146         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5147         if (BindingHandle == NULL)
5148             return CR_FAILURE;
5149
5150         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5151         if (StringTable == 0)
5152             return CR_FAILURE;
5153     }
5154     else
5155     {
5156         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5157             return CR_FAILURE;
5158     }
5159
5160     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
5161     if (lpDevInst == NULL)
5162         return CR_INVALID_DEVNODE;
5163
5164     switch (ulProperty)
5165     {
5166         case CM_DRP_DEVICEDESC:
5167             ulType = REG_SZ;
5168             break;
5169
5170         case CM_DRP_HARDWAREID:
5171             ulType = REG_MULTI_SZ;
5172             break;
5173
5174         case CM_DRP_COMPATIBLEIDS:
5175             ulType = REG_MULTI_SZ;
5176             break;
5177
5178         case CM_DRP_SERVICE:
5179             ulType = REG_SZ;
5180             break;
5181
5182         case CM_DRP_CLASS:
5183             ulType = REG_SZ;
5184             break;
5185
5186         case CM_DRP_CLASSGUID:
5187             ulType = REG_SZ;
5188             break;
5189
5190         case CM_DRP_DRIVER:
5191             ulType = REG_SZ;
5192             break;
5193
5194         case CM_DRP_CONFIGFLAGS:
5195             ulType = REG_DWORD;
5196             break;
5197
5198         case CM_DRP_MFG:
5199             ulType = REG_SZ;
5200             break;
5201
5202         case CM_DRP_FRIENDLYNAME:
5203             ulType = REG_SZ;
5204             break;
5205
5206         case CM_DRP_LOCATION_INFORMATION:
5207             ulType = REG_SZ;
5208             break;
5209
5210         case CM_DRP_UPPERFILTERS:
5211             ulType = REG_MULTI_SZ;
5212             break;
5213
5214         case CM_DRP_LOWERFILTERS:
5215             ulType = REG_MULTI_SZ;
5216             break;
5217
5218         default:
5219             return CR_INVALID_PROPERTY;
5220     }
5221
5222     RpcTryExcept
5223     {
5224         ret = PNP_SetDeviceRegProp(BindingHandle,
5225                                    lpDevInst,
5226                                    ulProperty,
5227                                    ulType,
5228                                    (BYTE *)Buffer,
5229                                    ulLength,
5230                                    ulFlags);
5231     }
5232     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5233     {
5234         ret = RpcStatusToCmStatus(RpcExceptionCode());
5235     }
5236     RpcEndExcept;
5237
5238     return ret;
5239 }
5240
5241
5242 /***********************************************************************
5243  * CM_Set_HW_Prof [SETUPAPI.@]
5244  */
5245 CONFIGRET WINAPI CM_Set_HW_Prof(
5246     ULONG ulHardwareProfile, ULONG ulFlags)
5247 {
5248     TRACE("%lu %lu\n", ulHardwareProfile, ulFlags);
5249     return CM_Set_HW_Prof_Ex(ulHardwareProfile, ulFlags, NULL);
5250 }
5251
5252
5253 /***********************************************************************
5254  * CM_Set_HW_Prof_Ex [SETUPAPI.@]
5255  */
5256 CONFIGRET WINAPI CM_Set_HW_Prof_Ex(
5257     ULONG ulHardwareProfile, ULONG ulFlags, HMACHINE hMachine)
5258 {
5259     RPC_BINDING_HANDLE BindingHandle = NULL;
5260     CONFIGRET ret;
5261
5262     TRACE("%lu %lu %lx\n", ulHardwareProfile, ulFlags, hMachine);
5263
5264     if (!pSetupIsUserAdmin())
5265         return CR_ACCESS_DENIED;
5266
5267     if (ulFlags != 0)
5268         return CR_INVALID_FLAG;
5269
5270     if (hMachine != NULL)
5271     {
5272         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5273         if (BindingHandle == NULL)
5274             return CR_FAILURE;
5275     }
5276     else
5277     {
5278         if (!PnpGetLocalHandles(&BindingHandle, NULL))
5279             return CR_FAILURE;
5280     }
5281
5282     RpcTryExcept
5283     {
5284         ret = PNP_SetHwProf(BindingHandle, ulHardwareProfile, ulFlags);
5285     }
5286     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5287     {
5288         ret = RpcStatusToCmStatus(RpcExceptionCode());
5289     }
5290     RpcEndExcept;
5291
5292     return ret;
5293 }
5294
5295
5296 /***********************************************************************
5297  * CM_Set_HW_Prof_FlagsA [SETUPAPI.@]
5298  */
5299 CONFIGRET WINAPI CM_Set_HW_Prof_FlagsA(
5300     DEVINSTID_A szDevInstName, ULONG ulConfig, ULONG ulValue,
5301     ULONG ulFlags)
5302 {
5303     TRACE("%s %lu %lu %lx\n", szDevInstName,
5304           ulConfig, ulValue, ulFlags);
5305     return CM_Set_HW_Prof_Flags_ExA(szDevInstName, ulConfig, ulValue,
5306                                     ulFlags, NULL);
5307 }
5308
5309
5310 /***********************************************************************
5311  * CM_Set_HW_Prof_FlagsW [SETUPAPI.@]
5312  */
5313 CONFIGRET WINAPI CM_Set_HW_Prof_FlagsW(
5314     DEVINSTID_W szDevInstName, ULONG ulConfig, ULONG ulValue,
5315     ULONG ulFlags)
5316 {
5317     TRACE("%s %lu %lu %lx\n", debugstr_w(szDevInstName),
5318           ulConfig, ulValue, ulFlags);
5319     return CM_Set_HW_Prof_Flags_ExW(szDevInstName, ulConfig, ulValue,
5320                                     ulFlags, NULL);
5321 }
5322
5323
5324 /***********************************************************************
5325  * CM_Set_HW_Prof_Flags_ExA [SETUPAPI.@]
5326  */
5327 CONFIGRET WINAPI CM_Set_HW_Prof_Flags_ExA(
5328     DEVINSTID_A szDevInstName, ULONG ulConfig, ULONG ulValue,
5329     ULONG ulFlags, HMACHINE hMachine)
5330 {
5331     DEVINSTID_W pszDevIdW = NULL;
5332     CONFIGRET ret = CR_SUCCESS;
5333
5334     TRACE("%s %lu %lu %lx %lx\n", szDevInstName,
5335           ulConfig, ulValue, ulFlags, hMachine);
5336
5337     if (szDevInstName != NULL)
5338     {
5339        if (pSetupCaptureAndConvertAnsiArg(szDevInstName, &pszDevIdW))
5340          return CR_INVALID_DEVICE_ID;
5341     }
5342
5343     ret = CM_Set_HW_Prof_Flags_ExW(pszDevIdW, ulConfig, ulValue,
5344                                    ulFlags, hMachine);
5345
5346     if (pszDevIdW != NULL)
5347         MyFree(pszDevIdW);
5348
5349     return ret;
5350 }
5351
5352
5353 /***********************************************************************
5354  * CM_Set_HW_Prof_Flags_ExW [SETUPAPI.@]
5355  */
5356 CONFIGRET WINAPI CM_Set_HW_Prof_Flags_ExW(
5357     DEVINSTID_W szDevInstName, ULONG ulConfig, ULONG ulValue,
5358     ULONG ulFlags, HMACHINE hMachine)
5359 {
5360     RPC_BINDING_HANDLE BindingHandle = NULL;
5361     CONFIGRET ret;
5362
5363     FIXME("%s %lu %lu %lx %lx\n", debugstr_w(szDevInstName),
5364           ulConfig, ulValue, ulFlags, hMachine);
5365
5366     if (szDevInstName == NULL)
5367         return CR_INVALID_POINTER;
5368
5369     if (ulFlags & ~ CM_SET_HW_PROF_FLAGS_BITS)
5370         return CR_INVALID_FLAG;
5371
5372     /* FIXME: Check whether szDevInstName is valid */
5373
5374     if (hMachine != NULL)
5375     {
5376         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5377         if (BindingHandle == NULL)
5378             return CR_FAILURE;
5379     }
5380     else
5381     {
5382         if (!PnpGetLocalHandles(&BindingHandle, NULL))
5383             return CR_FAILURE;
5384     }
5385
5386     RpcTryExcept
5387     {
5388         ret = PNP_HwProfFlags(BindingHandle, PNP_SET_HWPROFFLAGS, szDevInstName,
5389                               ulConfig, &ulValue, NULL, NULL, 0, 0);
5390     }
5391     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5392     {
5393         ret = RpcStatusToCmStatus(RpcExceptionCode());
5394     }
5395     RpcEndExcept;
5396
5397     return ret;
5398 }
5399
5400
5401 /***********************************************************************
5402  * CM_Setup_DevNode [SETUPAPI.@]
5403  */
5404 CONFIGRET WINAPI CM_Setup_DevNode(
5405     DEVINST dnDevInst, ULONG ulFlags)
5406 {
5407     TRACE("%lx %lx\n", dnDevInst, ulFlags);
5408     return CM_Setup_DevNode_Ex(dnDevInst, ulFlags, NULL);
5409 }
5410
5411
5412 /***********************************************************************
5413  * CM_Setup_DevNode_Ex [SETUPAPI.@]
5414  */
5415 CONFIGRET WINAPI CM_Setup_DevNode_Ex(
5416     DEVINST dnDevInst, ULONG ulFlags, HMACHINE hMachine)
5417 {
5418     RPC_BINDING_HANDLE BindingHandle = NULL;
5419     HSTRING_TABLE StringTable = NULL;
5420     LPWSTR lpDevInst;
5421     CONFIGRET ret;
5422
5423     FIXME("%lx %lx %lx\n", dnDevInst, ulFlags, hMachine);
5424
5425     if (!pSetupIsUserAdmin())
5426         return CR_ACCESS_DENIED;
5427
5428     if (dnDevInst == 0)
5429         return CR_INVALID_DEVNODE;
5430
5431     if (ulFlags & ~CM_SETUP_BITS)
5432         return CR_INVALID_FLAG;
5433
5434     if (hMachine != NULL)
5435     {
5436         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5437         if (BindingHandle == NULL)
5438             return CR_FAILURE;
5439
5440         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5441         if (StringTable == 0)
5442             return CR_FAILURE;
5443     }
5444     else
5445     {
5446         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5447             return CR_FAILURE;
5448     }
5449
5450     lpDevInst = pSetupStringTableStringFromId(StringTable, dnDevInst);
5451     if (lpDevInst == NULL)
5452         return CR_INVALID_DEVNODE;
5453
5454     RpcTryExcept
5455     {
5456         ret = PNP_DeviceInstanceAction(BindingHandle,
5457                                        PNP_DEVINST_SETUP,
5458                                        ulFlags,
5459                                        lpDevInst,
5460                                        NULL);
5461     }
5462     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5463     {
5464         ret = RpcStatusToCmStatus(RpcExceptionCode());
5465     }
5466     RpcEndExcept;
5467
5468     return ret;
5469 }
5470
5471
5472 /***********************************************************************
5473  * CM_Uninstall_DevNode [SETUPAPI.@]
5474  */
5475 CONFIGRET WINAPI CM_Uninstall_DevNode(
5476     DEVINST dnPhantom, ULONG ulFlags)
5477 {
5478     TRACE("%lx %lx\n", dnPhantom, ulFlags);
5479     return CM_Uninstall_DevNode_Ex(dnPhantom, ulFlags, NULL);
5480 }
5481
5482
5483 /***********************************************************************
5484  * CM_Uninstall_DevNode_Ex [SETUPAPI.@]
5485  */
5486 CONFIGRET WINAPI CM_Uninstall_DevNode_Ex(
5487     DEVINST dnPhantom, ULONG ulFlags, HMACHINE hMachine)
5488 {
5489     RPC_BINDING_HANDLE BindingHandle = NULL;
5490     HSTRING_TABLE StringTable = NULL;
5491     LPWSTR lpDevInst;
5492     CONFIGRET ret;
5493
5494     TRACE("%lx %lx %lx\n", dnPhantom, ulFlags, hMachine);
5495
5496     if (dnPhantom == 0)
5497         return CR_INVALID_DEVNODE;
5498
5499     if (ulFlags != 0)
5500         return CR_INVALID_FLAG;
5501
5502     if (hMachine != NULL)
5503     {
5504         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5505         if (BindingHandle == NULL)
5506             return CR_FAILURE;
5507
5508         StringTable = ((PMACHINE_INFO)hMachine)->StringTable;
5509         if (StringTable == 0)
5510             return CR_FAILURE;
5511     }
5512     else
5513     {
5514         if (!PnpGetLocalHandles(&BindingHandle, &StringTable))
5515             return CR_FAILURE;
5516     }
5517
5518     lpDevInst = pSetupStringTableStringFromId(StringTable, dnPhantom);
5519     if (lpDevInst == NULL)
5520         return CR_INVALID_DEVNODE;
5521
5522     RpcTryExcept
5523     {
5524         ret = PNP_UninstallDevInst(BindingHandle,
5525                                    lpDevInst,
5526                                    ulFlags);
5527     }
5528     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5529     {
5530         ret = RpcStatusToCmStatus(RpcExceptionCode());
5531     }
5532     RpcEndExcept;
5533
5534     return ret;
5535 }
5536
5537
5538 /***********************************************************************
5539  * CM_Unregister_Device_InterfaceA [SETUPAPI.@]
5540  */
5541 CONFIGRET WINAPI CM_Unregister_Device_InterfaceA(
5542     LPCSTR pszDeviceInterface, ULONG ulFlags)
5543 {
5544     TRACE("%s %lx\n", pszDeviceInterface, ulFlags);
5545
5546     return CM_Unregister_Device_Interface_ExA(pszDeviceInterface,
5547                                               ulFlags, NULL);
5548 }
5549
5550
5551 /***********************************************************************
5552  * CM_Unregister_Device_InterfaceW [SETUPAPI.@]
5553  */
5554 CONFIGRET WINAPI CM_Unregister_Device_InterfaceW(
5555     LPCWSTR pszDeviceInterface, ULONG ulFlags)
5556 {
5557     TRACE("%s %lx\n", debugstr_w(pszDeviceInterface), ulFlags);
5558
5559     return CM_Unregister_Device_Interface_ExW(pszDeviceInterface,
5560                                               ulFlags, NULL);
5561 }
5562
5563
5564 /***********************************************************************
5565  * CM_Unregister_Device_Interface_ExA [SETUPAPI.@]
5566  */
5567 CONFIGRET WINAPI CM_Unregister_Device_Interface_ExA(
5568     LPCSTR pszDeviceInterface, ULONG ulFlags, HMACHINE hMachine)
5569 {
5570     LPWSTR pszDeviceInterfaceW = NULL;
5571     CONFIGRET ret;
5572
5573     TRACE("%s %lx %lx\n", pszDeviceInterface, ulFlags, hMachine);
5574
5575     if (pszDeviceInterface == NULL)
5576         return CR_INVALID_POINTER;
5577
5578     if (pSetupCaptureAndConvertAnsiArg(pszDeviceInterface, &pszDeviceInterfaceW))
5579         return CR_INVALID_DATA;
5580
5581     ret = CM_Unregister_Device_Interface_ExW(pszDeviceInterfaceW,
5582                                              ulFlags, hMachine);
5583
5584     if (pszDeviceInterfaceW != NULL)
5585         MyFree(pszDeviceInterfaceW);
5586
5587     return ret;
5588 }
5589
5590
5591 /***********************************************************************
5592  * CM_Unregister_Device_Interface_ExW [SETUPAPI.@]
5593  */
5594 CONFIGRET WINAPI CM_Unregister_Device_Interface_ExW(
5595     LPCWSTR pszDeviceInterface, ULONG ulFlags, HMACHINE hMachine)
5596 {
5597     RPC_BINDING_HANDLE BindingHandle = NULL;
5598     CONFIGRET ret;
5599
5600     TRACE("%s %lx %lx\n", debugstr_w(pszDeviceInterface), ulFlags, hMachine);
5601
5602     if (pszDeviceInterface == NULL)
5603         return CR_INVALID_POINTER;
5604
5605     if (ulFlags != 0)
5606         return CR_INVALID_FLAG;
5607
5608     if (hMachine != NULL)
5609     {
5610         BindingHandle = ((PMACHINE_INFO)hMachine)->BindingHandle;
5611         if (BindingHandle == NULL)
5612             return CR_FAILURE;
5613     }
5614     else
5615     {
5616         if (!PnpGetLocalHandles(&BindingHandle, NULL))
5617             return CR_FAILURE;
5618     }
5619
5620     RpcTryExcept
5621     {
5622         ret = PNP_UnregisterDeviceClassAssociation(BindingHandle,
5623                                                    (LPWSTR)pszDeviceInterface,
5624                                                    ulFlags);
5625     }
5626     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
5627     {
5628         ret = RpcStatusToCmStatus(RpcExceptionCode());
5629     }
5630     RpcEndExcept;
5631
5632     return ret;
5633 }