reactos/lib/setupapi/devinst.c

   1 /*
   2  * SetupAPI device installer
   3  *
   4  * Copyright 2000 Andreas Mohr for CodeWeavers
   5  *           2005 Hervé Poussineau (hpoussin@reactos.org)
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #define INITGUID
  23 #include "setupapi_private.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
  26
  27 /* Unicode constants */
  28 static const WCHAR ClassGUID[]  = {'C','l','a','s','s','G','U','I','D',0};
  29 static const WCHAR Class[]  = {'C','l','a','s','s',0};
  30 static const WCHAR ClassInstall32[]  = {'C','l','a','s','s','I','n','s','t','a','l','l','3','2',0};
  31 static const WCHAR DeviceInstance[]  = {'D','e','v','i','c','e','I','n','s','t','a','n','c','e',0};
  32 static const WCHAR DotServices[]  = {'.','S','e','r','v','i','c','e','s',0};
  33 static const WCHAR InterfaceInstall32[]  = {'I','n','t','e','r','f','a','c','e','I','n','s','t','a','l','l','3','2',0};
  34 static const WCHAR SymbolicLink[]  = {'S','y','m','b','o','l','i','c','L','i','n','k',0};
  35 static const WCHAR Version[]  = {'V','e','r','s','i','o','n',0};
  36
  37 /* FIXME: header mess */
  38 DEFINE_GUID(GUID_NULL,
  39   0x00000000L, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
  40 typedef DWORD
  41 (CALLBACK* CLASS_INSTALL_PROC) (
  42     IN DI_FUNCTION InstallFunction,
  43     IN HDEVINFO DeviceInfoSet,
  44     IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL);
  45 typedef BOOL
  46 (WINAPI* DEFAULT_CLASS_INSTALL_PROC) (
  47     IN HDEVINFO DeviceInfoSet,
  48     IN OUT PSP_DEVINFO_DATA DeviceInfoData);
  49 typedef DWORD
  50 (CALLBACK* COINSTALLER_PROC) (
  51     IN DI_FUNCTION InstallFunction,
  52     IN HDEVINFO DeviceInfoSet,
  53     IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
  54     IN OUT PCOINSTALLER_CONTEXT_DATA Context);
  55 typedef BOOL
  56 (WINAPI* PROPERTY_PAGE_PROVIDER) (
  57     IN PSP_PROPSHEETPAGE_REQUEST PropPageRequest,
  58     IN LPFNADDPROPSHEETPAGE fAddFunc,
  59     IN LPARAM lParam);
  60 typedef BOOL
  61 (*UPDATE_CLASS_PARAM_HANDLER) (
  62     IN HDEVINFO DeviceInfoSet,
  63     IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
  64     IN PSP_CLASSINSTALL_HEADER ClassInstallParams OPTIONAL,
  65     IN DWORD ClassInstallParamsSize);
  66
  67 struct CoInstallerElement
  68 {
  69     LIST_ENTRY ListEntry;
  70
  71     HMODULE Module;
  72     COINSTALLER_PROC Function;
  73     BOOL DoPostProcessing;
  74     PVOID PrivateData;
  75 };
  76
  77 static BOOL
  78 PropertyChangeHandler(
  79     IN HDEVINFO DeviceInfoSet,
  80     IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
  81     IN PSP_CLASSINSTALL_HEADER ClassInstallParams OPTIONAL,
  82     IN DWORD ClassInstallParamsSize);
  83
  84 static UPDATE_CLASS_PARAM_HANDLER UpdateClassInstallParamHandlers[] = {
  85     NULL, /* DIF_SELECTDEVICE */
  86     NULL, /* DIF_INSTALLDEVICE */
  87     NULL, /* DIF_ASSIGNRESOURCES */
  88     NULL, /* DIF_PROPERTIES */
  89     NULL, /* DIF_REMOVE */
  90     NULL, /* DIF_FIRSTTIMESETUP */
  91     NULL, /* DIF_FOUNDDEVICE */
  92     NULL, /* DIF_SELECTCLASSDRIVERS */
  93     NULL, /* DIF_VALIDATECLASSDRIVERS */
  94     NULL, /* DIF_INSTALLCLASSDRIVERS */
  95     NULL, /* DIF_CALCDISKSPACE */
  96     NULL, /* DIF_DESTROYPRIVATEDATA */
  97     NULL, /* DIF_VALIDATEDRIVER */
  98     NULL, /* DIF_MOVEDEVICE */
  99     NULL, /* DIF_DETECT */
 100     NULL, /* DIF_INSTALLWIZARD */
 101     NULL, /* DIF_DESTROYWIZARDDATA */
 102     PropertyChangeHandler, /* DIF_PROPERTYCHANGE */
 103     NULL, /* DIF_ENABLECLASS */
 104     NULL, /* DIF_DETECTVERIFY */
 105     NULL, /* DIF_INSTALLDEVICEFILES */
 106     NULL, /* DIF_UNREMOVE */
 107     NULL, /* DIF_SELECTBESTCOMPATDRV */
 108     NULL, /* DIF_ALLOW_INSTALL */
 109     NULL, /* DIF_REGISTERDEVICE */
 110     NULL, /* DIF_NEWDEVICEWIZARD_PRESELECT */
 111     NULL, /* DIF_NEWDEVICEWIZARD_SELECT */
 112     NULL, /* DIF_NEWDEVICEWIZARD_PREANALYZE */
 113     NULL, /* DIF_NEWDEVICEWIZARD_POSTANALYZE */
 114     NULL, /* DIF_NEWDEVICEWIZARD_FINISHINSTALL */
 115     NULL, /* DIF_UNUSED1 */
 116     NULL, /* DIF_INSTALLINTERFACES */
 117     NULL, /* DIF_DETECTCANCEL */
 118     NULL, /* DIF_REGISTER_COINSTALLERS */
 119     NULL, /* DIF_ADDPROPERTYPAGE_ADVANCED */
 120     NULL, /* DIF_ADDPROPERTYPAGE_BASIC */
 121     NULL, /* DIF_RESERVED1 */
 122     NULL, /* DIF_TROUBLESHOOTER */
 123     NULL, /* DIF_POWERMESSAGEWAKE */
 124     NULL, /* DIF_ADDREMOTEPROPERTYPAGE_ADVANCED */
 125     NULL, /* DIF_UPDATEDRIVER_UI */
 126     NULL  /* DIF_RESERVED2 */
 127 };
 128
 129 /***********************************************************************
 130  *              SetupDiBuildClassInfoList  (SETUPAPI.@)
 131  */
 132 BOOL WINAPI SetupDiBuildClassInfoList(
 133         DWORD Flags,
 134         LPGUID ClassGuidList,
 135         DWORD ClassGuidListSize,
 136         PDWORD RequiredSize)
 137 {
 138     TRACE("\n");
 139     return SetupDiBuildClassInfoListExW(Flags, ClassGuidList,
 140                                         ClassGuidListSize, RequiredSize,
 141                                         NULL, NULL);
 142 }
 143
 144 /***********************************************************************
 145  *              SetupDiBuildClassInfoListExA  (SETUPAPI.@)
 146  */
 147 BOOL WINAPI SetupDiBuildClassInfoListExA(
 148         DWORD Flags,
 149         LPGUID ClassGuidList,
 150         DWORD ClassGuidListSize,
 151         PDWORD RequiredSize,
 152         LPCSTR MachineName,
 153         PVOID Reserved)
 154 {
 155     LPWSTR MachineNameW = NULL;
 156     BOOL bResult;
 157
 158     TRACE("\n");
 159
 160     if (MachineName)
 161     {
 162         MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
 163         if (MachineNameW == NULL) return FALSE;
 164     }
 165
 166     bResult = SetupDiBuildClassInfoListExW(Flags, ClassGuidList,
 167                                            ClassGuidListSize, RequiredSize,
 168                                            MachineNameW, Reserved);
 169
 170     if (MachineNameW)
 171         MyFree(MachineNameW);
 172
 173     return bResult;
 174 }
 175
 176 /***********************************************************************
 177  *              SetupDiBuildClassInfoListExW  (SETUPAPI.@)
 178  */
 179 BOOL WINAPI SetupDiBuildClassInfoListExW(
 180         DWORD Flags,
 181         LPGUID ClassGuidList,
 182         DWORD ClassGuidListSize,
 183         PDWORD RequiredSize,
 184         LPCWSTR MachineName,
 185         PVOID Reserved)
 186 {
 187     WCHAR szKeyName[MAX_GUID_STRING_LEN + 1];
 188     HKEY hClassesKey;
 189     HKEY hClassKey;
 190     DWORD dwLength;
 191     DWORD dwIndex;
 192     LONG lError;
 193     DWORD dwGuidListIndex = 0;
 194
 195     TRACE("0x%lx %p %lu %p %s %p\n", Flags, ClassGuidList,
 196         ClassGuidListSize, RequiredSize, debugstr_w(MachineName), Reserved);
 197
 198     if (RequiredSize != NULL)
 199         *RequiredSize = 0;
 200
 201     hClassesKey = SetupDiOpenClassRegKeyExW(NULL,
 202                                             KEY_ENUMERATE_SUB_KEYS,
 203                                             DIOCR_INSTALLER,
 204                                             MachineName,
 205                                             Reserved);
 206     if (hClassesKey == INVALID_HANDLE_VALUE)
 207     {
 208         return FALSE;
 209     }
 210
 211     for (dwIndex = 0; ; dwIndex++)
 212     {
 213         dwLength = MAX_GUID_STRING_LEN + 1;
 214         lError = RegEnumKeyExW(hClassesKey,
 215                                dwIndex,
 216                                szKeyName,
 217                                &dwLength,
 218                                NULL,
 219                                NULL,
 220                                NULL,
 221                                NULL);
 222         TRACE("RegEnumKeyExW() returns %ld\n", lError);
 223         if (lError == ERROR_SUCCESS || lError == ERROR_MORE_DATA)
 224         {
 225             TRACE("Key name: %s\n", debugstr_w(szKeyName));
 226
 227             if (RegOpenKeyExW(hClassesKey,
 228                               szKeyName,
 229                               0,
 230                               KEY_QUERY_VALUE,
 231                               &hClassKey))
 232             {
 233                 RegCloseKey(hClassesKey);
 234                 return FALSE;
 235             }
 236
 237             if (!RegQueryValueExW(hClassKey,
 238                                   REGSTR_VAL_NOUSECLASS,
 239                                   NULL,
 240                                   NULL,
 241                                   NULL,
 242                                   NULL))
 243             {
 244                 TRACE("'NoUseClass' value found!\n");
 245                 RegCloseKey(hClassKey);
 246                 continue;
 247             }
 248
 249             if ((Flags & DIBCI_NOINSTALLCLASS) &&
 250                 (!RegQueryValueExW(hClassKey,
 251                                    REGSTR_VAL_NOINSTALLCLASS,
 252                                    NULL,
 253                                    NULL,
 254                                    NULL,
 255                                    NULL)))
 256             {
 257                 TRACE("'NoInstallClass' value found!\n");
 258                 RegCloseKey(hClassKey);
 259                 continue;
 260             }
 261
 262             if ((Flags & DIBCI_NODISPLAYCLASS) &&
 263                 (!RegQueryValueExW(hClassKey,
 264                                    REGSTR_VAL_NODISPLAYCLASS,
 265                                    NULL,
 266                                    NULL,
 267                                    NULL,
 268                                    NULL)))
 269             {
 270                 TRACE("'NoDisplayClass' value found!\n");
 271                 RegCloseKey(hClassKey);
 272                 continue;
 273             }
 274
 275             RegCloseKey(hClassKey);
 276
 277             TRACE("Guid: %s\n", debugstr_w(szKeyName));
 278             if (dwGuidListIndex < ClassGuidListSize)
 279             {
 280                 if (szKeyName[0] == L'{' && szKeyName[37] == L'}')
 281                 {
 282                     szKeyName[37] = 0;
 283                 }
 284                 TRACE("Guid: %s\n", debugstr_w(&szKeyName[1]));
 285
 286                 UuidFromStringW(&szKeyName[1],
 287                                 &ClassGuidList[dwGuidListIndex]);
 288             }
 289
 290             dwGuidListIndex++;
 291         }
 292
 293         if (lError != ERROR_SUCCESS)
 294             break;
 295     }
 296
 297     RegCloseKey(hClassesKey);
 298
 299     if (RequiredSize != NULL)
 300         *RequiredSize = dwGuidListIndex;
 301
 302     if (ClassGuidListSize < dwGuidListIndex)
 303     {
 304         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 305         return FALSE;
 306     }
 307
 308     return TRUE;
 309 }
 310
 311 /***********************************************************************
 312  *              SetupDiClassGuidsFromNameA  (SETUPAPI.@)
 313  */
 314 BOOL WINAPI SetupDiClassGuidsFromNameA(
 315         LPCSTR ClassName,
 316         LPGUID ClassGuidList,
 317         DWORD ClassGuidListSize,
 318         PDWORD RequiredSize)
 319 {
 320   return SetupDiClassGuidsFromNameExA(ClassName, ClassGuidList,
 321                                       ClassGuidListSize, RequiredSize,
 322                                       NULL, NULL);
 323 }
 324
 325 /***********************************************************************
 326  *              SetupDiClassGuidsFromNameW  (SETUPAPI.@)
 327  */
 328 BOOL WINAPI SetupDiClassGuidsFromNameW(
 329         LPCWSTR ClassName,
 330         LPGUID ClassGuidList,
 331         DWORD ClassGuidListSize,
 332         PDWORD RequiredSize)
 333 {
 334   return SetupDiClassGuidsFromNameExW(ClassName, ClassGuidList,
 335                                       ClassGuidListSize, RequiredSize,
 336                                       NULL, NULL);
 337 }
 338
 339 /***********************************************************************
 340  *              SetupDiClassGuidsFromNameExA  (SETUPAPI.@)
 341  */
 342 BOOL WINAPI SetupDiClassGuidsFromNameExA(
 343         LPCSTR ClassName,
 344         LPGUID ClassGuidList,
 345         DWORD ClassGuidListSize,
 346         PDWORD RequiredSize,
 347         LPCSTR MachineName,
 348         PVOID Reserved)
 349 {
 350     LPWSTR ClassNameW = NULL;
 351     LPWSTR MachineNameW = NULL;
 352     BOOL bResult;
 353
 354     TRACE("\n");
 355
 356     ClassNameW = MultiByteToUnicode(ClassName, CP_ACP);
 357     if (ClassNameW == NULL)
 358         return FALSE;
 359
 360     if (MachineNameW)
 361     {
 362         MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
 363         if (MachineNameW == NULL)
 364         {
 365             MyFree(ClassNameW);
 366             return FALSE;
 367         }
 368     }
 369
 370     bResult = SetupDiClassGuidsFromNameExW(ClassNameW, ClassGuidList,
 371                                            ClassGuidListSize, RequiredSize,
 372                                            MachineNameW, Reserved);
 373
 374     if (MachineNameW)
 375         MyFree(MachineNameW);
 376
 377     MyFree(ClassNameW);
 378
 379     return bResult;
 380 }
 381
 382 /***********************************************************************
 383  *              SetupDiClassGuidsFromNameExW  (SETUPAPI.@)
 384  */
 385 BOOL WINAPI SetupDiClassGuidsFromNameExW(
 386         LPCWSTR ClassName,
 387         LPGUID ClassGuidList,
 388         DWORD ClassGuidListSize,
 389         PDWORD RequiredSize,
 390         LPCWSTR MachineName,
 391         PVOID Reserved)
 392 {
 393     WCHAR szKeyName[MAX_GUID_STRING_LEN + 1];
 394     WCHAR szClassName[256];
 395     HKEY hClassesKey;
 396     HKEY hClassKey;
 397     DWORD dwLength;
 398     DWORD dwIndex;
 399     LONG lError;
 400     DWORD dwGuidListIndex = 0;
 401
 402     TRACE("%s %p %lu %p %s %p\n", debugstr_w(ClassName), ClassGuidList,
 403         ClassGuidListSize, RequiredSize, debugstr_w(MachineName), Reserved);
 404
 405     if (RequiredSize != NULL)
 406         *RequiredSize = 0;
 407
 408     hClassesKey = SetupDiOpenClassRegKeyExW(NULL,
 409                                             KEY_ENUMERATE_SUB_KEYS,
 410                                             DIOCR_INSTALLER,
 411                                             MachineName,
 412                                             Reserved);
 413     if (hClassesKey == INVALID_HANDLE_VALUE)
 414     {
 415         return FALSE;
 416     }
 417
 418     for (dwIndex = 0; ; dwIndex++)
 419     {
 420         dwLength = MAX_GUID_STRING_LEN + 1;
 421         lError = RegEnumKeyExW(hClassesKey,
 422                                dwIndex,
 423                                szKeyName,
 424                                &dwLength,
 425                                NULL,
 426                                NULL,
 427                                NULL,
 428                                NULL);
 429         TRACE("RegEnumKeyExW() returns %ld\n", lError);
 430         if (lError == ERROR_SUCCESS || lError == ERROR_MORE_DATA)
 431         {
 432             TRACE("Key name: %s\n", debugstr_w(szKeyName));
 433
 434             if (RegOpenKeyExW(hClassesKey,
 435                               szKeyName,
 436                               0,
 437                               KEY_QUERY_VALUE,
 438                               &hClassKey))
 439             {
 440                 RegCloseKey(hClassesKey);
 441                 return FALSE;
 442             }
 443
 444             dwLength = 256 * sizeof(WCHAR);
 445             if (!RegQueryValueExW(hClassKey,
 446                                   Class,
 447                                   NULL,
 448                                   NULL,
 449                                   (LPBYTE)szClassName,
 450                                   &dwLength))
 451             {
 452                 TRACE("Class name: %s\n", debugstr_w(szClassName));
 453
 454                 if (strcmpiW(szClassName, ClassName) == 0)
 455                 {
 456                     TRACE("Found matching class name\n");
 457
 458                     TRACE("Guid: %s\n", debugstr_w(szKeyName));
 459                     if (dwGuidListIndex < ClassGuidListSize)
 460                     {
 461                         if (szKeyName[0] == L'{' && szKeyName[37] == L'}')
 462                         {
 463                             szKeyName[37] = 0;
 464                         }
 465                         TRACE("Guid: %s\n", debugstr_w(&szKeyName[1]));
 466
 467                         UuidFromStringW(&szKeyName[1],
 468                                         &ClassGuidList[dwGuidListIndex]);
 469                     }
 470
 471                     dwGuidListIndex++;
 472                 }
 473             }
 474
 475             RegCloseKey(hClassKey);
 476         }
 477
 478         if (lError != ERROR_SUCCESS)
 479             break;
 480     }
 481
 482     RegCloseKey(hClassesKey);
 483
 484     if (RequiredSize != NULL)
 485         *RequiredSize = dwGuidListIndex;
 486
 487     if (ClassGuidListSize < dwGuidListIndex)
 488     {
 489         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 490         return FALSE;
 491     }
 492
 493     return TRUE;
 494 }
 495
 496 /***********************************************************************
 497  *              SetupDiClassNameFromGuidA  (SETUPAPI.@)
 498  */
 499 BOOL WINAPI SetupDiClassNameFromGuidA(
 500         const GUID* ClassGuid,
 501         PSTR ClassName,
 502         DWORD ClassNameSize,
 503         PDWORD RequiredSize)
 504 {
 505   return SetupDiClassNameFromGuidExA(ClassGuid, ClassName,
 506                                      ClassNameSize, RequiredSize,
 507                                      NULL, NULL);
 508 }
 509
 510 /***********************************************************************
 511  *              SetupDiClassNameFromGuidW  (SETUPAPI.@)
 512  */
 513 BOOL WINAPI SetupDiClassNameFromGuidW(
 514         const GUID* ClassGuid,
 515         PWSTR ClassName,
 516         DWORD ClassNameSize,
 517         PDWORD RequiredSize)
 518 {
 519   return SetupDiClassNameFromGuidExW(ClassGuid, ClassName,
 520                                      ClassNameSize, RequiredSize,
 521                                      NULL, NULL);
 522 }
 523
 524 /***********************************************************************
 525  *              SetupDiClassNameFromGuidExA  (SETUPAPI.@)
 526  */
 527 BOOL WINAPI SetupDiClassNameFromGuidExA(
 528         const GUID* ClassGuid,
 529         PSTR ClassName,
 530         DWORD ClassNameSize,
 531         PDWORD RequiredSize,
 532         PCSTR MachineName,
 533         PVOID Reserved)
 534 {
 535     WCHAR ClassNameW[MAX_CLASS_NAME_LEN];
 536     LPWSTR MachineNameW = NULL;
 537     BOOL ret;
 538
 539     if (MachineName)
 540         MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
 541     ret = SetupDiClassNameFromGuidExW(ClassGuid, ClassNameW, MAX_CLASS_NAME_LEN,
 542      NULL, MachineNameW, Reserved);
 543     if (ret)
 544     {
 545         int len = WideCharToMultiByte(CP_ACP, 0, ClassNameW, -1, ClassName,
 546          ClassNameSize, NULL, NULL);
 547
 548         if (!ClassNameSize && RequiredSize)
 549             *RequiredSize = len;
 550     }
 551     MyFree(MachineNameW);
 552     return ret;
 553 }
 554
 555 /***********************************************************************
 556  *              SetupDiClassNameFromGuidExW  (SETUPAPI.@)
 557  */
 558 BOOL WINAPI SetupDiClassNameFromGuidExW(
 559         const GUID* ClassGuid,
 560         PWSTR ClassName,
 561         DWORD ClassNameSize,
 562         PDWORD RequiredSize,
 563         PCWSTR MachineName,
 564         PVOID Reserved)
 565 {
 566     HKEY hKey;
 567     DWORD dwLength;
 568     LONG rc;
 569
 570     TRACE("%s %p %lu %p %s %p\n", debugstr_guid(ClassGuid), ClassName,
 571         ClassNameSize, RequiredSize, debugstr_w(MachineName), Reserved);
 572
 573     hKey = SetupDiOpenClassRegKeyExW(ClassGuid,
 574                                      KEY_QUERY_VALUE,
 575                                      DIOCR_INSTALLER,
 576                                      MachineName,
 577                                      Reserved);
 578     if (hKey == INVALID_HANDLE_VALUE)
 579     {
 580         return FALSE;
 581     }
 582
 583     if (RequiredSize != NULL)
 584     {
 585         dwLength = 0;
 586         rc = RegQueryValueExW(hKey,
 587                              Class,
 588                              NULL,
 589                              NULL,
 590                              NULL,
 591                              &dwLength);
 592         if (rc != ERROR_SUCCESS)
 593         {
 594             SetLastError(rc);
 595             RegCloseKey(hKey);
 596             return FALSE;
 597         }
 598
 599         *RequiredSize = dwLength / sizeof(WCHAR);
 600     }
 601
 602     dwLength = ClassNameSize * sizeof(WCHAR);
 603     rc = RegQueryValueExW(hKey,
 604                          Class,
 605                          NULL,
 606                          NULL,
 607                          (LPBYTE)ClassName,
 608                          &dwLength);
 609     if (rc != ERROR_SUCCESS)
 610     {
 611         SetLastError(rc);
 612         RegCloseKey(hKey);
 613         return FALSE;
 614     }
 615
 616     RegCloseKey(hKey);
 617
 618     return TRUE;
 619 }
 620
 621 /***********************************************************************
 622  *              SetupDiCreateDeviceInfoList (SETUPAPI.@)
 623  */
 624 HDEVINFO WINAPI
 625 SetupDiCreateDeviceInfoList(const GUID *ClassGuid,
 626                             HWND hwndParent)
 627 {
 628   return SetupDiCreateDeviceInfoListExW(ClassGuid, hwndParent, NULL, NULL);
 629 }
 630
 631 /***********************************************************************
 632  *              SetupDiCreateDeviceInfoListExA (SETUPAPI.@)
 633  */
 634 HDEVINFO WINAPI
 635 SetupDiCreateDeviceInfoListExA(const GUID *ClassGuid,
 636                                HWND hwndParent,
 637                                PCSTR MachineName,
 638                                PVOID Reserved)
 639 {
 640     LPWSTR MachineNameW = NULL;
 641     HDEVINFO hDevInfo;
 642
 643     TRACE("%s %p %s %p\n", debugstr_guid(ClassGuid), hwndParent,
 644       debugstr_a(MachineName), Reserved);
 645
 646     if (MachineName)
 647     {
 648         MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
 649         if (MachineNameW == NULL)
 650             return (HDEVINFO)INVALID_HANDLE_VALUE;
 651     }
 652
 653     hDevInfo = SetupDiCreateDeviceInfoListExW(ClassGuid, hwndParent,
 654                                               MachineNameW, Reserved);
 655
 656     if (MachineNameW)
 657         MyFree(MachineNameW);
 658
 659     return hDevInfo;
 660 }
 661
 662 static DWORD
 663 GetErrorCodeFromCrCode(const IN CONFIGRET cr)
 664 {
 665   switch (cr)
 666   {
 667     case CR_INVALID_MACHINENAME: return ERROR_INVALID_COMPUTERNAME;
 668     case CR_OUT_OF_MEMORY: return ERROR_NOT_ENOUGH_MEMORY;
 669     case CR_SUCCESS: return ERROR_SUCCESS;
 670     default:
 671       /* FIXME */
 672       return ERROR_GEN_FAILURE;
 673   }
 674
 675   /* Does not happen */
 676 }
 677
 678 /***********************************************************************
 679  *              SetupDiCreateDeviceInfoListExW (SETUPAPI.@)
 680  */
 681 HDEVINFO WINAPI
 682 SetupDiCreateDeviceInfoListExW(const GUID *ClassGuid,
 683                                HWND hwndParent,
 684                                PCWSTR MachineName,
 685                                PVOID Reserved)
 686 {
 687   struct DeviceInfoSet *list;
 688   LPWSTR UNCServerName = NULL;
 689   DWORD size;
 690   DWORD rc;
 691   //CONFIGRET cr;
 692   HDEVINFO ret = (HDEVINFO)INVALID_HANDLE_VALUE;;
 693
 694   TRACE("%s %p %s %p\n", debugstr_guid(ClassGuid), hwndParent,
 695       debugstr_w(MachineName), Reserved);
 696
 697   size = FIELD_OFFSET(struct DeviceInfoSet, szData);
 698   if (MachineName)
 699     size += (wcslen(MachineName) + 3) * sizeof(WCHAR);
 700   list = HeapAlloc(GetProcessHeap(), 0, size);
 701   if (!list)
 702   {
 703     SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 704     goto cleanup;
 705   }
 706   memset(list, 0, sizeof(struct DeviceInfoSet));
 707
 708   list->magic = SETUP_DEV_INFO_SET_MAGIC;
 709   memcpy(
 710     &list->ClassGuid,
 711     ClassGuid ? ClassGuid : &GUID_NULL,
 712     sizeof(list->ClassGuid));
 713   list->InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
 714   list->InstallParams.Flags |= DI_CLASSINSTALLPARAMS;
 715   list->InstallParams.hwndParent = hwndParent;
 716   if (MachineName)
 717   {
 718     rc = RegConnectRegistryW(MachineName, HKEY_LOCAL_MACHINE, &list->HKLM);
 719     if (rc != ERROR_SUCCESS)
 720     {
 721       SetLastError(rc);
 722       goto cleanup;
 723     }
 724     UNCServerName = HeapAlloc(GetProcessHeap(), 0, (strlenW(MachineName) + 3) * sizeof(WCHAR));
 725     if (!UNCServerName)
 726     {
 727       SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 728       goto cleanup;
 729     }
 730
 731     strcpyW(UNCServerName + 2, MachineName);
 732     list->szData[0] = list->szData[1] = '\\';
 733     strcpyW(list->szData + 2, MachineName);
 734     list->MachineName = list->szData;
 735   }
 736   else
 737   {
 738     DWORD Size = MAX_PATH;
 739     list->HKLM = HKEY_LOCAL_MACHINE;
 740     UNCServerName = HeapAlloc(GetProcessHeap(), 0, (MAX_PATH + 2) * sizeof(WCHAR));
 741     if (!UNCServerName)
 742     {
 743       SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 744       goto cleanup;
 745     }
 746     if (!GetComputerNameW(UNCServerName + 2, &Size))
 747       goto cleanup;
 748     list->MachineName = NULL;
 749   }
 750 #if 0
 751   UNCServerName[0] = UNCServerName[1] = '\\';
 752   cr = CM_Connect_MachineW(UNCServerName, &list->hMachine);
 753   if (cr != CR_SUCCESS)
 754   {
 755     SetLastError(GetErrorCodeFromCrCode(cr));
 756     goto cleanup;
 757   }
 758 #endif
 759   InitializeListHead(&list->DriverListHead);
 760   InitializeListHead(&list->ListHead);
 761
 762   ret = (HDEVINFO)list;
 763
 764 cleanup:
 765   if (ret == INVALID_HANDLE_VALUE)
 766   {
 767     if (list && list->HKLM != 0 && list->HKLM != HKEY_LOCAL_MACHINE)
 768       RegCloseKey(list->HKLM);
 769     HeapFree(GetProcessHeap(), 0, list);
 770   }
 771   HeapFree(GetProcessHeap(), 0, UNCServerName);
 772   return ret;
 773 }
 774
 775 /***********************************************************************
 776  *              SetupDiEnumDeviceInfo (SETUPAPI.@)
 777  */
 778 BOOL WINAPI SetupDiEnumDeviceInfo(
 779         HDEVINFO DeviceInfoSet,
 780         DWORD MemberIndex,
 781         PSP_DEVINFO_DATA DeviceInfoData)
 782 {
 783     BOOL ret = FALSE;
 784
 785     TRACE("%p, 0x%08lx, %p\n", DeviceInfoSet, MemberIndex, DeviceInfoData);
 786     if (!DeviceInfoData)
 787         SetLastError(ERROR_INVALID_PARAMETER);
 788     else if (DeviceInfoSet && DeviceInfoSet != (HDEVINFO)INVALID_HANDLE_VALUE)
 789     {
 790         struct DeviceInfoSet *list = (struct DeviceInfoSet *)DeviceInfoSet;
 791
 792         if (list->magic != SETUP_DEV_INFO_SET_MAGIC)
 793             SetLastError(ERROR_INVALID_HANDLE);
 794         else if (DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
 795             SetLastError(ERROR_INVALID_USER_BUFFER);
 796         else
 797         {
 798             PLIST_ENTRY ItemList = list->ListHead.Flink;
 799             while (ItemList != &list->ListHead && MemberIndex-- > 0)
 800                 ItemList = ItemList->Flink;
 801             if (ItemList == &list->ListHead)
 802                 SetLastError(ERROR_NO_MORE_ITEMS);
 803             else
 804             {
 805                 struct DeviceInfoElement *DevInfo = (struct DeviceInfoElement *)ItemList;
 806                 memcpy(&DeviceInfoData->ClassGuid,
 807                     &DevInfo->ClassGuid,
 808                     sizeof(GUID));
 809                 DeviceInfoData->DevInst = DevInfo->dnDevInst;
 810                 DeviceInfoData->Reserved = (ULONG_PTR)DevInfo;
 811                 ret = TRUE;
 812             }
 813         }
 814     }
 815     else
 816         SetLastError(ERROR_INVALID_HANDLE);
 817     return ret;
 818 }
 819
 820 /***********************************************************************
 821  *              SetupDiGetActualSectionToInstallA (SETUPAPI.@)
 822  */
 823 BOOL WINAPI
 824 SetupDiGetActualSectionToInstallA(
 825         IN HINF InfHandle,
 826         IN PCSTR InfSectionName,
 827         OUT PSTR InfSectionWithExt OPTIONAL,
 828         IN DWORD InfSectionWithExtSize,
 829         OUT PDWORD RequiredSize OPTIONAL,
 830         OUT PSTR *Extension OPTIONAL)
 831 {
 832     return SetupDiGetActualSectionToInstallExA(InfHandle, InfSectionName,
 833         NULL, InfSectionWithExt, InfSectionWithExtSize, RequiredSize,
 834         Extension, NULL);
 835 }
 836
 837 /***********************************************************************
 838  *              SetupDiGetActualSectionToInstallW (SETUPAPI.@)
 839  */
 840 BOOL WINAPI
 841 SetupDiGetActualSectionToInstallW(
 842         IN HINF InfHandle,
 843         IN PCWSTR InfSectionName,
 844         OUT PWSTR InfSectionWithExt OPTIONAL,
 845         IN DWORD InfSectionWithExtSize,
 846         OUT PDWORD RequiredSize OPTIONAL,
 847         OUT PWSTR *Extension OPTIONAL)
 848 {
 849     return SetupDiGetActualSectionToInstallExW(InfHandle, InfSectionName,
 850         NULL, InfSectionWithExt, InfSectionWithExtSize, RequiredSize,
 851         Extension, NULL);
 852 }
 853
 854 /***********************************************************************
 855  *              SetupDiGetActualSectionToInstallExA  (SETUPAPI.@)
 856  */
 857 BOOL WINAPI
 858 SetupDiGetActualSectionToInstallExA(
 859         IN HINF InfHandle,
 860         IN PCSTR InfSectionName,
 861         IN PSP_ALTPLATFORM_INFO AlternatePlatformInfo OPTIONAL,
 862         OUT PSTR InfSectionWithExt OPTIONAL,
 863         IN DWORD InfSectionWithExtSize,
 864         OUT PDWORD RequiredSize OPTIONAL,
 865         OUT PSTR* Extension OPTIONAL,
 866         IN PVOID Reserved)
 867 {
 868     LPWSTR InfSectionNameW = NULL;
 869     LPWSTR InfSectionWithExtW = NULL;
 870     PWSTR ExtensionW;
 871     BOOL bResult = FALSE;
 872
 873     TRACE("\n");
 874
 875     if (InfSectionName)
 876     {
 877         InfSectionNameW = MultiByteToUnicode(InfSectionName, CP_ACP);
 878         if (InfSectionNameW == NULL)
 879             goto cleanup;
 880     }
 881     if (InfSectionWithExt)
 882     {
 883         InfSectionWithExtW = MyMalloc(InfSectionWithExtSize * sizeof(WCHAR));
 884         if (InfSectionWithExtW == NULL)
 885             goto cleanup;
 886     }
 887
 888     bResult = SetupDiGetActualSectionToInstallExW(
 889         InfHandle, InfSectionNameW, AlternatePlatformInfo,
 890         InfSectionWithExt ? InfSectionWithExtW : NULL,
 891         InfSectionWithExtSize,
 892         RequiredSize,
 893         Extension ? &ExtensionW : NULL,
 894         Reserved);
 895
 896     if (bResult && InfSectionWithExt)
 897     {
 898          bResult = WideCharToMultiByte(CP_ACP, 0, InfSectionWithExtW, -1, InfSectionWithExt,
 899              InfSectionWithExtSize, NULL, NULL) != 0;
 900     }
 901     if (bResult && Extension)
 902     {
 903         if (ExtensionW == NULL)
 904             *Extension = NULL;
 905          else
 906             *Extension = &InfSectionWithExt[ExtensionW - InfSectionWithExtW];
 907     }
 908
 909 cleanup:
 910     MyFree(InfSectionNameW);
 911     MyFree(InfSectionWithExtW);
 912
 913     return bResult;
 914 }
 915
 916 /***********************************************************************
 917  *              SetupDiGetActualSectionToInstallExW (SETUPAPI.@)
 918  */
 919 BOOL WINAPI
 920 SetupDiGetActualSectionToInstallExW(
 921         IN HINF InfHandle,
 922         IN PCWSTR InfSectionName,
 923         IN PSP_ALTPLATFORM_INFO AlternatePlatformInfo OPTIONAL,
 924         OUT PWSTR InfSectionWithExt OPTIONAL,
 925         IN DWORD InfSectionWithExtSize,
 926         OUT PDWORD RequiredSize OPTIONAL,
 927         OUT PWSTR* Extension OPTIONAL,
 928         IN PVOID Reserved)
 929 {
 930     BOOL ret = FALSE;
 931
 932     TRACE("%p %s %p %p %lu %p %p %p\n", InfHandle, debugstr_w(InfSectionName),
 933         AlternatePlatformInfo, InfSectionWithExt, InfSectionWithExtSize,
 934         RequiredSize, Extension, Reserved);
 935
 936     if (!InfHandle || InfHandle == (HINF)INVALID_HANDLE_VALUE)
 937         SetLastError(ERROR_INVALID_HANDLE);
 938     else if (!InfSectionName)
 939         SetLastError(ERROR_INVALID_PARAMETER);
 940     else if (AlternatePlatformInfo && AlternatePlatformInfo->cbSize != sizeof(SP_ALTPLATFORM_INFO))
 941         SetLastError(ERROR_INVALID_USER_BUFFER);
 942     else if (Reserved != NULL)
 943         SetLastError(ERROR_INVALID_PARAMETER);
 944     else
 945     {
 946         static SP_ALTPLATFORM_INFO CurrentPlatform = { 0, };
 947         PSP_ALTPLATFORM_INFO pPlatformInfo = &CurrentPlatform;
 948         LPCWSTR pExtensionPlatform, pExtensionArchitecture;
 949         WCHAR SectionName[LINE_LEN + 1];
 950         LONG lLineCount = -1;
 951         DWORD dwFullLength;
 952
 953         /* Fill platform info if needed */
 954         if (AlternatePlatformInfo)
 955             pPlatformInfo = AlternatePlatformInfo;
 956         else if (CurrentPlatform.cbSize != sizeof(SP_ALTPLATFORM_INFO))
 957         {
 958             /* That's the first time we go here. We need to fill in the structure */
 959             OSVERSIONINFO VersionInfo;
 960             SYSTEM_INFO SystemInfo;
 961             VersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
 962             ret = GetVersionEx(&VersionInfo);
 963             if (!ret)
 964                 goto done;
 965             GetSystemInfo(&SystemInfo);
 966             CurrentPlatform.cbSize = sizeof(SP_ALTPLATFORM_INFO);
 967             CurrentPlatform.Platform = VersionInfo.dwPlatformId;
 968             CurrentPlatform.MajorVersion = VersionInfo.dwMajorVersion;
 969             CurrentPlatform.MinorVersion = VersionInfo.dwMinorVersion;
 970             CurrentPlatform.ProcessorArchitecture = SystemInfo.wProcessorArchitecture;
 971             CurrentPlatform.Reserved = 0;
 972         }
 973
 974 static const WCHAR ExtensionPlatformNone[]  = {'.',0};
 975 static const WCHAR ExtensionPlatformNT[]  = {'.','N','T',0};
 976 static const WCHAR ExtensionPlatformWindows[]  = {'.','W','i','n',0};
 977
 978 static const WCHAR ExtensionArchitectureNone[]  = {0};
 979 static const WCHAR ExtensionArchitectureamd64[]  = {'a','m','d','6','4',0};
 980 static const WCHAR ExtensionArchitectureppc[]  = {'p','p','c',0};
 981 static const WCHAR ExtensionArchitecturex86[]  = {'x','8','6',0};
 982
 983         /* Set various extensions values */
 984         switch (pPlatformInfo->Platform)
 985         {
 986             case VER_PLATFORM_WIN32_WINDOWS:
 987                 pExtensionPlatform = ExtensionPlatformWindows;
 988                 break;
 989             case VER_PLATFORM_WIN32_NT:
 990                 pExtensionPlatform = ExtensionPlatformNT;
 991                 break;
 992             default:
 993                 pExtensionPlatform = ExtensionPlatformNone;
 994                 break;
 995         }
 996         switch (pPlatformInfo->ProcessorArchitecture)
 997         {
 998             case PROCESSOR_ARCHITECTURE_AMD64:
 999                 pExtensionArchitecture = ExtensionArchitectureamd64;
1000                 break;
1001             case PROCESSOR_ARCHITECTURE_INTEL:
1002                 pExtensionArchitecture = ExtensionArchitecturex86;
1003                 break;
1004             case PROCESSOR_ARCHITECTURE_PPC:
1005                 pExtensionArchitecture = ExtensionArchitectureppc;
1006                 break;
1007             default:
1008                 ERR("Unknown processor architecture 0x%x\n", pPlatformInfo->ProcessorArchitecture);
1009             case PROCESSOR_ARCHITECTURE_UNKNOWN:
1010                 pExtensionArchitecture = ExtensionArchitectureNone;
1011                 break;
1012         }
1013
1014         SectionName[LINE_LEN] = UNICODE_NULL;
1015
1016         /* Test with platform.architecture.major.minor extension */
1017         snprintfW(SectionName, LINE_LEN, L"%s%s%s.%lu.%lu", InfSectionName,
1018             pExtensionPlatform, pExtensionArchitecture, pPlatformInfo->MajorVersion, pPlatformInfo->MinorVersion);
1019         lLineCount = SetupGetLineCountW(InfHandle, SectionName);
1020         if (lLineCount != -1) goto sectionfound;
1021
1022         /* Test with platform.major.minor extension */
1023         snprintfW(SectionName, LINE_LEN, L"%s%s.%lu.%lu", InfSectionName,
1024             pExtensionPlatform, pPlatformInfo->MajorVersion, pPlatformInfo->MinorVersion);
1025         lLineCount = SetupGetLineCountW(InfHandle, SectionName);
1026         if (lLineCount != -1) goto sectionfound;
1027
1028         /* Test with platform.architecture.major extension */
1029         snprintfW(SectionName, LINE_LEN, L"%s%s%s.%lu", InfSectionName,
1030             pExtensionPlatform, pExtensionArchitecture, pPlatformInfo->MajorVersion);
1031         lLineCount = SetupGetLineCountW(InfHandle, SectionName);
1032         if (lLineCount != -1) goto sectionfound;
1033
1034         /* Test with platform.major extension */
1035         snprintfW(SectionName, LINE_LEN, L"%s%s.%lu", InfSectionName,
1036             pExtensionPlatform, pPlatformInfo->MajorVersion);
1037         lLineCount = SetupGetLineCountW(InfHandle, SectionName);
1038         if (lLineCount != -1) goto sectionfound;
1039
1040         /* Test with platform.architecture extension */
1041         snprintfW(SectionName, LINE_LEN, L"%s%s%s", InfSectionName,
1042             pExtensionPlatform, pExtensionArchitecture);
1043         lLineCount = SetupGetLineCountW(InfHandle, SectionName);
1044         if (lLineCount != -1) goto sectionfound;
1045
1046         /* Test with platform extension */
1047         snprintfW(SectionName, LINE_LEN, L"%s%s", InfSectionName,
1048             pExtensionPlatform);
1049         lLineCount = SetupGetLineCountW(InfHandle, SectionName);
1050         if (lLineCount != -1) goto sectionfound;
1051
1052         /* Test without extension */
1053         snprintfW(SectionName, LINE_LEN, L"%s", InfSectionName);
1054         lLineCount = SetupGetLineCountW(InfHandle, SectionName);
1055         if (lLineCount != -1) goto sectionfound;
1056
1057         /* No appropriate section found */
1058         SetLastError(ERROR_INVALID_PARAMETER);
1059         goto done;
1060
1061 sectionfound:
1062         dwFullLength = lstrlenW(SectionName);
1063         if (InfSectionWithExt != NULL && InfSectionWithExtSize != 0)
1064         {
1065             if (InfSectionWithExtSize < (dwFullLength + 1))
1066             {
1067                 SetLastError(ERROR_INSUFFICIENT_BUFFER);
1068                 goto done;
1069             }
1070
1071             lstrcpyW(InfSectionWithExt, SectionName);
1072             if (Extension != NULL)
1073             {
1074                 DWORD dwLength = lstrlenW(SectionName);
1075                 *Extension = (dwLength == dwFullLength) ? NULL : &InfSectionWithExt[dwLength];
1076             }
1077         }
1078
1079         if (RequiredSize != NULL)
1080             *RequiredSize = dwFullLength + 1;
1081
1082         ret = TRUE;
1083     }
1084
1085 done:
1086     TRACE("Returning %d\n", ret);
1087     return ret;
1088 }
1089
1090
1091 /***********************************************************************
1092  *              SetupDiGetClassDescriptionA  (SETUPAPI.@)
1093  */
1094 BOOL WINAPI SetupDiGetClassDescriptionA(
1095         const GUID* ClassGuid,
1096         PSTR ClassDescription,
1097         DWORD ClassDescriptionSize,
1098         PDWORD RequiredSize)
1099 {
1100   return SetupDiGetClassDescriptionExA(ClassGuid, ClassDescription,
1101                                        ClassDescriptionSize,
1102                                        RequiredSize, NULL, NULL);
1103 }
1104
1105 /***********************************************************************
1106  *              SetupDiGetClassDescriptionW  (SETUPAPI.@)
1107  */
1108 BOOL WINAPI SetupDiGetClassDescriptionW(
1109         const GUID* ClassGuid,
1110         PWSTR ClassDescription,
1111         DWORD ClassDescriptionSize,
1112         PDWORD RequiredSize)
1113 {
1114   return SetupDiGetClassDescriptionExW(ClassGuid, ClassDescription,
1115                                        ClassDescriptionSize,
1116                                        RequiredSize, NULL, NULL);
1117 }
1118
1119 /***********************************************************************
1120  *              SetupDiGetClassDescriptionExA  (SETUPAPI.@)
1121  */
1122 BOOL WINAPI SetupDiGetClassDescriptionExA(
1123         const GUID* ClassGuid,
1124         PSTR ClassDescription,
1125         DWORD ClassDescriptionSize,
1126         PDWORD RequiredSize,
1127         PCSTR MachineName,
1128         PVOID Reserved)
1129 {
1130     PWCHAR ClassDescriptionW;
1131     LPWSTR MachineNameW = NULL;
1132     BOOL ret;
1133
1134     TRACE("\n");
1135     if (ClassDescriptionSize > 0)
1136     {
1137         ClassDescriptionW = HeapAlloc(GetProcessHeap(), 0, ClassDescriptionSize * sizeof(WCHAR));
1138         if (!ClassDescriptionW)
1139         {
1140             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1141             ret = FALSE;
1142             goto end;
1143         }
1144     }
1145     else
1146         ClassDescriptionW = NULL;
1147
1148     if (MachineName)
1149     {
1150         MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
1151         if (!MachineNameW)
1152         {
1153             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1154             ret = FALSE;
1155             goto end;
1156         }
1157     }
1158
1159     ret = SetupDiGetClassDescriptionExW(ClassGuid, ClassDescriptionW, ClassDescriptionSize * sizeof(WCHAR),
1160      NULL, MachineNameW, Reserved);
1161     if (ret)
1162     {
1163         int len = WideCharToMultiByte(CP_ACP, 0, ClassDescriptionW, -1, ClassDescription,
1164          ClassDescriptionSize, NULL, NULL);
1165
1166         if (!ClassDescriptionSize && RequiredSize)
1167             *RequiredSize = len;
1168     }
1169
1170 end:
1171     HeapFree(GetProcessHeap(), 0, ClassDescriptionW);
1172     MyFree(MachineNameW);
1173     return ret;
1174 }
1175
1176 /***********************************************************************
1177  *              SetupDiGetClassDescriptionExW  (SETUPAPI.@)
1178  */
1179 BOOL WINAPI SetupDiGetClassDescriptionExW(
1180         const GUID* ClassGuid,
1181         PWSTR ClassDescription,
1182         DWORD ClassDescriptionSize,
1183         PDWORD RequiredSize,
1184         PCWSTR MachineName,
1185         PVOID Reserved)
1186 {
1187     HKEY hKey;
1188     DWORD dwLength;
1189
1190     TRACE("%s %p %lu %p %s %p\n", debugstr_guid(ClassGuid), ClassDescription,
1191         ClassDescriptionSize, RequiredSize, debugstr_w(MachineName), Reserved);
1192
1193     hKey = SetupDiOpenClassRegKeyExW(ClassGuid,
1194                                      KEY_QUERY_VALUE,
1195                                      DIOCR_INSTALLER,
1196                                      MachineName,
1197                                      Reserved);
1198     if (hKey == INVALID_HANDLE_VALUE)
1199     {
1200         WARN("SetupDiOpenClassRegKeyExW() failed (Error %lu)\n", GetLastError());
1201         return FALSE;
1202     }
1203
1204     if (RequiredSize != NULL)
1205     {
1206         dwLength = 0;
1207         if (RegQueryValueExW(hKey,
1208                              NULL,
1209                              NULL,
1210                              NULL,
1211                              NULL,
1212                              &dwLength))
1213         {
1214             RegCloseKey(hKey);
1215             return FALSE;
1216         }
1217
1218         *RequiredSize = dwLength / sizeof(WCHAR);
1219     }
1220
1221     dwLength = ClassDescriptionSize * sizeof(WCHAR);
1222     if (RegQueryValueExW(hKey,
1223                          NULL,
1224                          NULL,
1225                          NULL,
1226                          (LPBYTE)ClassDescription,
1227                          &dwLength))
1228     {
1229         RegCloseKey(hKey);
1230         return FALSE;
1231     }
1232
1233     RegCloseKey(hKey);
1234
1235     return TRUE;
1236 }
1237
1238 /***********************************************************************
1239  *              SetupDiGetClassDevsA (SETUPAPI.@)
1240  */
1241 HDEVINFO WINAPI SetupDiGetClassDevsA(
1242        CONST GUID *class,
1243        LPCSTR enumstr,
1244        HWND parent,
1245        DWORD flags)
1246 {
1247     return SetupDiGetClassDevsExA(class, enumstr, parent,
1248                                   flags, NULL, NULL, NULL);
1249 }
1250
1251 /***********************************************************************
1252  *              SetupDiGetClassDevsW (SETUPAPI.@)
1253  */
1254 HDEVINFO WINAPI SetupDiGetClassDevsW(
1255        CONST GUID *class,
1256        LPCWSTR enumstr,
1257        HWND parent,
1258        DWORD flags)
1259 {
1260     return SetupDiGetClassDevsExW(class, enumstr, parent,
1261                                   flags, NULL, NULL, NULL);
1262 }
1263
1264 /***********************************************************************
1265  *              SetupDiGetClassDevsExA (SETUPAPI.@)
1266  */
1267 HDEVINFO WINAPI SetupDiGetClassDevsExA(
1268        CONST GUID *class,
1269        LPCSTR enumstr,
1270        HWND parent,
1271        DWORD flags,
1272        HDEVINFO deviceset,
1273        LPCSTR machine,
1274        PVOID reserved)
1275 {
1276     HDEVINFO ret;
1277     LPWSTR enumstrW = NULL;
1278     LPWSTR machineW = NULL;
1279
1280     if (enumstr)
1281     {
1282         int len = MultiByteToWideChar(CP_ACP, 0, enumstr, -1, NULL, 0);
1283         enumstrW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1284         if (!enumstrW)
1285         {
1286             ret = (HDEVINFO)INVALID_HANDLE_VALUE;
1287             goto end;
1288         }
1289         MultiByteToWideChar(CP_ACP, 0, enumstr, -1, enumstrW, len);
1290     }
1291     if (machine)
1292     {
1293         int len = MultiByteToWideChar(CP_ACP, 0, machine, -1, NULL, 0);
1294         machineW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1295         if (!machineW)
1296         {
1297             ret = (HDEVINFO)INVALID_HANDLE_VALUE;
1298             goto end;
1299         }
1300         MultiByteToWideChar(CP_ACP, 0, machine, -1, machineW, len);
1301     }
1302     ret = SetupDiGetClassDevsExW(class, enumstrW, parent, flags, deviceset, machineW, reserved);
1303
1304 end:
1305     HeapFree(GetProcessHeap(), 0, enumstrW);
1306     HeapFree(GetProcessHeap(), 0, machineW);
1307     return ret;
1308 }
1309
1310 static BOOL
1311 CreateDeviceInfoElement(
1312     IN struct DeviceInfoSet *list,
1313     IN LPCWSTR InstancePath,
1314     IN LPCGUID pClassGuid,
1315     OUT struct DeviceInfoElement **pDeviceInfo)
1316 {
1317     DWORD size;
1318     CONFIGRET cr;
1319     struct DeviceInfoElement *deviceInfo;
1320
1321     *pDeviceInfo = NULL;
1322
1323     size = FIELD_OFFSET(struct DeviceInfoElement, Data) + (wcslen(InstancePath) + 1) * sizeof(WCHAR);
1324     deviceInfo = HeapAlloc(GetProcessHeap(), 0, size);
1325     if (!deviceInfo)
1326     {
1327         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1328         return FALSE;
1329     }
1330     memset(deviceInfo, 0, size);
1331
1332     cr = CM_Locate_DevNode_ExW(&deviceInfo->dnDevInst, (DEVINSTID_W)InstancePath, CM_LOCATE_DEVNODE_PHANTOM, list->hMachine);
1333     if (cr != CR_SUCCESS)
1334     {
1335         SetLastError(GetErrorCodeFromCrCode(cr));
1336         return FALSE;
1337     }
1338
1339     deviceInfo->InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
1340     wcscpy(deviceInfo->Data, InstancePath);
1341     deviceInfo->DeviceName = deviceInfo->Data;
1342     deviceInfo->UniqueId = wcsrchr(deviceInfo->Data, '\\');
1343     deviceInfo->DeviceDescription = NULL;
1344     memcpy(&deviceInfo->ClassGuid, pClassGuid, sizeof(GUID));
1345     deviceInfo->CreationFlags = 0;
1346     InitializeListHead(&deviceInfo->DriverListHead);
1347     InitializeListHead(&deviceInfo->InterfaceListHead);
1348
1349     *pDeviceInfo = deviceInfo;
1350     return TRUE;
1351 }
1352
1353 static BOOL
1354 CreateDeviceInterface(
1355     IN struct DeviceInfoElement* deviceInfo,
1356     IN LPCWSTR SymbolicLink,
1357     IN LPCGUID pInterfaceGuid,
1358     OUT struct DeviceInterface **pDeviceInterface)
1359 {
1360     struct DeviceInterface *deviceInterface;
1361
1362     *pDeviceInterface = NULL;
1363
1364     deviceInterface = HeapAlloc(GetProcessHeap(), 0,
1365         FIELD_OFFSET(struct DeviceInterface, SymbolicLink) + (wcslen(SymbolicLink) + 1) * sizeof(WCHAR));
1366     if (!deviceInterface)
1367     {
1368         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1369         return FALSE;
1370     }
1371     deviceInterface->DeviceInfo = deviceInfo;
1372     wcscpy(deviceInterface->SymbolicLink, SymbolicLink);
1373     deviceInterface->Flags = 0; /* FIXME */
1374     memcpy(&deviceInterface->InterfaceClassGuid, pInterfaceGuid, sizeof(GUID));
1375
1376     *pDeviceInterface = deviceInterface;
1377     return TRUE;
1378 }
1379
1380 static LONG SETUP_CreateDevListFromEnumerator(
1381        struct DeviceInfoSet *list,
1382        LPCGUID pClassGuid OPTIONAL,
1383        LPCWSTR Enumerator,
1384        HKEY hEnumeratorKey) /* handle to Enumerator registry key */
1385 {
1386     HKEY hDeviceIdKey, hInstanceIdKey;
1387     WCHAR KeyBuffer[MAX_PATH];
1388     WCHAR InstancePath[MAX_PATH];
1389     LPWSTR pEndOfInstancePath; /* Pointer into InstancePath buffer */
1390     struct DeviceInfoElement *deviceInfo;
1391     DWORD i = 0, j;
1392     DWORD dwLength, dwRegType;
1393     DWORD rc;
1394
1395     /* Enumerate device IDs (subkeys of hEnumeratorKey) */
1396     while (TRUE)
1397     {
1398         dwLength = sizeof(KeyBuffer) / sizeof(KeyBuffer[0]);
1399         rc = RegEnumKeyExW(hEnumeratorKey, i, KeyBuffer, &dwLength, NULL, NULL, NULL, NULL);
1400         if (rc == ERROR_NO_MORE_ITEMS)
1401             break;
1402         if (rc != ERROR_SUCCESS)
1403             return rc;
1404         i++;
1405
1406         /* Open device id sub key */
1407         rc = RegOpenKeyExW(hEnumeratorKey, KeyBuffer, 0, KEY_ENUMERATE_SUB_KEYS, &hDeviceIdKey);
1408         if (rc != ERROR_SUCCESS)
1409             return rc;
1410         wcscpy(InstancePath, Enumerator);
1411         wcscat(InstancePath, L"\\");
1412         wcscat(InstancePath, KeyBuffer);
1413         wcscat(InstancePath, L"\\");
1414         pEndOfInstancePath = &InstancePath[wcslen(InstancePath)];
1415
1416         /* Enumerate instance IDs (subkeys of hDeviceIdKey) */
1417         j = 0;
1418         while (TRUE)
1419         {
1420             GUID KeyGuid;
1421
1422             dwLength = sizeof(KeyBuffer) / sizeof(KeyBuffer[0]);
1423             rc = RegEnumKeyExW(hDeviceIdKey, j, KeyBuffer, &dwLength, NULL, NULL, NULL, NULL);
1424             if (rc == ERROR_NO_MORE_ITEMS)
1425                 break;
1426             if (rc != ERROR_SUCCESS)
1427             {
1428                 RegCloseKey(hDeviceIdKey);
1429                 return rc;
1430             }
1431             j++;
1432
1433             /* Open instance id sub key */
1434             rc = RegOpenKeyExW(hDeviceIdKey, KeyBuffer, 0, KEY_QUERY_VALUE, &hInstanceIdKey);
1435             if (rc != ERROR_SUCCESS)
1436             {
1437                 RegCloseKey(hDeviceIdKey);
1438                 return rc;
1439             }
1440             *pEndOfInstancePath = '\0';
1441             wcscat(InstancePath, KeyBuffer);
1442
1443             /* Read ClassGUID value */
1444             dwLength = sizeof(KeyBuffer) - sizeof(WCHAR);
1445             rc = RegQueryValueExW(hInstanceIdKey, ClassGUID, NULL, &dwRegType, (LPBYTE)KeyBuffer, &dwLength);
1446             RegCloseKey(hInstanceIdKey);
1447             if (rc == ERROR_FILE_NOT_FOUND)
1448             {
1449                 if (pClassGuid)
1450                     /* Skip this bad entry as we can't verify it */
1451                     continue;
1452                 /* Set a default GUID for this device */
1453                 memcpy(&KeyGuid, &GUID_NULL, sizeof(GUID));
1454             }
1455             else if (rc != ERROR_SUCCESS)
1456             {
1457                 RegCloseKey(hDeviceIdKey);
1458                 return rc;
1459             }
1460             else if (dwRegType != REG_SZ)
1461             {
1462                 RegCloseKey(hDeviceIdKey);
1463                 return ERROR_GEN_FAILURE;
1464             }
1465             else
1466             {
1467                 KeyBuffer[37] = '\0'; /* Replace the } by a NULL character */
1468                 if (UuidFromStringW(&KeyBuffer[1], &KeyGuid) != RPC_S_OK)
1469                     /* Bad GUID, skip the entry */
1470                     continue;
1471             }
1472
1473             if (pClassGuid && !IsEqualIID(&KeyGuid, pClassGuid))
1474             {
1475                 /* Skip this entry as it is not the right device class */
1476                 continue;
1477             }
1478
1479             /* Add the entry to the list */
1480             if (!CreateDeviceInfoElement(list, InstancePath, &KeyGuid, &deviceInfo))
1481             {
1482                 RegCloseKey(hDeviceIdKey);
1483                 return GetLastError();
1484             }
1485             TRACE("Adding '%S' to device info set %p\n", InstancePath, list);
1486             InsertTailList(&list->ListHead, &deviceInfo->ListEntry);
1487         }
1488         RegCloseKey(hDeviceIdKey);
1489     }
1490
1491     return ERROR_SUCCESS;
1492 }
1493
1494 static LONG SETUP_CreateDevList(
1495        struct DeviceInfoSet *list,
1496        PCWSTR MachineName OPTIONAL,
1497        LPGUID class OPTIONAL,
1498        PCWSTR Enumerator OPTIONAL)
1499 {
1500     HKEY HKLM, hEnumKey, hEnumeratorKey;
1501     WCHAR KeyBuffer[MAX_PATH];
1502     DWORD i;
1503     DWORD dwLength;
1504     DWORD rc;
1505
1506     if (class && IsEqualIID(class, &GUID_NULL))
1507         class = NULL;
1508
1509     /* Open Enum key */
1510     if (MachineName != NULL)
1511     {
1512         rc = RegConnectRegistryW(MachineName, HKEY_LOCAL_MACHINE, &HKLM);
1513         if (rc != ERROR_SUCCESS)
1514             return rc;
1515     }
1516     else
1517         HKLM = HKEY_LOCAL_MACHINE;
1518
1519     rc = RegOpenKeyExW(HKLM,
1520         REGSTR_PATH_SYSTEMENUM,
1521         0,
1522         KEY_ENUMERATE_SUB_KEYS,
1523         &hEnumKey);
1524     if (MachineName != NULL) RegCloseKey(HKLM);
1525     if (rc != ERROR_SUCCESS)
1526         return rc;
1527
1528     /* If enumerator is provided, call directly SETUP_CreateDevListFromEnumerator.
1529      * Else, enumerate all enumerators and call SETUP_CreateDevListFromEnumerator
1530      * for each one.
1531      */
1532     if (Enumerator)
1533     {
1534         rc = RegOpenKeyExW(
1535             hEnumKey,
1536             Enumerator,
1537             0,
1538             KEY_ENUMERATE_SUB_KEYS,
1539             &hEnumeratorKey);
1540         RegCloseKey(hEnumKey);
1541         if (rc != ERROR_SUCCESS)
1542             return rc;
1543         rc = SETUP_CreateDevListFromEnumerator(list, class, Enumerator, hEnumeratorKey);
1544         RegCloseKey(hEnumeratorKey);
1545         return rc;
1546     }
1547     else
1548     {
1549         /* Enumerate enumerators */
1550         i = 0;
1551         while (TRUE)
1552         {
1553             dwLength = sizeof(KeyBuffer) / sizeof(KeyBuffer[0]);
1554             rc = RegEnumKeyExW(hEnumKey, i, KeyBuffer, &dwLength, NULL, NULL, NULL, NULL);
1555             if (rc == ERROR_NO_MORE_ITEMS)
1556                 break;
1557             if (rc != ERROR_SUCCESS)
1558             {
1559                 RegCloseKey(hEnumKey);
1560                 return rc;
1561             }
1562             i++;
1563
1564             /* Open sub key */
1565             rc = RegOpenKeyExW(hEnumKey, KeyBuffer, 0, KEY_ENUMERATE_SUB_KEYS, &hEnumeratorKey);
1566             if (rc != ERROR_SUCCESS)
1567             {
1568                 RegCloseKey(hEnumKey);
1569                 return rc;
1570             }
1571
1572             /* Call SETUP_CreateDevListFromEnumerator */
1573             rc = SETUP_CreateDevListFromEnumerator(list, class, KeyBuffer, hEnumeratorKey);
1574             RegCloseKey(hEnumeratorKey);
1575             if (rc != ERROR_SUCCESS)
1576             {
1577                 RegCloseKey(hEnumKey);
1578                 return rc;
1579             }
1580         }
1581         RegCloseKey(hEnumKey);
1582         return ERROR_SUCCESS;
1583     }
1584 }
1585
1586 #ifndef __REACTOS__
1587 static LONG SETUP_CreateSerialDeviceList(
1588        struct DeviceInfoSet *list,
1589        PCWSTR MachineName,
1590        LPGUID InterfaceGuid,
1591        PCWSTR DeviceInstanceW)
1592 {
1593     static const size_t initialSize = 100;
1594     size_t size;
1595     WCHAR buf[initialSize];
1596     LPWSTR devices;
1597     static const WCHAR devicePrefixW[] = { 'C','O','M',0 };
1598     LPWSTR ptr;
1599     struct DeviceInfoElement *deviceInfo;
1600
1601     if (MachineName)
1602         WARN("'MachineName' is ignored on Wine!\n");
1603     if (DeviceInstanceW)
1604         WARN("'DeviceInstanceW' can't be set on Wine!\n");
1605
1606     devices = buf;
1607     size = initialSize;
1608     while (TRUE)
1609     {
1610         if (QueryDosDeviceW(NULL, devices, size) != 0)
1611             break;
1612         if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
1613         {
1614             size *= 2;
1615             if (devices != buf)
1616                 HeapFree(GetProcessHeap(), 0, devices);
1617             devices = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
1618             if (!devices)
1619                 return ERROR_NOT_ENOUGH_MEMORY;
1620             *devices = '\0';
1621         }
1622         else
1623         {
1624             if (devices != buf)
1625                 HeapFree(GetProcessHeap(), 0, devices);
1626             return GetLastError();
1627         }
1628     }
1629
1630     /* 'devices' is a MULTI_SZ string */
1631     for (ptr = devices; *ptr; ptr += strlenW(ptr) + 1)
1632     {
1633         if (strncmpW(devicePrefixW, ptr, sizeof(devicePrefixW) / sizeof(devicePrefixW[0]) - 1) == 0)
1634         {
1635             /* We have found a device */
1636             struct DeviceInterface *interfaceInfo;
1637             TRACE("Adding %s to list\n", debugstr_w(ptr));
1638             /* Step 1. Create a device info element */
1639             if (!CreateDeviceInfoElement(list, ptr, &GUID_SERENUM_BUS_ENUMERATOR, &deviceInfo))
1640             {
1641                 if (devices != buf)
1642                     HeapFree(GetProcessHeap(), 0, devices);
1643                 return GetLastError();
1644             }
1645             InsertTailList(&list->ListHead, &deviceInfo->ListEntry);
1646
1647             /* Step 2. Create an interface list for this element */
1648             if (!CreateDeviceInterface(deviceInfo, ptr, InterfaceGuid, &interfaceInfo))
1649             {
1650                 if (devices != buf)
1651                     HeapFree(GetProcessHeap(), 0, devices);
1652                 return GetLastError();
1653             }
1654             InsertTailList(&deviceInfo->InterfaceListHead, &interfaceInfo->ListEntry);
1655         }
1656     }
1657     if (devices != buf)
1658         HeapFree(GetProcessHeap(), 0, devices);
1659     return ERROR_SUCCESS;
1660 }
1661
1662 #else /* __REACTOS__ */
1663
1664 static LONG SETUP_CreateInterfaceList(
1665        struct DeviceInfoSet *list,
1666        PCWSTR MachineName,
1667        LPGUID InterfaceGuid,
1668        PCWSTR DeviceInstanceW /* OPTIONAL */)
1669 {
1670     HKEY hInterfaceKey;      /* HKLM\SYSTEM\CurrentControlSet\Control\DeviceClasses\{GUID} */
1671     HKEY hDeviceInstanceKey; /* HKLM\SYSTEM\CurrentControlSet\Control\DeviceClasses\{GUID}\##?#{InstancePath} */
1672     HKEY hReferenceKey;      /* HKLM\SYSTEM\CurrentControlSet\Control\DeviceClasses\{GUID}\##?#{InstancePath}\#{ReferenceString} */
1673     HKEY hEnumKey;           /* HKLM\SYSTEM\CurrentControlSet\Enum */
1674     HKEY hKey;               /* HKLM\SYSTEM\CurrentControlSet\Enum\{Instance\Path} */
1675     LONG rc;
1676     WCHAR KeyBuffer[max(MAX_PATH, MAX_GUID_STRING_LEN) + 1];
1677     PWSTR InstancePath;
1678     DWORD i, j;
1679     DWORD dwLength, dwInstancePathLength;
1680     DWORD dwRegType;
1681     GUID ClassGuid;
1682     struct DeviceInfoElement *deviceInfo;
1683
1684     /* Open registry key related to this interface */
1685     hInterfaceKey = SetupDiOpenClassRegKeyExW(InterfaceGuid, KEY_ENUMERATE_SUB_KEYS, DIOCR_INTERFACE, MachineName, NULL);
1686     if (hInterfaceKey == INVALID_HANDLE_VALUE)
1687         return GetLastError();
1688
1689     /* Enumerate sub keys of hInterfaceKey */
1690     i = 0;
1691     while (TRUE)
1692     {
1693         dwLength = sizeof(KeyBuffer) / sizeof(KeyBuffer[0]);
1694         rc = RegEnumKeyExW(hInterfaceKey, i, KeyBuffer, &dwLength, NULL, NULL, NULL, NULL);
1695         if (rc == ERROR_NO_MORE_ITEMS)
1696             break;
1697         if (rc != ERROR_SUCCESS)
1698         {
1699             RegCloseKey(hInterfaceKey);
1700             return rc;
1701         }
1702         i++;
1703
1704         /* Open sub key */
1705         rc = RegOpenKeyExW(hInterfaceKey, KeyBuffer, 0, KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS, &hDeviceInstanceKey);
1706         if (rc != ERROR_SUCCESS)
1707         {
1708             RegCloseKey(hInterfaceKey);
1709             return rc;
1710         }
1711
1712         /* Read DeviceInstance */
1713         rc = RegQueryValueExW(hDeviceInstanceKey, DeviceInstance, NULL, &dwRegType, NULL, &dwInstancePathLength);
1714         if (rc != ERROR_SUCCESS )
1715         {
1716             RegCloseKey(hDeviceInstanceKey);
1717             RegCloseKey(hInterfaceKey);
1718             return rc;
1719         }
1720         if (dwRegType != REG_SZ)
1721         {
1722             RegCloseKey(hDeviceInstanceKey);
1723             RegCloseKey(hInterfaceKey);
1724             return ERROR_GEN_FAILURE;
1725         }
1726         InstancePath = HeapAlloc(GetProcessHeap(), 0, dwInstancePathLength + sizeof(WCHAR));
1727         if (!InstancePath)
1728         {
1729             RegCloseKey(hDeviceInstanceKey);
1730             RegCloseKey(hInterfaceKey);
1731             return ERROR_NOT_ENOUGH_MEMORY;
1732         }
1733         rc = RegQueryValueExW(hDeviceInstanceKey, DeviceInstance, NULL, NULL, (LPBYTE)InstancePath, &dwInstancePathLength);
1734         if (rc != ERROR_SUCCESS)
1735         {
1736             HeapFree(GetProcessHeap(), 0, InstancePath);
1737             RegCloseKey(hDeviceInstanceKey);
1738             RegCloseKey(hInterfaceKey);
1739             return rc;
1740         }
1741         InstancePath[dwInstancePathLength / sizeof(WCHAR)] = '\0';
1742         TRACE("DeviceInstance %s\n", debugstr_w(InstancePath));
1743
1744         if (DeviceInstanceW)
1745         {
1746             /* Check if device enumerator is not the right one */
1747             if (wcscmp(DeviceInstanceW, InstancePath) != 0)
1748             {
1749                 HeapFree(GetProcessHeap(), 0, InstancePath);
1750                 RegCloseKey(hDeviceInstanceKey);
1751                 continue;
1752             }
1753         }
1754
1755         /* Find class GUID associated to the device instance */
1756         rc = RegOpenKeyExW(
1757             list->HKLM,
1758             REGSTR_PATH_SYSTEMENUM,
1759             0, /* Options */
1760             0,
1761             &hEnumKey);
1762         if (rc != ERROR_SUCCESS)
1763         {
1764             HeapFree(GetProcessHeap(), 0, InstancePath);
1765             RegCloseKey(hDeviceInstanceKey);
1766             RegCloseKey(hInterfaceKey);
1767             return rc;
1768         }
1769         rc = RegOpenKeyExW(
1770             hEnumKey,
1771             InstancePath,
1772             0, /* Options */
1773             KEY_QUERY_VALUE,
1774             &hKey);
1775         RegCloseKey(hEnumKey);
1776         if (rc != ERROR_SUCCESS)
1777         {
1778             HeapFree(GetProcessHeap(), 0, InstancePath);
1779             RegCloseKey(hDeviceInstanceKey);
1780             RegCloseKey(hInterfaceKey);
1781             return rc;
1782         }
1783         dwLength = sizeof(KeyBuffer) - sizeof(WCHAR);
1784         rc = RegQueryValueExW(hKey, ClassGUID, NULL, NULL, (LPBYTE)KeyBuffer, &dwLength);
1785         RegCloseKey(hKey);
1786         if (rc != ERROR_SUCCESS)
1787         {
1788             HeapFree(GetProcessHeap(), 0, InstancePath);
1789             RegCloseKey(hDeviceInstanceKey);
1790             RegCloseKey(hInterfaceKey);
1791             return rc;
1792         }
1793         KeyBuffer[dwLength / sizeof(WCHAR)] = '\0';
1794         KeyBuffer[37] = '\0'; /* Replace the } by a NULL character */
1795         if (UuidFromStringW(&KeyBuffer[1], &ClassGuid) != RPC_S_OK)
1796         {
1797             HeapFree(GetProcessHeap(), 0, InstancePath);
1798             RegCloseKey(hDeviceInstanceKey);
1799             RegCloseKey(hInterfaceKey);
1800             return ERROR_GEN_FAILURE;
1801         }
1802         TRACE("ClassGUID %s\n", debugstr_guid(&ClassGuid));
1803
1804         /* If current device doesn't match the list GUID (if any), skip this entry */
1805         if (!IsEqualIID(&list->ClassGuid, &GUID_NULL) && !IsEqualIID(&list->ClassGuid, &ClassGuid))
1806         {
1807             HeapFree(GetProcessHeap(), 0, InstancePath);
1808             RegCloseKey(hDeviceInstanceKey);
1809             continue;
1810         }
1811
1812         /* Enumerate subkeys of hDeviceInstanceKey (ie "#ReferenceString" in IoRegisterDeviceInterface). Skip entries that don't start with '#' */
1813         j = 0;
1814         while (TRUE)
1815         {
1816             LPWSTR pSymbolicLink;
1817             struct DeviceInterface *interfaceInfo;
1818
1819             dwLength = sizeof(KeyBuffer) / sizeof(KeyBuffer[0]);
1820             rc = RegEnumKeyExW(hDeviceInstanceKey, j, KeyBuffer, &dwLength, NULL, NULL, NULL, NULL);
1821             if (rc == ERROR_NO_MORE_ITEMS)
1822                 break;
1823             if (rc != ERROR_SUCCESS)
1824             {
1825                 HeapFree(GetProcessHeap(), 0, InstancePath);
1826                 RegCloseKey(hDeviceInstanceKey);
1827                 RegCloseKey(hInterfaceKey);
1828                 return rc;
1829             }
1830             j++;
1831             if (KeyBuffer[0] != '#')
1832                 /* This entry doesn't represent an interesting entry */
1833                 continue;
1834
1835             /* Open sub key */
1836             rc = RegOpenKeyExW(hDeviceInstanceKey, KeyBuffer, 0, KEY_QUERY_VALUE, &hReferenceKey);
1837             if (rc != ERROR_SUCCESS)
1838             {
1839                 RegCloseKey(hDeviceInstanceKey);
1840                 RegCloseKey(hInterfaceKey);
1841                 return rc;
1842             }
1843
1844             /* Read SymbolicLink value */
1845             rc = RegQueryValueExW(hReferenceKey, SymbolicLink, NULL, &dwRegType, NULL, &dwLength);
1846             if (rc != ERROR_SUCCESS )
1847             {
1848                 RegCloseKey(hReferenceKey);
1849                 RegCloseKey(hDeviceInstanceKey);
1850                 RegCloseKey(hInterfaceKey);
1851                 return rc;
1852             }
1853             if (dwRegType != REG_SZ)
1854             {
1855                 RegCloseKey(hReferenceKey);
1856                 RegCloseKey(hDeviceInstanceKey);
1857                 RegCloseKey(hInterfaceKey);
1858                 return ERROR_GEN_FAILURE;
1859             }
1860
1861             /* We have found a device */
1862             /* Step 1. Create a device info element */
1863             if (!CreateDeviceInfoElement(list, InstancePath, &ClassGuid, &deviceInfo))
1864             {
1865                 RegCloseKey(hReferenceKey);
1866                 RegCloseKey(hDeviceInstanceKey);
1867                 RegCloseKey(hInterfaceKey);
1868                 return GetLastError();
1869             }
1870             TRACE("Adding device %s to list\n", debugstr_w(InstancePath));
1871             InsertTailList(&list->ListHead, &deviceInfo->ListEntry);
1872
1873             /* Step 2. Create an interface list for this element */
1874             pSymbolicLink = HeapAlloc(GetProcessHeap(), 0, (dwLength + 1) * sizeof(WCHAR));
1875             if (!pSymbolicLink)
1876             {
1877                 RegCloseKey(hReferenceKey);
1878                 RegCloseKey(hDeviceInstanceKey);
1879                 RegCloseKey(hInterfaceKey);
1880                 return ERROR_NOT_ENOUGH_MEMORY;
1881             }
1882             rc = RegQueryValueExW(hReferenceKey, SymbolicLink, NULL, NULL, (LPBYTE)pSymbolicLink, &dwLength);
1883             pSymbolicLink[dwLength / sizeof(WCHAR)] = '\0';
1884             RegCloseKey(hReferenceKey);
1885             if (rc != ERROR_SUCCESS)
1886             {
1887                 HeapFree(GetProcessHeap(), 0, pSymbolicLink);
1888                 RegCloseKey(hDeviceInstanceKey);
1889                 RegCloseKey(hInterfaceKey);
1890                 return rc;
1891             }
1892             if (!CreateDeviceInterface(deviceInfo, pSymbolicLink, InterfaceGuid, &interfaceInfo))
1893             {
1894                 HeapFree(GetProcessHeap(), 0, pSymbolicLink);
1895                 RegCloseKey(hDeviceInstanceKey);
1896                 RegCloseKey(hInterfaceKey);
1897                 return GetLastError();
1898             }
1899             TRACE("Adding interface %s to list\n", debugstr_w(pSymbolicLink));
1900             HeapFree(GetProcessHeap(), 0, pSymbolicLink);
1901             InsertTailList(&deviceInfo->InterfaceListHead, &interfaceInfo->ListEntry);
1902         }
1903         RegCloseKey(hDeviceInstanceKey);
1904     }
1905     RegCloseKey(hInterfaceKey);
1906     return ERROR_SUCCESS;
1907 }
1908 #endif /* __REACTOS__ */
1909
1910 /***********************************************************************
1911  *              SetupDiGetClassDevsExW (SETUPAPI.@)
1912  */
1913 HDEVINFO WINAPI SetupDiGetClassDevsExW(
1914        CONST GUID *class,
1915        LPCWSTR enumstr,
1916        HWND parent,
1917        DWORD flags,
1918        HDEVINFO deviceset,
1919        LPCWSTR machine,
1920        PVOID reserved)
1921 {
1922     HDEVINFO hDeviceInfo = INVALID_HANDLE_VALUE;
1923     struct DeviceInfoSet *list;
1924     LPGUID pClassGuid;
1925     LONG rc;
1926
1927     TRACE("%s %s %p 0x%08lx %p %s %p\n", debugstr_guid(class), debugstr_w(enumstr),
1928      parent, flags, deviceset, debugstr_w(machine), reserved);
1929
1930     /* Create the deviceset if not set */
1931     if (deviceset)
1932     {
1933         list = (struct DeviceInfoSet *)deviceset;
1934         if (list->magic != SETUP_DEV_INFO_SET_MAGIC)
1935         {
1936             SetLastError(ERROR_INVALID_HANDLE);
1937             return INVALID_HANDLE_VALUE;
1938         }
1939         hDeviceInfo = deviceset;
1940     }
1941     else
1942     {
1943          hDeviceInfo = SetupDiCreateDeviceInfoListExW(
1944              flags & DIGCF_DEVICEINTERFACE ? NULL : class,
1945              NULL, machine, NULL);
1946          if (hDeviceInfo == INVALID_HANDLE_VALUE)
1947              return INVALID_HANDLE_VALUE;
1948          list = (struct DeviceInfoSet *)hDeviceInfo;
1949     }
1950
1951     if (IsEqualIID(&list->ClassGuid, &GUID_NULL))
1952         pClassGuid = NULL;
1953     else
1954         pClassGuid = &list->ClassGuid;
1955
1956     if (flags & DIGCF_PRESENT)
1957         FIXME(": flag DIGCF_PRESENT ignored\n");
1958     if (flags & DIGCF_PROFILE)
1959         FIXME(": flag DIGCF_PROFILE ignored\n");
1960
1961     if (flags & DIGCF_ALLCLASSES)
1962     {
1963         rc = SETUP_CreateDevList(list, machine, pClassGuid, enumstr);
1964         if (rc != ERROR_SUCCESS)
1965         {
1966             SetLastError(rc);
1967             if (!deviceset)
1968                 SetupDiDestroyDeviceInfoList(hDeviceInfo);
1969             return INVALID_HANDLE_VALUE;
1970         }
1971         return hDeviceInfo;
1972     }
1973     else if (flags & DIGCF_DEVICEINTERFACE)
1974     {
1975         if (class == NULL)
1976         {
1977             SetLastError(ERROR_INVALID_PARAMETER);
1978             if (!deviceset)
1979                 SetupDiDestroyDeviceInfoList(hDeviceInfo);
1980             return INVALID_HANDLE_VALUE;
1981         }
1982
1983 #ifndef __REACTOS__
1984         /* Special case: find serial ports by calling QueryDosDevice */
1985         if (IsEqualIID(class, &GUID_DEVINTERFACE_COMPORT))
1986             rc = SETUP_CreateSerialDeviceList(list, machine, (LPGUID)class, enumstr);
1987         if (IsEqualIID(class, &GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR))
1988             rc = SETUP_CreateSerialDeviceList(list, machine, (LPGUID)class, enumstr);
1989         else
1990         {
1991             ERR("Wine can only enumerate serial devices at the moment!\n");
1992             rc = ERROR_INVALID_PARAMETER;
1993         }
1994 #else /* __REACTOS__ */
1995         rc = SETUP_CreateInterfaceList(list, machine, (LPGUID)class, enumstr);
1996 #endif /* __REACTOS__ */
1997         if (rc != ERROR_SUCCESS)
1998         {
1999             SetLastError(rc);
2000             if (!deviceset)
2001                 SetupDiDestroyDeviceInfoList(hDeviceInfo);
2002             return INVALID_HANDLE_VALUE;
2003         }
2004         return hDeviceInfo;
2005     }
2006     else
2007     {
2008         rc = SETUP_CreateDevList(list, machine, (LPGUID)class, enumstr);
2009         if (rc != ERROR_SUCCESS)
2010         {
2011             SetLastError(rc);
2012             if (!deviceset)
2013                 SetupDiDestroyDeviceInfoList(hDeviceInfo);
2014             return INVALID_HANDLE_VALUE;
2015         }
2016         return hDeviceInfo;
2017     }
2018 }
2019
2020 /***********************************************************************
2021  *              SetupDiGetClassImageIndex (SETUPAPI.@)
2022  */
2023
2024 static BOOL GetIconIndex(
2025        IN HKEY hClassKey,
2026        OUT PINT ImageIndex)
2027 {
2028     LPWSTR Buffer = NULL;
2029     DWORD dwRegType, dwLength;
2030     LONG rc;
2031     BOOL ret = FALSE;
2032
2033     /* Read icon registry key */
2034     rc = RegQueryValueExW(hClassKey, REGSTR_VAL_INSICON, NULL, &dwRegType, NULL, &dwLength);
2035     if (rc != ERROR_SUCCESS)
2036     {
2037         SetLastError(rc);
2038         goto cleanup;
2039     } else if (dwRegType != REG_SZ)
2040     {
2041         SetLastError(ERROR_INVALID_INDEX);
2042         goto cleanup;
2043     }
2044     Buffer = MyMalloc(dwLength + sizeof(WCHAR));
2045     if (!Buffer)
2046     {
2047         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2048         goto cleanup;
2049     }
2050     rc = RegQueryValueExW(hClassKey, REGSTR_VAL_INSICON, NULL, NULL, (LPBYTE)Buffer, &dwLength);
2051     if (rc != ERROR_SUCCESS)
2052     {
2053         SetLastError(rc);
2054         goto cleanup;
2055     }
2056     /* make sure the returned buffer is NULL-terminated */
2057     Buffer[dwLength / sizeof(WCHAR)] = 0;
2058
2059     /* Transform icon value to a INT */
2060     *ImageIndex = atoiW(Buffer);
2061     ret = TRUE;
2062
2063 cleanup:
2064     MyFree(Buffer);
2065     return ret;
2066 }
2067
2068 BOOL WINAPI SetupDiGetClassImageIndex(
2069        IN PSP_CLASSIMAGELIST_DATA ClassImageListData,
2070        IN CONST GUID *ClassGuid,
2071        OUT PINT ImageIndex)
2072 {
2073     struct ClassImageList *list;
2074     BOOL ret = FALSE;
2075
2076     TRACE("%p %s %p\n", ClassImageListData, debugstr_guid(ClassGuid), ImageIndex);
2077
2078     if (!ClassImageListData || !ClassGuid || !ImageIndex)
2079         SetLastError(ERROR_INVALID_PARAMETER);
2080     else if (ClassImageListData->cbSize != sizeof(SP_CLASSIMAGELIST_DATA))
2081         SetLastError(ERROR_INVALID_USER_BUFFER);
2082     else if ((list = (struct ClassImageList *)ClassImageListData->Reserved) == NULL)
2083         SetLastError(ERROR_INVALID_USER_BUFFER);
2084     else if (list->magic != SETUP_CLASS_IMAGE_LIST_MAGIC)
2085         SetLastError(ERROR_INVALID_USER_BUFFER);
2086     else if (!ImageIndex)
2087         SetLastError(ERROR_INVALID_PARAMETER);
2088     else
2089     {
2090         HKEY hKey = INVALID_HANDLE_VALUE;
2091         INT iconIndex;
2092
2093         /* Read Icon registry entry into Buffer */
2094         hKey = SetupDiOpenClassRegKeyExW(ClassGuid, KEY_QUERY_VALUE, DIOCR_INTERFACE, list->MachineName, NULL);
2095         if (hKey == INVALID_HANDLE_VALUE)
2096             goto cleanup;
2097         if (!GetIconIndex(hKey, &iconIndex))
2098             goto cleanup;
2099
2100         if (iconIndex >= 0)
2101         {
2102             SetLastError(ERROR_INVALID_INDEX);
2103             goto cleanup;
2104         }
2105
2106         *ImageIndex = -iconIndex;
2107         ret = TRUE;
2108
2109 cleanup:
2110         if (hKey != INVALID_HANDLE_VALUE)
2111             RegCloseKey(hKey);
2112     }
2113
2114     TRACE("Returning %d\n", ret);
2115     return ret;
2116 }
2117
2118 /***********************************************************************
2119  *              SetupDiGetClassImageList(SETUPAPI.@)
2120  */
2121 BOOL WINAPI SetupDiGetClassImageList(
2122        OUT PSP_CLASSIMAGELIST_DATA ClassImageListData)
2123 {
2124     return SetupDiGetClassImageListExW(ClassImageListData, NULL, NULL);
2125 }
2126
2127 /***********************************************************************
2128  *              SetupDiGetClassImageListExA(SETUPAPI.@)
2129  */
2130 BOOL WINAPI SetupDiGetClassImageListExA(
2131        OUT PSP_CLASSIMAGELIST_DATA ClassImageListData,
2132        IN PCSTR MachineName OPTIONAL,
2133        IN PVOID Reserved)
2134 {
2135     PWSTR MachineNameW = NULL;
2136     BOOL ret;
2137
2138     if (MachineName)
2139     {
2140         MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
2141         if (MachineNameW == NULL)
2142             return FALSE;
2143     }
2144
2145     ret = SetupDiGetClassImageListExW(ClassImageListData, MachineNameW, Reserved);
2146
2147     if (MachineNameW)
2148         MyFree(MachineNameW);
2149
2150     return ret;
2151 }
2152
2153 /***********************************************************************
2154  *              SetupDiGetClassImageListExW(SETUPAPI.@)
2155  */
2156 BOOL WINAPI SetupDiGetClassImageListExW(
2157        OUT PSP_CLASSIMAGELIST_DATA ClassImageListData,
2158        IN PCWSTR MachineName OPTIONAL,
2159        IN PVOID Reserved)
2160 {
2161     BOOL ret = FALSE;
2162
2163     TRACE("%p %p %p\n", ClassImageListData, debugstr_w(MachineName), Reserved);
2164
2165     if (!ClassImageListData)
2166         SetLastError(ERROR_INVALID_PARAMETER);
2167     else if (ClassImageListData->cbSize != sizeof(SP_CLASSIMAGELIST_DATA))
2168         SetLastError(ERROR_INVALID_USER_BUFFER);
2169     else if (Reserved)
2170         SetLastError(ERROR_INVALID_PARAMETER);
2171     else
2172     {
2173         struct ClassImageList *list = NULL;
2174         DWORD size;
2175
2176         size = FIELD_OFFSET(struct ClassImageList, szData);
2177         if (MachineName)
2178             size += (wcslen(MachineName) + 3) * sizeof(WCHAR);
2179         list = HeapAlloc(GetProcessHeap(), 0, size);
2180         if (!list)
2181         {
2182             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2183             goto cleanup;
2184         }
2185         list->magic = SETUP_CLASS_IMAGE_LIST_MAGIC;
2186         if (MachineName)
2187         {
2188             list->szData[0] = list->szData[1] = '\\';
2189             strcpyW(list->szData + 2, MachineName);
2190             list->MachineName = list->szData;
2191         }
2192         else
2193         {
2194             list->MachineName = NULL;
2195         }
2196
2197         ClassImageListData->Reserved = (DWORD)list; /* FIXME: 64 bit portability issue */
2198         ret = TRUE;
2199
2200 cleanup:
2201         if (!ret)
2202             MyFree(list);
2203     }
2204
2205     TRACE("Returning %d\n", ret);
2206     return ret;
2207 }
2208
2209 /***********************************************************************
2210  *              SetupDiLoadClassIcon(SETUPAPI.@)
2211  */
2212 BOOL WINAPI SetupDiLoadClassIcon(
2213        IN CONST GUID *ClassGuid,
2214        OUT HICON *LargeIcon OPTIONAL,
2215        OUT PINT MiniIconIndex OPTIONAL)
2216 {
2217     BOOL ret = FALSE;
2218
2219     if (!ClassGuid)
2220         SetLastError(ERROR_INVALID_PARAMETER);
2221     else
2222     {
2223         LPWSTR Buffer = NULL;
2224         LPCWSTR DllName;
2225         INT iconIndex;
2226         HKEY hKey = INVALID_HANDLE_VALUE;
2227
2228         hKey = SetupDiOpenClassRegKey(ClassGuid, KEY_QUERY_VALUE);
2229         if (hKey == INVALID_HANDLE_VALUE)
2230             goto cleanup;
2231
2232         if (!GetIconIndex(hKey, &iconIndex))
2233             goto cleanup;
2234
2235         if (iconIndex > 0)
2236         {
2237             /* Look up icon in dll specified by Installer32 or EnumPropPages32 key */
2238             PWCHAR Comma;
2239             LONG rc;
2240             DWORD dwRegType, dwLength;
2241             rc = RegQueryValueExW(hKey, REGSTR_VAL_INSTALLER_32, NULL, &dwRegType, NULL, &dwLength);
2242             if (rc == ERROR_SUCCESS && dwRegType == REG_SZ)
2243             {
2244                 Buffer = MyMalloc(dwLength + sizeof(WCHAR));
2245                 if (Buffer == NULL)
2246                 {
2247                     SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2248                     goto cleanup;
2249                 }
2250                 rc = RegQueryValueExW(hKey, REGSTR_VAL_INSTALLER_32, NULL, NULL, (LPBYTE)Buffer, &dwLength);
2251                 if (rc != ERROR_SUCCESS)
2252                 {
2253                     SetLastError(rc);
2254                     goto cleanup;
2255                 }
2256                 /* make sure the returned buffer is NULL-terminated */
2257                 Buffer[dwLength / sizeof(WCHAR)] = 0;
2258             }
2259             else if
2260                 (ERROR_SUCCESS == (rc = RegQueryValueExW(hKey, REGSTR_VAL_ENUMPROPPAGES_32, NULL, &dwRegType, NULL, &dwLength))
2261                 && dwRegType == REG_SZ)
2262             {
2263                 Buffer = MyMalloc(dwLength + sizeof(WCHAR));
2264                 if (Buffer == NULL)
2265                 {
2266                     SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2267                     goto cleanup;
2268                 }
2269                 rc = RegQueryValueExW(hKey, REGSTR_VAL_ENUMPROPPAGES_32, NULL, NULL, (LPBYTE)Buffer, &dwLength);
2270                 if (rc != ERROR_SUCCESS)
2271                 {
2272                     SetLastError(rc);
2273                     goto cleanup;
2274                 }
2275                 /* make sure the returned buffer is NULL-terminated */
2276                 Buffer[dwLength / sizeof(WCHAR)] = 0;
2277             }
2278             else
2279             {
2280                 /* Unable to find where to load the icon */
2281                 SetLastError(ERROR_FILE_NOT_FOUND);
2282                 goto cleanup;
2283             }
2284             Comma = strchrW(Buffer, ',');
2285             if (!Comma)
2286             {
2287                 SetLastError(ERROR_GEN_FAILURE);
2288                 goto cleanup;
2289             }
2290             *Comma = '\0';
2291             DllName = Buffer;
2292         }
2293         else
2294         {
2295             /* Look up icon in setupapi.dll */
2296             DllName = L"setupapi.dll";
2297             iconIndex = -iconIndex;
2298         }
2299
2300         TRACE("Icon index %d, dll name %s\n", iconIndex, debugstr_w(DllName));
2301         if (LargeIcon)
2302         {
2303             if (1 != ExtractIconEx(DllName, iconIndex, LargeIcon, NULL, 1))
2304             {
2305                 SetLastError(ERROR_INVALID_INDEX);
2306                 goto cleanup;
2307             }
2308         }
2309         if (MiniIconIndex)
2310             *MiniIconIndex = iconIndex;
2311         ret = TRUE;
2312
2313 cleanup:
2314         if (hKey != INVALID_HANDLE_VALUE)
2315             RegCloseKey(hKey);
2316         MyFree(Buffer);
2317     }
2318
2319     TRACE("Returning %d\n", ret);
2320     return ret;
2321 }
2322
2323 /***********************************************************************
2324  *              SetupDiEnumDeviceInterfaces (SETUPAPI.@)
2325  */
2326 BOOL WINAPI SetupDiEnumDeviceInterfaces(
2327        HDEVINFO DeviceInfoSet,
2328        PSP_DEVINFO_DATA DeviceInfoData,
2329        CONST GUID * InterfaceClassGuid,
2330        DWORD MemberIndex,
2331        PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
2332 {
2333     BOOL ret = FALSE;
2334
2335     TRACE("%p, %p, %s, %ld, %p\n", DeviceInfoSet, DeviceInfoData,
2336      debugstr_guid(InterfaceClassGuid), MemberIndex, DeviceInterfaceData);
2337
2338     if (!DeviceInterfaceData)
2339         SetLastError(ERROR_INVALID_PARAMETER);
2340     else if (DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA))
2341         SetLastError(ERROR_INVALID_USER_BUFFER);
2342     else if (DeviceInfoSet && DeviceInfoSet != (HDEVINFO)INVALID_HANDLE_VALUE)
2343     {
2344         struct DeviceInfoSet *list = (struct DeviceInfoSet *)DeviceInfoSet;
2345
2346         if (list->magic == SETUP_DEV_INFO_SET_MAGIC)
2347         {
2348             PLIST_ENTRY ItemList = list->ListHead.Flink;
2349             BOOL Found = FALSE;
2350             while (ItemList != &list->ListHead && !Found)
2351             {
2352                 PLIST_ENTRY InterfaceListEntry;
2353                 struct DeviceInfoElement *DevInfo = (struct DeviceInfoElement *)ItemList;
2354                 if (DeviceInfoData && (struct DeviceInfoElement *)DeviceInfoData->Reserved != DevInfo)
2355                 {
2356                     /* We are not searching for this element */
2357                     ItemList = ItemList->Flink;
2358                     continue;
2359                 }
2360                 InterfaceListEntry = DevInfo->InterfaceListHead.Flink;
2361                 while (InterfaceListEntry != &DevInfo->InterfaceListHead && !Found)
2362                 {
2363                     struct DeviceInterface *DevItf = (struct DeviceInterface *)InterfaceListEntry;
2364                     if (!IsEqualIID(&DevItf->InterfaceClassGuid, InterfaceClassGuid))
2365                     {
2366                         InterfaceListEntry = InterfaceListEntry->Flink;
2367                         continue;
2368                     }
2369                     if (MemberIndex-- == 0)
2370                     {
2371                         /* return this item */
2372                         memcpy(&DeviceInterfaceData->InterfaceClassGuid,
2373                             &DevItf->InterfaceClassGuid,
2374                             sizeof(GUID));
2375                         DeviceInterfaceData->Flags = 0; /* FIXME */
2376                         DeviceInterfaceData->Reserved = (ULONG_PTR)DevItf;
2377                         Found = TRUE;
2378                     }
2379                     InterfaceListEntry = InterfaceListEntry->Flink;
2380                 }
2381                 ItemList = ItemList->Flink;
2382             }
2383             if (!Found)
2384                 SetLastError(ERROR_NO_MORE_ITEMS);
2385             else
2386                 ret = TRUE;
2387         }
2388         else
2389             SetLastError(ERROR_INVALID_HANDLE);
2390     }
2391     else
2392         SetLastError(ERROR_INVALID_HANDLE);
2393     return ret;
2394 }
2395
2396 static VOID ReferenceInfFile(struct InfFileDetails* infFile)
2397 {
2398     InterlockedIncrement(&infFile->References);
2399 }
2400
2401 static VOID DereferenceInfFile(struct InfFileDetails* infFile)
2402 {
2403     if (InterlockedDecrement(&infFile->References) == 0)
2404     {
2405         SetupCloseInfFile(infFile->hInf);
2406         HeapFree(GetProcessHeap(), 0, infFile);
2407     }
2408 }
2409
2410 static BOOL DestroyDriverInfoElement(struct DriverInfoElement* driverInfo)
2411 {
2412     DereferenceInfFile(driverInfo->InfFileDetails);
2413     HeapFree(GetProcessHeap(), 0, driverInfo->MatchingId);
2414     HeapFree(GetProcessHeap(), 0, driverInfo);
2415     return TRUE;
2416 }
2417
2418 static BOOL DestroyClassInstallParams(struct ClassInstallParams* installParams)
2419 {
2420     HeapFree(GetProcessHeap(), 0, installParams->PropChange);
2421     return TRUE;
2422 }
2423
2424 static BOOL DestroyDeviceInfoElement(struct DeviceInfoElement* deviceInfo)
2425 {
2426     PLIST_ENTRY ListEntry;
2427     struct DriverInfoElement *driverInfo;
2428
2429     while (!IsListEmpty(&deviceInfo->DriverListHead))
2430     {
2431         ListEntry = RemoveHeadList(&deviceInfo->DriverListHead);
2432         driverInfo = (struct DriverInfoElement *)ListEntry;
2433         if (!DestroyDriverInfoElement(driverInfo))
2434             return FALSE;
2435     }
2436     while (!IsListEmpty(&deviceInfo->InterfaceListHead))
2437     {
2438         ListEntry = RemoveHeadList(&deviceInfo->InterfaceListHead);
2439         HeapFree(GetProcessHeap(), 0, ListEntry);
2440     }
2441     DestroyClassInstallParams(&deviceInfo->ClassInstallParams);
2442     HeapFree(GetProcessHeap(), 0, deviceInfo);
2443     return TRUE;
2444 }
2445
2446 static BOOL DestroyDeviceInfoSet(struct DeviceInfoSet* list)
2447 {
2448     PLIST_ENTRY ListEntry;
2449     struct DeviceInfoElement *deviceInfo;
2450
2451     while (!IsListEmpty(&list->ListHead))
2452     {
2453         ListEntry = RemoveHeadList(&list->ListHead);
2454         deviceInfo = (struct DeviceInfoElement *)ListEntry;
2455         if (!DestroyDeviceInfoElement(deviceInfo))
2456             return FALSE;
2457     }
2458     if (list->HKLM != HKEY_LOCAL_MACHINE)
2459         RegCloseKey(list->HKLM);
2460     CM_Disconnect_Machine(list->hMachine);
2461     DestroyClassInstallParams(&list->ClassInstallParams);
2462     HeapFree(GetProcessHeap(), 0, list);
2463     return TRUE;
2464 }
2465
2466 /***********************************************************************
2467  *              SetupDiDestroyDeviceInfoList (SETUPAPI.@)
2468  */
2469 BOOL WINAPI SetupDiDestroyDeviceInfoList(HDEVINFO devinfo)
2470 {
2471     BOOL ret = FALSE;
2472
2473     TRACE("%p\n", devinfo);
2474     if (devinfo && devinfo != (HDEVINFO)INVALID_HANDLE_VALUE)
2475     {
2476         struct DeviceInfoSet *list = (struct DeviceInfoSet *)devinfo;
2477
2478         if (list->magic == SETUP_DEV_INFO_SET_MAGIC)
2479             ret = DestroyDeviceInfoSet(list);
2480         else
2481             SetLastError(ERROR_INVALID_HANDLE);
2482     }
2483     else
2484         SetLastError(ERROR_INVALID_HANDLE);
2485
2486     TRACE("Returning %d\n", ret);
2487     return ret;
2488 }
2489
2490 /***********************************************************************
2491  *              SetupDiGetDeviceInterfaceDetailA (SETUPAPI.@)
2492  */
2493 BOOL WINAPI SetupDiGetDeviceInterfaceDetailA(
2494       HDEVINFO DeviceInfoSet,
2495       PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData,
2496       PSP_DEVICE_INTERFACE_DETAIL_DATA_A DeviceInterfaceDetailData,
2497       DWORD DeviceInterfaceDetailDataSize,
2498       PDWORD RequiredSize,
2499       PSP_DEVINFO_DATA DeviceInfoData)
2500 {
2501     PSP_DEVICE_INTERFACE_DETAIL_DATA_W DeviceInterfaceDetailDataW = NULL;
2502     DWORD sizeW = 0, sizeA;
2503     BOOL ret = FALSE;
2504
2505     TRACE("%p %p %p %lu %p %p\n", DeviceInfoSet,
2506         DeviceInterfaceData, DeviceInterfaceDetailData,
2507         DeviceInterfaceDetailDataSize, RequiredSize, DeviceInfoData);
2508
2509     if (DeviceInterfaceDetailData->cbSize != sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A))
2510         SetLastError(ERROR_INVALID_USER_BUFFER);
2511     else if (DeviceInterfaceDetailData == NULL && DeviceInterfaceDetailDataSize != 0)
2512         SetLastError(ERROR_INVALID_PARAMETER);
2513     else if (DeviceInterfaceDetailData != NULL && DeviceInterfaceDetailDataSize < FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_A, DevicePath) + 1)
2514         SetLastError(ERROR_INVALID_PARAMETER);
2515     else
2516     {
2517         if (DeviceInterfaceDetailData != NULL)
2518         {
2519             sizeW = FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_W, DevicePath)
2520                 + (DeviceInterfaceDetailDataSize - FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_A, DevicePath)) * sizeof(WCHAR);
2521             DeviceInterfaceDetailDataW = (PSP_DEVICE_INTERFACE_DETAIL_DATA_W)HeapAlloc(GetProcessHeap(), 0, sizeW);
2522             if (!DeviceInterfaceDetailDataW)
2523             {
2524                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2525             }
2526         }
2527         if (!DeviceInterfaceDetailData || (DeviceInterfaceDetailData && DeviceInterfaceDetailDataW))
2528         {
2529             DeviceInterfaceDetailDataW->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W);
2530             ret = SetupDiGetDeviceInterfaceDetailW(
2531                 DeviceInfoSet,
2532                 DeviceInterfaceData,
2533                 DeviceInterfaceDetailDataW,
2534                 sizeW,
2535                 &sizeW,
2536                 DeviceInfoData);
2537             sizeA = (sizeW - FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_W, DevicePath)) / sizeof(WCHAR)
2538                 + FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_A, DevicePath);
2539             if (RequiredSize)
2540                 *RequiredSize = sizeA;
2541             if (ret && DeviceInterfaceDetailData && DeviceInterfaceDetailDataSize <= sizeA)
2542             {
2543                 if (!WideCharToMultiByte(
2544                     CP_ACP, 0,
2545                     DeviceInterfaceDetailDataW->DevicePath, -1,
2546                     DeviceInterfaceDetailData->DevicePath, DeviceInterfaceDetailDataSize - FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_A, DevicePath),
2547                     NULL, NULL))
2548                 {
2549                     ret = FALSE;
2550                 }
2551             }
2552         }
2553         HeapFree(GetProcessHeap(), 0, DeviceInterfaceDetailDataW);
2554     }
2555
2556     TRACE("Returning %d\n", ret);
2557     return ret;
2558 }
2559
2560 /***********************************************************************
2561  *              SetupDiGetDeviceInterfaceDetailW (SETUPAPI.@)
2562  */
2563 BOOL WINAPI SetupDiGetDeviceInterfaceDetailW(
2564       HDEVINFO DeviceInfoSet,
2565       PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData,
2566       PSP_DEVICE_INTERFACE_DETAIL_DATA_W DeviceInterfaceDetailData,
2567       DWORD DeviceInterfaceDetailDataSize,
2568       PDWORD RequiredSize,
2569       PSP_DEVINFO_DATA DeviceInfoData)
2570 {
2571     BOOL ret = FALSE;
2572
2573     TRACE("%p %p %p %lu %p %p\n", DeviceInfoSet,
2574         DeviceInterfaceData, DeviceInterfaceDetailData,
2575         DeviceInterfaceDetailDataSize, RequiredSize, DeviceInfoData);
2576
2577     if (!DeviceInfoSet || !DeviceInterfaceData)
2578         SetLastError(ERROR_INVALID_PARAMETER);
2579     else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
2580         SetLastError(ERROR_INVALID_HANDLE);
2581     else if (((struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
2582         SetLastError(ERROR_INVALID_HANDLE);
2583     else if (DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA))
2584         SetLastError(ERROR_INVALID_USER_BUFFER);
2585     else if (DeviceInterfaceDetailData->cbSize != sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W))
2586         SetLastError(ERROR_INVALID_USER_BUFFER);
2587     else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
2588         SetLastError(ERROR_INVALID_USER_BUFFER);
2589     else if (DeviceInterfaceDetailData == NULL && DeviceInterfaceDetailDataSize != 0)
2590         SetLastError(ERROR_INVALID_PARAMETER);
2591     else if (DeviceInterfaceDetailData != NULL && DeviceInterfaceDetailDataSize < FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_W, DevicePath) + sizeof(WCHAR))
2592         SetLastError(ERROR_INVALID_PARAMETER);
2593     else
2594     {
2595         struct DeviceInterface *deviceInterface = (struct DeviceInterface *)DeviceInterfaceData->Reserved;
2596         LPCWSTR devName = deviceInterface->SymbolicLink;
2597         DWORD sizeRequired = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W) +
2598             (lstrlenW(devName) + 1) * sizeof(WCHAR);
2599
2600         if (sizeRequired > DeviceInterfaceDetailDataSize)
2601         {
2602             SetLastError(ERROR_INSUFFICIENT_BUFFER);
2603             if (RequiredSize)
2604                 *RequiredSize = sizeRequired;
2605         }
2606         else
2607         {
2608             wcscpy(DeviceInterfaceDetailData->DevicePath, devName);
2609             TRACE("DevicePath is %s\n", debugstr_w(DeviceInterfaceDetailData->DevicePath));
2610             if (DeviceInfoData)
2611             {
2612                 memcpy(&DeviceInfoData->ClassGuid,
2613                     &deviceInterface->DeviceInfo->ClassGuid,
2614                     sizeof(GUID));
2615                 DeviceInfoData->DevInst = deviceInterface->DeviceInfo->dnDevInst;
2616                 DeviceInfoData->Reserved = (ULONG_PTR)deviceInterface->DeviceInfo;
2617             }
2618             ret = TRUE;
2619         }
2620     }
2621
2622     TRACE("Returning %d\n", ret);
2623     return ret;
2624 }
2625
2626 /***********************************************************************
2627  *              SetupDiGetDeviceRegistryPropertyA (SETUPAPI.@)
2628  */
2629 BOOL WINAPI SetupDiGetDeviceRegistryPropertyA(
2630         HDEVINFO  devinfo,
2631         PSP_DEVINFO_DATA  DeviceInfoData,
2632         DWORD   Property,
2633         PDWORD  PropertyRegDataType,
2634         PBYTE   PropertyBuffer,
2635         DWORD   PropertyBufferSize,
2636         PDWORD  RequiredSize)
2637 {
2638     BOOL bResult;
2639     BOOL bIsStringProperty;
2640     DWORD RegType;
2641     DWORD RequiredSizeA, RequiredSizeW;
2642     DWORD PropertyBufferSizeW;
2643     PBYTE PropertyBufferW;
2644
2645     TRACE("%p %p %ld %p %p %ld %p\n", devinfo, DeviceInfoData,
2646         Property, PropertyRegDataType, PropertyBuffer, PropertyBufferSize,
2647         RequiredSize);
2648
2649     PropertyBufferSizeW = PropertyBufferSize * 2;
2650     PropertyBufferW = HeapAlloc(GetProcessHeap(), 0, PropertyBufferSizeW);
2651
2652     bResult = SetupDiGetDeviceRegistryPropertyW(
2653         devinfo,
2654         DeviceInfoData,
2655         Property,
2656         &RegType,
2657         PropertyBufferW,
2658         PropertyBufferSizeW,
2659         &RequiredSizeW);
2660
2661     if (bResult || GetLastError() == ERROR_INSUFFICIENT_BUFFER)
2662     {
2663         bIsStringProperty = (RegType == REG_SZ || RegType == REG_MULTI_SZ || RegType == REG_EXPAND_SZ);
2664
2665         if (bIsStringProperty)
2666            RequiredSizeA = RequiredSizeW / sizeof(WCHAR);
2667         else
2668             RequiredSizeA = RequiredSizeW;
2669         if (RequiredSize)
2670             *RequiredSize = RequiredSizeA;
2671         if (PropertyRegDataType)
2672             *PropertyRegDataType = RegType;
2673     }
2674
2675     if (!bResult)
2676     {
2677         HeapFree(GetProcessHeap(), 0, PropertyBufferW);
2678         return bResult;
2679     }
2680
2681     if (RequiredSizeA <= PropertyBufferSize)
2682     {
2683         if (bIsStringProperty && PropertyBufferSize > 0)
2684         {
2685             if (WideCharToMultiByte(CP_ACP, 0, (LPWSTR)PropertyBufferW, RequiredSizeW / sizeof(WCHAR), (LPSTR)PropertyBuffer, PropertyBufferSize, NULL, NULL) == 0)
2686             {
2687                 /* Last error is already set by WideCharToMultiByte */
2688                 bResult = FALSE;
2689             }
2690         }
2691         else
2692             memcpy(PropertyBuffer, PropertyBufferW, RequiredSizeA);
2693     }
2694     else
2695     {
2696         SetLastError(ERROR_INSUFFICIENT_BUFFER);
2697         bResult = FALSE;
2698     }
2699
2700     HeapFree(GetProcessHeap(), 0, PropertyBufferW);
2701     return bResult;
2702 }
2703
2704 /***********************************************************************
2705  *              SetupDiGetDeviceRegistryPropertyW (SETUPAPI.@)
2706  */
2707 BOOL WINAPI SetupDiGetDeviceRegistryPropertyW(
2708         HDEVINFO  DeviceInfoSet,
2709         PSP_DEVINFO_DATA  DeviceInfoData,
2710         DWORD   Property,
2711         PDWORD  PropertyRegDataType,
2712         PBYTE   PropertyBuffer,
2713         DWORD   PropertyBufferSize,
2714         PDWORD  RequiredSize)
2715 {
2716     HKEY hEnumKey, hKey;
2717     DWORD rc;
2718     BOOL ret = FALSE;
2719
2720     TRACE("%p %p %ld %p %p %ld %p\n", DeviceInfoSet, DeviceInfoData,
2721         Property, PropertyRegDataType, PropertyBuffer, PropertyBufferSize,
2722         RequiredSize);
2723
2724     if (!DeviceInfoSet || DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
2725         SetLastError(ERROR_INVALID_HANDLE);
2726     else if (((struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
2727         SetLastError(ERROR_INVALID_HANDLE);
2728     else if (!DeviceInfoData)
2729         SetLastError(ERROR_INVALID_PARAMETER);
2730     else if (DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
2731         SetLastError(ERROR_INVALID_USER_BUFFER);
2732     else if (Property >= SPDRP_MAXIMUM_PROPERTY)
2733         SetLastError(ERROR_INVALID_PARAMETER);
2734     else
2735     {
2736         struct DeviceInfoSet *list = (struct DeviceInfoSet *)DeviceInfoSet;
2737         struct DeviceInfoElement *DevInfo = (struct DeviceInfoElement *)DeviceInfoData->Reserved;
2738
2739         switch (Property)
2740         {
2741             case SPDRP_CAPABILITIES:
2742             case SPDRP_CLASS:
2743             case SPDRP_CLASSGUID:
2744             case SPDRP_COMPATIBLEIDS:
2745             case SPDRP_CONFIGFLAGS:
2746             case SPDRP_DEVICEDESC:
2747             case SPDRP_DRIVER:
2748             case SPDRP_FRIENDLYNAME:
2749             case SPDRP_HARDWAREID:
2750             case SPDRP_LOCATION_INFORMATION:
2751             case SPDRP_LOWERFILTERS:
2752             case SPDRP_MFG:
2753             case SPDRP_SECURITY:
2754             case SPDRP_SERVICE:
2755             case SPDRP_UI_NUMBER:
2756             case SPDRP_UI_NUMBER_DESC_FORMAT:
2757             case SPDRP_UPPERFILTERS:
2758             {
2759                 LPCWSTR RegistryPropertyName;
2760                 DWORD BufferSize;
2761
2762                 switch (Property)
2763                 {
2764                     case SPDRP_CAPABILITIES:
2765                         RegistryPropertyName = REGSTR_VAL_CAPABILITIES; break;
2766                     case SPDRP_CLASS:
2767                         RegistryPropertyName = REGSTR_VAL_CLASS; break;
2768                     case SPDRP_CLASSGUID:
2769                         RegistryPropertyName = REGSTR_VAL_CLASSGUID; break;
2770                     case SPDRP_COMPATIBLEIDS:
2771                         RegistryPropertyName = REGSTR_VAL_COMPATIBLEIDS; break;
2772                     case SPDRP_CONFIGFLAGS:
2773                         RegistryPropertyName = REGSTR_VAL_CONFIGFLAGS; break;
2774                     case SPDRP_DEVICEDESC:
2775                         RegistryPropertyName = REGSTR_VAL_DEVDESC; break;
2776                     case SPDRP_DRIVER:
2777                         RegistryPropertyName = REGSTR_VAL_DRIVER; break;
2778                     case SPDRP_FRIENDLYNAME:
2779                         RegistryPropertyName = REGSTR_VAL_FRIENDLYNAME; break;
2780                     case SPDRP_HARDWAREID:
2781                         RegistryPropertyName = REGSTR_VAL_HARDWAREID; break;
2782                     case SPDRP_LOCATION_INFORMATION:
2783                         RegistryPropertyName = REGSTR_VAL_LOCATION_INFORMATION; break;
2784                     case SPDRP_LOWERFILTERS:
2785                         RegistryPropertyName = REGSTR_VAL_LOWERFILTERS; break;
2786                     case SPDRP_MFG:
2787                         RegistryPropertyName = REGSTR_VAL_MFG; break;
2788                     case SPDRP_SECURITY:
2789                         RegistryPropertyName = L"Security"; break;
2790                     case SPDRP_SERVICE:
2791                         RegistryPropertyName = REGSTR_VAL_SERVICE; break;
2792                     case SPDRP_UI_NUMBER:
2793                         RegistryPropertyName = REGSTR_VAL_UI_NUMBER; break;
2794                     case SPDRP_UI_NUMBER_DESC_FORMAT:
2795                         RegistryPropertyName = L"UINumberDescFormat"; break;
2796                     case SPDRP_UPPERFILTERS:
2797                         RegistryPropertyName = REGSTR_VAL_UPPERFILTERS; break;
2798                     default:
2799                         /* Should not happen */
2800                         RegistryPropertyName = NULL; break;
2801                 }
2802
2803                 /* Open registry key name */
2804                 rc = RegOpenKeyExW(
2805                     list->HKLM,
2806                     REGSTR_PATH_SYSTEMENUM,
2807                     0, /* Options */
2808                     0,
2809                     &hEnumKey);
2810                 if (rc != ERROR_SUCCESS)
2811                 {
2812                     SetLastError(rc);
2813                     break;
2814                 }
2815                 rc = RegOpenKeyExW(
2816                     hEnumKey,
2817                     DevInfo->Data,
2818                     0, /* Options */
2819                     KEY_QUERY_VALUE,
2820                     &hKey);
2821                 RegCloseKey(hEnumKey);
2822                 if (rc != ERROR_SUCCESS)
2823                 {
2824                     SetLastError(rc);
2825                     break;
2826                 }
2827                 /* Read registry entry */
2828                 BufferSize = PropertyBufferSize;
2829                 rc = RegQueryValueExW(
2830                     hKey,
2831                     RegistryPropertyName,
2832                     NULL, /* Reserved */
2833                     PropertyRegDataType,
2834                     PropertyBuffer,
2835                     &BufferSize);
2836                 if (RequiredSize)
2837                     *RequiredSize = BufferSize;
2838                 switch(rc) {
2839                     case ERROR_SUCCESS:
2840                         if (PropertyBuffer != NULL || BufferSize == 0)
2841                             ret = TRUE;
2842                         else
2843                             SetLastError(ERROR_INSUFFICIENT_BUFFER);
2844                         break;
2845                     case ERROR_MORE_DATA:
2846                         SetLastError(ERROR_INSUFFICIENT_BUFFER);
2847                         break;
2848                     default:
2849                         SetLastError(rc);
2850                 }
2851                 RegCloseKey(hKey);
2852                 break;
2853             }
2854
2855             case SPDRP_PHYSICAL_DEVICE_OBJECT_NAME:
2856             {
2857                 DWORD required = (wcslen(DevInfo->Data) + 1) * sizeof(WCHAR);
2858
2859                 if (PropertyRegDataType)
2860                     *PropertyRegDataType = REG_SZ;
2861                 if (RequiredSize)
2862                     *RequiredSize = required;
2863                 if (PropertyBufferSize >= required)
2864                 {
2865                     wcscpy((LPWSTR)PropertyBuffer, DevInfo->Data);
2866                     ret = TRUE;
2867                 }
2868                 else
2869                     SetLastError(ERROR_INSUFFICIENT_BUFFER);
2870                 break;
2871             }
2872
2873             /*case SPDRP_BUSTYPEGUID:
2874             case SPDRP_LEGACYBUSTYPE:
2875             case SPDRP_BUSNUMBER:
2876             case SPDRP_ENUMERATOR_NAME:
2877             case SPDRP_SECURITY_SDS:
2878             case SPDRP_DEVTYPE:
2879             case SPDRP_EXCLUSIVE:
2880             case SPDRP_CHARACTERISTICS:
2881             case SPDRP_ADDRESS:
2882             case SPDRP_DEVICE_POWER_DATA:*/
2883 #if (WINVER >= 0x501)
2884             /*case SPDRP_REMOVAL_POLICY:
2885             case SPDRP_REMOVAL_POLICY_HW_DEFAULT:
2886             case SPDRP_REMOVAL_POLICY_OVERRIDE:
2887             case SPDRP_INSTALL_STATE:*/
2888 #endif
2889
2890             default:
2891             {
2892                 ERR("Property 0x%lx not implemented\n", Property);
2893                 SetLastError(ERROR_NOT_SUPPORTED);
2894             }
2895         }
2896     }
2897
2898     TRACE("Returning %d\n", ret);
2899     return ret;
2900 }
2901
2902 /***********************************************************************
2903  *              SetupDiSetDeviceRegistryPropertyA (SETUPAPI.@)
2904  */
2905 BOOL WINAPI SetupDiSetDeviceRegistryPropertyA(
2906         IN HDEVINFO DeviceInfoSet,
2907         IN OUT PSP_DEVINFO_DATA DeviceInfoData,
2908         IN DWORD Property,
2909         IN CONST BYTE *PropertyBuffer,
2910         IN DWORD PropertyBufferSize)
2911 {
2912     FIXME("%p %p 0x%lx %p 0x%lx\n", DeviceInfoSet, DeviceInfoData,
2913         Property, PropertyBuffer, PropertyBufferSize);
2914     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2915     return FALSE;
2916 }
2917
2918 /***********************************************************************
2919  *              SetupDiSetDeviceRegistryPropertyW (SETUPAPI.@)
2920  */
2921 BOOL WINAPI SetupDiSetDeviceRegistryPropertyW(
2922         IN HDEVINFO DeviceInfoSet,
2923         IN OUT PSP_DEVINFO_DATA DeviceInfoData,
2924         IN DWORD Property,
2925         IN const BYTE *PropertyBuffer,
2926         IN DWORD PropertyBufferSize)
2927 {
2928     struct DeviceInfoSet *list;
2929     BOOL ret = FALSE;
2930
2931     TRACE("%p %p 0x%lx %p 0x%lx\n", DeviceInfoSet, DeviceInfoData,
2932         Property, PropertyBuffer, PropertyBufferSize);
2933
2934     if (!DeviceInfoSet)
2935         SetLastError(ERROR_INVALID_HANDLE);
2936     else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
2937         SetLastError(ERROR_INVALID_HANDLE);
2938     else if (!DeviceInfoData)
2939         SetLastError(ERROR_INVALID_HANDLE);
2940     else if (DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
2941         SetLastError(ERROR_INVALID_USER_BUFFER);
2942     else
2943     {
2944         switch (Property)
2945         {
2946             case SPDRP_COMPATIBLEIDS:
2947             case SPDRP_CONFIGFLAGS:
2948             case SPDRP_FRIENDLYNAME:
2949             case SPDRP_HARDWAREID:
2950             case SPDRP_LOCATION_INFORMATION:
2951             case SPDRP_LOWERFILTERS:
2952             case SPDRP_SECURITY:
2953             case SPDRP_SERVICE:
2954             case SPDRP_UI_NUMBER_DESC_FORMAT:
2955             case SPDRP_UPPERFILTERS:
2956             {
2957                 LPCWSTR RegistryPropertyName;
2958                 DWORD RegistryDataType;
2959                 HKEY hKey;
2960                 LONG rc;
2961
2962                 switch (Property)
2963                 {
2964                     case SPDRP_COMPATIBLEIDS:
2965                         RegistryPropertyName = REGSTR_VAL_COMPATIBLEIDS;
2966                         RegistryDataType = REG_MULTI_SZ;
2967                         break;
2968                     case SPDRP_CONFIGFLAGS:
2969                         RegistryPropertyName = REGSTR_VAL_CONFIGFLAGS;
2970                         RegistryDataType = REG_DWORD;
2971                         break;
2972                     case SPDRP_FRIENDLYNAME:
2973                         RegistryPropertyName = REGSTR_VAL_FRIENDLYNAME;
2974                         RegistryDataType = REG_SZ;
2975                         break;
2976                     case SPDRP_HARDWAREID:
2977                         RegistryPropertyName = REGSTR_VAL_HARDWAREID;
2978                         RegistryDataType = REG_MULTI_SZ;
2979                         break;
2980                     case SPDRP_LOCATION_INFORMATION:
2981                         RegistryPropertyName = REGSTR_VAL_LOCATION_INFORMATION;
2982                         RegistryDataType = REG_SZ;
2983                         break;
2984                     case SPDRP_LOWERFILTERS:
2985                         RegistryPropertyName = REGSTR_VAL_LOWERFILTERS;
2986                         RegistryDataType = REG_MULTI_SZ;
2987                         break;
2988                     case SPDRP_SECURITY:
2989                         RegistryPropertyName = L"Security";
2990                         RegistryDataType = REG_BINARY;
2991                         break;
2992                     case SPDRP_SERVICE:
2993                         RegistryPropertyName = REGSTR_VAL_SERVICE;
2994                         RegistryDataType = REG_SZ;
2995                         break;
2996                     case SPDRP_UI_NUMBER_DESC_FORMAT:
2997                         RegistryPropertyName = L"UINumberDescFormat";
2998                         RegistryDataType = REG_SZ;
2999                         break;
3000                     case SPDRP_UPPERFILTERS:
3001                         RegistryPropertyName = REGSTR_VAL_UPPERFILTERS;
3002                         RegistryDataType = REG_MULTI_SZ;
3003                         break;
3004                     default:
3005                         /* Should not happen */
3006                         RegistryPropertyName = NULL;
3007                         RegistryDataType = REG_BINARY;
3008                         break;
3009                 }
3010                 /* Open device registry key */
3011                 hKey = SetupDiOpenDevRegKey(DeviceInfoSet, DeviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_SET_VALUE);
3012                 if (hKey != INVALID_HANDLE_VALUE)
3013                 {
3014                     /* Write new data */
3015                     rc = RegSetValueExW(
3016                         hKey,
3017                         RegistryPropertyName,
3018                         0, /* Reserved */
3019                         RegistryDataType,
3020                         PropertyBuffer,
3021                         PropertyBufferSize);
3022                     if (rc == ERROR_SUCCESS)
3023                         ret = TRUE;
3024                     else
3025                         SetLastError(rc);
3026                     RegCloseKey(hKey);
3027                 }
3028                 break;
3029             }
3030
3031             /*case SPDRP_CHARACTERISTICS:
3032             case SPDRP_DEVTYPE:
3033             case SPDRP_EXCLUSIVE:*/
3034 #if (WINVER >= 0x501)
3035             //case SPDRP_REMOVAL_POLICY_OVERRIDE:
3036 #endif
3037             //case SPDRP_SECURITY_SDS:
3038
3039             default:
3040             {
3041                 ERR("Property 0x%lx not implemented\n", Property);
3042                 SetLastError(ERROR_NOT_SUPPORTED);
3043             }
3044         }
3045     }
3046
3047     TRACE("Returning %d\n", ret);
3048     return ret;
3049 }
3050
3051
3052 /***********************************************************************
3053  *              SetupDiInstallClassA (SETUPAPI.@)
3054  */
3055 BOOL WINAPI SetupDiInstallClassA(
3056         IN HWND hwndParent OPTIONAL,
3057         IN PCSTR InfFileName,
3058         IN DWORD Flags,
3059         IN HSPFILEQ FileQueue OPTIONAL)
3060 {
3061     return SetupDiInstallClassExA(hwndParent, InfFileName, Flags, FileQueue, NULL, NULL, NULL);
3062 }
3063
3064
3065 /***********************************************************************
3066  *              SetupDiInstallClassW (SETUPAPI.@)
3067  */
3068 BOOL WINAPI SetupDiInstallClassW(
3069         IN HWND hwndParent OPTIONAL,
3070         IN PCWSTR InfFileName,
3071         IN DWORD Flags,
3072         IN HSPFILEQ FileQueue OPTIONAL)
3073 {
3074     return SetupDiInstallClassExW(hwndParent, InfFileName, Flags, FileQueue, NULL, NULL, NULL);
3075 }
3076
3077
3078 /***********************************************************************
3079  *              SetupDiInstallClassExA (SETUPAPI.@)
3080  */
3081 BOOL WINAPI SetupDiInstallClassExA(
3082         IN HWND hwndParent OPTIONAL,
3083         IN PCSTR InfFileName OPTIONAL,
3084         IN DWORD Flags,
3085         IN HSPFILEQ FileQueue OPTIONAL,
3086         IN const GUID* InterfaceClassGuid OPTIONAL,
3087         IN PVOID Reserved1,
3088         IN PVOID Reserved2)
3089 {
3090     PWSTR InfFileNameW = NULL;
3091     BOOL Result;
3092
3093     if (InfFileName)
3094     {
3095         InfFileNameW = MultiByteToUnicode(InfFileName, CP_ACP);
3096         if (InfFileNameW == NULL)
3097         {
3098             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
3099             return FALSE;
3100         }
3101     }
3102
3103     Result = SetupDiInstallClassExW(hwndParent, InfFileNameW, Flags,
3104         FileQueue, InterfaceClassGuid, Reserved1, Reserved2);
3105
3106     MyFree(InfFileNameW);
3107
3108     return Result;
3109 }
3110
3111
3112 static HKEY CreateClassKey(HINF hInf)
3113 {
3114     WCHAR FullBuffer[MAX_PATH];
3115     WCHAR Buffer[MAX_PATH];
3116     DWORD RequiredSize;
3117     HKEY hClassKey;
3118
3119     Buffer[0] = '\\';
3120     if (!SetupGetLineTextW(NULL,
3121                            hInf,
3122                            Version,
3123                            ClassGUID,
3124                            &Buffer[1],
3125                            MAX_PATH - 1,
3126                            &RequiredSize))
3127     {
3128         return INVALID_HANDLE_VALUE;
3129     }
3130
3131     lstrcpyW(FullBuffer, REGSTR_PATH_CLASS_NT);
3132     lstrcatW(FullBuffer, Buffer);
3133
3134
3135     if (!SetupGetLineTextW(NULL,
3136                                hInf,
3137                                Version,
3138                                Class,
3139                                Buffer,
3140                                MAX_PATH,
3141                                &RequiredSize))
3142     {
3143         RegDeleteKeyW(HKEY_LOCAL_MACHINE, FullBuffer);
3144         return INVALID_HANDLE_VALUE;
3145     }
3146
3147     if (ERROR_SUCCESS != RegCreateKeyExW(HKEY_LOCAL_MACHINE,
3148                             FullBuffer,
3149                             0,
3150                             NULL,
3151                             REG_OPTION_NON_VOLATILE,
3152                             KEY_SET_VALUE,
3153                             NULL,
3154                             &hClassKey,
3155              NULL))
3156     {
3157         RegDeleteKeyW(HKEY_LOCAL_MACHINE, FullBuffer);
3158         return INVALID_HANDLE_VALUE;
3159     }
3160
3161     if (ERROR_SUCCESS != RegSetValueExW(hClassKey,
3162                        Class,
3163                        0,
3164                        REG_SZ,
3165                        (LPBYTE)Buffer,
3166              RequiredSize * sizeof(WCHAR)))
3167     {
3168         RegCloseKey(hClassKey);
3169         RegDeleteKeyW(HKEY_LOCAL_MACHINE, FullBuffer);
3170         return INVALID_HANDLE_VALUE;
3171     }
3172
3173     return hClassKey;
3174 }
3175
3176
3177 /***********************************************************************
3178  *              SetupDiInstallClassExW (SETUPAPI.@)
3179  */
3180 BOOL WINAPI SetupDiInstallClassExW(
3181         IN HWND hwndParent OPTIONAL,
3182         IN PCWSTR InfFileName OPTIONAL,
3183         IN DWORD Flags,
3184         IN HSPFILEQ FileQueue OPTIONAL,
3185         IN const GUID* InterfaceClassGuid OPTIONAL,
3186         IN PVOID Reserved1,
3187         IN PVOID Reserved2)
3188 {
3189     BOOL ret = FALSE;
3190
3191     TRACE("%p %s 0x%lx %p %s %p %p\n", hwndParent, debugstr_w(InfFileName), Flags,
3192         FileQueue, debugstr_guid(InterfaceClassGuid), Reserved1, Reserved2);
3193
3194     if (!InfFileName && !InterfaceClassGuid)
3195         SetLastError(ERROR_INVALID_PARAMETER);
3196     else if (Flags & ~(DI_NOVCP | DI_NOBROWSE | DI_FORCECOPY | DI_QUIETINSTALL))
3197     {
3198         TRACE("Unknown flags: 0x%08lx\n", Flags & ~(DI_NOVCP | DI_NOBROWSE | DI_FORCECOPY | DI_QUIETINSTALL));
3199         SetLastError(ERROR_INVALID_FLAGS);
3200     }
3201     else if ((Flags & DI_NOVCP) && FileQueue == NULL)
3202         SetLastError(ERROR_INVALID_PARAMETER);
3203     else if (Reserved1 != NULL)
3204         SetLastError(ERROR_INVALID_PARAMETER);
3205     else if (Reserved2 != NULL)
3206         SetLastError(ERROR_INVALID_PARAMETER);
3207     else
3208     {
3209         WCHAR SectionName[MAX_PATH];
3210         HINF hInf = INVALID_HANDLE_VALUE;
3211         HKEY hClassKey = INVALID_HANDLE_VALUE;
3212         PVOID callback_context = NULL;
3213
3214         if (InterfaceClassGuid)
3215         {
3216             /* SetupDiCreateDeviceInterface??? */
3217             FIXME("Installing an interface is not implemented\n");
3218             SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3219         }
3220         else
3221         {
3222             if (Flags & DI_NOVCP)
3223                 FIXME("FileQueue argument ignored\n");
3224             if (Flags & (DI_NOBROWSE | DI_FORCECOPY | DI_QUIETINSTALL))
3225                 FIXME("Flags 0x%lx ignored\n", Flags & (DI_NOBROWSE | DI_FORCECOPY | DI_QUIETINSTALL));
3226
3227             /* Open the .inf file */
3228             hInf = SetupOpenInfFileW(
3229                 InfFileName,
3230                 NULL,
3231                 INF_STYLE_WIN4,
3232                 NULL);
3233             if (hInf == INVALID_HANDLE_VALUE)
3234                 goto cleanup;
3235
3236             /* Create or open the class registry key 'HKLM\CurrentControlSet\Class\{GUID}' */
3237             hClassKey = CreateClassKey(hInf);
3238             if (hClassKey == INVALID_HANDLE_VALUE)
3239                 goto cleanup;
3240
3241             /* Try to append a layout file */
3242             ret = SetupOpenAppendInfFileW(NULL, hInf, NULL);
3243             if (!ret)
3244                 goto cleanup;
3245
3246             /* Retrieve the actual section name */
3247             ret = SetupDiGetActualSectionToInstallW(
3248                 hInf,
3249                 ClassInstall32,
3250                 SectionName,
3251                 MAX_PATH - wcslen(DotServices),
3252                 NULL,
3253                 NULL);
3254             if (!ret)
3255                 goto cleanup;
3256
3257             callback_context = SetupInitDefaultQueueCallback(hwndParent);
3258             if (!callback_context)
3259                 goto cleanup;
3260
3261             ret = SetupInstallFromInfSectionW(
3262                 hwndParent,
3263                 hInf,
3264                 SectionName,
3265                 SPINST_REGISTRY | SPINST_FILES | SPINST_BITREG | SPINST_INIFILES | SPINST_INI2REG,
3266                 hClassKey,
3267                 NULL, /* SourceRootPath */
3268                 0, /* CopyFlags */
3269                 SetupDefaultQueueCallbackW,
3270                 callback_context,
3271                 NULL,
3272                 NULL);
3273             if (!ret)
3274                 goto cleanup;
3275
3276             /* Install .Services section */
3277             lstrcatW(SectionName, DotServices);
3278             ret = SetupInstallServicesFromInfSectionW(hInf, SectionName, 0);
3279             if (!ret)
3280                 goto cleanup;
3281
3282             ret = TRUE;
3283         }
3284
3285 cleanup:
3286         if (hInf != INVALID_HANDLE_VALUE)
3287             SetupCloseInfFile(hInf);
3288         if (hClassKey != INVALID_HANDLE_VALUE)
3289             RegCloseKey(hClassKey);
3290         SetupTermDefaultQueueCallback(callback_context);
3291     }
3292
3293     TRACE("Returning %d\n", ret);
3294     return ret;
3295 }
3296
3297
3298 /***********************************************************************
3299  *              SetupDiOpenClassRegKey  (SETUPAPI.@)
3300  */
3301 HKEY WINAPI SetupDiOpenClassRegKey(
3302         const GUID* ClassGuid,
3303         REGSAM samDesired)
3304 {
3305     return SetupDiOpenClassRegKeyExW(ClassGuid, samDesired,
3306                                      DIOCR_INSTALLER, NULL, NULL);
3307 }
3308
3309
3310 /***********************************************************************
3311  *              SetupDiOpenClassRegKeyExA  (SETUPAPI.@)
3312  */
3313 HKEY WINAPI SetupDiOpenClassRegKeyExA(
3314         const GUID* ClassGuid OPTIONAL,
3315         REGSAM samDesired,
3316         DWORD Flags,
3317         PCSTR MachineName OPTIONAL,
3318         PVOID Reserved)
3319 {
3320     PWSTR MachineNameW = NULL;
3321     HKEY hKey;
3322
3323     TRACE("\n");
3324
3325     if (MachineName)
3326     {
3327         MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
3328         if (MachineNameW == NULL)
3329             return INVALID_HANDLE_VALUE;
3330     }
3331
3332     hKey = SetupDiOpenClassRegKeyExW(ClassGuid, samDesired,
3333                                      Flags, MachineNameW, Reserved);
3334
3335     if (MachineNameW)
3336         MyFree(MachineNameW);
3337
3338     return hKey;
3339 }
3340
3341
3342 /***********************************************************************
3343  *              SetupDiOpenClassRegKeyExW  (SETUPAPI.@)
3344  */
3345 HKEY WINAPI SetupDiOpenClassRegKeyExW(
3346         const GUID* ClassGuid OPTIONAL,
3347         REGSAM samDesired,
3348         DWORD Flags,
3349         PCWSTR MachineName OPTIONAL,
3350         PVOID Reserved)
3351 {
3352     LPWSTR lpGuidString;
3353     LPWSTR lpFullGuidString;
3354     DWORD dwLength;
3355     HKEY HKLM;
3356     HKEY hClassesKey;
3357     HKEY hClassKey;
3358     DWORD rc;
3359     LPCWSTR lpKeyName;
3360
3361     TRACE("%s 0x%lx 0x%lx %s %p\n", debugstr_guid(ClassGuid), samDesired,
3362         Flags, debugstr_w(MachineName), Reserved);
3363
3364     if (Flags == DIOCR_INSTALLER)
3365     {
3366         lpKeyName = REGSTR_PATH_CLASS_NT;
3367     }
3368     else if (Flags == DIOCR_INTERFACE)
3369     {
3370         lpKeyName = REGSTR_PATH_DEVICE_CLASSES;
3371     }
3372     else
3373     {
3374         ERR("Invalid Flags parameter!\n");
3375         SetLastError(ERROR_INVALID_FLAGS);
3376         return INVALID_HANDLE_VALUE;
3377     }
3378
3379     if (MachineName != NULL)
3380     {
3381         rc = RegConnectRegistryW(MachineName, HKEY_LOCAL_MACHINE, &HKLM);
3382         if (rc != ERROR_SUCCESS)
3383         {
3384             SetLastError(rc);
3385             return INVALID_HANDLE_VALUE;
3386         }
3387     }
3388     else
3389         HKLM = HKEY_LOCAL_MACHINE;
3390
3391     rc = RegOpenKeyExW(HKLM,
3392                       lpKeyName,
3393                       0,
3394                       ClassGuid ? 0 : samDesired,
3395                       &hClassesKey);
3396     if (MachineName != NULL) RegCloseKey(HKLM);
3397     if (rc != ERROR_SUCCESS)
3398     {
3399         SetLastError(rc);
3400         return INVALID_HANDLE_VALUE;
3401     }
3402
3403     if (ClassGuid == NULL)
3404         return hClassesKey;
3405
3406     if (UuidToStringW((UUID*)ClassGuid, &lpGuidString) != RPC_S_OK)
3407     {
3408         SetLastError(ERROR_GEN_FAILURE);
3409         RegCloseKey(hClassesKey);
3410         return INVALID_HANDLE_VALUE;
3411     }
3412
3413     dwLength = lstrlenW(lpGuidString);
3414     lpFullGuidString = HeapAlloc(GetProcessHeap(), 0, (dwLength + 3) * sizeof(WCHAR));
3415     if (!lpFullGuidString)
3416     {
3417         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
3418         RpcStringFreeW(&lpGuidString);
3419         return INVALID_HANDLE_VALUE;
3420     }
3421     lpFullGuidString[0] = '{';
3422     memcpy(&lpFullGuidString[1], lpGuidString, dwLength * sizeof(WCHAR));
3423     lpFullGuidString[dwLength + 1] = '}';
3424     lpFullGuidString[dwLength + 2] = '\0';
3425     RpcStringFreeW(&lpGuidString);
3426
3427     rc = RegOpenKeyExW(hClassesKey,
3428                       lpFullGuidString,
3429                       0,
3430                       samDesired,
3431                       &hClassKey);
3432     if (rc != ERROR_SUCCESS)
3433     {
3434         SetLastError(rc);
3435         HeapFree(GetProcessHeap(), 0, lpFullGuidString);
3436         RegCloseKey(hClassesKey);
3437         return INVALID_HANDLE_VALUE;
3438     }
3439
3440     HeapFree(GetProcessHeap(), 0, lpFullGuidString);
3441     RegCloseKey(hClassesKey);
3442
3443     return hClassKey;
3444 }
3445
3446 /***********************************************************************
3447  *              SetupDiOpenDeviceInterfaceW (SETUPAPI.@)
3448  */
3449 BOOL WINAPI SetupDiOpenDeviceInterfaceW(
3450        HDEVINFO DeviceInfoSet,
3451        PCWSTR DevicePath,
3452        DWORD OpenFlags,
3453        PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
3454 {
3455     FIXME("%p %s %08lx %p\n",
3456         DeviceInfoSet, debugstr_w(DevicePath), OpenFlags, DeviceInterfaceData);
3457     return FALSE;
3458 }
3459
3460 /***********************************************************************
3461  *              SetupDiOpenDeviceInterfaceA (SETUPAPI.@)
3462  */
3463 BOOL WINAPI SetupDiOpenDeviceInterfaceA(
3464        HDEVINFO DeviceInfoSet,
3465        PCSTR DevicePath,
3466        DWORD OpenFlags,
3467        PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
3468 {
3469     LPWSTR DevicePathW = NULL;
3470     BOOL bResult;
3471
3472     TRACE("%p %s %08lx %p\n", DeviceInfoSet, debugstr_a(DevicePath), OpenFlags, DeviceInterfaceData);
3473
3474     DevicePathW = MultiByteToUnicode(DevicePath, CP_ACP);
3475     if (DevicePathW == NULL)
3476         return FALSE;
3477
3478     bResult = SetupDiOpenDeviceInterfaceW(DeviceInfoSet,
3479         DevicePathW, OpenFlags, DeviceInterfaceData);
3480
3481     MyFree(DevicePathW);
3482
3483     return bResult;
3484 }
3485
3486 /***********************************************************************
3487  *              SetupDiSetClassInstallParamsA (SETUPAPI.@)
3488  */
3489 BOOL WINAPI SetupDiSetClassInstallParamsA(
3490        HDEVINFO  DeviceInfoSet,
3491        PSP_DEVINFO_DATA DeviceInfoData,
3492        PSP_CLASSINSTALL_HEADER ClassInstallParams,
3493        DWORD ClassInstallParamsSize)
3494 {
3495     FIXME("%p %p %x %lu\n",DeviceInfoSet, DeviceInfoData,
3496           ClassInstallParams->InstallFunction, ClassInstallParamsSize);
3497     return FALSE;
3498 }
3499
3500 /***********************************************************************
3501  *              SetupDiSetClassInstallParamsW (SETUPAPI.@)
3502  */
3503 BOOL WINAPI SetupDiSetClassInstallParamsW(
3504        IN HDEVINFO DeviceInfoSet,
3505        IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
3506        IN PSP_CLASSINSTALL_HEADER ClassInstallParams OPTIONAL,
3507        IN DWORD ClassInstallParamsSize)
3508 {
3509     struct DeviceInfoSet *list;
3510     BOOL ret = FALSE;
3511
3512     TRACE("%p %p %p %lu\n", DeviceInfoSet, DeviceInfoData,
3513         ClassInstallParams, ClassInstallParamsSize);
3514
3515     if (!DeviceInfoSet)
3516         SetLastError(ERROR_INVALID_PARAMETER);
3517     else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
3518         SetLastError(ERROR_INVALID_HANDLE);
3519     else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
3520         SetLastError(ERROR_INVALID_HANDLE);
3521     else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
3522         SetLastError(ERROR_INVALID_USER_BUFFER);
3523     else if (ClassInstallParams && ClassInstallParams->cbSize != sizeof(SP_CLASSINSTALL_HEADER))
3524         SetLastError(ERROR_INVALID_USER_BUFFER);
3525     else if (ClassInstallParams && ClassInstallParamsSize < sizeof(SP_CLASSINSTALL_HEADER))
3526         SetLastError(ERROR_INVALID_PARAMETER);
3527     else if (!ClassInstallParams && ClassInstallParamsSize != 0)
3528         SetLastError(ERROR_INVALID_PARAMETER);
3529     else
3530     {
3531         SP_DEVINSTALL_PARAMS_W InstallParams;
3532         BOOL Result;
3533
3534         InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
3535         Result = SetupDiGetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
3536         if (!Result)
3537             goto done;
3538
3539         if (ClassInstallParams)
3540         {
3541             /* Check parameters in ClassInstallParams */
3542             if (ClassInstallParams->InstallFunction < DIF_SELECTDEVICE
3543                 || ClassInstallParams->InstallFunction - DIF_SELECTDEVICE >= sizeof(UpdateClassInstallParamHandlers)/sizeof(UpdateClassInstallParamHandlers[0]))
3544             {
3545                 SetLastError(ERROR_INVALID_USER_BUFFER);
3546                 goto done;
3547             }
3548             else if (UpdateClassInstallParamHandlers[ClassInstallParams->InstallFunction - DIF_SELECTDEVICE] == NULL)
3549             {
3550                 FIXME("InstallFunction %u is valid, but has no associated update handler\n", ClassInstallParams->InstallFunction);
3551                 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3552                 goto done;
3553             }
3554             ret = UpdateClassInstallParamHandlers[ClassInstallParams->InstallFunction - DIF_SELECTDEVICE](DeviceInfoSet, DeviceInfoData, ClassInstallParams, ClassInstallParamsSize);
3555             if (!ret)
3556                 goto done;
3557             InstallParams.Flags |= DI_CLASSINSTALLPARAMS;
3558         }
3559         else
3560         {
3561             InstallParams.Flags &= ~DI_CLASSINSTALLPARAMS;
3562         }
3563
3564         ret = SetupDiSetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
3565     }
3566
3567 done:
3568     TRACE("Returning %d\n", ret);
3569     return ret;
3570 }
3571
3572 static BOOL PropertyChangeHandler(
3573        IN HDEVINFO DeviceInfoSet,
3574        IN PSP_DEVINFO_DATA DeviceInfoData,
3575        IN PSP_CLASSINSTALL_HEADER ClassInstallParams OPTIONAL,
3576        IN DWORD ClassInstallParamsSize)
3577 {
3578     PSP_PROPCHANGE_PARAMS PropChangeParams = (PSP_PROPCHANGE_PARAMS)ClassInstallParams;
3579     BOOL ret = FALSE;
3580
3581     if (!DeviceInfoData)
3582         SetLastError(ERROR_INVALID_PARAMETER);
3583     else if (ClassInstallParamsSize != sizeof(SP_PROPCHANGE_PARAMS))
3584         SetLastError(ERROR_INVALID_PARAMETER);
3585     else if (PropChangeParams && PropChangeParams->StateChange != DICS_ENABLE
3586         && PropChangeParams->StateChange != DICS_DISABLE && PropChangeParams->StateChange != DICS_PROPCHANGE
3587         && PropChangeParams->StateChange != DICS_START && PropChangeParams->StateChange != DICS_STOP)
3588         SetLastError(ERROR_INVALID_FLAGS);
3589     else if (PropChangeParams && PropChangeParams->Scope != DICS_FLAG_GLOBAL
3590         && PropChangeParams->Scope != DICS_FLAG_CONFIGSPECIFIC)
3591         SetLastError(ERROR_INVALID_FLAGS);
3592     else if (PropChangeParams
3593         && (PropChangeParams->StateChange == DICS_START || PropChangeParams->StateChange == DICS_STOP)
3594         && PropChangeParams->Scope != DICS_FLAG_CONFIGSPECIFIC)
3595         SetLastError(ERROR_INVALID_USER_BUFFER);
3596     else
3597     {
3598         PSP_PROPCHANGE_PARAMS *CurrentPropChangeParams;
3599         if (!DeviceInfoData)
3600         {
3601             struct DeviceInfoSet *list = (struct DeviceInfoSet *)DeviceInfoSet;
3602             CurrentPropChangeParams = &list->ClassInstallParams.PropChange;
3603         }
3604         else
3605         {
3606             struct DeviceInfoElement *deviceInfo = (struct DeviceInfoElement *)DeviceInfoData->Reserved;
3607             CurrentPropChangeParams = &deviceInfo->ClassInstallParams.PropChange;
3608         }
3609         if (*CurrentPropChangeParams)
3610         {
3611             MyFree(*CurrentPropChangeParams);
3612             *CurrentPropChangeParams = NULL;
3613         }
3614         if (PropChangeParams)
3615         {
3616             *CurrentPropChangeParams = MyMalloc(sizeof(SP_PROPCHANGE_PARAMS));
3617             if (!*CurrentPropChangeParams)
3618             {
3619                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
3620                 goto done;
3621             }
3622             memcpy(*CurrentPropChangeParams, PropChangeParams, sizeof(SP_PROPCHANGE_PARAMS));
3623         }
3624         ret = TRUE;
3625     }
3626
3627 done:
3628     return ret;
3629 }
3630
3631 static DWORD
3632 GetFunctionPointer(
3633         IN PWSTR InstallerName,
3634         OUT HMODULE* ModulePointer,
3635         OUT PVOID* FunctionPointer)
3636 {
3637     HMODULE hModule = NULL;
3638     LPSTR FunctionNameA = NULL;
3639     PWCHAR Comma;
3640     DWORD rc;
3641
3642     *ModulePointer = NULL;
3643     *FunctionPointer = NULL;
3644
3645     Comma = strchrW(InstallerName, ',');
3646     if (!Comma)
3647     {
3648         rc = ERROR_INVALID_PARAMETER;
3649         goto cleanup;
3650     }
3651
3652     /* Load library */
3653     *Comma = '\0';
3654     hModule = LoadLibraryW(InstallerName);
3655     *Comma = ',';
3656     if (!hModule)
3657     {
3658         rc = GetLastError();
3659         goto cleanup;
3660     }
3661
3662     /* Skip comma spaces */
3663     while (*Comma == ',' || isspaceW(*Comma))
3664         Comma++;
3665
3666     /* W->A conversion for function name */
3667     FunctionNameA = UnicodeToMultiByte(Comma, CP_ACP);
3668     if (!FunctionNameA)
3669     {
3670         rc = GetLastError();
3671         goto cleanup;
3672     }
3673
3674     /* Search function */
3675     *FunctionPointer = GetProcAddress(hModule, FunctionNameA);
3676     if (!*FunctionPointer)
3677     {
3678         rc = GetLastError();
3679         goto cleanup;
3680     }
3681
3682     *ModulePointer = hModule;
3683     rc = ERROR_SUCCESS;
3684
3685 cleanup:
3686     if (rc != ERROR_SUCCESS && hModule)
3687         FreeLibrary(hModule);
3688     MyFree(FunctionNameA);
3689     return rc;
3690 }
3691
3692 static DWORD
3693 FreeFunctionPointer(
3694         IN HMODULE ModulePointer,
3695         IN PVOID FunctionPointer)
3696 {
3697     if (ModulePointer == NULL)
3698         return ERROR_SUCCESS;
3699     if (FreeLibrary(ModulePointer))
3700        return ERROR_SUCCESS;
3701     else
3702        return GetLastError();
3703 }
3704
3705 /***********************************************************************
3706  *              SetupDiCallClassInstaller (SETUPAPI.@)
3707  */
3708 BOOL WINAPI SetupDiCallClassInstaller(
3709        IN DI_FUNCTION InstallFunction,
3710        IN HDEVINFO DeviceInfoSet,
3711        IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL)
3712 {
3713     BOOL ret = FALSE;
3714
3715     TRACE("%u %p %p\n", InstallFunction, DeviceInfoSet, DeviceInfoData);
3716
3717     if (!DeviceInfoSet)
3718         SetLastError(ERROR_INVALID_PARAMETER);
3719     else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
3720         SetLastError(ERROR_INVALID_HANDLE);
3721     else if (((struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
3722         SetLastError(ERROR_INVALID_HANDLE);
3723     else if (((struct DeviceInfoSet *)DeviceInfoSet)->HKLM != HKEY_LOCAL_MACHINE)
3724         SetLastError(ERROR_INVALID_HANDLE);
3725     else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
3726         SetLastError(ERROR_INVALID_USER_BUFFER);
3727     else
3728     {
3729         SP_DEVINSTALL_PARAMS_W InstallParams;
3730 #define CLASS_COINSTALLER  0x1
3731 #define DEVICE_COINSTALLER 0x2
3732 #define CLASS_INSTALLER    0x4
3733         UCHAR CanHandle = 0;
3734         DEFAULT_CLASS_INSTALL_PROC DefaultHandler = NULL;
3735
3736         switch (InstallFunction)
3737         {
3738             case DIF_ALLOW_INSTALL:
3739                 CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
3740                 break;
3741             case DIF_DESTROYPRIVATEDATA:
3742                 CanHandle = CLASS_INSTALLER;
3743                 break;
3744             case DIF_INSTALLDEVICE:
3745                 CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
3746                 DefaultHandler = SetupDiInstallDevice;
3747                 break;
3748             case DIF_INSTALLDEVICEFILES:
3749                 CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
3750                 DefaultHandler = SetupDiInstallDriverFiles;
3751                 break;
3752             case DIF_INSTALLINTERFACES:
3753                 CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
3754                 DefaultHandler = SetupDiInstallDeviceInterfaces;
3755                 break;
3756             case DIF_NEWDEVICEWIZARD_FINISHINSTALL:
3757                 CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
3758                 break;
3759             case DIF_NEWDEVICEWIZARD_POSTANALYZE:
3760                 CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
3761                 break;
3762             case DIF_NEWDEVICEWIZARD_PREANALYZE:
3763                 CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
3764                 break;
3765             case DIF_PROPERTYCHANGE:
3766                 CanHandle = CLASS_COINSTALLER | DEVICE_COINSTALLER | CLASS_INSTALLER;
3767                 DefaultHandler = SetupDiChangeState;
3768                 break;
3769             case DIF_REGISTER_COINSTALLERS:
3770                 CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
3771                 DefaultHandler = SetupDiRegisterCoDeviceInstallers;
3772                 break;
3773             case DIF_SELECTBESTCOMPATDRV:
3774                 CanHandle = CLASS_COINSTALLER | CLASS_INSTALLER;
3775                 DefaultHandler = SetupDiSelectBestCompatDrv;
3776                 break;
3777             default:
3778                 ERR("Install function %u not supported\n", InstallFunction);
3779                 SetLastError(ERROR_NOT_SUPPORTED);
3780         }
3781
3782         InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
3783         if (!SetupDiGetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams))
3784             /* Don't process this call, as a parameter is invalid */
3785             CanHandle = 0;
3786
3787         if (CanHandle != 0)
3788         {
3789             LIST_ENTRY ClassCoInstallersListHead;
3790             LIST_ENTRY DeviceCoInstallersListHead;
3791             HMODULE ClassInstallerLibrary = NULL;
3792             CLASS_INSTALL_PROC ClassInstaller = NULL;
3793             COINSTALLER_CONTEXT_DATA Context;
3794             PLIST_ENTRY ListEntry;
3795             HKEY hKey;
3796             DWORD dwRegType, dwLength;
3797             DWORD rc = NO_ERROR;
3798
3799             InitializeListHead(&ClassCoInstallersListHead);
3800             InitializeListHead(&DeviceCoInstallersListHead);
3801
3802             if (CanHandle & DEVICE_COINSTALLER)
3803             {
3804                 hKey = SetupDiOpenDevRegKey(DeviceInfoSet, DeviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DRV, KEY_QUERY_VALUE);
3805                 if (hKey != INVALID_HANDLE_VALUE)
3806                 {
3807                     rc = RegQueryValueExW(hKey, REGSTR_VAL_COINSTALLERS_32, NULL, &dwRegType, NULL, &dwLength);
3808                     if (rc == ERROR_SUCCESS && dwRegType == REG_MULTI_SZ)
3809                     {
3810                         LPWSTR KeyBuffer = HeapAlloc(GetProcessHeap(), 0, dwLength);
3811                         if (KeyBuffer != NULL)
3812                         {
3813                             rc = RegQueryValueExW(hKey, REGSTR_VAL_COINSTALLERS_32, NULL, NULL, (LPBYTE)KeyBuffer, &dwLength);
3814                             if (rc == ERROR_SUCCESS)
3815                             {
3816                                 LPWSTR ptr;
3817                                 for (ptr = KeyBuffer; *ptr; ptr += strlenW(ptr) + 1)
3818                                 {
3819                                     /* Add coinstaller to DeviceCoInstallersListHead list */
3820                                     struct CoInstallerElement *coinstaller;
3821                                     TRACE("Got device coinstaller '%s'\n", debugstr_w(ptr));
3822                                     coinstaller = HeapAlloc(GetProcessHeap(), 0, sizeof(struct CoInstallerElement));
3823                                     if (!coinstaller)
3824                                         continue;
3825                                     memset(coinstaller, 0, sizeof(struct CoInstallerElement));
3826                                     if (GetFunctionPointer(ptr, &coinstaller->Module, (PVOID*)&coinstaller->Function) == ERROR_SUCCESS)
3827                                         InsertTailList(&DeviceCoInstallersListHead, &coinstaller->ListEntry);
3828                                     else
3829                                         HeapFree(GetProcessHeap(), 0, coinstaller);
3830                                 }
3831                             }
3832                             HeapFree(GetProcessHeap(), 0, KeyBuffer);
3833                         }
3834                     }
3835                     RegCloseKey(hKey);
3836                 }
3837             }
3838             if (CanHandle & CLASS_COINSTALLER)
3839             {
3840                 rc = RegOpenKeyEx(
3841                     HKEY_LOCAL_MACHINE,
3842                     REGSTR_PATH_CODEVICEINSTALLERS,
3843                     0, /* Options */
3844                     KEY_QUERY_VALUE,
3845                     &hKey);
3846                 if (rc == ERROR_SUCCESS)
3847                 {
3848                     LPWSTR lpGuidString;
3849                     if (UuidToStringW((UUID*)&DeviceInfoData->ClassGuid, &lpGuidString) == RPC_S_OK)
3850                     {
3851                         rc = RegQueryValueExW(hKey, lpGuidString, NULL, &dwRegType, NULL, &dwLength);
3852                         if (rc == ERROR_SUCCESS && dwRegType == REG_MULTI_SZ)
3853                         {
3854                             LPWSTR KeyBuffer = HeapAlloc(GetProcessHeap(), 0, dwLength);
3855                             if (KeyBuffer != NULL)
3856                             {
3857                                 rc = RegQueryValueExW(hKey, lpGuidString, NULL, NULL, (LPBYTE)KeyBuffer, &dwLength);
3858                                 if (rc == ERROR_SUCCESS)
3859                                 {
3860                                     LPWSTR ptr;
3861                                     for (ptr = KeyBuffer; *ptr; ptr += strlenW(ptr) + 1)
3862                                     {
3863                                         /* Add coinstaller to ClassCoInstallersListHead list */
3864                                         struct CoInstallerElement *coinstaller;
3865                                         TRACE("Got class coinstaller '%s'\n", debugstr_w(ptr));
3866                                         coinstaller = HeapAlloc(GetProcessHeap(), 0, sizeof(struct CoInstallerElement));
3867                                         if (!coinstaller)
3868                                             continue;
3869                                         memset(coinstaller, 0, sizeof(struct CoInstallerElement));
3870                                         if (GetFunctionPointer(ptr, &coinstaller->Module, (PVOID*)&coinstaller->Function) == ERROR_SUCCESS)
3871                                             InsertTailList(&ClassCoInstallersListHead, &coinstaller->ListEntry);
3872                                         else
3873                                             HeapFree(GetProcessHeap(), 0, coinstaller);
3874                                     }
3875                                 }
3876                                 HeapFree(GetProcessHeap(), 0, KeyBuffer);
3877                             }
3878                         }
3879                         RpcStringFreeW(&lpGuidString);
3880                     }
3881                     RegCloseKey(hKey);
3882                 }
3883             }
3884             if ((CanHandle & CLASS_INSTALLER) && !(InstallParams.FlagsEx & DI_FLAGSEX_CI_FAILED))
3885             {
3886                 hKey = SetupDiOpenClassRegKey(&DeviceInfoData->ClassGuid, KEY_QUERY_VALUE);
3887                 if (hKey != INVALID_HANDLE_VALUE)
3888                 {
3889                     rc = RegQueryValueExW(hKey, REGSTR_VAL_INSTALLER_32, NULL, &dwRegType, NULL, &dwLength);
3890                     if (rc == ERROR_SUCCESS && dwRegType == REG_SZ)
3891                     {
3892                         LPWSTR KeyBuffer = HeapAlloc(GetProcessHeap(), 0, dwLength);
3893                         if (KeyBuffer != NULL)
3894                         {
3895                             rc = RegQueryValueExW(hKey, REGSTR_VAL_INSTALLER_32, NULL, NULL, (LPBYTE)KeyBuffer, &dwLength);
3896                             if (rc == ERROR_SUCCESS)
3897                             {
3898                                 /* Get ClassInstaller function pointer */
3899                                 TRACE("Got class installer '%s'\n", debugstr_w(KeyBuffer));
3900                                 if (GetFunctionPointer(KeyBuffer, &ClassInstallerLibrary, (PVOID*)&ClassInstaller) != ERROR_SUCCESS)
3901                                 {
3902                                     InstallParams.FlagsEx |= DI_FLAGSEX_CI_FAILED;
3903                                     SetupDiSetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
3904                                 }
3905                             }
3906                             HeapFree(GetProcessHeap(), 0, KeyBuffer);
3907                         }
3908                     }
3909                     RegCloseKey(hKey);
3910                 }
3911             }
3912
3913             /* Call Class co-installers */
3914             Context.PostProcessing = FALSE;
3915             rc = NO_ERROR;
3916             ListEntry = ClassCoInstallersListHead.Flink;
3917             while (rc == NO_ERROR && ListEntry != &ClassCoInstallersListHead)
3918             {
3919                 struct CoInstallerElement *coinstaller = (struct CoInstallerElement *)ListEntry;
3920                 rc = (*coinstaller->Function)(InstallFunction, DeviceInfoSet, DeviceInfoData, &Context);
3921                 coinstaller->PrivateData = Context.PrivateData;
3922                 if (rc == ERROR_DI_POSTPROCESSING_REQUIRED)
3923                 {
3924                     coinstaller->DoPostProcessing = TRUE;
3925                     rc = NO_ERROR;
3926                 }
3927                 ListEntry = ListEntry->Flink;
3928             }
3929
3930             /* Call Device co-installers */
3931             ListEntry = DeviceCoInstallersListHead.Flink;
3932             while (rc == NO_ERROR && ListEntry != &DeviceCoInstallersListHead)
3933             {
3934                 struct CoInstallerElement *coinstaller = (struct CoInstallerElement *)ListEntry;
3935                 rc = (*coinstaller->Function)(InstallFunction, DeviceInfoSet, DeviceInfoData, &Context);
3936                 coinstaller->PrivateData = Context.PrivateData;
3937                 if (rc == ERROR_DI_POSTPROCESSING_REQUIRED)
3938                 {
3939                     coinstaller->DoPostProcessing = TRUE;
3940                     rc = NO_ERROR;
3941                 }
3942                 ListEntry = ListEntry->Flink;
3943             }
3944
3945             /* Call Class installer */
3946             if (ClassInstaller)
3947             {
3948                 rc = (*ClassInstaller)(InstallFunction, DeviceInfoSet, DeviceInfoData);
3949                 FreeFunctionPointer(ClassInstallerLibrary, ClassInstaller);
3950             }
3951             else
3952                 rc = ERROR_DI_DO_DEFAULT;
3953
3954             /* Call default handler */
3955             if (rc == ERROR_DI_DO_DEFAULT)
3956             {
3957                 if (DefaultHandler && !(InstallParams.Flags & DI_NODI_DEFAULTACTION))
3958                 {
3959                     if ((*DefaultHandler)(DeviceInfoSet, DeviceInfoData))
3960                         rc = NO_ERROR;
3961                     else
3962                         rc = GetLastError();
3963                 }
3964                 else
3965                     rc = NO_ERROR;
3966             }
3967
3968             /* Call Class co-installers that required postprocessing */
3969             Context.PostProcessing = TRUE;
3970             ListEntry = ClassCoInstallersListHead.Flink;
3971             while (ListEntry != &ClassCoInstallersListHead)
3972             {
3973                 struct CoInstallerElement *coinstaller = (struct CoInstallerElement *)ListEntry;
3974                 if (coinstaller->DoPostProcessing)
3975                 {
3976                     Context.InstallResult = rc;
3977                     Context.PrivateData = coinstaller->PrivateData;
3978                     rc = (*coinstaller->Function)(InstallFunction, DeviceInfoSet, DeviceInfoData, &Context);
3979                 }
3980                 FreeFunctionPointer(coinstaller->Module, coinstaller->Function);
3981                 ListEntry = ListEntry->Flink;
3982             }
3983
3984             /* Call Device co-installers that required postprocessing */
3985             ListEntry = DeviceCoInstallersListHead.Flink;
3986             while (ListEntry != &DeviceCoInstallersListHead)
3987             {
3988                 struct CoInstallerElement *coinstaller = (struct CoInstallerElement *)ListEntry;
3989                 if (coinstaller->DoPostProcessing)
3990                 {
3991                     Context.InstallResult = rc;
3992                     Context.PrivateData = coinstaller->PrivateData;
3993                     rc = (*coinstaller->Function)(InstallFunction, DeviceInfoSet, DeviceInfoData, &Context);
3994                 }
3995                 FreeFunctionPointer(coinstaller->Module, coinstaller->Function);
3996                 ListEntry = ListEntry->Flink;
3997             }
3998
3999             /* Free allocated memory */
4000             while (!IsListEmpty(&ClassCoInstallersListHead))
4001             {
4002                 ListEntry = RemoveHeadList(&ClassCoInstallersListHead);
4003                 HeapFree(GetProcessHeap(), 0, ListEntry);
4004             }
4005             while (!IsListEmpty(&DeviceCoInstallersListHead))
4006             {
4007                 ListEntry = RemoveHeadList(&DeviceCoInstallersListHead);
4008                 HeapFree(GetProcessHeap(), 0, ListEntry);
4009             }
4010
4011             ret = (rc == NO_ERROR);
4012         }
4013     }
4014
4015     TRACE("Returning %d\n", ret);
4016     return ret;
4017 }
4018
4019 /***********************************************************************
4020  *              SetupDiGetDeviceInfoListClass  (SETUPAPI.@)
4021  */
4022 BOOL WINAPI SetupDiGetDeviceInfoListClass(
4023         IN HDEVINFO DeviceInfoSet,
4024         OUT LPGUID ClassGuid)
4025 {
4026     struct DeviceInfoSet *list;
4027     BOOL ret = FALSE;
4028
4029     TRACE("%p %p\n", DeviceInfoSet, ClassGuid);
4030
4031     if (!DeviceInfoSet)
4032         SetLastError(ERROR_INVALID_HANDLE);
4033     else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
4034         SetLastError(ERROR_INVALID_HANDLE);
4035     else if (IsEqualIID(&list->ClassGuid, &GUID_NULL))
4036         SetLastError(ERROR_NO_ASSOCIATED_CLASS);
4037     else
4038     {
4039         memcpy(&ClassGuid, &list->ClassGuid, sizeof(GUID));
4040
4041         ret = TRUE;
4042     }
4043
4044     TRACE("Returning %d\n", ret);
4045     return ret;
4046 }
4047
4048 /***********************************************************************
4049  *              SetupDiGetDeviceInfoListDetailW  (SETUPAPI.@)
4050  */
4051 BOOL WINAPI SetupDiGetDeviceInfoListDetailW(
4052         IN HDEVINFO DeviceInfoSet,
4053         OUT PSP_DEVINFO_LIST_DETAIL_DATA_W DeviceInfoListDetailData)
4054 {
4055     struct DeviceInfoSet *list;
4056     BOOL ret = FALSE;
4057
4058     TRACE("%p %p\n", DeviceInfoSet, DeviceInfoListDetailData);
4059
4060     if (!DeviceInfoSet)
4061         SetLastError(ERROR_INVALID_HANDLE);
4062     else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
4063         SetLastError(ERROR_INVALID_HANDLE);
4064     else if (!DeviceInfoListDetailData)
4065         SetLastError(ERROR_INVALID_PARAMETER);
4066     else if (DeviceInfoListDetailData->cbSize != sizeof(SP_DEVINFO_LIST_DETAIL_DATA_W))
4067         SetLastError(ERROR_INVALID_USER_BUFFER);
4068     else
4069     {
4070         memcpy(
4071             &DeviceInfoListDetailData->ClassGuid,
4072             &list->ClassGuid,
4073             sizeof(GUID));
4074         DeviceInfoListDetailData->RemoteMachineHandle = list->hMachine;
4075         if (list->MachineName)
4076             strcpyW(DeviceInfoListDetailData->RemoteMachineName, list->MachineName + 2);
4077         else
4078             DeviceInfoListDetailData->RemoteMachineName[0] = 0;
4079
4080         ret = TRUE;
4081     }
4082
4083     TRACE("Returning %d\n", ret);
4084     return ret;
4085 }
4086
4087 /***********************************************************************
4088  *              SetupDiGetDeviceInstallParamsA (SETUPAPI.@)
4089  */
4090 BOOL WINAPI SetupDiGetDeviceInstallParamsA(
4091        IN HDEVINFO DeviceInfoSet,
4092        IN PSP_DEVINFO_DATA DeviceInfoData,
4093        OUT PSP_DEVINSTALL_PARAMS_A DeviceInstallParams)
4094 {
4095     SP_DEVINSTALL_PARAMS_W deviceInstallParamsW;
4096     BOOL ret = FALSE;
4097
4098     TRACE("%p %p %p\n", DeviceInfoSet, DeviceInfoData, DeviceInstallParams);
4099
4100     if (DeviceInstallParams == NULL)
4101         SetLastError(ERROR_INVALID_PARAMETER);
4102     else if (DeviceInstallParams->cbSize != sizeof(SP_DEVINSTALL_PARAMS_A))
4103         SetLastError(ERROR_INVALID_USER_BUFFER);
4104     else
4105     {
4106         deviceInstallParamsW.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
4107         ret = SetupDiGetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &deviceInstallParamsW);
4108
4109         if (ret)
4110         {
4111             /* Do W->A conversion */
4112             memcpy(
4113                 DeviceInstallParams,
4114                 &deviceInstallParamsW,
4115                 FIELD_OFFSET(SP_DEVINSTALL_PARAMS_W, DriverPath));
4116             if (WideCharToMultiByte(CP_ACP, 0, deviceInstallParamsW.DriverPath, -1,
4117                 DeviceInstallParams->DriverPath, MAX_PATH, NULL, NULL) == 0)
4118             {
4119                 DeviceInstallParams->DriverPath[0] = '\0';
4120                 ret = FALSE;
4121             }
4122         }
4123     }
4124
4125     TRACE("Returning %d\n", ret);
4126     return ret;
4127 }
4128
4129 /***********************************************************************
4130  *              SetupDiGetDeviceInstallParamsW (SETUPAPI.@)
4131  */
4132 BOOL WINAPI SetupDiGetDeviceInstallParamsW(
4133        IN HDEVINFO DeviceInfoSet,
4134        IN PSP_DEVINFO_DATA DeviceInfoData,
4135        OUT PSP_DEVINSTALL_PARAMS_W DeviceInstallParams)
4136 {
4137     struct DeviceInfoSet *list;
4138     BOOL ret = FALSE;
4139
4140     TRACE("%p %p %p\n", DeviceInfoSet, DeviceInfoData, DeviceInstallParams);
4141
4142     if (!DeviceInfoSet)
4143         SetLastError(ERROR_INVALID_HANDLE);
4144     else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
4145         SetLastError(ERROR_INVALID_HANDLE);
4146     else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
4147         SetLastError(ERROR_INVALID_USER_BUFFER);
4148     else if (!DeviceInstallParams)
4149         SetLastError(ERROR_INVALID_PARAMETER);
4150     else if (DeviceInstallParams->cbSize != sizeof(SP_DEVINSTALL_PARAMS_W))
4151         SetLastError(ERROR_INVALID_USER_BUFFER);
4152     else
4153     {
4154         PSP_DEVINSTALL_PARAMS_W Source;
4155
4156         if (DeviceInfoData)
4157             Source = &((struct DeviceInfoElement *)DeviceInfoData->Reserved)->InstallParams;
4158         else
4159             Source = &list->InstallParams;
4160         memcpy(DeviceInstallParams, Source, Source->cbSize);
4161         ret = TRUE;
4162     }
4163
4164     TRACE("Returning %d\n", ret);
4165     return ret;
4166 }
4167
4168 /***********************************************************************
4169  *              SetupDiSetDeviceInstallParamsW (SETUPAPI.@)
4170  */
4171 BOOL WINAPI SetupDiSetDeviceInstallParamsW(
4172        IN HDEVINFO DeviceInfoSet,
4173        IN PSP_DEVINFO_DATA DeviceInfoData,
4174        IN PSP_DEVINSTALL_PARAMS_W DeviceInstallParams)
4175 {
4176     struct DeviceInfoSet *list;
4177     BOOL ret = FALSE;
4178
4179     TRACE("%p %p %p\n", DeviceInfoSet, DeviceInfoData, DeviceInstallParams);
4180
4181     if (!DeviceInfoSet)
4182         SetLastError(ERROR_INVALID_HANDLE);
4183     else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
4184         SetLastError(ERROR_INVALID_HANDLE);
4185     else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
4186         SetLastError(ERROR_INVALID_USER_BUFFER);
4187     else if (!DeviceInstallParams)
4188         SetLastError(ERROR_INVALID_PARAMETER);
4189     else if (DeviceInstallParams->cbSize != sizeof(SP_DEVINSTALL_PARAMS_W))
4190         SetLastError(ERROR_INVALID_USER_BUFFER);
4191     else
4192     {
4193         PSP_DEVINSTALL_PARAMS_W Destination;
4194
4195         /* FIXME: Validate parameters */
4196
4197         if (DeviceInfoData)
4198             Destination = &((struct DeviceInfoElement *)DeviceInfoData->Reserved)->InstallParams;
4199         else
4200             Destination = &list->InstallParams;
4201         memcpy(Destination, DeviceInstallParams, DeviceInstallParams->cbSize);
4202         ret = TRUE;
4203     }
4204
4205     TRACE("Returning %d\n", ret);
4206     return ret;
4207 }
4208
4209 /***********************************************************************
4210  *              SetupDiGetDeviceInstanceIdA(SETUPAPI.@)
4211  */
4212 BOOL WINAPI SetupDiGetDeviceInstanceIdA(
4213         IN HDEVINFO DeviceInfoSet,
4214         IN PSP_DEVINFO_DATA DeviceInfoData,
4215         OUT PSTR DeviceInstanceId OPTIONAL,
4216         IN DWORD DeviceInstanceIdSize,
4217         OUT PDWORD RequiredSize OPTIONAL)
4218 {
4219     PWSTR DeviceInstanceIdW = NULL;
4220     BOOL ret = FALSE;
4221
4222     TRACE("%p %p %p %lu %p\n", DeviceInfoSet, DeviceInfoData,
4223           DeviceInstanceId, DeviceInstanceIdSize, RequiredSize);
4224
4225     if (!DeviceInstanceId && DeviceInstanceIdSize > 0)
4226         SetLastError(ERROR_INVALID_PARAMETER);
4227     else
4228     {
4229         if (DeviceInstanceIdSize != 0)
4230         {
4231             DeviceInstanceIdW = MyMalloc(DeviceInstanceIdSize * sizeof(WCHAR));
4232             if (DeviceInstanceIdW == NULL)
4233                 return FALSE;
4234         }
4235
4236         ret = SetupDiGetDeviceInstanceIdW(DeviceInfoSet, DeviceInfoData,
4237                                           DeviceInstanceIdW, DeviceInstanceIdSize,
4238                                           RequiredSize);
4239
4240         if (ret && DeviceInstanceIdW != NULL)
4241         {
4242             if (WideCharToMultiByte(CP_ACP, 0, DeviceInstanceIdW, -1,
4243                 DeviceInstanceId, DeviceInstanceIdSize, NULL, NULL) == 0)
4244             {
4245                 DeviceInstanceId[0] = '\0';
4246                 ret = FALSE;
4247             }
4248         }
4249     }
4250
4251     TRACE("Returning %d\n", ret);
4252     return ret;
4253 }
4254
4255 /***********************************************************************
4256  *              SetupDiGetDeviceInstanceIdW(SETUPAPI.@)
4257  */
4258 BOOL WINAPI SetupDiGetDeviceInstanceIdW(
4259         IN HDEVINFO DeviceInfoSet,
4260         IN PSP_DEVINFO_DATA DeviceInfoData,
4261         OUT PWSTR DeviceInstanceId OPTIONAL,
4262         IN DWORD DeviceInstanceIdSize,
4263         OUT PDWORD RequiredSize OPTIONAL)
4264 {
4265     BOOL ret = FALSE;
4266
4267     TRACE("%p %p %p %lu %p\n", DeviceInfoSet, DeviceInfoData,
4268           DeviceInstanceId, DeviceInstanceIdSize, RequiredSize);
4269
4270     if (!DeviceInfoSet)
4271         SetLastError(ERROR_INVALID_HANDLE);
4272     else if (((struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
4273         SetLastError(ERROR_INVALID_HANDLE);
4274     else if (!DeviceInfoData)
4275         SetLastError(ERROR_INVALID_PARAMETER);
4276     else if (DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
4277         SetLastError(ERROR_INVALID_USER_BUFFER);
4278     else if (!DeviceInstanceId && DeviceInstanceIdSize > 0)
4279         SetLastError(ERROR_INVALID_PARAMETER);
4280     else if (DeviceInstanceId && DeviceInstanceIdSize == 0)
4281         SetLastError(ERROR_INVALID_PARAMETER);
4282     else
4283     {
4284         struct DeviceInfoElement *DevInfo = (struct DeviceInfoElement *)DeviceInfoData->Reserved;
4285         DWORD required;
4286
4287         required = (wcslen(DevInfo->DeviceName) + 1) * sizeof(WCHAR);
4288         if (RequiredSize)
4289             *RequiredSize = required;
4290
4291         if (required <= DeviceInstanceIdSize)
4292         {
4293             wcscpy(DeviceInstanceId, DevInfo->DeviceName);
4294             ret = TRUE;
4295         }
4296         else
4297             SetLastError(ERROR_INSUFFICIENT_BUFFER);
4298     }
4299
4300     TRACE("Returning %d\n", ret);
4301     return ret;
4302 }
4303
4304 /***********************************************************************
4305  *              SetupDiGetClassDevPropertySheetsA(SETUPAPI.@)
4306  */
4307 BOOL WINAPI SetupDiGetClassDevPropertySheetsA(
4308         IN HDEVINFO DeviceInfoSet,
4309         IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
4310         IN LPPROPSHEETHEADERA PropertySheetHeader,
4311         IN DWORD PropertySheetHeaderPageListSize,
4312         OUT PDWORD RequiredSize OPTIONAL,
4313         IN DWORD PropertySheetType)
4314 {
4315     PROPSHEETHEADERW psh;
4316     BOOL ret = FALSE;
4317
4318     TRACE("%p %p %p 0%lx %p 0x%lx\n", DeviceInfoSet, DeviceInfoData,
4319         PropertySheetHeader, PropertySheetHeaderPageListSize,
4320         RequiredSize, PropertySheetType);
4321
4322     psh.dwFlags = PropertySheetHeader->dwFlags;
4323     psh.phpage = PropertySheetHeader->phpage;
4324     psh.nPages = PropertySheetHeader->nPages;
4325
4326     ret = SetupDiGetClassDevPropertySheetsW(DeviceInfoSet, DeviceInfoData, PropertySheetHeader ? &psh : NULL,
4327                                             PropertySheetHeaderPageListSize, RequiredSize,
4328                                             PropertySheetType);
4329     if (ret)
4330     {
4331         PropertySheetHeader->nPages = psh.nPages;
4332     }
4333
4334     TRACE("Returning %d\n", ret);
4335     return ret;
4336 }
4337
4338 struct ClassDevPropertySheetsData
4339 {
4340     HPROPSHEETPAGE *PropertySheetPages;
4341     DWORD MaximumNumberOfPages;
4342     DWORD NumberOfPages;
4343 };
4344
4345 static BOOL WINAPI GetClassDevPropertySheetsCallback(
4346         IN HPROPSHEETPAGE hPropSheetPage,
4347         IN OUT LPARAM lParam)
4348 {
4349     struct ClassDevPropertySheetsData *PropPageData;
4350
4351     PropPageData = (struct ClassDevPropertySheetsData *)lParam;
4352
4353     if (PropPageData->NumberOfPages < PropPageData->MaximumNumberOfPages)
4354     {
4355         *PropPageData->PropertySheetPages = hPropSheetPage;
4356         PropPageData->PropertySheetPages++;
4357     }
4358
4359     PropPageData->NumberOfPages++;
4360     return TRUE;
4361 }
4362
4363 /***********************************************************************
4364  *              SetupDiGetClassDevPropertySheetsW(SETUPAPI.@)
4365  */
4366 BOOL WINAPI SetupDiGetClassDevPropertySheetsW(
4367         IN HDEVINFO DeviceInfoSet,
4368         IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
4369         IN OUT LPPROPSHEETHEADERW PropertySheetHeader,
4370         IN DWORD PropertySheetHeaderPageListSize,
4371         OUT PDWORD RequiredSize OPTIONAL,
4372         IN DWORD PropertySheetType)
4373 {
4374     struct DeviceInfoSet *list;
4375     BOOL ret = FALSE;
4376
4377     TRACE("%p %p %p 0%lx %p 0x%lx\n", DeviceInfoSet, DeviceInfoData,
4378         PropertySheetHeader, PropertySheetHeaderPageListSize,
4379         RequiredSize, PropertySheetType);
4380
4381     if (!DeviceInfoSet)
4382         SetLastError(ERROR_INVALID_HANDLE);
4383     else if (((struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
4384         SetLastError(ERROR_INVALID_HANDLE);
4385     else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
4386         SetLastError(ERROR_INVALID_HANDLE);
4387     else if (!PropertySheetHeader)
4388         SetLastError(ERROR_INVALID_PARAMETER);
4389     else if (PropertySheetHeader->dwFlags & PSH_PROPSHEETPAGE)
4390         SetLastError(ERROR_INVALID_FLAGS);
4391     else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
4392         SetLastError(ERROR_INVALID_USER_BUFFER);
4393     else if (!DeviceInfoData && IsEqualIID(&list->ClassGuid, &GUID_NULL))
4394         SetLastError(ERROR_INVALID_PARAMETER);
4395     else if (!PropertySheetHeader)
4396         SetLastError(ERROR_INVALID_PARAMETER);
4397     else if (PropertySheetType != DIGCDP_FLAG_ADVANCED
4398           && PropertySheetType != DIGCDP_FLAG_BASIC
4399           && PropertySheetType != DIGCDP_FLAG_REMOTE_ADVANCED
4400           && PropertySheetType != DIGCDP_FLAG_REMOTE_BASIC)
4401         SetLastError(ERROR_INVALID_PARAMETER);
4402     else
4403     {
4404         HKEY hKey = INVALID_HANDLE_VALUE;
4405         SP_PROPSHEETPAGE_REQUEST Request;
4406         LPWSTR PropPageProvider = NULL;
4407         HMODULE hModule = NULL;
4408         PROPERTY_PAGE_PROVIDER pPropPageProvider = NULL;
4409         struct ClassDevPropertySheetsData PropPageData;
4410         DWORD dwLength, dwRegType;
4411         DWORD rc;
4412
4413         if (DeviceInfoData)
4414             hKey = SetupDiOpenDevRegKey(DeviceInfoSet, DeviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DRV, KEY_QUERY_VALUE);
4415         else
4416         {
4417             hKey = SetupDiOpenClassRegKeyExW(&list->ClassGuid, KEY_QUERY_VALUE,
4418                 DIOCR_INSTALLER, list->MachineName + 2, NULL);
4419         }
4420         if (hKey == INVALID_HANDLE_VALUE)
4421             goto cleanup;
4422
4423         rc = RegQueryValueExW(hKey, REGSTR_VAL_ENUMPROPPAGES_32, NULL, &dwRegType, NULL, &dwLength);
4424         if (rc == ERROR_FILE_NOT_FOUND)
4425         {
4426             /* No registry key. As it is optional, don't say it's a bad error */
4427             if (RequiredSize)
4428                 *RequiredSize = 0;
4429             ret = TRUE;
4430             goto cleanup;
4431         }
4432         else if (rc != ERROR_SUCCESS && dwRegType != REG_SZ)
4433         {
4434             SetLastError(rc);
4435             goto cleanup;
4436         }
4437
4438         PropPageProvider = HeapAlloc(GetProcessHeap(), 0, dwLength + sizeof(WCHAR));
4439         if (!PropPageProvider)
4440         {
4441             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
4442             goto cleanup;
4443         }
4444         rc = RegQueryValueExW(hKey, REGSTR_VAL_ENUMPROPPAGES_32, NULL, NULL, (LPBYTE)PropPageProvider, &dwLength);
4445         if (rc != ERROR_SUCCESS)
4446         {
4447             SetLastError(rc);
4448             goto cleanup;
4449         }
4450         PropPageProvider[dwLength / sizeof(WCHAR)] = 0;
4451
4452         rc = GetFunctionPointer(PropPageProvider, &hModule, (PVOID*)&pPropPageProvider);
4453         if (rc != ERROR_SUCCESS)
4454         {
4455             SetLastError(ERROR_INVALID_PROPPAGE_PROVIDER);
4456             goto cleanup;
4457         }
4458
4459         Request.cbSize = sizeof(SP_PROPSHEETPAGE_REQUEST);
4460         Request.PageRequested = SPPSR_ENUM_ADV_DEVICE_PROPERTIES;
4461         Request.DeviceInfoSet = DeviceInfoSet;
4462         Request.DeviceInfoData = DeviceInfoData;
4463         PropPageData.PropertySheetPages = &PropertySheetHeader->phpage[PropertySheetHeader->nPages];
4464         PropPageData.MaximumNumberOfPages = PropertySheetHeaderPageListSize - PropertySheetHeader->nPages;
4465         PropPageData.NumberOfPages = 0;
4466         ret = pPropPageProvider(&Request, GetClassDevPropertySheetsCallback, (LPARAM)&PropPageData);
4467         if (!ret)
4468             goto cleanup;
4469
4470         if (RequiredSize)
4471             *RequiredSize = PropPageData.NumberOfPages + PropertySheetHeader->nPages;
4472         if (PropPageData.NumberOfPages <= PropPageData.MaximumNumberOfPages)
4473         {
4474             PropertySheetHeader->nPages += PropPageData.NumberOfPages;
4475             ret = TRUE;
4476         }
4477         else
4478         {
4479             PropertySheetHeader->nPages += PropPageData.MaximumNumberOfPages;
4480             SetLastError(ERROR_INSUFFICIENT_BUFFER);
4481         }
4482
4483 cleanup:
4484         if (hKey != INVALID_HANDLE_VALUE)
4485             RegCloseKey(hKey);
4486         HeapFree(GetProcessHeap(), 0, PropPageProvider);
4487         FreeFunctionPointer(hModule, pPropPageProvider);
4488     }
4489
4490     TRACE("Returning %d\n", ret);
4491     return ret;
4492 }
4493
4494 /***********************************************************************
4495  *              SetupDiCreateDevRegKeyA (SETUPAPI.@)
4496  */
4497 HKEY WINAPI SetupDiCreateDevRegKeyA(
4498         IN HDEVINFO DeviceInfoSet,
4499         IN PSP_DEVINFO_DATA DeviceInfoData,
4500         IN DWORD Scope,
4501         IN DWORD HwProfile,
4502         IN DWORD KeyType,
4503         IN HINF InfHandle OPTIONAL,
4504         IN PCSTR InfSectionName OPTIONAL)
4505 {
4506     PCWSTR InfSectionNameW = NULL;
4507     HKEY ret = INVALID_HANDLE_VALUE;
4508
4509     if (InfSectionName)
4510     {
4511         InfSectionNameW = MultiByteToUnicode(InfSectionName, CP_ACP);
4512         if (InfSectionNameW == NULL) return INVALID_HANDLE_VALUE;
4513     }
4514
4515     ret = SetupDiCreateDevRegKeyW(DeviceInfoSet,
4516                                   DeviceInfoData,
4517                                   Scope,
4518                                   HwProfile,
4519                                   KeyType,
4520                                   InfHandle,
4521                                   InfSectionNameW);
4522
4523     if (InfSectionNameW != NULL)
4524         MyFree((PVOID)InfSectionNameW);
4525
4526     return ret;
4527 }
4528
4529 static HKEY
4530 OpenHardwareProfileKey(
4531         IN HKEY HKLM,
4532         IN DWORD HwProfile,
4533         IN DWORD samDesired)
4534 {
4535     HKEY hHWProfilesKey = INVALID_HANDLE_VALUE;
4536     HKEY hHWProfileKey = INVALID_HANDLE_VALUE;
4537     HKEY ret = INVALID_HANDLE_VALUE;
4538     LONG rc;
4539
4540     rc = RegOpenKeyExW(HKLM,
4541         REGSTR_PATH_HWPROFILES,
4542         0,
4543         0,
4544         &hHWProfilesKey);
4545     if (rc != ERROR_SUCCESS)
4546     {
4547         SetLastError(rc);
4548         goto cleanup;
4549     }
4550     if (HwProfile == 0)
4551     {
4552         rc = RegOpenKeyExW(
4553             hHWProfilesKey,
4554             REGSTR_KEY_CURRENT,
4555             0,
4556             KEY_CREATE_SUB_KEY,
4557             &hHWProfileKey);
4558     }
4559     else
4560     {
4561         WCHAR subKey[5];
4562         snprintfW(subKey, 4, L"%04lu", HwProfile);
4563         subKey[4] = '\0';
4564         rc = RegOpenKeyExW(
4565             hHWProfilesKey,
4566             subKey,
4567             0,
4568             KEY_CREATE_SUB_KEY,
4569             &hHWProfileKey);
4570     }
4571     if (rc != ERROR_SUCCESS)
4572     {
4573         SetLastError(rc);
4574         goto cleanup;
4575     }
4576     ret = hHWProfileKey;
4577
4578 cleanup:
4579     if (hHWProfilesKey != INVALID_HANDLE_VALUE)
4580         RegCloseKey(hHWProfilesKey);
4581     if (hHWProfileKey != INVALID_HANDLE_VALUE && hHWProfileKey != ret)
4582         RegCloseKey(hHWProfileKey);
4583     return ret;
4584 }
4585
4586 /***********************************************************************
4587  *              SetupDiCreateDevRegKeyW (SETUPAPI.@)
4588  */
4589 HKEY WINAPI SetupDiCreateDevRegKeyW(
4590         IN HDEVINFO DeviceInfoSet,
4591         IN PSP_DEVINFO_DATA DeviceInfoData,
4592         IN DWORD Scope,
4593         IN DWORD HwProfile,
4594         IN DWORD KeyType,
4595         IN HINF InfHandle OPTIONAL,
4596         IN PCWSTR InfSectionName OPTIONAL)
4597 {
4598     struct DeviceInfoSet *list;
4599     HKEY ret = INVALID_HANDLE_VALUE;
4600
4601     TRACE("%p %p %lu %lu %lu %p %s\n", DeviceInfoSet, DeviceInfoData,
4602           Scope, HwProfile, KeyType, InfHandle, debugstr_w(InfSectionName));
4603
4604     if (!DeviceInfoSet)
4605         SetLastError(ERROR_INVALID_HANDLE);
4606     else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
4607         SetLastError(ERROR_INVALID_HANDLE);
4608     else if (!DeviceInfoData)
4609         SetLastError(ERROR_INVALID_PARAMETER);
4610     else if (DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
4611         SetLastError(ERROR_INVALID_USER_BUFFER);
4612     else if (Scope != DICS_FLAG_GLOBAL && Scope != DICS_FLAG_CONFIGSPECIFIC)
4613         SetLastError(ERROR_INVALID_PARAMETER);
4614     else if (KeyType != DIREG_DEV && KeyType != DIREG_DRV)
4615         SetLastError(ERROR_INVALID_PARAMETER);
4616     else if (InfHandle && !InfSectionName)
4617         SetLastError(ERROR_INVALID_PARAMETER);
4618     else if (!InfHandle && InfSectionName)
4619         SetLastError(ERROR_INVALID_PARAMETER);
4620     else
4621     {
4622         LPWSTR lpGuidString = NULL;
4623         LPWSTR DriverKey = NULL; /* {GUID}\Index */
4624         LPWSTR pDeviceInstance; /* Points into DriverKey, on the Index field */
4625         DWORD Index; /* Index used in the DriverKey name */
4626         DWORD rc;
4627         HKEY hHWProfileKey = INVALID_HANDLE_VALUE;
4628         HKEY hEnumKey = INVALID_HANDLE_VALUE;
4629         HKEY hClassKey = INVALID_HANDLE_VALUE;
4630         HKEY hDeviceKey = INVALID_HANDLE_VALUE;
4631         HKEY hKey = INVALID_HANDLE_VALUE;
4632         HKEY RootKey;
4633
4634         if (Scope == DICS_FLAG_GLOBAL)
4635             RootKey = list->HKLM;
4636         else /* Scope == DICS_FLAG_CONFIGSPECIFIC */
4637         {
4638             hHWProfileKey = OpenHardwareProfileKey(list->HKLM, HwProfile, KEY_CREATE_SUB_KEY);
4639             if (hHWProfileKey == INVALID_HANDLE_VALUE)
4640                 goto cleanup;
4641             RootKey = hHWProfileKey;
4642         }
4643
4644         if (KeyType == DIREG_DEV)
4645         {
4646             struct DeviceInfoElement *deviceInfo = (struct DeviceInfoElement *)DeviceInfoData->Reserved;
4647
4648             rc = RegCreateKeyExW(
4649                 RootKey,
4650                 REGSTR_PATH_SYSTEMENUM,
4651                 0,
4652                 NULL,
4653                 REG_OPTION_NON_VOLATILE,
4654                 KEY_CREATE_SUB_KEY,
4655                 NULL,
4656                 &hEnumKey,
4657                 NULL);
4658             if (rc != ERROR_SUCCESS)
4659             {
4660                 SetLastError(rc);
4661                 goto cleanup;
4662             }
4663             rc = RegCreateKeyExW(
4664                 hEnumKey,
4665                 deviceInfo->DeviceName,
4666                 0,
4667                 NULL,
4668                 REG_OPTION_NON_VOLATILE,
4669 #if _WIN32_WINNT >= 0x502
4670                 KEY_READ | KEY_WRITE,
4671 #else
4672                 KEY_ALL_ACCESS,
4673 #endif
4674                 NULL,
4675                 &hKey,
4676                 NULL);
4677             if (rc != ERROR_SUCCESS)
4678             {
4679                 SetLastError(rc);
4680                 goto cleanup;
4681             }
4682         }
4683         else /* KeyType == DIREG_DRV */
4684         {
4685             if (UuidToStringW((UUID*)&DeviceInfoData->ClassGuid, &lpGuidString) != RPC_S_OK)
4686                 goto cleanup;
4687             /* The driver key is in \System\CurrentControlSet\Control\Class\{GUID}\Index */
4688             DriverKey = HeapAlloc(GetProcessHeap(), 0, (wcslen(lpGuidString) + 7) * sizeof(WCHAR) + sizeof(UNICODE_STRING));
4689             if (!DriverKey)
4690             {
4691                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
4692                 goto cleanup;
4693             }
4694             wcscpy(DriverKey, L"{");
4695             wcscat(DriverKey, lpGuidString);
4696             wcscat(DriverKey, L"}\\");
4697             pDeviceInstance = &DriverKey[wcslen(DriverKey)];
4698             rc = RegOpenKeyExW(RootKey,
4699                 REGSTR_PATH_CLASS_NT,
4700                 0,
4701                 KEY_CREATE_SUB_KEY,
4702                 &hClassKey);
4703             if (rc != ERROR_SUCCESS)
4704             {
4705                 SetLastError(rc);
4706                 goto cleanup;
4707             }
4708
4709             /* Try all values for Index between 0 and 9999 */
4710             Index = 0;
4711             while (Index <= 9999)
4712             {
4713                 DWORD Disposition;
4714                 wsprintf(pDeviceInstance, L"%04lu", Index);
4715                 rc = RegCreateKeyEx(hClassKey,
4716                     DriverKey,
4717                     0,
4718                     NULL,
4719                     REG_OPTION_NON_VOLATILE,
4720 #if _WIN32_WINNT >= 0x502
4721                     KEY_READ | KEY_WRITE,
4722 #else
4723                     KEY_ALL_ACCESS,
4724 #endif
4725                     NULL,
4726                     &hKey,
4727                     &Disposition);
4728                 if (rc != ERROR_SUCCESS)
4729                 {
4730                     SetLastError(rc);
4731                     goto cleanup;
4732                 }
4733                 if (Disposition == REG_CREATED_NEW_KEY)
4734                     break;
4735                 RegCloseKey(hKey);
4736                 hKey = INVALID_HANDLE_VALUE;
4737                 Index++;
4738             }
4739             if (Index > 9999)
4740             {
4741                 /* Unable to create more than 9999 devices within the same class */
4742                 SetLastError(ERROR_GEN_FAILURE);
4743                 goto cleanup;
4744             }
4745
4746             /* Open device key, to write Driver value */
4747             hDeviceKey = SetupDiOpenDevRegKey(DeviceInfoSet, DeviceInfoData, Scope, HwProfile, DIREG_DEV, KEY_SET_VALUE);
4748             if (hDeviceKey == INVALID_HANDLE_VALUE)
4749                 goto cleanup;
4750             rc = RegSetValueEx(hDeviceKey, REGSTR_VAL_DRIVER, 0, REG_SZ, (const BYTE *)DriverKey, (wcslen(DriverKey) + 1) * sizeof(WCHAR));
4751             if (rc != ERROR_SUCCESS)
4752             {
4753                 SetLastError(rc);
4754                 goto cleanup;
4755             }
4756         }
4757
4758         /* Do installation of the specified section */
4759         if (InfHandle)
4760         {
4761             FIXME("Need to install section %s in file %p\n",
4762                 debugstr_w(InfSectionName), InfHandle);
4763         }
4764         ret = hKey;
4765
4766 cleanup:
4767         if (lpGuidString)
4768             RpcStringFreeW(&lpGuidString);
4769         HeapFree(GetProcessHeap(), 0, DriverKey);
4770         if (hHWProfileKey != INVALID_HANDLE_VALUE)
4771             RegCloseKey(hHWProfileKey);
4772         if (hEnumKey != INVALID_HANDLE_VALUE)
4773             RegCloseKey(hEnumKey);
4774         if (hClassKey != INVALID_HANDLE_VALUE)
4775             RegCloseKey(hClassKey);
4776         if (hDeviceKey != INVALID_HANDLE_VALUE)
4777             RegCloseKey(hDeviceKey);
4778         if (hKey != INVALID_HANDLE_VALUE && hKey != ret)
4779             RegCloseKey(hKey);
4780     }
4781
4782     TRACE("Returning 0x%p\n", ret);
4783     return ret;
4784 }
4785
4786 /***********************************************************************
4787  *              SetupDiOpenDevRegKey (SETUPAPI.@)
4788  */
4789 HKEY WINAPI SetupDiOpenDevRegKey(
4790        HDEVINFO DeviceInfoSet,
4791        PSP_DEVINFO_DATA DeviceInfoData,
4792        DWORD Scope,
4793        DWORD HwProfile,
4794        DWORD KeyType,
4795        REGSAM samDesired)
4796 {
4797     struct DeviceInfoSet *list;
4798     HKEY ret = INVALID_HANDLE_VALUE;
4799
4800     TRACE("%p %p %lu %lu %lu 0x%lx\n", DeviceInfoSet, DeviceInfoData,
4801           Scope, HwProfile, KeyType, samDesired);
4802
4803     if (!DeviceInfoSet)
4804         SetLastError(ERROR_INVALID_HANDLE);
4805     else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
4806         SetLastError(ERROR_INVALID_HANDLE);
4807     else if (!DeviceInfoData)
4808         SetLastError(ERROR_INVALID_PARAMETER);
4809     else if (DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
4810         SetLastError(ERROR_INVALID_USER_BUFFER);
4811     else if (Scope != DICS_FLAG_GLOBAL && Scope != DICS_FLAG_CONFIGSPECIFIC)
4812         SetLastError(ERROR_INVALID_PARAMETER);
4813     else if (KeyType != DIREG_DEV && KeyType != DIREG_DRV)
4814         SetLastError(ERROR_INVALID_PARAMETER);
4815     else
4816     {
4817         struct DeviceInfoElement *deviceInfo = (struct DeviceInfoElement *)DeviceInfoData->Reserved;
4818         LPWSTR DriverKey = NULL;
4819         DWORD dwLength = 0;
4820         DWORD dwRegType;
4821         DWORD rc;
4822         HKEY hHWProfileKey = INVALID_HANDLE_VALUE;
4823         HKEY hEnumKey = INVALID_HANDLE_VALUE;
4824         HKEY hKey = INVALID_HANDLE_VALUE;
4825         HKEY RootKey;
4826
4827         if (Scope == DICS_FLAG_GLOBAL)
4828             RootKey = list->HKLM;
4829         else /* Scope == DICS_FLAG_CONFIGSPECIFIC */
4830         {
4831             hHWProfileKey = OpenHardwareProfileKey(list->HKLM, HwProfile, 0);
4832             if (hHWProfileKey == INVALID_HANDLE_VALUE)
4833                 goto cleanup;
4834             RootKey = hHWProfileKey;
4835         }
4836
4837         rc = RegOpenKeyExW(
4838             RootKey,
4839             REGSTR_PATH_SYSTEMENUM,
4840             0, /* Options */
4841             0,
4842             &hEnumKey);
4843         if (rc != ERROR_SUCCESS)
4844         {
4845             SetLastError(rc);
4846             goto cleanup;
4847         }
4848         rc = RegOpenKeyExW(
4849             hEnumKey,
4850             deviceInfo->DeviceName,
4851             0, /* Options */
4852             KeyType == DIREG_DEV ? samDesired : KEY_QUERY_VALUE,
4853             &hKey);
4854         RegCloseKey(hEnumKey);
4855         hEnumKey = INVALID_HANDLE_VALUE;
4856         if (rc != ERROR_SUCCESS)
4857         {
4858             SetLastError(rc);
4859             goto cleanup;
4860         }
4861         if (KeyType == DIREG_DEV)
4862         {
4863             /* We're done. Just return the hKey handle */
4864             ret = hKey;
4865             goto cleanup;
4866         }
4867         /* Read the 'Driver' key */
4868         rc = RegQueryValueExW(hKey, REGSTR_VAL_DRIVER, NULL, &dwRegType, NULL, &dwLength);
4869         if (rc != ERROR_SUCCESS)
4870         {
4871             SetLastError(rc);
4872             goto cleanup;
4873         }
4874         else if (dwRegType != REG_SZ)
4875         {
4876             SetLastError(ERROR_GEN_FAILURE);
4877             goto cleanup;
4878         }
4879         DriverKey = HeapAlloc(GetProcessHeap(), 0, dwLength);
4880         if (!DriverKey)
4881         {
4882             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
4883             goto cleanup;
4884         }
4885         rc = RegQueryValueExW(hKey, REGSTR_VAL_DRIVER, NULL, &dwRegType, (LPBYTE)DriverKey, &dwLength);
4886         if (rc != ERROR_SUCCESS)
4887         {
4888             SetLastError(rc);
4889             goto cleanup;
4890         }
4891         RegCloseKey(hKey);
4892         hKey = INVALID_HANDLE_VALUE;
4893         /* Need to open the driver key */
4894         rc = RegOpenKeyExW(
4895             RootKey,
4896             REGSTR_PATH_CLASS_NT,
4897             0, /* Options */
4898             0,
4899             &hEnumKey);
4900         if (rc != ERROR_SUCCESS)
4901         {
4902             SetLastError(rc);
4903             goto cleanup;
4904         }
4905         rc = RegOpenKeyExW(
4906             hEnumKey,
4907             DriverKey,
4908             0, /* Options */
4909             samDesired,
4910             &hKey);
4911         if (rc != ERROR_SUCCESS)
4912         {
4913             SetLastError(rc);
4914             goto cleanup;
4915         }
4916         ret = hKey;
4917
4918 cleanup:
4919         if (hHWProfileKey != INVALID_HANDLE_VALUE)
4920             RegCloseKey(hHWProfileKey);
4921         if (hEnumKey != INVALID_HANDLE_VALUE)
4922             RegCloseKey(hEnumKey);
4923         if (hKey != INVALID_HANDLE_VALUE && hKey != ret)
4924             RegCloseKey(hKey);
4925     }
4926
4927     TRACE("Returning 0x%p\n", ret);
4928     return ret;
4929 }
4930
4931 /***********************************************************************
4932  *              SetupDiCreateDeviceInfoA (SETUPAPI.@)
4933  */
4934 BOOL WINAPI SetupDiCreateDeviceInfoA(
4935        HDEVINFO DeviceInfoSet,
4936        PCSTR DeviceName,
4937        CONST GUID *ClassGuid,
4938        PCSTR DeviceDescription,
4939        HWND hwndParent,
4940        DWORD CreationFlags,
4941        PSP_DEVINFO_DATA DeviceInfoData)
4942 {
4943     LPWSTR DeviceNameW = NULL;
4944     LPWSTR DeviceDescriptionW = NULL;
4945     BOOL bResult;
4946
4947     TRACE("\n");
4948
4949     if (DeviceName)
4950     {
4951         DeviceNameW = MultiByteToUnicode(DeviceName, CP_ACP);
4952         if (DeviceNameW == NULL) return FALSE;
4953     }
4954     if (DeviceDescription)
4955     {
4956         DeviceDescriptionW = MultiByteToUnicode(DeviceDescription, CP_ACP);
4957         if (DeviceDescriptionW == NULL)
4958         {
4959             if (DeviceNameW) MyFree(DeviceNameW);
4960             return FALSE;
4961         }
4962     }
4963
4964     bResult = SetupDiCreateDeviceInfoW(DeviceInfoSet, DeviceNameW,
4965                                        ClassGuid, DeviceDescriptionW,
4966                                        hwndParent, CreationFlags,
4967                                        DeviceInfoData);
4968
4969     if (DeviceNameW) MyFree(DeviceNameW);
4970     if (DeviceDescriptionW) MyFree(DeviceDescriptionW);
4971
4972     return bResult;
4973 }
4974
4975 /***********************************************************************
4976  *              SetupDiCreateDeviceInfoW (SETUPAPI.@)
4977  */
4978 BOOL WINAPI SetupDiCreateDeviceInfoW(
4979        HDEVINFO DeviceInfoSet,
4980        PCWSTR DeviceName,
4981        CONST GUID *ClassGuid,
4982        PCWSTR DeviceDescription,
4983        HWND hwndParent,
4984        DWORD CreationFlags,
4985        PSP_DEVINFO_DATA DeviceInfoData)
4986 {
4987     struct DeviceInfoSet *list;
4988     BOOL ret = FALSE;
4989
4990     TRACE("%p %S %s %S %p %lx %p\n", DeviceInfoSet, DeviceName,
4991         debugstr_guid(ClassGuid), DeviceDescription,
4992         hwndParent, CreationFlags, DeviceInfoData);
4993
4994     if (!DeviceInfoSet)
4995         SetLastError(ERROR_INVALID_HANDLE);
4996     else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
4997         SetLastError(ERROR_INVALID_HANDLE);
4998     else if (!ClassGuid)
4999         SetLastError(ERROR_INVALID_PARAMETER);
5000     else if (!IsEqualIID(&list->ClassGuid, &GUID_NULL) && !IsEqualIID(&list->ClassGuid, ClassGuid))
5001         SetLastError(ERROR_CLASS_MISMATCH);
5002     else if (CreationFlags & ~(DICD_GENERATE_ID | DICD_INHERIT_CLASSDRVS))
5003     {
5004         TRACE("Unknown flags: 0x%08lx\n", CreationFlags & ~(DICD_GENERATE_ID | DICD_INHERIT_CLASSDRVS));
5005         SetLastError(ERROR_INVALID_FLAGS);
5006     }
5007     else
5008     {
5009         SP_DEVINFO_DATA DevInfo;
5010
5011         if (CreationFlags & DICD_GENERATE_ID)
5012         {
5013             /* Generate a new unique ID for this device */
5014             SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5015             FIXME("not implemented\n");
5016         }
5017         else
5018         {
5019             /* Device name is fully qualified. Try to open it */
5020             BOOL rc;
5021
5022             DevInfo.cbSize = sizeof(SP_DEVINFO_DATA);
5023             rc = SetupDiOpenDeviceInfoW(
5024                 DeviceInfoSet,
5025                 DeviceName,
5026                 NULL, /* hwndParent */
5027                 CreationFlags & DICD_INHERIT_CLASSDRVS ? DIOD_INHERIT_CLASSDRVS : 0,
5028                 &DevInfo);
5029
5030             if (rc)
5031             {
5032                 /* SetupDiOpenDeviceInfoW has already added
5033                  * the device info to the device info set
5034                  */
5035                 SetLastError(ERROR_DEVINST_ALREADY_EXISTS);
5036             }
5037             else if (GetLastError() == ERROR_FILE_NOT_FOUND)
5038             {
5039                 struct DeviceInfoElement *deviceInfo;
5040
5041                 if (CreateDeviceInfoElement(list, DeviceName, ClassGuid, &deviceInfo))
5042                 {
5043                     InsertTailList(&list->ListHead, &deviceInfo->ListEntry);
5044
5045                     if (!DeviceInfoData)
5046                         ret = TRUE;
5047                     else
5048                     {
5049                         if (DeviceInfoData->cbSize != sizeof(PSP_DEVINFO_DATA))
5050                         {
5051                             SetLastError(ERROR_INVALID_USER_BUFFER);
5052                         }
5053                         else
5054                         {
5055                             memcpy(&DeviceInfoData->ClassGuid, ClassGuid, sizeof(GUID));
5056                             DeviceInfoData->DevInst = deviceInfo->dnDevInst;
5057                             DeviceInfoData->Reserved = (ULONG_PTR)deviceInfo;
5058                             ret = TRUE;
5059                         }
5060                     }
5061                 }
5062             }
5063         }
5064     }
5065
5066     TRACE("Returning %d\n", ret);
5067     return ret;
5068 }
5069
5070 /***********************************************************************
5071  *              Helper functions for SetupDiBuildDriverInfoList
5072  */
5073 static BOOL
5074 AddDriverToList(
5075     IN PLIST_ENTRY DriverListHead,
5076     IN DWORD DriverType, /* SPDIT_CLASSDRIVER or SPDIT_COMPATDRIVER */
5077     IN LPGUID ClassGuid,
5078     IN INFCONTEXT ContextDevice,
5079     IN struct InfFileDetails *InfFileDetails,
5080     IN LPCWSTR InfFile,
5081     IN LPCWSTR ProviderName,
5082     IN LPCWSTR ManufacturerName,
5083     IN LPCWSTR MatchingId,
5084     FILETIME DriverDate,
5085     DWORDLONG DriverVersion,
5086     IN DWORD Rank)
5087 {
5088     struct DriverInfoElement *driverInfo = NULL;
5089     HANDLE hFile = INVALID_HANDLE_VALUE;
5090     DWORD RequiredSize = 128; /* Initial buffer size */
5091     BOOL Result = FALSE;
5092     PLIST_ENTRY PreviousEntry;
5093     LPWSTR InfInstallSection = NULL;
5094     BOOL ret = FALSE;
5095
5096     driverInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(struct DriverInfoElement));
5097     if (!driverInfo)
5098     {
5099         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
5100         goto cleanup;
5101     }
5102     memset(driverInfo, 0, sizeof(struct DriverInfoElement));
5103
5104     driverInfo->Details.cbSize = sizeof(SP_DRVINFO_DETAIL_DATA);
5105     driverInfo->Details.Reserved = (ULONG_PTR)driverInfo;
5106
5107     /* Copy InfFileName field */
5108     wcsncpy(driverInfo->Details.InfFileName, InfFile, MAX_PATH - 1);
5109     driverInfo->Details.InfFileName[MAX_PATH - 1] = '\0';
5110
5111     /* Fill InfDate field */
5112     /* FIXME: hFile = CreateFile(driverInfo->Details.InfFileName,
5113         GENERIC_READ, FILE_SHARE_READ,
5114         NULL, OPEN_EXISTING, 0, NULL);
5115     if (hFile == INVALID_HANDLE_VALUE)
5116         goto cleanup;
5117     Result = GetFileTime(hFile, NULL, NULL, &driverInfo->Details.InfDate);
5118     if (!Result)
5119         goto cleanup;*/
5120
5121     /* Fill SectionName field */
5122     Result = SetupGetStringFieldW(
5123         &ContextDevice,
5124         1,
5125         driverInfo->Details.SectionName, LINE_LEN,
5126         NULL);
5127     if (!Result)
5128         goto cleanup;
5129
5130     /* Fill DrvDescription field */
5131     Result = SetupGetStringFieldW(
5132         &ContextDevice,
5133         0, /* Field index */
5134         driverInfo->Details.DrvDescription, LINE_LEN,
5135         NULL);
5136
5137     /* Copy MatchingId information */
5138     if (MatchingId)
5139     {
5140         driverInfo->MatchingId = HeapAlloc(GetProcessHeap(), 0, (wcslen(MatchingId) + 1) * sizeof(WCHAR));
5141         if (!driverInfo->MatchingId)
5142         {
5143             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
5144             goto cleanup;
5145         }
5146         RtlCopyMemory(driverInfo->MatchingId, MatchingId, (wcslen(MatchingId) + 1) * sizeof(WCHAR));
5147     }
5148     else
5149         driverInfo->MatchingId = NULL;
5150
5151     /* Get inf install section */
5152     Result = FALSE;
5153     RequiredSize = 128; /* Initial buffer size */
5154     SetLastError(ERROR_INSUFFICIENT_BUFFER);
5155     while (!Result && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
5156     {
5157         HeapFree(GetProcessHeap(), 0, InfInstallSection);
5158         InfInstallSection = HeapAlloc(GetProcessHeap(), 0, RequiredSize * sizeof(WCHAR));
5159         if (!InfInstallSection)
5160             goto cleanup;
5161         Result = SetupGetStringFieldW(
5162             &ContextDevice,
5163             1, /* Field index */
5164             InfInstallSection, RequiredSize,
5165             &RequiredSize);
5166     }
5167     if (!Result)
5168         goto cleanup;
5169
5170     TRACE("Adding driver '%S' [%S/%S] (Rank 0x%lx)\n",
5171         driverInfo->Details.DrvDescription, InfFile, InfInstallSection, Rank);
5172
5173     driverInfo->DriverRank = Rank;
5174     memcpy(&driverInfo->DriverDate, &DriverDate, sizeof(FILETIME));
5175     memcpy(&driverInfo->ClassGuid, ClassGuid, sizeof(GUID));
5176     driverInfo->Info.DriverType = DriverType;
5177     driverInfo->Info.Reserved = (ULONG_PTR)driverInfo;
5178     wcsncpy(driverInfo->Info.Description, driverInfo->Details.DrvDescription, LINE_LEN - 1);
5179     driverInfo->Info.Description[LINE_LEN - 1] = '\0';
5180     wcsncpy(driverInfo->Info.MfgName, ManufacturerName, LINE_LEN - 1);
5181     driverInfo->Info.MfgName[LINE_LEN - 1] = '\0';
5182     if (ProviderName)
5183     {
5184         wcsncpy(driverInfo->Info.ProviderName, ProviderName, LINE_LEN - 1);
5185         driverInfo->Info.ProviderName[LINE_LEN - 1] = '\0';
5186     }
5187     else
5188         driverInfo->Info.ProviderName[0] = '\0';
5189     driverInfo->Info.DriverDate = DriverDate;
5190     driverInfo->Info.DriverVersion = DriverVersion;
5191     ReferenceInfFile(InfFileDetails);
5192     driverInfo->InfFileDetails = InfFileDetails;
5193
5194     /* Insert current driver in driver list, according to its rank */
5195     PreviousEntry = DriverListHead->Flink;
5196     while (PreviousEntry != DriverListHead)
5197     {
5198         struct DriverInfoElement *CurrentDriver;
5199         CurrentDriver = CONTAINING_RECORD(PreviousEntry, struct DriverInfoElement, ListEntry);
5200         if (CurrentDriver->DriverRank > Rank ||
5201             (CurrentDriver->DriverRank == Rank && CurrentDriver->DriverDate.QuadPart > driverInfo->DriverDate.QuadPart))
5202         {
5203             /* Insert before the current item */
5204             InsertHeadList(PreviousEntry, &driverInfo->ListEntry);
5205             break;
5206         }
5207         PreviousEntry = PreviousEntry->Flink;
5208     }
5209     if (PreviousEntry == DriverListHead)
5210     {
5211         /* Insert at the end of the list */
5212         InsertTailList(DriverListHead, &driverInfo->ListEntry);
5213     }
5214
5215     ret = TRUE;
5216
5217 cleanup:
5218     if (!ret)
5219     {
5220         if (driverInfo)
5221             HeapFree(GetProcessHeap(), 0, driverInfo->MatchingId);
5222         HeapFree(GetProcessHeap(), 0, driverInfo);
5223     }
5224     if (hFile != INVALID_HANDLE_VALUE)
5225         CloseHandle(hFile);
5226     HeapFree(GetProcessHeap(), 0, InfInstallSection);
5227
5228     return ret;
5229 }
5230
5231 static BOOL
5232 GetVersionInformationFromInfFile(
5233     IN HINF hInf,
5234     OUT LPGUID ClassGuid,
5235     OUT LPWSTR* pProviderName,
5236     OUT FILETIME* DriverDate,
5237     OUT DWORDLONG* DriverVersion)
5238 {
5239     DWORD RequiredSize;
5240     WCHAR guidW[MAX_GUID_STRING_LEN + 1];
5241     LPWSTR DriverVer = NULL;
5242     LPWSTR ProviderName = NULL;
5243     LPWSTR pComma; /* Points into DriverVer */
5244     LPWSTR pVersion = NULL; /* Points into DriverVer */
5245     SYSTEMTIME SystemTime;
5246     BOOL Result;
5247     BOOL ret = FALSE; /* Final result */
5248
5249     /* Get class Guid */
5250     if (!SetupGetLineTextW(
5251         NULL, /* Context */
5252         hInf,
5253         L"Version", L"ClassGUID",
5254         guidW, sizeof(guidW),
5255         NULL /* Required size */))
5256     {
5257         goto cleanup;
5258     }
5259     guidW[37] = '\0'; /* Replace the } by a NULL character */
5260     if (UuidFromStringW(&guidW[1], ClassGuid) != RPC_S_OK)
5261     {
5262         SetLastError(ERROR_GEN_FAILURE);
5263         goto cleanup;
5264     }
5265
5266     /* Get provider name */
5267     Result = SetupGetLineTextW(
5268         NULL, /* Context */
5269         hInf, L"Version", L"Provider",
5270         NULL, 0,
5271         &RequiredSize);
5272     if (Result)
5273     {
5274         /* We know know the needed buffer size */
5275         ProviderName = HeapAlloc(GetProcessHeap(), 0, RequiredSize * sizeof(WCHAR));
5276         if (!ProviderName)
5277         {
5278             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
5279             goto cleanup;
5280         }
5281         Result = SetupGetLineTextW(
5282             NULL, /* Context */
5283             hInf, L"Version", L"Provider",
5284             ProviderName, RequiredSize,
5285             &RequiredSize);
5286     }
5287     if (!Result)
5288         goto cleanup;
5289     *pProviderName = ProviderName;
5290
5291     /* Read the "DriverVer" value */
5292     Result = SetupGetLineTextW(
5293         NULL, /* Context */
5294         hInf, L"Version", L"DriverVer",
5295         NULL, 0,
5296         &RequiredSize);
5297     if (Result)
5298     {
5299         /* We know know the needed buffer size */
5300         DriverVer = HeapAlloc(GetProcessHeap(), 0, RequiredSize * sizeof(WCHAR));
5301         if (!DriverVer)
5302         {
5303             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
5304             goto cleanup;
5305         }
5306         Result = SetupGetLineTextW(
5307             NULL, /* Context */
5308             hInf, L"Version", L"DriverVer",
5309             DriverVer, RequiredSize,
5310             &RequiredSize);
5311     }
5312     if (!Result)
5313         goto cleanup;
5314
5315     /* Get driver date and driver version, by analyzing the "DriverVer" value */
5316     pComma = wcschr(DriverVer, ',');
5317     if (pComma != NULL)
5318     {
5319         *pComma = UNICODE_NULL;
5320         pVersion = pComma + 1;
5321     }
5322     /* Get driver date version. Invalid date = 00/00/00 */
5323     memset(DriverDate, 0, sizeof(FILETIME));
5324     if (wcslen(DriverVer) == 10
5325         && (DriverVer[2] == '-' || DriverVer[2] == '/')
5326         && (DriverVer[5] == '-' || DriverVer[5] == '/'))
5327     {
5328         memset(&SystemTime, 0, sizeof(SYSTEMTIME));
5329         DriverVer[2] = DriverVer[5] = UNICODE_NULL;
5330         SystemTime.wMonth = ((DriverVer[0] - '0') * 10) + DriverVer[1] - '0';
5331         SystemTime.wDay  = ((DriverVer[3] - '0') * 10) + DriverVer[4] - '0';
5332         SystemTime.wYear = ((DriverVer[6] - '0') * 1000) + ((DriverVer[7] - '0') * 100) + ((DriverVer[8] - '0') * 10) + DriverVer[9] - '0';
5333         SystemTimeToFileTime(&SystemTime, DriverDate);
5334     }
5335     /* Get driver version. Invalid version = 0.0.0.0 */
5336     *DriverVersion = 0;
5337     if (pVersion)
5338     {
5339         WORD Major, Minor = 0, Revision = 0, Build = 0;
5340         LPWSTR pMinor = NULL, pRevision = NULL, pBuild = NULL;
5341         LARGE_INTEGER fullVersion;
5342
5343         pMinor = strchrW(pVersion, '.');
5344         if (pMinor)
5345         {
5346             *pMinor = 0;
5347             pRevision = strchrW(++pMinor, '.');
5348             Minor = atoiW(pMinor);
5349         }
5350         if (pRevision)
5351         {
5352             *pRevision = 0;
5353             pBuild = strchrW(++pRevision, '.');
5354             Revision = atoiW(pRevision);
5355         }
5356         if (pBuild)
5357         {
5358             *pBuild = 0;
5359             pBuild++;
5360             Build = atoiW(pBuild);
5361         }
5362         Major = atoiW(pVersion);
5363         fullVersion.u.HighPart = Major << 16 | Minor;
5364         fullVersion.u.LowPart = Revision << 16 | Build;
5365         memcpy(DriverVersion, &fullVersion, sizeof(LARGE_INTEGER));
5366     }
5367
5368     ret = TRUE;
5369
5370 cleanup:
5371     if (!ret)
5372         HeapFree(GetProcessHeap(), 0, ProviderName);
5373     HeapFree(GetProcessHeap(), 0, DriverVer);
5374
5375     return ret;
5376 }
5377
5378 /***********************************************************************
5379  *              SetupDiBuildDriverInfoList (SETUPAPI.@)
5380  */
5381 BOOL WINAPI
5382 SetupDiBuildDriverInfoList(
5383     IN HDEVINFO DeviceInfoSet,
5384     IN OUT PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
5385     IN DWORD DriverType)
5386 {
5387     struct DeviceInfoSet *list;
5388     SP_DEVINSTALL_PARAMS_W InstallParams;
5389     PVOID Buffer = NULL;
5390     struct InfFileDetails *currentInfFileDetails = NULL;
5391     LPWSTR ProviderName = NULL;
5392     LPWSTR ManufacturerName = NULL;
5393     WCHAR ManufacturerSection[LINE_LEN + 1];
5394     LPWSTR HardwareIDs = NULL;
5395     LPWSTR CompatibleIDs = NULL;
5396     LPWSTR FullInfFileName = NULL;
5397     FILETIME DriverDate;
5398     DWORDLONG DriverVersion = 0;
5399     DWORD RequiredSize;
5400     BOOL ret = FALSE;
5401
5402     TRACE("%p %p %ld\n", DeviceInfoSet, DeviceInfoData, DriverType);
5403
5404     if (!DeviceInfoSet)
5405         SetLastError(ERROR_INVALID_HANDLE);
5406     else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
5407         SetLastError(ERROR_INVALID_HANDLE);
5408     else if (list->HKLM != HKEY_LOCAL_MACHINE)
5409         SetLastError(ERROR_INVALID_HANDLE);
5410     else if (DriverType != SPDIT_CLASSDRIVER && DriverType != SPDIT_COMPATDRIVER)
5411         SetLastError(ERROR_INVALID_PARAMETER);
5412     else if (DriverType == SPDIT_COMPATDRIVER && !DeviceInfoData)
5413         SetLastError(ERROR_INVALID_PARAMETER);
5414     else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
5415         SetLastError(ERROR_INVALID_USER_BUFFER);
5416     else
5417     {
5418         BOOL Result;
5419
5420         InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
5421         Result = SetupDiGetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
5422         if (!Result)
5423             goto done;
5424
5425         if (DriverType == SPDIT_COMPATDRIVER)
5426         {
5427             /* Get hardware IDs list */
5428             Result = FALSE;
5429             RequiredSize = 512; /* Initial buffer size */
5430             SetLastError(ERROR_INSUFFICIENT_BUFFER);
5431             while (!Result && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
5432             {
5433                 HeapFree(GetProcessHeap(), 0, HardwareIDs);
5434                 HardwareIDs = HeapAlloc(GetProcessHeap(), 0, RequiredSize);
5435                 if (!HardwareIDs)
5436                 {
5437                     SetLastError(ERROR_NOT_ENOUGH_MEMORY);
5438                     goto done;
5439                 }
5440                 Result = SetupDiGetDeviceRegistryPropertyW(
5441                     DeviceInfoSet,
5442                     DeviceInfoData,
5443                     SPDRP_HARDWAREID,
5444                     NULL,
5445                     (PBYTE)HardwareIDs,
5446                     RequiredSize,
5447                     &RequiredSize);
5448             }
5449             if (!Result)
5450                 goto done;
5451
5452             /* Get compatible IDs list */
5453             Result = FALSE;
5454             RequiredSize = 512; /* Initial buffer size */
5455             SetLastError(ERROR_INSUFFICIENT_BUFFER);
5456             while (!Result && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
5457             {
5458                 HeapFree(GetProcessHeap(), 0, CompatibleIDs);
5459                 CompatibleIDs = HeapAlloc(GetProcessHeap(), 0, RequiredSize);
5460                 if (!CompatibleIDs)
5461                 {
5462                     SetLastError(ERROR_NOT_ENOUGH_MEMORY);
5463                     goto done;
5464                 }
5465                 Result = SetupDiGetDeviceRegistryPropertyW(
5466                     DeviceInfoSet,
5467                     DeviceInfoData,
5468                     SPDRP_COMPATIBLEIDS,
5469                     NULL,
5470                     (PBYTE)CompatibleIDs,
5471                     RequiredSize,
5472                     &RequiredSize);
5473                 if (!Result && GetLastError() == ERROR_FILE_NOT_FOUND)
5474                 {
5475                     /* No compatible ID for this device */
5476                     HeapFree(GetProcessHeap(), 0, CompatibleIDs);
5477                     CompatibleIDs = NULL;
5478                     Result = TRUE;
5479                 }
5480             }
5481             if (!Result)
5482                 goto done;
5483         }
5484
5485         if (InstallParams.Flags & DI_ENUMSINGLEINF)
5486         {
5487             /* InstallParams.DriverPath contains the name of a .inf file */
5488             RequiredSize = wcslen(InstallParams.DriverPath) + 2;
5489             Buffer = HeapAlloc(GetProcessHeap(), 0, RequiredSize * sizeof(WCHAR));
5490             if (!Buffer)
5491             {
5492                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
5493                 goto done;
5494             }
5495             wcscpy(Buffer, InstallParams.DriverPath);
5496             ((LPWSTR)Buffer)[RequiredSize - 1] = 0;
5497             Result = TRUE;
5498         }
5499         else
5500         {
5501             /* Enumerate .inf files */
5502             Result = FALSE;
5503             RequiredSize = 32768; /* Initial buffer size */
5504             SetLastError(ERROR_INSUFFICIENT_BUFFER);
5505             while (!Result && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
5506             {
5507                 HeapFree(GetProcessHeap(), 0, Buffer);
5508                 Buffer = HeapAlloc(GetProcessHeap(), 0, RequiredSize * sizeof(WCHAR));
5509                 if (!Buffer)
5510                 {
5511                     Result = FALSE;
5512                     SetLastError(ERROR_NOT_ENOUGH_MEMORY);
5513                     break;
5514                 }
5515                 Result = SetupGetInfFileListW(
5516                     *InstallParams.DriverPath ? InstallParams.DriverPath : NULL,
5517                     INF_STYLE_WIN4,
5518                     Buffer, RequiredSize,
5519                     &RequiredSize);
5520             }
5521             if (!Result && GetLastError() == ERROR_FILE_NOT_FOUND)
5522             {
5523                 /* No .inf file in specified directory. So, we should
5524                  * success as we created an empty driver info list.
5525                  */
5526                 ret = TRUE;
5527                 goto done;
5528             }
5529         }
5530         if (Result)
5531         {
5532             LPCWSTR filename;
5533             LPWSTR pFullFilename;
5534
5535             if (InstallParams.Flags & DI_ENUMSINGLEINF)
5536             {
5537                 FullInfFileName = HeapAlloc(GetProcessHeap(), 0, MAX_PATH);
5538                 if (!FullInfFileName)
5539                     goto done;
5540                 pFullFilename = &FullInfFileName[0];
5541             }
5542             else if (*InstallParams.DriverPath)
5543             {
5544                 DWORD len;
5545                 len = GetFullPathNameW(InstallParams.DriverPath, 0, NULL, NULL);
5546                 if (len == 0)
5547                     goto done;
5548                 FullInfFileName = HeapAlloc(GetProcessHeap(), 0, len + MAX_PATH);
5549                 if (!FullInfFileName)
5550                     goto done;
5551                 len = GetFullPathNameW(InstallParams.DriverPath, len, FullInfFileName, NULL);
5552                 if (len == 0)
5553                     goto done;
5554                 if (*FullInfFileName && FullInfFileName[wcslen(FullInfFileName) - 1] != '\\')
5555                     wcscat(FullInfFileName, L"\\");
5556                 pFullFilename = &FullInfFileName[wcslen(FullInfFileName)];
5557             }
5558             else
5559             {
5560                 FullInfFileName = HeapAlloc(GetProcessHeap(), 0, MAX_PATH);
5561                 if (!FullInfFileName)
5562                     goto done;
5563                 pFullFilename = &FullInfFileName[0];
5564             }
5565
5566             for (filename = (LPCWSTR)Buffer; *filename; filename += wcslen(filename) + 1)
5567             {
5568                 INFCONTEXT ContextManufacturer, ContextDevice;
5569                 GUID ClassGuid;
5570
5571                 wcscpy(pFullFilename, filename);
5572                 TRACE("Opening file %S\n", FullInfFileName);
5573
5574                 currentInfFileDetails = HeapAlloc(
5575                     GetProcessHeap(),
5576                     0,
5577                     FIELD_OFFSET(struct InfFileDetails, FullInfFileName) + wcslen(FullInfFileName) * sizeof(WCHAR) + UNICODE_NULL);
5578                 if (!currentInfFileDetails)
5579                     continue;
5580                 memset(currentInfFileDetails, 0, sizeof(struct InfFileDetails));
5581                 wcscpy(currentInfFileDetails->FullInfFileName, FullInfFileName);
5582
5583                 currentInfFileDetails->hInf = SetupOpenInfFileW(FullInfFileName, NULL, INF_STYLE_WIN4, NULL);
5584                 ReferenceInfFile(currentInfFileDetails);
5585                 if (currentInfFileDetails->hInf == INVALID_HANDLE_VALUE)
5586                 {
5587                     HeapFree(GetProcessHeap(), 0, currentInfFileDetails);
5588                     currentInfFileDetails = NULL;
5589                     continue;
5590                 }
5591
5592                 if (!GetVersionInformationFromInfFile(
5593                     currentInfFileDetails->hInf,
5594                     &ClassGuid,
5595                     &ProviderName,
5596                     &DriverDate,
5597                     &DriverVersion))
5598                 {
5599                     SetupCloseInfFile(currentInfFileDetails->hInf);
5600                     HeapFree(GetProcessHeap(), 0, currentInfFileDetails->hInf);
5601                     currentInfFileDetails = NULL;
5602                     continue;
5603                 }
5604
5605                 if (DriverType == SPDIT_CLASSDRIVER)
5606                 {
5607                     /* Check if the ClassGuid in this .inf file is corresponding with our needs */
5608                     if (!IsEqualIID(&list->ClassGuid, &GUID_NULL) && !IsEqualIID(&list->ClassGuid, &ClassGuid))
5609                     {
5610                         goto next;
5611                     }
5612                 }
5613
5614                 /* Get the manufacturers list */
5615                 Result = SetupFindFirstLineW(currentInfFileDetails->hInf, L"Manufacturer", NULL, &ContextManufacturer);
5616                 while (Result)
5617                 {
5618                     Result = SetupGetStringFieldW(
5619                         &ContextManufacturer,
5620                         0, /* Field index */
5621                         NULL, 0,
5622                         &RequiredSize);
5623                     if (Result)
5624                     {
5625                         /* We got the needed size for the buffer */
5626                         ManufacturerName = HeapAlloc(GetProcessHeap(), 0, RequiredSize * sizeof(WCHAR));
5627                         if (!ManufacturerName)
5628                         {
5629                             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
5630                             goto done;
5631                         }
5632                         Result = SetupGetStringFieldW(
5633                             &ContextManufacturer,
5634                             0, /* Field index */
5635                             ManufacturerName, RequiredSize,
5636                             &RequiredSize);
5637                     }
5638                     /* Get manufacturer section name */
5639                     Result = SetupGetStringFieldW(
5640                         &ContextManufacturer,
5641                         1, /* Field index */
5642                         ManufacturerSection, LINE_LEN,
5643                         &RequiredSize);
5644                     if (Result)
5645                     {
5646                         ManufacturerSection[RequiredSize] = 0; /* Final NULL char */
5647                         /* Add (possible) extension to manufacturer section name */
5648                         Result = SetupDiGetActualSectionToInstallW(
5649                             currentInfFileDetails->hInf, ManufacturerSection, ManufacturerSection, LINE_LEN, NULL, NULL);
5650                         if (Result)
5651                         {
5652                             TRACE("Enumerating devices in manufacturer %S\n", ManufacturerSection);
5653                             Result = SetupFindFirstLineW(currentInfFileDetails->hInf, ManufacturerSection, NULL, &ContextDevice);
5654                         }
5655                     }
5656                     while (Result)
5657                     {
5658                         if (DriverType == SPDIT_CLASSDRIVER)
5659                         {
5660                             /* FIXME: read [ControlFlags] / ExcludeFromSelect */
5661                             if (!AddDriverToList(
5662                                 &list->DriverListHead,
5663                                 DriverType,
5664                                 &ClassGuid,
5665                                 ContextDevice,
5666                                 currentInfFileDetails,
5667                                 filename,
5668                                 ProviderName,
5669                                 ManufacturerName,
5670                                 NULL,
5671                                 DriverDate, DriverVersion,
5672                                 0))
5673                             {
5674                                 break;
5675                             }
5676                         }
5677                         else /* DriverType = SPDIT_COMPATDRIVER */
5678                         {
5679                             /* 1. Get all fields */
5680                             DWORD FieldCount = SetupGetFieldCount(&ContextDevice);
5681                             DWORD DriverRank;
5682                             DWORD i;
5683                             LPCWSTR currentId;
5684                             BOOL DriverAlreadyAdded;
5685
5686                             for (i = 2; i <= FieldCount; i++)
5687                             {
5688                                 LPWSTR DeviceId = NULL;
5689                                 Result = FALSE;
5690                                 RequiredSize = 128; /* Initial buffer size */
5691                                 SetLastError(ERROR_INSUFFICIENT_BUFFER);
5692                                 while (!Result && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
5693                                 {
5694                                     HeapFree(GetProcessHeap(), 0, DeviceId);
5695                                     DeviceId = HeapAlloc(GetProcessHeap(), 0, RequiredSize * sizeof(WCHAR));
5696                                     if (!DeviceId)
5697                                     {
5698                                         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
5699                                         goto done;
5700                                     }
5701                                     Result = SetupGetStringFieldW(
5702                                         &ContextDevice,
5703                                         i,
5704                                         DeviceId, RequiredSize,
5705                                         &RequiredSize);
5706                                 }
5707                                 if (!Result)
5708                                 {
5709                                     HeapFree(GetProcessHeap(), 0, DeviceId);
5710                                     goto done;
5711                                 }
5712                                 DriverAlreadyAdded = FALSE;
5713                                 for (DriverRank = 0, currentId = (LPCWSTR)HardwareIDs; !DriverAlreadyAdded && *currentId; currentId += wcslen(currentId) + 1, DriverRank++)
5714                                 {
5715                                     if (wcsicmp(DeviceId, currentId) == 0)
5716                                     {
5717                                         AddDriverToList(
5718                                             &((struct DeviceInfoElement *)DeviceInfoData->Reserved)->DriverListHead,
5719                                             DriverType,
5720                                             &ClassGuid,
5721                                             ContextDevice,
5722                                             currentInfFileDetails,
5723                                             filename,
5724                                             ProviderName,
5725                                             ManufacturerName,
5726                                             currentId,
5727                                             DriverDate, DriverVersion,
5728                                             DriverRank  + (i == 2 ? 0 : 0x1000 + i - 3));
5729                                         DriverAlreadyAdded = TRUE;
5730                                     }
5731                                 }
5732                                 if (CompatibleIDs)
5733                                 {
5734                                     for (DriverRank = 0, currentId = (LPCWSTR)CompatibleIDs; !DriverAlreadyAdded && *currentId; currentId += wcslen(currentId) + 1, DriverRank++)
5735                                     {
5736                                         if (wcsicmp(DeviceId, currentId) == 0)
5737                                         {
5738                                             AddDriverToList(
5739                                                 &((struct DeviceInfoElement *)DeviceInfoData->Reserved)->DriverListHead,
5740                                                 DriverType,
5741                                                 &ClassGuid,
5742                                                 ContextDevice,
5743                                                 currentInfFileDetails,
5744                                                 filename,
5745                                                 ProviderName,
5746                                                 ManufacturerName,
5747                                                 currentId,
5748                                                 DriverDate, DriverVersion,
5749                                                 DriverRank + (i == 2 ? 0x2000 : 0x3000 + i - 3));
5750                                             DriverAlreadyAdded = TRUE;
5751                                         }
5752                                     }
5753                                 }
5754                                 HeapFree(GetProcessHeap(), 0, DeviceId);
5755                             }
5756                         }
5757                         Result = SetupFindNextLine(&ContextDevice, &ContextDevice);
5758                     }
5759
5760                     HeapFree(GetProcessHeap(), 0, ManufacturerName);
5761                     ManufacturerName = NULL;
5762                     Result = SetupFindNextLine(&ContextManufacturer, &ContextManufacturer);
5763                 }
5764
5765                 ret = TRUE;
5766 next:
5767                 HeapFree(GetProcessHeap(), 0, ProviderName);
5768                 ProviderName = NULL;
5769
5770                 DereferenceInfFile(currentInfFileDetails);
5771                 currentInfFileDetails = NULL;
5772             }
5773             ret = TRUE;
5774         }
5775     }
5776
5777 done:
5778     if (ret)
5779     {
5780         if (DeviceInfoData)
5781         {
5782             InstallParams.Flags |= DI_DIDCOMPAT;
5783             InstallParams.FlagsEx |= DI_FLAGSEX_DIDCOMPATINFO;
5784         }
5785         else
5786         {
5787             InstallParams.Flags |= DI_DIDCLASS;
5788             InstallParams.FlagsEx |= DI_FLAGSEX_DIDINFOLIST;
5789         }
5790         ret = SetupDiSetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
5791     }
5792
5793     HeapFree(GetProcessHeap(), 0, ProviderName);
5794     HeapFree(GetProcessHeap(), 0, ManufacturerName);
5795     HeapFree(GetProcessHeap(), 0, HardwareIDs);
5796     HeapFree(GetProcessHeap(), 0, CompatibleIDs);
5797     HeapFree(GetProcessHeap(), 0, FullInfFileName);
5798     if (currentInfFileDetails)
5799         DereferenceInfFile(currentInfFileDetails);
5800     HeapFree(GetProcessHeap(), 0, Buffer);
5801
5802     TRACE("Returning %d\n", ret);
5803     return ret;
5804 }
5805
5806 /***********************************************************************
5807  *              SetupDiDeleteDeviceInfo (SETUPAPI.@)
5808  */
5809 BOOL WINAPI
5810 SetupDiDeleteDeviceInfo(
5811     IN HDEVINFO DeviceInfoSet,
5812     IN PSP_DEVINFO_DATA DeviceInfoData)
5813 {
5814     TRACE("%p %p\n", DeviceInfoSet, DeviceInfoData);
5815
5816     FIXME("not implemented\n");
5817     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5818     return FALSE;
5819 }
5820
5821
5822 /***********************************************************************
5823  *              SetupDiDestroyDriverInfoList (SETUPAPI.@)
5824  */
5825 BOOL WINAPI
5826 SetupDiDestroyDriverInfoList(
5827     IN HDEVINFO DeviceInfoSet,
5828     IN PSP_DEVINFO_DATA DeviceInfoData,
5829     IN DWORD DriverType)
5830 {
5831     struct DeviceInfoSet *list;
5832     BOOL ret = FALSE;
5833
5834     TRACE("%p %p 0x%lx\n", DeviceInfoSet, DeviceInfoData, DriverType);
5835
5836     if (!DeviceInfoSet)
5837         SetLastError(ERROR_INVALID_HANDLE);
5838     else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
5839         SetLastError(ERROR_INVALID_HANDLE);
5840     else if (DriverType != SPDIT_CLASSDRIVER && DriverType != SPDIT_COMPATDRIVER)
5841         SetLastError(ERROR_INVALID_PARAMETER);
5842     else if (DriverType == SPDIT_COMPATDRIVER && !DeviceInfoData)
5843         SetLastError(ERROR_INVALID_PARAMETER);
5844     else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
5845         SetLastError(ERROR_INVALID_USER_BUFFER);
5846     else
5847     {
5848         PLIST_ENTRY ListEntry;
5849         struct DriverInfoElement *driverInfo;
5850         SP_DEVINSTALL_PARAMS_W InstallParams;
5851
5852         InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
5853         if (!SetupDiGetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams))
5854             goto done;
5855
5856         if (!DeviceInfoData)
5857             /* Fall back to destroying class driver list */
5858             DriverType = SPDIT_CLASSDRIVER;
5859
5860         if (DriverType == SPDIT_CLASSDRIVER)
5861         {
5862             while (!IsListEmpty(&list->DriverListHead))
5863             {
5864                  ListEntry = RemoveHeadList(&list->DriverListHead);
5865                  driverInfo = (struct DriverInfoElement *)ListEntry;
5866                  DestroyDriverInfoElement(driverInfo);
5867             }
5868             InstallParams.Reserved = 0;
5869             InstallParams.Flags &= ~(DI_DIDCLASS | DI_MULTMFGS);
5870             InstallParams.FlagsEx &= ~DI_FLAGSEX_DIDINFOLIST;
5871             ret = SetupDiSetDeviceInstallParamsW(DeviceInfoSet, NULL, &InstallParams);
5872         }
5873         else
5874         {
5875             SP_DEVINSTALL_PARAMS_W InstallParamsSet;
5876             struct DeviceInfoElement *deviceInfo;
5877
5878             InstallParamsSet.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
5879             if (!SetupDiGetDeviceInstallParamsW(DeviceInfoSet, NULL, &InstallParamsSet))
5880                 goto done;
5881             deviceInfo = (struct DeviceInfoElement *)DeviceInfoData->Reserved;
5882             while (!IsListEmpty(&deviceInfo->DriverListHead))
5883             {
5884                  ListEntry = RemoveHeadList(&deviceInfo->DriverListHead);
5885                  driverInfo = (struct DriverInfoElement *)ListEntry;
5886                  if ((PVOID)InstallParamsSet.Reserved == driverInfo)
5887                  {
5888                      InstallParamsSet.Reserved = 0;
5889                      SetupDiSetDeviceInstallParamsW(DeviceInfoSet, NULL, &InstallParamsSet);
5890                  }
5891                  DestroyDriverInfoElement(driverInfo);
5892             }
5893             InstallParams.Reserved = 0;
5894             InstallParams.Flags &= ~DI_DIDCOMPAT;
5895             InstallParams.FlagsEx &= ~DI_FLAGSEX_DIDCOMPATINFO;
5896             ret = SetupDiSetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
5897         }
5898     }
5899
5900 done:
5901     TRACE("Returning %d\n", ret);
5902     return ret;
5903 }
5904
5905
5906 /***********************************************************************
5907  *              SetupDiOpenDeviceInfoA (SETUPAPI.@)
5908  */
5909 BOOL WINAPI
5910 SetupDiOpenDeviceInfoA(
5911     IN HDEVINFO DeviceInfoSet,
5912     IN PCSTR DeviceInstanceId,
5913     IN HWND hwndParent OPTIONAL,
5914     IN DWORD OpenFlags,
5915     OUT PSP_DEVINFO_DATA DeviceInfoData OPTIONAL)
5916 {
5917     LPWSTR DeviceInstanceIdW = NULL;
5918     BOOL bResult;
5919
5920     TRACE("%p %s %p %lx %p\n", DeviceInfoSet, DeviceInstanceId, hwndParent, OpenFlags, DeviceInfoData);
5921
5922     DeviceInstanceIdW = MultiByteToUnicode(DeviceInstanceId, CP_ACP);
5923     if (DeviceInstanceIdW == NULL)
5924         return FALSE;
5925
5926     bResult = SetupDiOpenDeviceInfoW(DeviceInfoSet,
5927         DeviceInstanceIdW, hwndParent, OpenFlags, DeviceInfoData);
5928
5929     MyFree(DeviceInstanceIdW);
5930
5931     return bResult;
5932 }
5933
5934
5935 /***********************************************************************
5936  *              SetupDiOpenDeviceInfoW (SETUPAPI.@)
5937  */
5938 BOOL WINAPI
5939 SetupDiOpenDeviceInfoW(
5940     IN HDEVINFO DeviceInfoSet,
5941     IN PCWSTR DeviceInstanceId,
5942     IN HWND hwndParent OPTIONAL,
5943     IN DWORD OpenFlags,
5944     OUT PSP_DEVINFO_DATA DeviceInfoData OPTIONAL)
5945 {
5946     struct DeviceInfoSet *list;
5947     HKEY hEnumKey, hKey;
5948     DWORD rc;
5949     BOOL ret = FALSE;
5950
5951     TRACE("%p %S %p %lx %p\n", DeviceInfoSet, DeviceInstanceId, hwndParent, OpenFlags, DeviceInfoData);
5952
5953     if (OpenFlags & DIOD_CANCEL_REMOVE)
5954         FIXME("DIOD_CANCEL_REMOVE flag not implemented\n");
5955
5956     if (!DeviceInfoSet)
5957         SetLastError(ERROR_INVALID_HANDLE);
5958     else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
5959         SetLastError(ERROR_INVALID_HANDLE);
5960     else if (!DeviceInstanceId)
5961         SetLastError(ERROR_INVALID_PARAMETER);
5962     else if (OpenFlags & ~(DIOD_CANCEL_REMOVE | DIOD_INHERIT_CLASSDRVS))
5963     {
5964         TRACE("Unknown flags: 0x%08lx\n", OpenFlags & ~(DIOD_CANCEL_REMOVE | DIOD_INHERIT_CLASSDRVS));
5965         SetLastError(ERROR_INVALID_FLAGS);
5966     }
5967     else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
5968         SetLastError(ERROR_INVALID_USER_BUFFER);
5969     else
5970     {
5971         struct DeviceInfoElement *deviceInfo = NULL;
5972         /* Search if device already exists in DeviceInfoSet.
5973          *    If yes, return the existing element
5974          *    If no, create a new element using informations in registry
5975          */
5976         PLIST_ENTRY ItemList = list->ListHead.Flink;
5977         while (ItemList != &list->ListHead)
5978         {
5979             // TODO
5980             //if (good one)
5981             //    break;
5982             FIXME("not implemented\n");
5983             ItemList = ItemList->Flink;
5984         }
5985
5986         if (deviceInfo)
5987         {
5988             /* good one found */
5989             ret = TRUE;
5990         }
5991         else
5992         {
5993             /* Open supposed registry key */
5994             rc = RegOpenKeyExW(
5995                 list->HKLM,
5996                 REGSTR_PATH_SYSTEMENUM,
5997                 0, /* Options */
5998                 0,
5999                 &hEnumKey);
6000             if (rc != ERROR_SUCCESS)
6001             {
6002                 SetLastError(rc);
6003                 return FALSE;
6004             }
6005             rc = RegOpenKeyExW(
6006                 hEnumKey,
6007                 DeviceInstanceId,
6008                 0, /* Options */
6009                 KEY_QUERY_VALUE,
6010                 &hKey);
6011             RegCloseKey(hEnumKey);
6012             if (rc != ERROR_SUCCESS)
6013             {
6014                 if (rc == ERROR_FILE_NOT_FOUND)
6015                     rc = ERROR_NO_SUCH_DEVINST;
6016                 SetLastError(rc);
6017                 return FALSE;
6018             }
6019
6020             /* FIXME: try to get ClassGUID from registry, instead of
6021              * sending GUID_NULL to CreateDeviceInfoElement
6022              */
6023             if (!CreateDeviceInfoElement(list, DeviceInstanceId, &GUID_NULL, &deviceInfo))
6024             {
6025                 RegCloseKey(hKey);
6026                 return FALSE;
6027             }
6028             InsertTailList(&list->ListHead, &deviceInfo->ListEntry);
6029
6030             RegCloseKey(hKey);
6031             ret = TRUE;
6032         }
6033
6034         if (ret && deviceInfo && DeviceInfoData)
6035         {
6036             memcpy(&DeviceInfoData->ClassGuid, &deviceInfo->ClassGuid, sizeof(GUID));
6037             DeviceInfoData->DevInst = deviceInfo->dnDevInst;
6038             DeviceInfoData->Reserved = (ULONG_PTR)deviceInfo;
6039         }
6040     }
6041
6042     return ret;
6043 }
6044
6045
6046 /***********************************************************************
6047  *              SetupDiEnumDriverInfoA (SETUPAPI.@)
6048  */
6049 BOOL WINAPI
6050 SetupDiEnumDriverInfoA(
6051     IN HDEVINFO DeviceInfoSet,
6052     IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
6053     IN DWORD DriverType,
6054     IN DWORD MemberIndex,
6055     OUT PSP_DRVINFO_DATA_A DriverInfoData)
6056 {
6057     SP_DRVINFO_DATA_V2_W driverInfoData2W;
6058     BOOL ret = FALSE;
6059
6060     TRACE("%p %p 0x%lx %ld %p\n", DeviceInfoSet, DeviceInfoData,
6061         DriverType, MemberIndex, DriverInfoData);
6062
6063     if (DriverInfoData == NULL)
6064         SetLastError(ERROR_INVALID_PARAMETER);
6065     else if (DriverInfoData->cbSize != sizeof(SP_DRVINFO_DATA_V1_A) && DriverInfoData->cbSize != sizeof(SP_DRVINFO_DATA_V2_A))
6066         SetLastError(ERROR_INVALID_USER_BUFFER);
6067     else
6068     {
6069         driverInfoData2W.cbSize = sizeof(SP_DRVINFO_DATA_V2_W);
6070         ret = SetupDiEnumDriverInfoW(DeviceInfoSet, DeviceInfoData,
6071             DriverType, MemberIndex, &driverInfoData2W);
6072
6073         if (ret)
6074         {
6075             /* Do W->A conversion */
6076             DriverInfoData->DriverType = driverInfoData2W.DriverType;
6077             DriverInfoData->Reserved = driverInfoData2W.Reserved;
6078             if (WideCharToMultiByte(CP_ACP, 0, driverInfoData2W.Description, -1,
6079                 DriverInfoData->Description, LINE_LEN, NULL, NULL) == 0)
6080             {
6081                 DriverInfoData->Description[0] = '\0';
6082                 ret = FALSE;
6083             }
6084             if (WideCharToMultiByte(CP_ACP, 0, driverInfoData2W.MfgName, -1,
6085                 DriverInfoData->MfgName, LINE_LEN, NULL, NULL) == 0)
6086             {
6087                 DriverInfoData->MfgName[0] = '\0';
6088                 ret = FALSE;
6089             }
6090             if (WideCharToMultiByte(CP_ACP, 0, driverInfoData2W.ProviderName, -1,
6091                 DriverInfoData->ProviderName, LINE_LEN, NULL, NULL) == 0)
6092             {
6093                 DriverInfoData->ProviderName[0] = '\0';
6094                 ret = FALSE;
6095             }
6096             if (DriverInfoData->cbSize == sizeof(SP_DRVINFO_DATA_V2_A))
6097             {
6098                 /* Copy more fields */
6099                 DriverInfoData->DriverDate = driverInfoData2W.DriverDate;
6100                 DriverInfoData->DriverVersion = driverInfoData2W.DriverVersion;
6101             }
6102         }
6103     }
6104
6105     TRACE("Returning %d\n", ret);
6106     return ret;
6107 }
6108
6109
6110 /***********************************************************************
6111  *              SetupDiEnumDriverInfoW (SETUPAPI.@)
6112  */
6113 BOOL WINAPI
6114 SetupDiEnumDriverInfoW(
6115     IN HDEVINFO DeviceInfoSet,
6116     IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
6117     IN DWORD DriverType,
6118     IN DWORD MemberIndex,
6119     OUT PSP_DRVINFO_DATA_W DriverInfoData)
6120 {
6121     PLIST_ENTRY ListHead;
6122     BOOL ret = FALSE;
6123
6124     TRACE("%p %p 0x%lx %ld %p\n", DeviceInfoSet, DeviceInfoData,
6125         DriverType, MemberIndex, DriverInfoData);
6126
6127     if (!DeviceInfoSet || !DriverInfoData)
6128         SetLastError(ERROR_INVALID_PARAMETER);
6129     else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
6130         SetLastError(ERROR_INVALID_HANDLE);
6131     else if (((struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
6132         SetLastError(ERROR_INVALID_HANDLE);
6133     else if (DriverType != SPDIT_CLASSDRIVER && DriverType != SPDIT_COMPATDRIVER)
6134         SetLastError(ERROR_INVALID_PARAMETER);
6135     else if (DriverType == SPDIT_CLASSDRIVER && DeviceInfoData)
6136         SetLastError(ERROR_INVALID_PARAMETER);
6137     else if (DriverType == SPDIT_COMPATDRIVER && !DeviceInfoData)
6138         SetLastError(ERROR_INVALID_PARAMETER);
6139     else if (DriverInfoData->cbSize != sizeof(SP_DRVINFO_DATA_V1_W) && DriverInfoData->cbSize != sizeof(SP_DRVINFO_DATA_V2_W))
6140         SetLastError(ERROR_INVALID_USER_BUFFER);
6141     else
6142     {
6143         struct DeviceInfoElement *devInfo = NULL;
6144         PLIST_ENTRY ItemList;
6145         if (DeviceInfoData)
6146             devInfo = (struct DeviceInfoElement *)DeviceInfoData->Reserved;
6147         if (DriverType == SPDIT_CLASSDRIVER ||
6148             (devInfo && devInfo->CreationFlags & DICD_INHERIT_CLASSDRVS))
6149         {
6150             ListHead = &((struct DeviceInfoSet *)DeviceInfoSet)->DriverListHead;
6151         }
6152         else
6153         {
6154             ListHead = &devInfo->DriverListHead;
6155         }
6156
6157         ItemList = ListHead->Flink;
6158         while (ItemList != ListHead && MemberIndex-- > 0)
6159             ItemList = ItemList->Flink;
6160         if (ItemList == ListHead)
6161             SetLastError(ERROR_NO_MORE_ITEMS);
6162         else
6163         {
6164             struct DriverInfoElement *DrvInfo = (struct DriverInfoElement *)ItemList;
6165
6166             memcpy(
6167                 &DriverInfoData->DriverType,
6168                 &DrvInfo->Info.DriverType,
6169                 DriverInfoData->cbSize - FIELD_OFFSET(SP_DRVINFO_DATA_W, DriverType));
6170             ret = TRUE;
6171         }
6172     }
6173
6174     TRACE("Returning %d\n", ret);
6175     return ret;
6176 }
6177
6178
6179 /***********************************************************************
6180  *              SetupDiGetSelectedDevice (SETUPAPI.@)
6181  */
6182 BOOL WINAPI
6183 SetupDiGetSelectedDevice(
6184     IN HDEVINFO DeviceInfoSet,
6185     OUT PSP_DEVINFO_DATA DeviceInfoData)
6186 {
6187     struct DeviceInfoSet *list;
6188     BOOL ret = FALSE;
6189
6190     TRACE("%p %p\n", DeviceInfoSet, DeviceInfoData);
6191
6192     if (!DeviceInfoSet)
6193         SetLastError(ERROR_INVALID_HANDLE);
6194     else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
6195         SetLastError(ERROR_INVALID_HANDLE);
6196     else if (list->SelectedDevice == NULL)
6197         SetLastError(ERROR_NO_DEVICE_SELECTED);
6198     else if (!DeviceInfoData)
6199         SetLastError(ERROR_INVALID_PARAMETER);
6200     else if (DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
6201         SetLastError(ERROR_INVALID_USER_BUFFER);
6202     else
6203     {
6204         memcpy(&DeviceInfoData->ClassGuid,
6205             &list->SelectedDevice->ClassGuid,
6206             sizeof(GUID));
6207         DeviceInfoData->DevInst = list->SelectedDevice->dnDevInst;
6208         DeviceInfoData->Reserved = (ULONG_PTR)list->SelectedDevice;
6209         ret = TRUE;
6210     }
6211
6212     TRACE("Returning %d\n", ret);
6213     return ret;
6214 }
6215
6216
6217 /***********************************************************************
6218  *              SetupDiGetSelectedDriverA (SETUPAPI.@)
6219  */
6220 BOOL WINAPI
6221 SetupDiGetSelectedDriverA(
6222     IN HDEVINFO DeviceInfoSet,
6223     IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
6224     OUT PSP_DRVINFO_DATA_A DriverInfoData)
6225 {
6226     SP_DRVINFO_DATA_V2_W driverInfoData2W;
6227     BOOL ret = FALSE;
6228
6229     if (DriverInfoData == NULL)
6230         SetLastError(ERROR_INVALID_PARAMETER);
6231     else if (DriverInfoData->cbSize != sizeof(SP_DRVINFO_DATA_V1_A) && DriverInfoData->cbSize != sizeof(SP_DRVINFO_DATA_V2_A))
6232         SetLastError(ERROR_INVALID_USER_BUFFER);
6233     else
6234     {
6235         driverInfoData2W.cbSize = sizeof(SP_DRVINFO_DATA_V2_W);
6236
6237         ret = SetupDiGetSelectedDriverW(DeviceInfoSet,
6238                                         DeviceInfoData,
6239                                         &driverInfoData2W);
6240
6241         if (ret)
6242         {
6243             /* Do W->A conversion */
6244             DriverInfoData->DriverType = driverInfoData2W.DriverType;
6245             DriverInfoData->Reserved = driverInfoData2W.Reserved;
6246             if (WideCharToMultiByte(CP_ACP, 0, driverInfoData2W.Description, -1,
6247                 DriverInfoData->Description, LINE_LEN, NULL, NULL) == 0)
6248             {
6249                 DriverInfoData->Description[0] = '\0';
6250                 ret = FALSE;
6251             }
6252             if (WideCharToMultiByte(CP_ACP, 0, driverInfoData2W.MfgName, -1,
6253                 DriverInfoData->MfgName, LINE_LEN, NULL, NULL) == 0)
6254             {
6255                 DriverInfoData->MfgName[0] = '\0';
6256                 ret = FALSE;
6257             }
6258             if (WideCharToMultiByte(CP_ACP, 0, driverInfoData2W.ProviderName, -1,
6259                 DriverInfoData->ProviderName, LINE_LEN, NULL, NULL) == 0)
6260             {
6261                 DriverInfoData->ProviderName[0] = '\0';
6262                 ret = FALSE;
6263             }
6264             if (DriverInfoData->cbSize == sizeof(SP_DRVINFO_DATA_V2_A))
6265             {
6266                 /* Copy more fields */
6267                 DriverInfoData->DriverDate = driverInfoData2W.DriverDate;
6268                 DriverInfoData->DriverVersion = driverInfoData2W.DriverVersion;
6269             }
6270         }
6271     }
6272
6273     return ret;
6274 }
6275
6276
6277 /***********************************************************************
6278  *              SetupDiGetSelectedDriverW (SETUPAPI.@)
6279  */
6280 BOOL WINAPI
6281 SetupDiGetSelectedDriverW(
6282     IN HDEVINFO DeviceInfoSet,
6283     IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
6284     OUT PSP_DRVINFO_DATA_W DriverInfoData)
6285 {
6286     BOOL ret = FALSE;
6287
6288     TRACE("%p %p %p\n", DeviceInfoSet, DeviceInfoData, DriverInfoData);
6289
6290     if (!DeviceInfoSet || !DriverInfoData)
6291         SetLastError(ERROR_INVALID_PARAMETER);
6292     else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
6293         SetLastError(ERROR_INVALID_HANDLE);
6294     else if (((struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
6295         SetLastError(ERROR_INVALID_HANDLE);
6296     else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
6297         SetLastError(ERROR_INVALID_USER_BUFFER);
6298     else if (DriverInfoData->cbSize != sizeof(SP_DRVINFO_DATA_V1_W) && DriverInfoData->cbSize != sizeof(SP_DRVINFO_DATA_V2_W))
6299         SetLastError(ERROR_INVALID_USER_BUFFER);
6300     else
6301     {
6302         SP_DEVINSTALL_PARAMS InstallParams;
6303
6304         InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
6305         if (SetupDiGetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams))
6306         {
6307             struct DriverInfoElement *driverInfo;
6308             driverInfo = (struct DriverInfoElement *)InstallParams.Reserved;
6309             if (driverInfo == NULL)
6310                 SetLastError(ERROR_NO_DRIVER_SELECTED);
6311             else
6312             {
6313                 memcpy(
6314                     &DriverInfoData->DriverType,
6315                     &driverInfo->Info.DriverType,
6316                     DriverInfoData->cbSize - FIELD_OFFSET(SP_DRVINFO_DATA_W, DriverType));
6317                 ret = TRUE;
6318             }
6319         }
6320     }
6321
6322     TRACE("Returning %d\n", ret);
6323     return ret;
6324 }
6325
6326
6327 /***********************************************************************
6328  *              SetupDiSetSelectedDevice (SETUPAPI.@)
6329  */
6330 BOOL WINAPI
6331 SetupDiSetSelectedDevice(
6332     IN HDEVINFO DeviceInfoSet,
6333     IN PSP_DEVINFO_DATA DeviceInfoData)
6334 {
6335     struct DeviceInfoSet *list;
6336     BOOL ret = FALSE;
6337
6338     TRACE("%p %p\n", DeviceInfoSet, DeviceInfoData);
6339
6340     if (!DeviceInfoSet)
6341         SetLastError(ERROR_INVALID_HANDLE);
6342     else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
6343         SetLastError(ERROR_INVALID_HANDLE);
6344     else if (!DeviceInfoData)
6345         SetLastError(ERROR_INVALID_PARAMETER);
6346     else if (DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
6347         SetLastError(ERROR_INVALID_USER_BUFFER);
6348     else if (DeviceInfoData->Reserved == 0)
6349         SetLastError(ERROR_INVALID_USER_BUFFER);
6350     else
6351     {
6352         list->SelectedDevice = (struct DeviceInfoElement *)DeviceInfoData->Reserved;
6353         ret = TRUE;
6354     }
6355
6356     TRACE("Returning %d\n", ret);
6357     return ret;
6358 }
6359
6360
6361 /***********************************************************************
6362  *              SetupDiSetSelectedDriverA (SETUPAPI.@)
6363  */
6364 BOOL WINAPI
6365 SetupDiSetSelectedDriverA(
6366     IN HDEVINFO DeviceInfoSet,
6367     IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
6368     IN OUT PSP_DRVINFO_DATA_A DriverInfoData OPTIONAL)
6369 {
6370     SP_DRVINFO_DATA_V1_W DriverInfoDataW;
6371     PSP_DRVINFO_DATA_W pDriverInfoDataW = NULL;
6372     BOOL ret = FALSE;
6373
6374     if (DriverInfoData != NULL)
6375     {
6376         if (DriverInfoData->cbSize != sizeof(SP_DRVINFO_DATA_V2_A) &&
6377             DriverInfoData->cbSize != sizeof(SP_DRVINFO_DATA_V1_A));
6378         {
6379             SetLastError(ERROR_INVALID_PARAMETER);
6380             return FALSE;
6381         }
6382
6383         DriverInfoDataW.cbSize = sizeof(SP_DRVINFO_DATA_V1_W);
6384         DriverInfoDataW.Reserved = DriverInfoData->Reserved;
6385
6386         if (DriverInfoDataW.Reserved == 0)
6387         {
6388             DriverInfoDataW.DriverType = DriverInfoData->DriverType;
6389
6390             /* convert the strings to unicode */
6391             if (!MultiByteToWideChar(CP_ACP,
6392                                      0,
6393                                      DriverInfoData->Description,
6394                                      LINE_LEN,
6395                                      DriverInfoDataW.Description,
6396                                      LINE_LEN) ||
6397                 !MultiByteToWideChar(CP_ACP,
6398                                      0,
6399                                      DriverInfoData->ProviderName,
6400                                      LINE_LEN,
6401                                      DriverInfoDataW.ProviderName,
6402                                      LINE_LEN))
6403             {
6404                 return FALSE;
6405             }
6406         }
6407
6408         pDriverInfoDataW = (PSP_DRVINFO_DATA_W)&DriverInfoDataW;
6409     }
6410
6411     ret = SetupDiSetSelectedDriverW(DeviceInfoSet,
6412                                     DeviceInfoData,
6413                                     pDriverInfoDataW);
6414
6415     if (ret && pDriverInfoDataW != NULL)
6416     {
6417         DriverInfoData->Reserved = DriverInfoDataW.Reserved;
6418     }
6419
6420     return ret;
6421 }
6422
6423
6424 /***********************************************************************
6425  *              SetupDiSetSelectedDriverW (SETUPAPI.@)
6426  */
6427 BOOL WINAPI
6428 SetupDiSetSelectedDriverW(
6429     IN HDEVINFO DeviceInfoSet,
6430     IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
6431     IN OUT PSP_DRVINFO_DATA_W DriverInfoData OPTIONAL)
6432 {
6433     BOOL ret = FALSE;
6434
6435     TRACE("%p %p %p\n", DeviceInfoSet, DeviceInfoData, DriverInfoData);
6436
6437     if (!DeviceInfoSet)
6438         SetLastError(ERROR_INVALID_PARAMETER);
6439     else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
6440         SetLastError(ERROR_INVALID_HANDLE);
6441     else if (((struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
6442         SetLastError(ERROR_INVALID_HANDLE);
6443     else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
6444         SetLastError(ERROR_INVALID_USER_BUFFER);
6445     else if (DriverInfoData && DriverInfoData->cbSize != sizeof(SP_DRVINFO_DATA_V1_W) && DriverInfoData->cbSize != sizeof(SP_DRVINFO_DATA_V2_W))
6446         SetLastError(ERROR_INVALID_USER_BUFFER);
6447     else
6448     {
6449         struct DriverInfoElement **pDriverInfo;
6450         PLIST_ENTRY ListHead, ItemList;
6451
6452         if (DeviceInfoData)
6453         {
6454             pDriverInfo = (struct DriverInfoElement **)&((struct DeviceInfoElement *)DeviceInfoData->Reserved)->InstallParams.Reserved;
6455             ListHead = &((struct DeviceInfoElement *)DeviceInfoData->Reserved)->DriverListHead;
6456         }
6457         else
6458         {
6459             pDriverInfo = (struct DriverInfoElement **)&((struct DeviceInfoSet *)DeviceInfoSet)->InstallParams.Reserved;
6460             ListHead = &((struct DeviceInfoSet *)DeviceInfoSet)->DriverListHead;
6461         }
6462
6463         if (!DriverInfoData)
6464         {
6465             *pDriverInfo = NULL;
6466             ret = TRUE;
6467         }
6468         else
6469         {
6470             /* Search selected driver in list */
6471             ItemList = ListHead->Flink;
6472             while (ItemList != ListHead)
6473             {
6474                 if (DriverInfoData->Reserved != 0)
6475                 {
6476                     if (DriverInfoData->Reserved == (ULONG_PTR)ItemList)
6477                         break;
6478                 }
6479                 else
6480                 {
6481                     /* The caller wants to compare only DriverType, Description and ProviderName fields */
6482                     struct DriverInfoElement *driverInfo = (struct DriverInfoElement *)ItemList;
6483                     if (driverInfo->Info.DriverType == DriverInfoData->DriverType
6484                         && wcscmp(driverInfo->Info.Description, DriverInfoData->Description) == 0
6485                         && wcscmp(driverInfo->Info.ProviderName, DriverInfoData->ProviderName) == 0)
6486                     {
6487                         break;
6488                     }
6489                 }
6490             }
6491             if (ItemList == ListHead)
6492                 SetLastError(ERROR_INVALID_PARAMETER);
6493             else
6494             {
6495                 *pDriverInfo = (struct DriverInfoElement *)ItemList;
6496                 DriverInfoData->Reserved = (ULONG_PTR)ItemList;
6497                 ret = TRUE;
6498                 TRACE("Choosing driver whose rank is 0x%lx\n",
6499                     ((struct DriverInfoElement *)ItemList)->DriverRank);
6500                 if (DeviceInfoData)
6501                     memcpy(&DeviceInfoData->ClassGuid, &(*pDriverInfo)->ClassGuid, sizeof(GUID));
6502             }
6503         }
6504     }
6505
6506     TRACE("Returning %d\n", ret);
6507     return ret;
6508 }
6509
6510 /***********************************************************************
6511  *              SetupDiGetDriverInfoDetailA (SETUPAPI.@)
6512  */
6513 BOOL WINAPI
6514 SetupDiGetDriverInfoDetailA(
6515     IN HDEVINFO DeviceInfoSet,
6516     IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
6517     IN PSP_DRVINFO_DATA_A DriverInfoData,
6518     OUT PSP_DRVINFO_DETAIL_DATA_A DriverInfoDetailData OPTIONAL,
6519     IN DWORD DriverInfoDetailDataSize,
6520     OUT PDWORD RequiredSize OPTIONAL)
6521 {
6522     SP_DRVINFO_DATA_V2_W DriverInfoDataW;
6523     PSP_DRVINFO_DETAIL_DATA_W DriverInfoDetailDataW = NULL;
6524     DWORD BufSize = 0;
6525     DWORD HardwareIDLen = 0;
6526     BOOL ret = FALSE;
6527
6528     /* do some sanity checks, the unicode version might do more thorough checks */
6529     if (DriverInfoData == NULL ||
6530         (DriverInfoDetailData == NULL && DriverInfoDetailDataSize != 0) ||
6531         (DriverInfoDetailData != NULL &&
6532          (DriverInfoDetailDataSize < FIELD_OFFSET(SP_DRVINFO_DETAIL_DATA_A, HardwareID) + sizeof(CHAR) ||
6533           DriverInfoDetailData->cbSize != sizeof(SP_DRVINFO_DETAIL_DATA_A))))
6534     {
6535         SetLastError(ERROR_INVALID_PARAMETER);
6536         goto Cleanup;
6537     }
6538
6539     /* make sure we support both versions of the SP_DRVINFO_DATA structure */
6540     if (DriverInfoData->cbSize == sizeof(SP_DRVINFO_DATA_V1_A))
6541     {
6542         DriverInfoDataW.cbSize = sizeof(SP_DRVINFO_DATA_V1_W);
6543     }
6544     else if (DriverInfoData->cbSize == sizeof(SP_DRVINFO_DATA_V2_A))
6545     {
6546         DriverInfoDataW.cbSize = sizeof(SP_DRVINFO_DATA_V2_W);
6547     }
6548     else
6549     {
6550         SetLastError(ERROR_INVALID_PARAMETER);
6551         goto Cleanup;
6552     }
6553     DriverInfoDataW.DriverType = DriverInfoData->DriverType;
6554     DriverInfoDataW.Reserved = DriverInfoData->Reserved;
6555
6556     /* convert the strings to unicode */
6557     if (MultiByteToWideChar(CP_ACP,
6558                             0,
6559                             DriverInfoData->Description,
6560                             LINE_LEN,
6561                             DriverInfoDataW.Description,
6562                             LINE_LEN) &&
6563         MultiByteToWideChar(CP_ACP,
6564                             0,
6565                             DriverInfoData->MfgName,
6566                             LINE_LEN,
6567                             DriverInfoDataW.MfgName,
6568                             LINE_LEN) &&
6569         MultiByteToWideChar(CP_ACP,
6570                             0,
6571                             DriverInfoData->ProviderName,
6572                             LINE_LEN,
6573                             DriverInfoDataW.ProviderName,
6574                             LINE_LEN))
6575     {
6576         if (DriverInfoDataW.cbSize == sizeof(SP_DRVINFO_DATA_V2_W))
6577         {
6578             DriverInfoDataW.DriverDate = ((PSP_DRVINFO_DATA_V2_A)DriverInfoData)->DriverDate;
6579             DriverInfoDataW.DriverVersion = ((PSP_DRVINFO_DATA_V2_A)DriverInfoData)->DriverVersion;
6580         }
6581
6582         if (DriverInfoDetailData != NULL)
6583         {
6584             /* calculate the unicode buffer size from the ansi buffer size */
6585             HardwareIDLen = DriverInfoDetailDataSize - FIELD_OFFSET(SP_DRVINFO_DETAIL_DATA_A, HardwareID);
6586             BufSize = FIELD_OFFSET(SP_DRVINFO_DETAIL_DATA_W, HardwareID) +
6587                       (HardwareIDLen * sizeof(WCHAR));
6588
6589             DriverInfoDetailDataW = MyMalloc(BufSize);
6590             if (DriverInfoDetailDataW == NULL)
6591             {
6592                 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
6593                 goto Cleanup;
6594             }
6595
6596             /* initialize the buffer */
6597             ZeroMemory(DriverInfoDetailDataW,
6598                        BufSize);
6599             DriverInfoDetailDataW->cbSize = sizeof(SP_DRVINFO_DETAIL_DATA_W);
6600         }
6601
6602         /* call the unicode version */
6603         ret = SetupDiGetDriverInfoDetailW(DeviceInfoSet,
6604                                           DeviceInfoData,
6605                                           &DriverInfoDataW,
6606                                           DriverInfoDetailDataW,
6607                                           BufSize,
6608                                           RequiredSize);
6609
6610         if (ret)
6611         {
6612             if (DriverInfoDetailDataW != NULL)
6613             {
6614                 /* convert the SP_DRVINFO_DETAIL_DATA_W structure to ansi */
6615                 DriverInfoDetailData->cbSize = sizeof(SP_DRVINFO_DETAIL_DATA_A);
6616                 DriverInfoDetailData->InfDate = DriverInfoDetailDataW->InfDate;
6617                 DriverInfoDetailData->Reserved = DriverInfoDetailDataW->Reserved;
6618                 if (WideCharToMultiByte(CP_ACP,
6619                                         0,
6620                                         DriverInfoDetailDataW->SectionName,
6621                                         LINE_LEN,
6622                                         DriverInfoDetailData->SectionName,
6623                                         LINE_LEN,
6624                                         NULL,
6625                                         NULL) &&
6626                     WideCharToMultiByte(CP_ACP,
6627                                         0,
6628                                         DriverInfoDetailDataW->InfFileName,
6629                                         MAX_PATH,
6630                                         DriverInfoDetailData->InfFileName,
6631                                         MAX_PATH,
6632                                         NULL,
6633                                         NULL) &&
6634                     WideCharToMultiByte(CP_ACP,
6635                                         0,
6636                                         DriverInfoDetailDataW->DrvDescription,
6637                                         LINE_LEN,
6638                                         DriverInfoDetailData->DrvDescription,
6639                                         LINE_LEN,
6640                                         NULL,
6641                                         NULL) &&
6642                     WideCharToMultiByte(CP_ACP,
6643                                         0,
6644                                         DriverInfoDetailDataW->HardwareID,
6645                                         HardwareIDLen,
6646                                         DriverInfoDetailData->HardwareID,
6647                                         HardwareIDLen,
6648                                         NULL,
6649                                         NULL))
6650                 {
6651                     DWORD len, cnt = 0;
6652                     DWORD hwidlen = HardwareIDLen;
6653                     CHAR *s = DriverInfoDetailData->HardwareID;
6654
6655                     /* count the strings in the list */
6656                     while (*s != '\0')
6657                     {
6658                         len = lstrlenA(s) + 1;
6659                         if (hwidlen > len)
6660                         {
6661                             cnt++;
6662                             s += len;
6663                             hwidlen -= len;
6664                         }
6665                         else
6666                         {
6667                             /* looks like the string list wasn't terminated... */
6668                             SetLastError(ERROR_INVALID_USER_BUFFER);
6669                             ret = FALSE;
6670                             break;
6671                         }
6672                     }
6673
6674                     /* make sure CompatIDsOffset points to the second string in the
6675                        list, if present */
6676                     if (cnt > 1)
6677                     {
6678                         DriverInfoDetailData->CompatIDsOffset = lstrlenA(DriverInfoDetailData->HardwareID) + 1;
6679                         DriverInfoDetailData->CompatIDsLength = (DWORD)(s - DriverInfoDetailData->HardwareID) -
6680                                                                 DriverInfoDetailData->CompatIDsOffset + 1;
6681                     }
6682                     else
6683                     {
6684                         DriverInfoDetailData->CompatIDsOffset = 0;
6685                         DriverInfoDetailData->CompatIDsLength = 0;
6686                     }
6687                 }
6688                 else
6689                 {
6690                     ret = FALSE;
6691                 }
6692             }
6693
6694             if (RequiredSize != NULL)
6695             {
6696                 *RequiredSize = FIELD_OFFSET(SP_DRVINFO_DETAIL_DATA_A, HardwareID) +
6697                                 (((*RequiredSize) - FIELD_OFFSET(SP_DRVINFO_DETAIL_DATA_W, HardwareID)) / sizeof(WCHAR));
6698             }
6699         }
6700     }
6701
6702 Cleanup:
6703     if (DriverInfoDetailDataW != NULL)
6704     {
6705         MyFree(DriverInfoDetailDataW);
6706     }
6707
6708     return ret;
6709 }
6710
6711 /***********************************************************************
6712  *              SetupDiGetDriverInfoDetailW (SETUPAPI.@)
6713  */
6714 BOOL WINAPI
6715 SetupDiGetDriverInfoDetailW(
6716     IN HDEVINFO DeviceInfoSet,
6717     IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
6718     IN PSP_DRVINFO_DATA_W DriverInfoData,
6719     OUT PSP_DRVINFO_DETAIL_DATA_W DriverInfoDetailData OPTIONAL,
6720     IN DWORD DriverInfoDetailDataSize,
6721     OUT PDWORD RequiredSize OPTIONAL)
6722 {
6723     BOOL ret = FALSE;
6724
6725     TRACE("%p %p %p %p %lu %p\n", DeviceInfoSet, DeviceInfoData,
6726         DriverInfoData, DriverInfoDetailData,
6727         DriverInfoDetailDataSize, RequiredSize);
6728
6729     if (!DeviceInfoSet)
6730         SetLastError(ERROR_INVALID_PARAMETER);
6731     else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
6732         SetLastError(ERROR_INVALID_HANDLE);
6733     else if (((struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
6734         SetLastError(ERROR_INVALID_HANDLE);
6735     else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
6736         SetLastError(ERROR_INVALID_USER_BUFFER);
6737     else if (!DriverInfoData)
6738         SetLastError(ERROR_INVALID_PARAMETER);
6739     else if (!DriverInfoDetailData && DriverInfoDetailDataSize != 0)
6740         SetLastError(ERROR_INVALID_PARAMETER);
6741     else if (DriverInfoDetailData && DriverInfoDetailDataSize < sizeof(SP_DRVINFO_DETAIL_DATA_W))
6742         SetLastError(ERROR_INVALID_PARAMETER);
6743     else if (DriverInfoDetailData && DriverInfoDetailData->cbSize != sizeof(SP_DRVINFO_DETAIL_DATA_W))
6744         SetLastError(ERROR_INVALID_USER_BUFFER);
6745     else if (DriverInfoData->Reserved == 0)
6746         SetLastError(ERROR_NO_DRIVER_SELECTED);
6747     else
6748     {
6749         struct DriverInfoElement *driverInfoElement;
6750         driverInfoElement = (struct DriverInfoElement *)DriverInfoData->Reserved;
6751
6752         memcpy(
6753             DriverInfoDetailData,
6754             &driverInfoElement->Details,
6755             driverInfoElement->Details.cbSize);
6756         /* FIXME: copy HardwareIDs/CompatibleIDs if buffer is big enough
6757          * Don't forget to set CompatIDsOffset and CompatIDsLength fields.
6758          */
6759         ret = TRUE;
6760     }
6761
6762     TRACE("Returning %d\n", ret);
6763     return ret;
6764 }
6765
6766 /* Return the current hardware profile id, or -1 if error */
6767 static DWORD
6768 GetCurrentHwProfile(
6769     IN HDEVINFO DeviceInfoSet)
6770 {
6771     HKEY hKey = INVALID_HANDLE_VALUE;
6772     DWORD dwRegType, dwLength;
6773     DWORD hwProfile;
6774     LONG rc;
6775     DWORD ret = (DWORD)-1;
6776
6777     rc = RegOpenKeyExW(
6778         ((struct DeviceInfoSet *)DeviceInfoSet)->HKLM,
6779         REGSTR_PATH_IDCONFIGDB,
6780         0, /* Options */
6781         KEY_QUERY_VALUE,
6782         &hKey);
6783     if (rc != ERROR_SUCCESS)
6784     {
6785         SetLastError(rc);
6786         goto cleanup;
6787     }
6788
6789     dwLength = sizeof(DWORD);
6790     rc = RegQueryValueExW(
6791         hKey,
6792         REGSTR_VAL_CURRENTCONFIG,
6793         NULL,
6794         &dwRegType,
6795         (LPBYTE)&hwProfile, &dwLength);
6796     if (rc != ERROR_SUCCESS)
6797     {
6798         SetLastError(rc);
6799         goto cleanup;
6800     }
6801     else if (dwRegType != REG_DWORD || dwLength != sizeof(DWORD))
6802     {
6803         SetLastError(ERROR_GEN_FAILURE);
6804         goto cleanup;
6805     }
6806
6807     ret = hwProfile;
6808
6809 cleanup:
6810     if (hKey != INVALID_HANDLE_VALUE)
6811         RegCloseKey(hKey);
6812
6813     return hwProfile;
6814 }
6815
6816 static BOOL
6817 ResetDevice(
6818     IN HDEVINFO DeviceInfoSet,
6819     IN PSP_DEVINFO_DATA DeviceInfoData)
6820 {
6821     PLUGPLAY_CONTROL_RESET_DEVICE_DATA ResetDeviceData;
6822     struct DeviceInfoElement *deviceInfo = (struct DeviceInfoElement *)DeviceInfoData->Reserved;
6823     NTSTATUS Status;
6824
6825     if (((struct DeviceInfoSet *)DeviceInfoSet)->HKLM != HKEY_LOCAL_MACHINE)
6826     {
6827         /* At the moment, I only know how to start local devices */
6828         SetLastError(ERROR_INVALID_COMPUTERNAME);
6829         return FALSE;
6830     }
6831
6832     RtlInitUnicodeString(&ResetDeviceData.DeviceInstance, deviceInfo->DeviceName);
6833     Status = NtPlugPlayControl(PlugPlayControlResetDevice, &ResetDeviceData, sizeof(PLUGPLAY_CONTROL_RESET_DEVICE_DATA));
6834     SetLastError(RtlNtStatusToDosError(Status));
6835     return NT_SUCCESS(Status);
6836 }
6837
6838 static BOOL StopDevice(
6839     IN HDEVINFO DeviceInfoSet,
6840     IN PSP_DEVINFO_DATA DeviceInfoData)
6841 {
6842     FIXME("Stub %p %p\n", DeviceInfoSet, DeviceInfoData);
6843     return TRUE;
6844 }
6845
6846 /***********************************************************************
6847  *              SetupDiChangeState (SETUPAPI.@)
6848  */
6849 BOOL WINAPI
6850 SetupDiChangeState(
6851     IN HDEVINFO DeviceInfoSet,
6852     IN OUT PSP_DEVINFO_DATA DeviceInfoData OPTIONAL)
6853 {
6854     PSP_PROPCHANGE_PARAMS PropChange;
6855     HKEY hKey = INVALID_HANDLE_VALUE;
6856     LPCWSTR RegistryValueName;
6857     DWORD dwConfigFlags, dwLength, dwRegType;
6858     LONG rc;
6859     BOOL ret = FALSE;
6860
6861     TRACE("%p %p\n", DeviceInfoSet, DeviceInfoData);
6862
6863     if (!DeviceInfoData)
6864         PropChange = ((struct DeviceInfoSet *)DeviceInfoSet)->ClassInstallParams.PropChange;
6865     else
6866         PropChange = ((struct DeviceInfoElement *)DeviceInfoData->Reserved)->ClassInstallParams.PropChange;
6867     if (!PropChange)
6868     {
6869         SetLastError(ERROR_INVALID_PARAMETER);
6870         goto cleanup;
6871     }
6872
6873     if (PropChange->Scope == DICS_FLAG_GLOBAL)
6874         RegistryValueName = REGSTR_VAL_CONFIGFLAGS;
6875     else
6876         RegistryValueName = REGSTR_VAL_CSCONFIGFLAGS;
6877
6878     switch (PropChange->StateChange)
6879     {
6880         case DICS_ENABLE:
6881         case DICS_DISABLE:
6882         {
6883             /* Enable/disable device in registry */
6884             hKey = SetupDiOpenDevRegKey(DeviceInfoSet, DeviceInfoData, PropChange->Scope, PropChange->HwProfile, DIREG_DEV, KEY_QUERY_VALUE | KEY_SET_VALUE);
6885             if (hKey == INVALID_HANDLE_VALUE && GetLastError() == ERROR_FILE_NOT_FOUND)
6886                 hKey = SetupDiCreateDevRegKeyW(DeviceInfoSet, DeviceInfoData, PropChange->Scope, PropChange->HwProfile, DIREG_DEV, NULL, NULL);
6887             if (hKey == INVALID_HANDLE_VALUE)
6888                 break;
6889             dwLength = sizeof(DWORD);
6890             rc = RegQueryValueExW(
6891                 hKey,
6892                 RegistryValueName,
6893                 NULL,
6894                 &dwRegType,
6895                 (LPBYTE)&dwConfigFlags, &dwLength);
6896             if (rc == ERROR_FILE_NOT_FOUND)
6897                 dwConfigFlags = 0;
6898             else if (rc != ERROR_SUCCESS)
6899             {
6900                 SetLastError(rc);
6901                 goto cleanup;
6902             }
6903             else if (dwRegType != REG_DWORD || dwLength != sizeof(DWORD))
6904             {
6905                 SetLastError(ERROR_GEN_FAILURE);
6906                 goto cleanup;
6907             }
6908             if (PropChange->StateChange == DICS_ENABLE)
6909                 dwConfigFlags &= ~(PropChange->Scope == DICS_FLAG_GLOBAL ? CONFIGFLAG_DISABLED : CSCONFIGFLAG_DISABLED);
6910             else
6911                 dwConfigFlags |= (PropChange->Scope == DICS_FLAG_GLOBAL ? CONFIGFLAG_DISABLED : CSCONFIGFLAG_DISABLED);
6912             rc = RegSetValueEx(
6913                 hKey,
6914                 RegistryValueName,
6915                 0,
6916                 REG_DWORD,
6917                 (LPBYTE)&dwConfigFlags, sizeof(DWORD));
6918             if (rc != ERROR_SUCCESS)
6919             {
6920                 SetLastError(rc);
6921                 goto cleanup;
6922             }
6923
6924             /* Enable/disable device if needed */
6925             if (PropChange->Scope == DICS_FLAG_GLOBAL
6926                 || PropChange->HwProfile == 0
6927                 || PropChange->HwProfile == GetCurrentHwProfile(DeviceInfoSet))
6928             {
6929                 if (PropChange->StateChange == DICS_ENABLE)
6930                     ret = ResetDevice(DeviceInfoSet, DeviceInfoData);
6931                 else
6932                     ret = StopDevice(DeviceInfoSet, DeviceInfoData);
6933             }
6934             else
6935                 ret = TRUE;
6936             break;
6937         }
6938         case DICS_PROPCHANGE:
6939         {
6940             ret = ResetDevice(DeviceInfoSet, DeviceInfoData);
6941             break;
6942         }
6943         default:
6944         {
6945             FIXME("Unknown StateChange 0x%lx\n", PropChange->StateChange);
6946             SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
6947         }
6948     }
6949
6950 cleanup:
6951     if (hKey != INVALID_HANDLE_VALUE)
6952         RegCloseKey(hKey);
6953
6954     TRACE("Returning %d\n", ret);
6955     return ret;
6956 }
6957
6958 /***********************************************************************
6959  *              SetupDiSelectBestCompatDrv (SETUPAPI.@)
6960  */
6961 BOOL WINAPI
6962 SetupDiSelectBestCompatDrv(
6963     IN HDEVINFO DeviceInfoSet,
6964     IN PSP_DEVINFO_DATA DeviceInfoData)
6965 {
6966     SP_DRVINFO_DATA_W drvInfoData;
6967     BOOL ret;
6968
6969     TRACE("%p %p\n", DeviceInfoSet, DeviceInfoData);
6970
6971     /* Drivers are sorted by rank in the driver list, so
6972      * the first driver in the list is the best one.
6973      */
6974     drvInfoData.cbSize = sizeof(SP_DRVINFO_DATA_W);
6975     ret = SetupDiEnumDriverInfoW(
6976         DeviceInfoSet,
6977         DeviceInfoData,
6978         SPDIT_COMPATDRIVER,
6979         0, /* Member index */
6980         &drvInfoData);
6981
6982     if (ret)
6983     {
6984         ret = SetupDiSetSelectedDriverW(
6985             DeviceInfoSet,
6986             DeviceInfoData,
6987             &drvInfoData);
6988     }
6989
6990     TRACE("Returning %d\n", ret);
6991     return ret;
6992 }
6993
6994 /***********************************************************************
6995  *              SetupDiInstallDriverFiles (SETUPAPI.@)
6996  */
6997 BOOL WINAPI
6998 SetupDiInstallDriverFiles(
6999     IN HDEVINFO DeviceInfoSet,
7000     IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL)
7001 {
7002     BOOL ret = FALSE;
7003
7004     TRACE("%p %p\n", DeviceInfoSet, DeviceInfoData);
7005
7006     if (!DeviceInfoSet)
7007         SetLastError(ERROR_INVALID_PARAMETER);
7008     else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
7009         SetLastError(ERROR_INVALID_HANDLE);
7010     else if (((struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
7011         SetLastError(ERROR_INVALID_HANDLE);
7012     else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
7013         SetLastError(ERROR_INVALID_USER_BUFFER);
7014     else if (DeviceInfoData && ((struct DeviceInfoElement *)DeviceInfoData->Reserved)->InstallParams.Reserved == 0)
7015         SetLastError(ERROR_NO_DRIVER_SELECTED);
7016     else if (!DeviceInfoData && ((struct DeviceInfoSet *)DeviceInfoSet)->InstallParams.Reserved == 0)
7017         SetLastError(ERROR_NO_DRIVER_SELECTED);
7018     else
7019     {
7020         SP_DEVINSTALL_PARAMS_W InstallParams;
7021         struct DriverInfoElement *SelectedDriver;
7022         WCHAR SectionName[MAX_PATH];
7023         DWORD SectionNameLength = 0;
7024
7025         InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
7026         ret = SetupDiGetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
7027         if (!ret)
7028             goto done;
7029
7030         SelectedDriver = (struct DriverInfoElement *)InstallParams.Reserved;
7031         if (!SelectedDriver)
7032         {
7033             SetLastError(ERROR_NO_DRIVER_SELECTED);
7034             goto done;
7035         }
7036
7037         ret = SetupDiGetActualSectionToInstallW(
7038             SelectedDriver->InfFileDetails->hInf,
7039             SelectedDriver->Details.SectionName,
7040             SectionName, MAX_PATH, &SectionNameLength, NULL);
7041         if (!ret)
7042             goto done;
7043
7044         if (!InstallParams.InstallMsgHandler)
7045         {
7046             InstallParams.InstallMsgHandler = SetupDefaultQueueCallbackW;
7047             InstallParams.InstallMsgHandlerContext = SetupInitDefaultQueueCallback(InstallParams.hwndParent);
7048             SetupDiSetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
7049         }
7050         ret = SetupInstallFromInfSectionW(InstallParams.hwndParent,
7051             SelectedDriver->InfFileDetails->hInf, SectionName,
7052             SPINST_FILES, NULL, NULL, SP_COPY_NEWER,
7053             InstallParams.InstallMsgHandler, InstallParams.InstallMsgHandlerContext,
7054             DeviceInfoSet, DeviceInfoData);
7055     }
7056
7057 done:
7058     TRACE("Returning %d\n", ret);
7059     return ret;
7060 }
7061
7062 /***********************************************************************
7063  *              SetupDiRegisterCoDeviceInstallers (SETUPAPI.@)
7064  */
7065 BOOL WINAPI
7066 SetupDiRegisterCoDeviceInstallers(
7067     IN HDEVINFO DeviceInfoSet,
7068     IN PSP_DEVINFO_DATA DeviceInfoData)
7069 {
7070     BOOL ret = FALSE; /* Return value */
7071
7072     TRACE("%p %p\n", DeviceInfoSet, DeviceInfoData);
7073
7074     if (!DeviceInfoSet)
7075         SetLastError(ERROR_INVALID_PARAMETER);
7076     else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
7077         SetLastError(ERROR_INVALID_HANDLE);
7078     else if (((struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
7079         SetLastError(ERROR_INVALID_HANDLE);
7080     else if (!DeviceInfoData)
7081         SetLastError(ERROR_INVALID_PARAMETER);
7082     else if (DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
7083         SetLastError(ERROR_INVALID_USER_BUFFER);
7084     else
7085     {
7086         SP_DEVINSTALL_PARAMS_W InstallParams;
7087         struct DriverInfoElement *SelectedDriver;
7088         BOOL Result;
7089         DWORD DoAction;
7090         WCHAR SectionName[MAX_PATH];
7091         DWORD SectionNameLength = 0;
7092         HKEY hKey = INVALID_HANDLE_VALUE;
7093
7094         InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
7095         Result = SetupDiGetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
7096         if (!Result)
7097             goto cleanup;
7098
7099         SelectedDriver = (struct DriverInfoElement *)InstallParams.Reserved;
7100         if (SelectedDriver == NULL)
7101         {
7102             SetLastError(ERROR_NO_DRIVER_SELECTED);
7103             goto cleanup;
7104         }
7105
7106         /* Get .CoInstallers section name */
7107         Result = SetupDiGetActualSectionToInstallW(
7108             SelectedDriver->InfFileDetails->hInf,
7109             SelectedDriver->Details.SectionName,
7110             SectionName, MAX_PATH, &SectionNameLength, NULL);
7111         if (!Result || SectionNameLength > MAX_PATH - wcslen(L".CoInstallers") - 1)
7112             goto cleanup;
7113         wcscat(SectionName, L".CoInstallers");
7114
7115         /* Open/Create driver key information */
7116 #if _WIN32_WINNT >= 0x502
7117         hKey = SetupDiOpenDevRegKey(DeviceInfoSet, DeviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DRV, KEY_READ | KEY_WRITE);
7118 #else
7119         hKey = SetupDiOpenDevRegKey(DeviceInfoSet, DeviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DRV, KEY_ALL_ACCESS);
7120 #endif
7121         if (hKey == INVALID_HANDLE_VALUE && GetLastError() == ERROR_FILE_NOT_FOUND)
7122             hKey = SetupDiCreateDevRegKeyW(DeviceInfoSet, DeviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DRV, NULL, NULL);
7123         if (hKey == INVALID_HANDLE_VALUE)
7124             goto cleanup;
7125
7126         /* Install .CoInstallers section */
7127         DoAction = SPINST_REGISTRY;
7128         if (!(InstallParams.Flags & DI_NOFILECOPY))
7129         {
7130             DoAction |= SPINST_FILES;
7131             if (!InstallParams.InstallMsgHandler)
7132             {
7133                 InstallParams.InstallMsgHandler = SetupDefaultQueueCallbackW;
7134                 InstallParams.InstallMsgHandlerContext = SetupInitDefaultQueueCallback(InstallParams.hwndParent);
7135                 SetupDiSetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
7136             }
7137         }
7138         Result = SetupInstallFromInfSectionW(InstallParams.hwndParent,
7139             SelectedDriver->InfFileDetails->hInf, SectionName,
7140             DoAction, hKey, NULL, SP_COPY_NEWER,
7141             InstallParams.InstallMsgHandler, InstallParams.InstallMsgHandlerContext,
7142             DeviceInfoSet, DeviceInfoData);
7143         if (!Result)
7144             goto cleanup;
7145
7146         ret = TRUE;
7147
7148 cleanup:
7149         if (hKey != INVALID_HANDLE_VALUE)
7150             RegCloseKey(hKey);
7151     }
7152
7153     TRACE("Returning %d\n", ret);
7154     return ret;
7155 }
7156
7157 /***********************************************************************
7158  *              SetupDiInstallDeviceInterfaces (SETUPAPI.@)
7159  */
7160 BOOL WINAPI
7161 SetupDiInstallDeviceInterfaces(
7162     IN HDEVINFO DeviceInfoSet,
7163     IN PSP_DEVINFO_DATA DeviceInfoData)
7164 {
7165     TRACE("%p %p\n", DeviceInfoSet, DeviceInfoData);
7166
7167     FIXME("SetupDiInstallDeviceInterfaces not implemented. Doing nothing\n");
7168     //SetLastError(ERROR_GEN_FAILURE);
7169     //return FALSE;
7170     return TRUE;
7171 }
7172
7173 BOOL
7174 InfIsFromOEMLocation(
7175     IN PCWSTR FullName,
7176     OUT LPBOOL IsOEMLocation)
7177 {
7178     PWCHAR last;
7179
7180     last = strrchrW(FullName, '\\');
7181     if (!last)
7182     {
7183         /* No directory specified */
7184         *IsOEMLocation = FALSE;
7185     }
7186     else
7187     {
7188         WCHAR Windir[MAX_PATH];
7189         UINT ret;
7190
7191         ret = GetWindowsDirectory(Windir, MAX_PATH);
7192         if (ret == 0 || ret >= MAX_PATH)
7193         {
7194             SetLastError(ERROR_GEN_FAILURE);
7195             return FALSE;
7196         }
7197
7198         if (strncmpW(FullName, Windir, last - FullName) == 0)
7199         {
7200             /* The path is %SYSTEMROOT%\Inf */
7201             *IsOEMLocation = FALSE;
7202         }
7203         else
7204         {
7205             /* The file is in another place */
7206             *IsOEMLocation = TRUE;
7207         }
7208     }
7209     return TRUE;
7210 }
7211
7212 /***********************************************************************
7213  *              SetupDiInstallDevice (SETUPAPI.@)
7214  */
7215 BOOL WINAPI
7216 SetupDiInstallDevice(
7217     IN HDEVINFO DeviceInfoSet,
7218     IN PSP_DEVINFO_DATA DeviceInfoData)
7219 {
7220     SP_DEVINSTALL_PARAMS_W InstallParams;
7221     struct DriverInfoElement *SelectedDriver;
7222     SYSTEMTIME DriverDate;
7223     WCHAR SectionName[MAX_PATH];
7224     WCHAR Buffer[32];
7225     DWORD SectionNameLength = 0;
7226     BOOL Result = FALSE;
7227     ULONG DoAction;
7228     DWORD RequiredSize;
7229     LPWSTR pSectionName = NULL;
7230     WCHAR ClassName[MAX_CLASS_NAME_LEN];
7231     GUID ClassGuid;
7232     LPWSTR lpGuidString = NULL, lpFullGuidString = NULL;
7233     BOOL RebootRequired = FALSE;
7234     HKEY hKey = INVALID_HANDLE_VALUE;
7235     HKEY hClassKey = INVALID_HANDLE_VALUE;
7236     BOOL NeedtoCopyFile;
7237     LARGE_INTEGER fullVersion;
7238     LONG rc;
7239     BOOL ret = FALSE; /* Return value */
7240
7241     TRACE("%p %p\n", DeviceInfoSet, DeviceInfoData);
7242
7243     if (!DeviceInfoSet)
7244         SetLastError(ERROR_INVALID_PARAMETER);
7245     else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
7246         SetLastError(ERROR_INVALID_HANDLE);
7247     else if (((struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEV_INFO_SET_MAGIC)
7248         SetLastError(ERROR_INVALID_HANDLE);
7249     else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
7250         SetLastError(ERROR_INVALID_USER_BUFFER);
7251     else
7252         Result = TRUE;
7253
7254     if (!Result)
7255     {
7256         /* One parameter is bad */
7257         goto cleanup;
7258     }
7259
7260     InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
7261     Result = SetupDiGetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
7262     if (!Result)
7263         goto cleanup;
7264
7265     if (InstallParams.FlagsEx & DI_FLAGSEX_SETFAILEDINSTALL)
7266     {
7267         /* FIXME: set FAILEDINSTALL in ConfigFlags registry value */
7268         goto cleanup;
7269     }
7270
7271     SelectedDriver = (struct DriverInfoElement *)InstallParams.Reserved;
7272     if (SelectedDriver == NULL)
7273     {
7274         SetLastError(ERROR_NO_DRIVER_SELECTED);
7275         goto cleanup;
7276     }
7277
7278     FileTimeToSystemTime(&SelectedDriver->Info.DriverDate, &DriverDate);
7279
7280     Result = SetupDiGetActualSectionToInstallW(
7281         SelectedDriver->InfFileDetails->hInf,
7282         SelectedDriver->Details.SectionName,
7283         SectionName, MAX_PATH, &SectionNameLength, NULL);
7284     if (!Result || SectionNameLength > MAX_PATH - wcslen(DotServices))
7285         goto cleanup;
7286     pSectionName = &SectionName[wcslen(SectionName)];
7287
7288     /* Get information from [Version] section */
7289     if (!SetupDiGetINFClassW(SelectedDriver->Details.InfFileName, &ClassGuid, ClassName, MAX_CLASS_NAME_LEN, &RequiredSize))
7290         goto cleanup;
7291     /* Format ClassGuid to a string */
7292     if (UuidToStringW((UUID*)&ClassGuid, &lpGuidString) != RPC_S_OK)
7293         goto cleanup;
7294     RequiredSize = lstrlenW(lpGuidString);
7295     lpFullGuidString = HeapAlloc(GetProcessHeap(), 0, (RequiredSize + 3) * sizeof(WCHAR));
7296     if (!lpFullGuidString)
7297     {
7298         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
7299         goto cleanup;
7300     }
7301     lpFullGuidString[0] = '{';
7302     memcpy(&lpFullGuidString[1], lpGuidString, RequiredSize * sizeof(WCHAR));
7303     lpFullGuidString[RequiredSize + 1] = '}';
7304     lpFullGuidString[RequiredSize + 2] = '\0';
7305
7306     /* Open/Create driver key information */
7307 #if _WIN32_WINNT >= 0x502
7308     hKey = SetupDiOpenDevRegKey(DeviceInfoSet, DeviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DRV, KEY_READ | KEY_WRITE);
7309 #else
7310     hKey = SetupDiOpenDevRegKey(DeviceInfoSet, DeviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DRV, KEY_ALL_ACCESS);
7311 #endif
7312     if (hKey == INVALID_HANDLE_VALUE && GetLastError() == ERROR_FILE_NOT_FOUND)
7313         hKey = SetupDiCreateDevRegKeyW(DeviceInfoSet, DeviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DRV, NULL, NULL);
7314     if (hKey == INVALID_HANDLE_VALUE)
7315         goto cleanup;
7316
7317     /* Install main section */
7318     DoAction = SPINST_REGISTRY;
7319     if (!(InstallParams.Flags & DI_NOFILECOPY))
7320     {
7321         DoAction |= SPINST_FILES;
7322         if (!InstallParams.InstallMsgHandler)
7323         {
7324             InstallParams.InstallMsgHandler = SetupDefaultQueueCallbackW;
7325             InstallParams.InstallMsgHandlerContext = SetupInitDefaultQueueCallback(InstallParams.hwndParent);
7326             SetupDiSetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
7327         }
7328     }
7329     *pSectionName = '\0';
7330     Result = SetupInstallFromInfSectionW(InstallParams.hwndParent,
7331         SelectedDriver->InfFileDetails->hInf, SectionName,
7332         DoAction, hKey, NULL, SP_COPY_NEWER,
7333         InstallParams.InstallMsgHandler, InstallParams.InstallMsgHandlerContext,
7334         DeviceInfoSet, DeviceInfoData);
7335     if (!Result)
7336         goto cleanup;
7337     if (!(InstallParams.Flags & DI_NOFILECOPY) && !(InstallParams.Flags & DI_NOVCP))
7338     {
7339         if (Result && InstallParams.InstallMsgHandler == SetupDefaultQueueCallbackW)
7340         {
7341             /* Delete resources allocated by SetupInitDefaultQueueCallback */
7342             SetupTermDefaultQueueCallback(InstallParams.InstallMsgHandlerContext);
7343         }
7344     }
7345     InstallParams.Flags |= DI_NOFILECOPY;
7346     SetupDiSetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
7347
7348     /* Write information to driver key */
7349     *pSectionName = UNICODE_NULL;
7350     memcpy(&fullVersion, &SelectedDriver->Info.DriverVersion, sizeof(LARGE_INTEGER));
7351     TRACE("Write information to driver key\n");
7352     TRACE("DriverDate      : '%u-%u-%u'\n", DriverDate.wMonth, DriverDate.wDay, DriverDate.wYear);
7353     TRACE("DriverDesc      : '%S'\n", SelectedDriver->Info.Description);
7354     TRACE("DriverVersion   : '%u.%u.%u.%u'\n", fullVersion.HighPart >> 16, fullVersion.HighPart & 0xffff, fullVersion.LowPart >> 16, fullVersion.LowPart & 0xffff);
7355     TRACE("InfPath         : '%S'\n", SelectedDriver->Details.InfFileName);
7356     TRACE("InfSection      : '%S'\n", SelectedDriver->Details.SectionName);
7357     TRACE("InfSectionExt   : '%S'\n", &SectionName[wcslen(SelectedDriver->Details.SectionName)]);
7358     TRACE("MatchingDeviceId: '%S'\n", SelectedDriver->MatchingId);
7359     TRACE("ProviderName    : '%S'\n", SelectedDriver->Info.ProviderName);
7360     swprintf(Buffer, L"%u-%u-%u", DriverDate.wMonth, DriverDate.wDay, DriverDate.wYear);
7361     rc = RegSetValueEx(hKey, L"DriverDate", 0, REG_SZ, (const BYTE *)Buffer, (wcslen(Buffer) + 1) * sizeof(WCHAR));
7362     if (rc == ERROR_SUCCESS)
7363         rc = RegSetValueEx(hKey, L"DriverDateData", 0, REG_BINARY, (const BYTE *)&SelectedDriver->Info.DriverDate, sizeof(FILETIME));
7364     if (rc == ERROR_SUCCESS)
7365         rc = RegSetValueEx(hKey, L"DriverDesc", 0, REG_SZ, (const BYTE *)SelectedDriver->Info.Description, (wcslen(SelectedDriver->Info.Description) + 1) * sizeof(WCHAR));
7366     if (rc == ERROR_SUCCESS)
7367     {
7368         swprintf(Buffer, L"%u.%u.%u.%u", fullVersion.HighPart >> 16, fullVersion.HighPart & 0xffff, fullVersion.LowPart >> 16, fullVersion.LowPart & 0xffff);
7369         rc = RegSetValueEx(hKey, L"DriverVersion", 0, REG_SZ, (const BYTE *)Buffer, (wcslen(Buffer) + 1) * sizeof(WCHAR));
7370     }
7371     if (rc == ERROR_SUCCESS)
7372         rc = RegSetValueEx(hKey, L"InfPath", 0, REG_SZ, (const BYTE *)SelectedDriver->Details.InfFileName, (wcslen(SelectedDriver->Details.InfFileName) + 1) * sizeof(WCHAR));
7373     if (rc == ERROR_SUCCESS)
7374         rc = RegSetValueEx(hKey, L"InfSection", 0, REG_SZ, (const BYTE *)SelectedDriver->Details.SectionName, (wcslen(SelectedDriver->Details.SectionName) + 1) * sizeof(WCHAR));
7375     if (rc == ERROR_SUCCESS)
7376         rc = RegSetValueEx(hKey, L"InfSectionExt", 0, REG_SZ, (const BYTE *)&SectionName[wcslen(SelectedDriver->Details.SectionName)], (wcslen(SectionName) - wcslen(SelectedDriver->Details.SectionName) + 1) * sizeof(WCHAR));
7377     if (rc == ERROR_SUCCESS)
7378         rc = RegSetValueEx(hKey, L"MatchingDeviceId", 0, REG_SZ, (const BYTE *)SelectedDriver->MatchingId, (wcslen(SelectedDriver->MatchingId) + 1) * sizeof(WCHAR));
7379     if (rc == ERROR_SUCCESS)
7380         rc = RegSetValueEx(hKey, L"ProviderName", 0, REG_SZ, (const BYTE *)SelectedDriver->Info.ProviderName, (wcslen(SelectedDriver->Info.ProviderName) + 1) * sizeof(WCHAR));
7381     if (rc != ERROR_SUCCESS)
7382     {
7383        SetLastError(rc);
7384        goto cleanup;
7385     }
7386     RegCloseKey(hKey);
7387     hKey = INVALID_HANDLE_VALUE;
7388
7389     /* FIXME: Process .LogConfigOverride section */
7390
7391     /* Install .Services section */
7392     wcscpy(pSectionName, DotServices);
7393     Result = SetupInstallServicesFromInfSectionExW(
7394         SelectedDriver->InfFileDetails->hInf,
7395         SectionName,
7396         0,
7397         DeviceInfoSet,
7398         DeviceInfoData,
7399         NULL,
7400         NULL);
7401     if (!Result)
7402         goto cleanup;
7403     if (GetLastError() == ERROR_SUCCESS_REBOOT_REQUIRED)
7404         RebootRequired = TRUE;
7405
7406     /* Copy .inf file to Inf\ directory (if needed) */
7407     Result = InfIsFromOEMLocation(SelectedDriver->InfFileDetails->FullInfFileName, &NeedtoCopyFile);
7408     if (!Result)
7409         goto cleanup;
7410     if (NeedtoCopyFile)
7411     {
7412         Result = SetupCopyOEMInfW(
7413             SelectedDriver->InfFileDetails->FullInfFileName,
7414             NULL,
7415             SPOST_NONE,
7416             SP_COPY_NOOVERWRITE,
7417             NULL, 0,
7418             NULL,
7419             NULL);
7420         if (!Result)
7421             goto cleanup;
7422         /* FIXME: create a new struct InfFileDetails, and set it to SelectedDriver->InfFileDetails,
7423          * to release use of current InfFile */
7424     }
7425
7426     /* Open device registry key */
7427     hKey = SetupDiOpenDevRegKey(DeviceInfoSet, DeviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_SET_VALUE);
7428     if (hKey == INVALID_HANDLE_VALUE)
7429         goto cleanup;
7430
7431     /* Install .HW section */
7432     wcscpy(pSectionName, L".HW");
7433     Result = SetupInstallFromInfSectionW(InstallParams.hwndParent,
7434         SelectedDriver->InfFileDetails->hInf, SectionName,
7435         SPINST_REGISTRY, hKey, NULL, 0,
7436         InstallParams.InstallMsgHandler, InstallParams.InstallMsgHandlerContext,
7437         DeviceInfoSet, DeviceInfoData);
7438     if (!Result)
7439         goto cleanup;
7440
7441     /* Write information to enum key */
7442     TRACE("Write information to enum key\n");
7443     TRACE("Class           : '%S'\n", ClassName);
7444     TRACE("ClassGUID       : '%S'\n", lpFullGuidString);
7445     TRACE("DeviceDesc      : '%S'\n", SelectedDriver->Info.Description);
7446     TRACE("Mfg             : '%S'\n", SelectedDriver->Info.MfgName);
7447     rc = RegSetValueEx(hKey, REGSTR_VAL_CLASS, 0, REG_SZ, (const BYTE *)ClassName, (wcslen(ClassName) + 1) * sizeof(WCHAR));
7448     if (rc == ERROR_SUCCESS)
7449         rc = RegSetValueEx(hKey, REGSTR_VAL_CLASSGUID, 0, REG_SZ, (const BYTE *)lpFullGuidString, (wcslen(lpFullGuidString) + 1) * sizeof(WCHAR));
7450     if (rc == ERROR_SUCCESS)
7451         rc = RegSetValueEx(hKey, REGSTR_VAL_DEVDESC, 0, REG_SZ, (const BYTE *)SelectedDriver->Info.Description, (wcslen(SelectedDriver->Info.Description) + 1) * sizeof(WCHAR));
7452     if (rc == ERROR_SUCCESS)
7453         rc = RegSetValueEx(hKey, REGSTR_VAL_MFG, 0, REG_SZ, (const BYTE *)SelectedDriver->Info.MfgName, (wcslen(SelectedDriver->Info.MfgName) + 1) * sizeof(WCHAR));
7454     if (rc != ERROR_SUCCESS)
7455     {
7456        SetLastError(rc);
7457        goto cleanup;
7458     }
7459
7460     /* Start the device */
7461     if (!RebootRequired && !(InstallParams.Flags & (DI_NEEDRESTART | DI_NEEDREBOOT | DI_DONOTCALLCONFIGMG)))
7462         ret = ResetDevice(DeviceInfoSet, DeviceInfoData);
7463     else
7464         ret = TRUE;
7465
7466 cleanup:
7467     /* End of installation */
7468     if (hClassKey != INVALID_HANDLE_VALUE)
7469         RegCloseKey(hClassKey);
7470     if (hKey != INVALID_HANDLE_VALUE)
7471         RegCloseKey(hKey);
7472     if (lpGuidString)
7473         RpcStringFreeW(&lpGuidString);
7474     HeapFree(GetProcessHeap(), 0, lpFullGuidString);
7475
7476     TRACE("Returning %d\n", ret);
7477     return ret;
7478 }