[ros-diffs] [hpoussin] 17212: Implement SetupDiBuildDriverInfoList, SetupDiOpenDeviceInfoA/W, SetupDiEnumDriverInfoA/W, SetupDiCreateDeviceInfoW

Implement SetupDiBuildDriverInfoList, SetupDiOpenDeviceInfoA/W,
SetupDiEnumDriverInfoA/W, SetupDiCreateDeviceInfoW
Add stubs for SetupDiDeleteDeviceInfo, SetupDiDestroyDriverInfoList
Modified: trunk/reactos/lib/setupapi/devinst.c
Modified: trunk/reactos/lib/setupapi/setupapi.spec
  _____  

Modified: trunk/reactos/lib/setupapi/devinst.c
--- trunk/reactos/lib/setupapi/devinst.c	2005-08-08 16:08:30 UTC
(rev 17211)
+++ trunk/reactos/lib/setupapi/devinst.c	2005-08-08 16:09:48 UTC
(rev 17212)
@@ -2787,8 +2787,904 @@

        DWORD CreationFlags,
        PSP_DEVINFO_DATA DeviceInfoData)
 {
-    FIXME("%p %s %s %s %p %lx %p\n", DeviceInfoSet,
debugstr_w(DeviceName),
-          debugstr_guid(ClassGuid), debugstr_w(DeviceDescription),
hwndParent,
-          CreationFlags, DeviceInfoData);
+    struct DeviceInfoSet *list;
+    BOOL ret = FALSE;
+
+    TRACE("%p %S %s %S %p %lx %p\n", DeviceInfoSet, DeviceName,
+        debugstr_guid(ClassGuid), DeviceDescription,
+        hwndParent, CreationFlags, DeviceInfoData);
+
+    if (!DeviceInfoSet)
+        SetLastError(ERROR_INVALID_HANDLE);
+    else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic !=
SETUP_DEV_INFO_SET_MAGIC)
+        SetLastError(ERROR_INVALID_HANDLE);
+    else if (!ClassGuid)
+        SetLastError(ERROR_INVALID_PARAMETER);
+    else if (!IsEqualIID(&list->ClassGuid, &GUID_NULL) &&
!IsEqualIID(&list->ClassGuid, ClassGuid))
+        SetLastError(ERROR_CLASS_MISMATCH);
+    else if (CreationFlags & ~(DICD_GENERATE_ID |
DICD_INHERIT_CLASSDRVS))
+    {
+        TRACE("Unknown flags: 0x%08lx\n", CreationFlags &
~(DICD_GENERATE_ID | DICD_INHERIT_CLASSDRVS));
+        SetLastError(ERROR_INVALID_PARAMETER);
+    }
+    else
+    {
+        SP_DEVINFO_DATA DevInfo;
+
+        if (CreationFlags & DICD_GENERATE_ID)
+        {
+            /* Generate a new unique ID for this device */
+            SetLastError(ERROR_GEN_FAILURE);
+            FIXME("not implemented\n");
+        }
+        else
+        {
+            /* Device name is fully qualified. Try to open it */
+            BOOL rc;
+
+            DevInfo.cbSize = sizeof(SP_DEVINFO_DATA);
+            rc = SetupDiOpenDeviceInfoW(
+                DeviceInfoSet,
+                DeviceName,
+                NULL, /* hwndParent */
+                CreationFlags & DICD_INHERIT_CLASSDRVS ?
DIOD_INHERIT_CLASSDRVS : 0,
+                &DevInfo);
+
+            if (rc)
+            {
+                /* SetupDiOpenDeviceInfoW has already added
+                 * the device info to the device info set
+                 */
+                SetLastError(ERROR_DEVINST_ALREADY_EXISTS);
+            }
+            else if (GetLastError() == ERROR_FILE_NOT_FOUND)
+            {
+                struct DeviceInfoElement *deviceInfo;
+
+                deviceInfo = HeapAlloc(GetProcessHeap(), 0,
sizeof(struct DeviceInfoElement) + (wcslen(DeviceName) + 1) *
sizeof(WCHAR));
+                if (!deviceInfo)
+                {
+                    SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+                }
+                else
+                {
+                    /* Fill members of the new structure */
+                    wcscpy(deviceInfo->Data, DeviceName);
+                    deviceInfo->DeviceName = deviceInfo->Data;
+                    deviceInfo->UniqueId = wcsrchr(deviceInfo->Data,
'\\');
+                    deviceInfo->DeviceDescription = NULL;
+                    //FIXME memcpy(&deviceInfo->ClassGuid, pClassGuid,
sizeof(GUID));
+                    deviceInfo->CreationFlags = 0;
+                    deviceInfo->hwndParent = hwndParent;
+                    deviceInfo->Flags = 0; /* FIXME */
+                    deviceInfo->FlagsEx = 0; /* FIXME */
+                    InitializeListHead(&deviceInfo->DriverListHead);
+                    InitializeListHead(&deviceInfo->InterfaceHead);
+                    InsertTailList(&list->ListHead,
&deviceInfo->ListEntry);
+
+                    if (!DeviceInfoData)
+                        ret = TRUE;
+                    else
+                    {
+                        if (DeviceInfoData->cbSize !=
sizeof(PSP_DEVINFO_DATA))
+                        {
+                            SetLastError(ERROR_INVALID_USER_BUFFER);
+                        }
+                        else
+                        {
+                            memcpy(&DeviceInfoData->ClassGuid,
ClassGuid, sizeof(GUID));
+                            DeviceInfoData->DevInst = 0; /* FIXME */
+                            DeviceInfoData->Reserved =
(ULONG_PTR)deviceInfo;
+                            ret = TRUE;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    TRACE("Returning %d\n", ret);
+    return ret;
+}
+
+/**********************************************************************
*
+ *		Helper functions for SetupDiBuildDriverInfoList
+ */
+static BOOL
+AddDriverToList(
+    IN PLIST_ENTRY DriverListHead,
+    IN DWORD DriverType, /* SPDIT_CLASSDRIVER or SPDIT_COMPATDRIVER */
+    IN INFCONTEXT ContextDevice,
+    IN LPCWSTR InfFile,
+    IN LPCWSTR ProviderName,
+    IN LPCWSTR ManufacturerName,
+    FILETIME DriverDate,
+    DWORDLONG DriverVersion,
+    IN DWORD Rank,
+    IN DWORD SubRank)
+{
+    struct DriverInfoElement *driverInfo;
+    DWORD RequiredSize = 128; /* Initial buffer size */
+    BOOL Result = FALSE;
+    LPWSTR DeviceDescription = NULL;
+    LPWSTR InfInstallSection = NULL;
+
+    driverInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(struct
DriverInfoElement));
+    if (!driverInfo)
+    {
+        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+        return FALSE;
+    }
+
+    SetLastError(ERROR_INSUFFICIENT_BUFFER);
+    while (!Result && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
+    {
+        HeapFree(GetProcessHeap(), 0, DeviceDescription);
+        DeviceDescription = HeapAlloc(GetProcessHeap(), 0, RequiredSize
* sizeof(WCHAR));
+        if (!DeviceDescription)
+            return FALSE;
+        Result = SetupGetStringFieldW(
+            &ContextDevice,
+            0, /* Field index */
+            DeviceDescription, RequiredSize,
+            &RequiredSize);
+    }
+    if (!Result)
+    {
+        HeapFree(GetProcessHeap(), 0, driverInfo);
+        HeapFree(GetProcessHeap(), 0, DeviceDescription);
+        return FALSE;
+    }
+
+    Result = FALSE;
+    RequiredSize = 128; /* Initial buffer size */
+    SetLastError(ERROR_INSUFFICIENT_BUFFER);
+    while (!Result && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
+    {
+        HeapFree(GetProcessHeap(), 0, InfInstallSection);
+        InfInstallSection = HeapAlloc(GetProcessHeap(), 0, RequiredSize
* sizeof(WCHAR));
+        if (!InfInstallSection)
+        {
+            HeapFree(GetProcessHeap(), 0, driverInfo);
+            HeapFree(GetProcessHeap(), 0, DeviceDescription);
+            return FALSE;
+        }
+        Result = SetupGetStringFieldW(
+            &ContextDevice,
+            1, /* Field index */
+            InfInstallSection, RequiredSize,
+            &RequiredSize);
+    }
+    if (!Result)
+    {
+        HeapFree(GetProcessHeap(), 0, driverInfo);
+        HeapFree(GetProcessHeap(), 0, DeviceDescription);
+        HeapFree(GetProcessHeap(), 0, InfInstallSection);
+        return FALSE;
+    }
+
+    TRACE("Adding driver '%S' [%S/%S]\n", DeviceDescription, InfFile,
InfInstallSection);
+
+    driverInfo->Info.DriverType = DriverType;
+    driverInfo->Info.Reserved = (ULONG_PTR)driverInfo;
+    wcsncpy(driverInfo->Info.Description, DeviceDescription, LINE_LEN -
1);
+    driverInfo->Info.Description[LINE_LEN - 1] = '\0';
+    wcsncpy(driverInfo->Info.MfgName, ManufacturerName, LINE_LEN - 1);
+    driverInfo->Info.MfgName[LINE_LEN - 1] = '\0';
+    if (ProviderName)
+    {
+        wcsncpy(driverInfo->Info.ProviderName, ProviderName, LINE_LEN -
1);
+        driverInfo->Info.ProviderName[LINE_LEN - 1] = '\0';
+    }
+    else
+        driverInfo->Info.ProviderName[0] = '\0';
+    driverInfo->Info.DriverDate = DriverDate;
+    driverInfo->Info.DriverVersion = DriverVersion;
+    InsertTailList(DriverListHead, &driverInfo->ListEntry);
+
+    HeapFree(GetProcessHeap(), 0, DeviceDescription);
+    HeapFree(GetProcessHeap(), 0, InfInstallSection);
+    return TRUE;
+}
+
+static BOOL
+GetVersionInformationFromInfFile(
+    IN HINF hInf,
+    OUT LPGUID ClassGuid,
+    OUT LPWSTR* pProviderName,
+    OUT FILETIME* DriverDate,
+    OUT DWORDLONG* DriverVersion)
+{
+    DWORD RequiredSize;
+    WCHAR guidW[MAX_GUID_STRING_LEN + 1];
+    LPWSTR ProviderName = NULL;
+    BOOL Result;
+
+    if (!SetupGetLineTextW(
+        NULL, /* Context */
+        hInf,
+        L"Version", L"ClassGUID",
+        guidW, sizeof(guidW),
+        NULL /* Required size */))
+    {
+        return FALSE;
+    }
+
+    /* Get Provider name, driver date, and driver version */
+
+    guidW[37] = '\0'; /* Replace the } by a NULL character */
+    if (UuidFromStringW(&guidW[1], ClassGuid) != RPC_S_OK)
+    {
+        return FALSE;
+    }
+    Result = SetupGetLineTextW(
+        NULL, /* Context */
+        hInf, L"Version", L"Provider",
+        NULL, 0,
+        &RequiredSize);
+    if (!Result && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
+    {
+        ProviderName = HeapAlloc(GetProcessHeap(), 0, RequiredSize *
sizeof(WCHAR));
+        if (!ProviderName)
+        {
+            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+            return FALSE;
+        }
+        Result = SetupGetLineTextW(
+            NULL, /* Context */
+            hInf, L"Version", L"Provider",
+            ProviderName, RequiredSize,
+            &RequiredSize);
+    }
+    //FIXME: DriverDate = Version.DriverVer => invalid date = 00/00/00
+    //FIXME: DriverVersion = Version.DriverVer => invalid = 0
+
+    *pProviderName = ProviderName;
+    return TRUE;
+}
+
+/**********************************************************************
*
+ *		SetupDiBuildDriverInfoList (SETUPAPI.@)
+ */
+BOOL WINAPI
+SetupDiBuildDriverInfoList(
+    IN HDEVINFO DeviceInfoSet,
+    IN OUT PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
+    IN DWORD DriverType)
+{
+    struct DeviceInfoSet *list;
+    PVOID Buffer = NULL;
+    HINF hInf = INVALID_HANDLE_VALUE;
+    LPWSTR ProviderName = NULL;
+    LPWSTR ManufacturerName = NULL;
+    LPWSTR ManufacturerSection = NULL;
+    LPWSTR HardwareIDs = NULL;
+    LPWSTR CompatibleIDs = NULL;
+    FILETIME DriverDate;
+    DWORDLONG DriverVersion;
+    DWORD RequiredSize;
+    BOOL ret = FALSE;
+
+    TRACE("%p %p %ld\n", DeviceInfoSet, DeviceInfoData, DriverType);
+
+    if (!DeviceInfoSet)
+        SetLastError(ERROR_INVALID_HANDLE);
+    else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic !=
SETUP_DEV_INFO_SET_MAGIC)
+        SetLastError(ERROR_INVALID_HANDLE);
+    else if (list->HKLM != HKEY_LOCAL_MACHINE)
+        SetLastError(ERROR_INVALID_HANDLE);
+    else if (DriverType != SPDIT_CLASSDRIVER && DriverType !=
SPDIT_COMPATDRIVER)
+        SetLastError(ERROR_INVALID_PARAMETER);
+    else if (DriverType == SPDIT_CLASSDRIVER && DeviceInfoData)
+        SetLastError(ERROR_INVALID_PARAMETER);
+    else if (DriverType == SPDIT_COMPATDRIVER && !DeviceInfoData)
+        SetLastError(ERROR_INVALID_PARAMETER);
+    else if (DeviceInfoData && DeviceInfoData->cbSize !=
sizeof(SP_DEVINFO_DATA))
+        SetLastError(ERROR_INVALID_USER_BUFFER);
+    else
+    {
+        BOOL Result = FALSE;
+
+        if (DriverType == SPDIT_COMPATDRIVER)
+        {
+            /* Get hardware IDs list */
+            Result = FALSE;
+            RequiredSize = 512; /* Initial buffer size */
+            SetLastError(ERROR_INSUFFICIENT_BUFFER);
+            while (!Result && GetLastError() ==
ERROR_INSUFFICIENT_BUFFER)
+            {
+                HeapFree(GetProcessHeap(), 0, HardwareIDs);
+                HardwareIDs = HeapAlloc(GetProcessHeap(), 0,
RequiredSize * sizeof(WCHAR));
+                if (!HardwareIDs)
+                {
+                    SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+                    goto done;
+                }
+                Result = SetupDiGetDeviceRegistryPropertyW(
+                    DeviceInfoSet,
+                    DeviceInfoData,
+                    SPDRP_HARDWAREID,
+                    NULL,
+                    (PBYTE)HardwareIDs,
+                    RequiredSize,
+                    &RequiredSize);
+            }
+            if (!Result)
+                goto done;
+
+            /* Get compatible IDs list */
+            Result = FALSE;
+            RequiredSize = 512; /* Initial buffer size */
+            SetLastError(ERROR_INSUFFICIENT_BUFFER);
+            while (!Result && GetLastError() ==
ERROR_INSUFFICIENT_BUFFER)
+            {
+                HeapFree(GetProcessHeap(), 0, CompatibleIDs);
+                CompatibleIDs = HeapAlloc(GetProcessHeap(), 0,
RequiredSize * sizeof(WCHAR));
+                if (!CompatibleIDs)
+                {
+                    SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+                    goto done;
+                }
+                Result = SetupDiGetDeviceRegistryPropertyW(
+                    DeviceInfoSet,
+                    DeviceInfoData,
+                    SPDRP_COMPATIBLEIDS,
+                    NULL,
+                    (PBYTE)CompatibleIDs,
+                    RequiredSize,
+                    &RequiredSize);
+                if (!Result && GetLastError() == ERROR_FILE_NOT_FOUND)
+                {
+                    /* No compatible ID for this device */
+                    HeapFree(GetProcessHeap(), 0, CompatibleIDs);
+                    CompatibleIDs = NULL;
+                    Result = TRUE;
+                }
+            }
+            if (!Result)
+                goto done;
+        }
+
+        /* Enumerate .inf files */
+        Result = FALSE;
+        RequiredSize = 32768; /* Initial buffer size */
+        SetLastError(ERROR_INSUFFICIENT_BUFFER);
+        while (!Result && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
+        {
+            HeapFree(GetProcessHeap(), 0, Buffer);
+            Buffer = HeapAlloc(GetProcessHeap(), 0, RequiredSize *
sizeof(WCHAR));
+            if (!Buffer)
+            {
+                Result = FALSE;
+                SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+                break;
+            }
+            Result = SetupGetInfFileListW(
+                NULL, /* Directory path */
+                INF_STYLE_WIN4,
+                Buffer, RequiredSize,
+                &RequiredSize);
+        }
+        if (Result)
+        {
+            LPCWSTR filename;
+            for (filename = (LPCWSTR)Buffer; *filename; filename +=
wcslen(filename) + 1)
+            {
+                INFCONTEXT ContextManufacturer, ContextDevice;
+                GUID ClassGuid;
+                TRACE("Opening file %S\n", filename);
+
+                hInf = SetupOpenInfFileW(filename, NULL,
INF_STYLE_WIN4, NULL);
+                if (hInf == INVALID_HANDLE_VALUE)
+                    continue;
+
+                if (!GetVersionInformationFromInfFile(
+                    hInf,
+                    &ClassGuid,
+                    &ProviderName,
+                    &DriverDate,
+                    &DriverVersion))
+                {
+                    SetupCloseInfFile(hInf);
+                    hInf = INVALID_HANDLE_VALUE;
+                    continue;
+                }
+
+                if (DriverType == SPDIT_CLASSDRIVER)
+                {
+                    /* Check if the ClassGuid in this .inf file is
corresponding with our needs */
+                    if (!IsEqualIID(&list->ClassGuid, &GUID_NULL) &&
!IsEqualIID(&list->ClassGuid, &ClassGuid))
+                    {
+                        SetupCloseInfFile(hInf);
+                        hInf = INVALID_HANDLE_VALUE;
+                        continue;
+                    }
+                }
+
+                /* Get the manufacturers list */
+                Result = SetupFindFirstLineW(hInf, L"Manufacturer",
NULL, &ContextManufacturer);
+                while (Result)
+                {
+                    Result = SetupGetStringFieldW(
+                        &ContextManufacturer,
+                        0, /* Field index */
+                        NULL, 0,
+                        &RequiredSize);
+                    if (!Result && GetLastError() ==
ERROR_INSUFFICIENT_BUFFER)
+                    {
+                        ManufacturerName = HeapAlloc(GetProcessHeap(),
0, RequiredSize * sizeof(WCHAR));
+                        if (!ManufacturerName)
+                        {
+                            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+                            goto done;
+                        }
+                        Result = SetupGetStringFieldW(
+                            &ContextManufacturer,
+                            0, /* Field index */
+                            ManufacturerName, RequiredSize,
+                            &RequiredSize);
+                    }
+                    Result = SetupGetStringFieldW(
+                        &ContextManufacturer,
+                        1, /* Field index */
+                        NULL, 0,
+                        &RequiredSize);
+                    if (!Result && GetLastError() ==
ERROR_INSUFFICIENT_BUFFER)
+                    {
+                        ManufacturerSection =
HeapAlloc(GetProcessHeap(), 0, RequiredSize * sizeof(WCHAR));
+                        if (!ManufacturerSection)
+                        {
+                            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+                            goto done;
+                        }
+                        Result = SetupGetStringFieldW(
+                            &ContextManufacturer,
+                            1, /* Field index */
+                            ManufacturerSection, RequiredSize,
+                            &RequiredSize);
+                    }
+
+                    TRACE("Enumerating devices in manufacturer %S\n",
ManufacturerSection);
+                    Result = SetupFindFirstLineW(hInf,
ManufacturerSection, NULL, &ContextDevice);
+                    while (Result)
+                    {
+                        if (DriverType == SPDIT_CLASSDRIVER)
+                        {
+                            /* FIXME: read [ControlFlags] /
ExcludeFromSelect */
+                            if (!AddDriverToList(
+                                &list->DriverListHead,
+                                DriverType,
+                                ContextDevice,
+                                filename,
+                                ProviderName,
+                                ManufacturerName,
+                                DriverDate, DriverVersion,
+                                0, 0))
+                            {
+                                break;
+                            }
+                        }
+                        else /* DriverType = SPDIT_COMPATDRIVER */
+                        {
+                            /* 1. Get all fields */
+                            DWORD FieldCount =
SetupGetFieldCount(&ContextDevice);
+                            DWORD DriverRank;
+                            DWORD i;
+                            LPCWSTR currentId;
+                            BOOL DriverAlreadyAdded;
+
+                            for (i = 2; i <= FieldCount; i++)
+                            {
+                                LPWSTR DeviceId = NULL;
+                                Result = FALSE;
+                                RequiredSize = 128; /* Initial buffer
size */
+
SetLastError(ERROR_INSUFFICIENT_BUFFER);
+                                while (!Result && GetLastError() ==
ERROR_INSUFFICIENT_BUFFER)
+                                {
+                                    HeapFree(GetProcessHeap(), 0,
DeviceId);
+                                    DeviceId =
HeapAlloc(GetProcessHeap(), 0, RequiredSize * sizeof(WCHAR));
+                                    if (!DeviceId)
+                                    {
+
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+                                        goto done;
+                                    }
+                                    Result = SetupGetStringFieldW(
+                                        &ContextDevice,
+                                        i,
+                                        DeviceId, RequiredSize,
+                                        &RequiredSize);
+                                }
+                                if (!Result)
+                                {
+                                    HeapFree(GetProcessHeap(), 0,
DeviceId);
+                                    goto done;
+                                }
+                                DriverRank = 0;
+                                DriverAlreadyAdded = FALSE;
+                                for (currentId = (LPCWSTR)HardwareIDs;
!DriverAlreadyAdded && *currentId; currentId += wcslen(currentId) + 1,
DriverRank++)
+                                {
+                                    if (wcscmp(DeviceId, currentId) ==
0)
+                                    {
+                                        AddDriverToList(
+                                            &((struct DeviceInfoElement
*)DeviceInfoData->Reserved)->DriverListHead,
+                                            DriverType,
+                                            ContextDevice,
+                                            filename,
+                                            ProviderName,
+                                            ManufacturerName,
+                                            DriverDate, DriverVersion,
+                                            DriverRank, i);
+                                        DriverAlreadyAdded = TRUE;
+                                    }
+                                }
+                                if (CompatibleIDs)
+                                {
+                                    for (currentId =
(LPCWSTR)CompatibleIDs; !DriverAlreadyAdded && *currentId; currentId +=
wcslen(currentId) + 1, DriverRank++)
+                                    {
+                                        if (wcscmp(DeviceId, currentId)
== 0)
+                                        {
+                                            AddDriverToList(
+                                                &((struct
DeviceInfoElement *)DeviceInfoData->Reserved)->DriverListHead,
+                                                DriverType,
+                                                ContextDevice,
+                                                filename,
+                                                ProviderName,
+                                                ManufacturerName,
+                                                DriverDate,
DriverVersion,
+                                                DriverRank, i);
+                                            DriverAlreadyAdded = TRUE;
+                                        }
+                                    }
+                                }
+                                HeapFree(GetProcessHeap(), 0,
DeviceId);
+                            }
+                        }
+                        Result = SetupFindNextLine(&ContextDevice,
&ContextDevice);
+                    }
+
+                    HeapFree(GetProcessHeap(), 0, ManufacturerName);
+                    HeapFree(GetProcessHeap(), 0, ManufacturerSection);
+                    ManufacturerName = ManufacturerSection = NULL;
+                    Result = SetupFindNextLine(&ContextManufacturer,
&ContextManufacturer);
+                }
+                HeapFree(GetProcessHeap(), 0, ProviderName);
+                ProviderName = NULL;
+                ret = TRUE;
+
+                SetupCloseInfFile(hInf);
+                hInf = INVALID_HANDLE_VALUE;
+            }
+            ret = TRUE;
+        }
+    }
+
+done:
+    HeapFree(GetProcessHeap(), 0, ProviderName);
+    HeapFree(GetProcessHeap(), 0, ManufacturerName);
+    HeapFree(GetProcessHeap(), 0, ManufacturerSection);
+    HeapFree(GetProcessHeap(), 0, HardwareIDs);
+    HeapFree(GetProcessHeap(), 0, CompatibleIDs);
+    if (hInf != INVALID_HANDLE_VALUE)
+        SetupCloseInfFile(hInf);
+    HeapFree(GetProcessHeap(), 0, Buffer);
+    TRACE("Returning %d\n", ret);
+    return ret;
+}
+
+/**********************************************************************
*
+ *		SetupDiDeleteDeviceInfo (SETUPAPI.@)
+ */
+BOOL WINAPI
+SetupDiDeleteDeviceInfo(
+    IN HDEVINFO DeviceInfoSet,
+    IN PSP_DEVINFO_DATA DeviceInfoData)
+{
+    TRACE("%p %p\n", DeviceInfoSet, DeviceInfoData);
+
+    FIXME("not implemented\n");
+    SetLastError(ERROR_GEN_FAILURE);
     return FALSE;
 }
+
+
+/**********************************************************************
*
+ *		SetupDiDestroyDriverInfoList (SETUPAPI.@)
+ */
+BOOL WINAPI
+SetupDiDestroyDriverInfoList(
+    IN HDEVINFO DeviceInfoSet,
+    IN PSP_DEVINFO_DATA DeviceInfoData,
+    IN DWORD DriverType)
+{
+    TRACE("%p %p 0x%lx\n", DeviceInfoSet, DeviceInfoData, DriverType);
+
+    FIXME("not implemented\n");
+    SetLastError(ERROR_GEN_FAILURE);
+    return FALSE;
+}
+
+
+/**********************************************************************
*
+ *		SetupDiOpenDeviceInfoA (SETUPAPI.@)
+ */
+BOOL WINAPI
+SetupDiOpenDeviceInfoA(
+    IN HDEVINFO DeviceInfoSet,
+    IN PCSTR DeviceInstanceId,
+    IN HWND hwndParent OPTIONAL,
+    IN DWORD OpenFlags,
+    OUT PSP_DEVINFO_DATA DeviceInfoData OPTIONAL)
+{
+    LPWSTR DeviceInstanceIdW = NULL;
+    BOOL bResult;
+
+    TRACE("%p %s %p %lx %p\n", DeviceInfoSet, DeviceInstanceId,
hwndParent, OpenFlags, DeviceInfoData);
+
+    DeviceInstanceIdW = MultiByteToUnicode(DeviceInstanceId, CP_ACP);
+    if (DeviceInstanceIdW == NULL)
+        return FALSE;
+
+    bResult = SetupDiOpenDeviceInfoW(DeviceInfoSet,
+        DeviceInstanceIdW, hwndParent, OpenFlags, DeviceInfoData);
+
+    MyFree(DeviceInstanceIdW);
+
+    return bResult;
+}
+
+
+/**********************************************************************
*
+ *		SetupDiOpenDeviceInfoW (SETUPAPI.@)
+ */
+BOOL WINAPI
+SetupDiOpenDeviceInfoW(
+    IN HDEVINFO DeviceInfoSet,
+    IN PCWSTR DeviceInstanceId,
+    IN HWND hwndParent OPTIONAL,
+    IN DWORD OpenFlags,
+    OUT PSP_DEVINFO_DATA DeviceInfoData OPTIONAL)
+{
+    struct DeviceInfoSet *list;
+    HKEY hEnumKey, hKey;
+    DWORD rc;
+    BOOL ret = FALSE;
+
+    TRACE("%p %S %p %lx %p\n", DeviceInfoSet, DeviceInstanceId,
hwndParent, OpenFlags, DeviceInfoData);
+
+    if (OpenFlags & DIOD_CANCEL_REMOVE)
+        FIXME("DIOD_CANCEL_REMOVE flag not implemented\n");
+
+    if (!DeviceInfoSet)
+        SetLastError(ERROR_INVALID_HANDLE);
+    else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic !=
SETUP_DEV_INFO_SET_MAGIC)
+        SetLastError(ERROR_INVALID_HANDLE);
+    else if (!DeviceInstanceId)
+        SetLastError(ERROR_INVALID_PARAMETER);
+    else if (OpenFlags & ~(DIOD_CANCEL_REMOVE |
DIOD_INHERIT_CLASSDRVS))
+    {
+        TRACE("Unknown flags: 0x%08lx\n", OpenFlags &
~(DIOD_CANCEL_REMOVE | DIOD_INHERIT_CLASSDRVS));
+        SetLastError(ERROR_INVALID_PARAMETER);
+    }
+    else if (DeviceInfoData && DeviceInfoData->cbSize !=
sizeof(SP_DEVINFO_DATA))
+        SetLastError(ERROR_INVALID_USER_BUFFER);
+    else
+    {
+        struct DeviceInfoElement *deviceInfo = NULL;
+        /* Search if device already exists in DeviceInfoSet.
+         *    If yes, return the existing element
+         *    If no, create a new element using informations in
registry
+         */
+        PLIST_ENTRY ItemList = list->ListHead.Flink;
+        while (ItemList != &list->ListHead)
+        {
+            // TODO
+            //if (good one)
+            //    break;
+            FIXME("not implemented\n");
+            ItemList = ItemList->Flink;
+        }
+
+        if (deviceInfo)
+        {
+            // good one found
+            if (DeviceInfoData)
+            {
+                memcpy(&DeviceInfoData->ClassGuid,
&deviceInfo->ClassGuid, sizeof(GUID));
+                DeviceInfoData->DevInst = 0; /* FIXME */
+                DeviceInfoData->Reserved = (ULONG_PTR)deviceInfo;
+            }
+            ret = TRUE;
+        }
+        else
+        {
+            /* Open supposed registry key */
+            rc = RegOpenKeyExW(
+                list->HKLM,
+                EnumKeyName,
+                0, /* Options */
+                KEY_ENUMERATE_SUB_KEYS,
+                &hEnumKey);
+            if (rc != ERROR_SUCCESS)
+            {
+                SetLastError(rc);
+                return FALSE;
+            }
+            rc = RegOpenKeyExW(
+                hEnumKey,
+                DeviceInstanceId,
+                0, /* Options */
+                KEY_QUERY_VALUE,
+                &hKey);
+            RegCloseKey(hEnumKey);
+            if (rc != ERROR_SUCCESS)
+            {
+                SetLastError(rc);
+                return FALSE;
+            }
+
+            deviceInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(struct
DeviceInfoElement) + (wcslen(DeviceInstanceId) + 1) * sizeof(WCHAR));
+            if (!deviceInfo)
+            {
+                RegCloseKey(hKey);
+                SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+                return FALSE;
+            }
+
+            wcscpy(deviceInfo->Data, DeviceInstanceId);
+            deviceInfo->DeviceName = deviceInfo->Data;
+            //FIXME deviceInfo->UniqueId =
&deviceInfo->Data[pEndOfInstancePath - InstancePath + 1];
+            deviceInfo->DeviceDescription = NULL;
+            //FIXME memcpy(&deviceInfo->ClassGuid, FIXME,
sizeof(GUID));
+            deviceInfo->CreationFlags = 0;
+            deviceInfo->hwndParent = hwndParent;
+            deviceInfo->Flags = 0; /* FIXME */
+            deviceInfo->FlagsEx = 0; /* FIXME */
+            InitializeListHead(&deviceInfo->DriverListHead);
+            InitializeListHead(&deviceInfo->InterfaceHead);
+            InsertTailList(&list->ListHead, &deviceInfo->ListEntry);
+
+            RegCloseKey(hKey);
+            ret = TRUE;
+        }
+
+        if (ret && deviceInfo && DeviceInfoData)
+        {
+            memcpy(&DeviceInfoData->ClassGuid, &deviceInfo->ClassGuid,
sizeof(GUID));
+            DeviceInfoData->DevInst = 0; /* FIXME */
+            DeviceInfoData->Reserved = (ULONG_PTR)deviceInfo;
+        }
+    }
+
+    return ret;
+}
+
+
+/**********************************************************************
*
+ *		SetupDiEnumDriverInfoA (SETUPAPI.@)
+ */
+BOOL WINAPI
+SetupDiEnumDriverInfoA(
+    IN HDEVINFO DeviceInfoSet,
+    IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
+    IN DWORD DriverType,
+    IN DWORD MemberIndex,
+    OUT PSP_DRVINFO_DATA_A DriverInfoData)
+{
+    SP_DRVINFO_DATA_V2_W driverInfoData2W;
+    BOOL ret = FALSE;
+
+    TRACE("%p %p 0x%lx %ld %p\n", DeviceInfoSet, DeviceInfoData,
+        DriverType, MemberIndex, DriverInfoData);
+
+    if (DriverInfoData == NULL)
+        SetLastError(ERROR_INVALID_PARAMETER);
+    else if (DriverInfoData->cbSize != sizeof(SP_DRVINFO_DATA_V1_A) &&
DriverInfoData->cbSize != sizeof(SP_DRVINFO_DATA_V2_A))
+        SetLastError(ERROR_INVALID_USER_BUFFER);
+    else
+    {
+        driverInfoData2W.cbSize = sizeof(SP_DRVINFO_DATA_V2_W);
+        ret = SetupDiEnumDriverInfoW(DeviceInfoSet, DeviceInfoData,
+            DriverType, MemberIndex, &driverInfoData2W);
+
+        if (ret)
+        {
+            /* Do W->A conversion */
+            DriverInfoData->DriverType = driverInfoData2W.DriverType;
+            DriverInfoData->Reserved = driverInfoData2W.Reserved;
+            if (WideCharToMultiByte(CP_ACP, 0,
driverInfoData2W.Description, -1,
+                DriverInfoData->Description, LINE_LEN, NULL, NULL) ==
0)
+            {
+                DriverInfoData->Description[0] = '\0';
+                ret = FALSE;
+            }
+            if (WideCharToMultiByte(CP_ACP, 0,
driverInfoData2W.MfgName, -1,
+                DriverInfoData->MfgName, LINE_LEN, NULL, NULL) == 0)
+            {
+                DriverInfoData->MfgName[0] = '\0';
+                ret = FALSE;
+            }
+            if (WideCharToMultiByte(CP_ACP, 0,
driverInfoData2W.ProviderName, -1,
+                DriverInfoData->ProviderName, LINE_LEN, NULL, NULL) ==
0)
+            {
+                DriverInfoData->ProviderName[0] = '\0';
+                ret = FALSE;
+            }
+            if (DriverInfoData->cbSize == sizeof(SP_DRVINFO_DATA_V2_A))
+            {
+                /* Copy more fields */
+                DriverInfoData->DriverDate =
driverInfoData2W.DriverDate;
+                DriverInfoData->DriverVersion =
driverInfoData2W.DriverVersion;
+            }
+        }
+    }
+
+    TRACE("Returning %d\n", ret);
+    return ret;
+}
+
+
+/**********************************************************************
*
+ *		SetupDiEnumDriverInfoW (SETUPAPI.@)
+ */
+BOOL WINAPI
+SetupDiEnumDriverInfoW(
+    IN HDEVINFO DeviceInfoSet,
+    IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
+    IN DWORD DriverType,
+    IN DWORD MemberIndex,
+    OUT PSP_DRVINFO_DATA_W DriverInfoData)
+{
+    PLIST_ENTRY ListHead;
+    BOOL ret = FALSE;
+
+    TRACE("%p %p 0x%lx %ld %p\n", DeviceInfoSet, DeviceInfoData,
+        DriverType, MemberIndex, DriverInfoData);
+
+    if (!DeviceInfoSet || !DriverInfoData)
+        SetLastError(ERROR_INVALID_PARAMETER);
+    else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
+        SetLastError(ERROR_INVALID_HANDLE);
+    else if (((struct DeviceInfoSet *)DeviceInfoSet)->magic !=
SETUP_DEV_INFO_SET_MAGIC)
+        SetLastError(ERROR_INVALID_HANDLE);
+    else if (DriverType != SPDIT_CLASSDRIVER && DriverType !=
SPDIT_COMPATDRIVER)
+        SetLastError(ERROR_INVALID_PARAMETER);
+    else if (DriverType == SPDIT_CLASSDRIVER && DeviceInfoData)
+        SetLastError(ERROR_INVALID_PARAMETER);
+    else if (DriverType == SPDIT_COMPATDRIVER && !DeviceInfoData)
+        SetLastError(ERROR_INVALID_PARAMETER);
+    else if (DriverInfoData->cbSize != sizeof(SP_DRVINFO_DATA_V1_W) &&
DriverInfoData->cbSize != sizeof(SP_DRVINFO_DATA_V2_W))
+        SetLastError(ERROR_INVALID_USER_BUFFER);
+    else
+    {
+        struct DeviceInfoElement *devInfo = (struct DeviceInfoElement
*)DeviceInfoData->Reserved;
+        PLIST_ENTRY ItemList;
+        if (DriverType == SPDIT_CLASSDRIVER ||
+            devInfo->CreationFlags & DICD_INHERIT_CLASSDRVS)
+        {
+            ListHead = &((struct DeviceInfoSet
*)DeviceInfoSet)->DriverListHead;
+        }
+        else
+        {
+            ListHead = &devInfo->DriverListHead;
+        }
+
+        ItemList = ListHead->Flink;
+        while (ItemList != ListHead && MemberIndex-- > 0)
+            ItemList = ItemList->Flink;
+        if (ItemList == ListHead)
+            SetLastError(ERROR_NO_MORE_ITEMS);
+        else
+        {
+            struct DriverInfoElement *DrvInfo = (struct
DriverInfoElement *)ItemList;
+
+            memcpy(
+                DriverInfoData,
+                &DrvInfo->Info,
+                DriverInfoData->cbSize);
+            ret = TRUE;
+        }
+    }
+
+    TRACE("Returning %d\n", ret);
+    return ret;
+}
  _____  

Modified: trunk/reactos/lib/setupapi/setupapi.spec
--- trunk/reactos/lib/setupapi/setupapi.spec	2005-08-08 16:08:30 UTC
(rev 17211)
+++ trunk/reactos/lib/setupapi/setupapi.spec	2005-08-08 16:09:48 UTC
(rev 17212)
@@ -268,7 +268,7 @@

 @ stdcall SetupDiBuildClassInfoList(long ptr long ptr)
 @ stdcall SetupDiBuildClassInfoListExA(long ptr long ptr str ptr)
 @ stdcall SetupDiBuildClassInfoListExW(long ptr long ptr wstr ptr)
-@ stub SetupDiBuildDriverInfoList
+@ stdcall SetupDiBuildDriverInfoList(long ptr long)
 @ stdcall SetupDiCallClassInstaller(long ptr ptr)
 @ stub SetupDiCancelDriverInfoSearch
 @ stub SetupDiChangeState
@@ -293,12 +293,12 @@
 @ stub SetupDiDeleteDeviceRegKey
 @ stub SetupDiDestroyClassImageList
 @ stdcall SetupDiDestroyDeviceInfoList(long)
-@ stub SetupDiDestroyDriverInfoList
+@ stdcall SetupDiDestroyDriverInfoList(long ptr long)
 @ stub SetupDiDrawMiniIcon
 @ stdcall SetupDiEnumDeviceInfo(long long ptr)
 @ stdcall SetupDiEnumDeviceInterfaces(long ptr ptr long ptr)
-@ stub SetupDiEnumDriverInfoA
-@ stub SetupDiEnumDriverInfoW
+@ stdcall SetupDiEnumDriverInfoA(long ptr long long ptr)
+@ stdcall SetupDiEnumDriverInfoW(long ptr long long ptr)
 @ stdcall SetupDiGetActualSectionToInstallA(long str str long ptr ptr)
 @ stdcall SetupDiGetActualSectionToInstallW(long wstr wstr long ptr
ptr)
 @ stub SetupDiGetClassBitmapIndex
@@ -359,8 +359,8 @@
 @ stdcall SetupDiOpenClassRegKeyExA(ptr long long str ptr)
 @ stdcall SetupDiOpenClassRegKeyExW(ptr long long wstr ptr)
 @ stdcall SetupDiOpenDevRegKey(ptr ptr long long long long)
-@ stub SetupDiOpenDeviceInfoA
-@ stub SetupDiOpenDeviceInfoW
+@ stdcall SetupDiOpenDeviceInfoA(ptr str long long ptr)
+@ stdcall SetupDiOpenDeviceInfoW(ptr wstr long long ptr)
 @ stdcall SetupDiOpenDeviceInterfaceA(ptr str long ptr)
 @ stub SetupDiOpenDeviceInterfaceRegKey
 @ stdcall SetupDiOpenDeviceInterfaceW(ptr wstr long ptr)