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