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