dll/win32/setupapi/cfgmgr.c

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