reactos/dll/win32/setupapi/cfgmgr.c

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