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