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