[ros-diffs] [hpoussin] 16622: Implement SetupDiGetDeviceInterfaceDetailA/W

Implement SetupDiGetDeviceInterfaceDetailA/W
Modified: trunk/reactos/include/wine/setupapi.h
Modified: trunk/reactos/lib/setupapi/devinst.c
Modified: trunk/reactos/lib/setupapi/setupapi.spec
  _____  

Modified: trunk/reactos/include/wine/setupapi.h
--- trunk/reactos/include/wine/setupapi.h	2005-07-17 15:10:03 UTC
(rev 16621)
+++ trunk/reactos/include/wine/setupapi.h	2005-07-17 15:57:41 UTC
(rev 16622)
@@ -20,6 +20,7 @@

 #define _INC_SETUPAPI
 
 #include <commctrl.h>
+#include <pshpack1.h>
 
 /* setupapi doesn't use the normal convention, it adds an underscore
before A/W */
 #ifdef __WINESRC__
@@ -859,4 +860,5 @@
 
 #undef DECL_WINELIB_SETUPAPI_TYPE_AW
 
+#include <poppack.h>
 #endif /* _INC_SETUPAPI */
  _____  

Modified: trunk/reactos/lib/setupapi/devinst.c
--- trunk/reactos/lib/setupapi/devinst.c	2005-07-17 15:10:03 UTC
(rev 16621)
+++ trunk/reactos/lib/setupapi/devinst.c	2005-07-17 15:57:41 UTC
(rev 16622)
@@ -56,6 +56,7 @@

 static const WCHAR NoUseClass[]  =
{'N','o','U','s','e','C','l','a','s','s',0};
 static const WCHAR NtExtension[]  = {'.','N','T',0};
 static const WCHAR NtPlatformExtension[]  =
{'.','N','T','x','8','6',0};
+static const WCHAR SymbolicLink[]  =
{'S','y','m','b','o','l','i','c','L','i','n','k',0};
 static const WCHAR Version[]  =
{'V','e','r','s','i','o','n',0};
 static const WCHAR WinExtension[]  =
{'.','W','i','n',0};
 
@@ -89,12 +90,16 @@
         struct
         {
             GUID InterfaceGuid;
-#ifdef __WINE__
-            WCHAR InterfaceName[0]; /* "COMx" */
-#else
             GUID ClassGuid;
-            WCHAR DeviceInstance[0]; /*
"ACPI\PNP0501\4&2658d0a0&0"...,
NULL on Wine */
+#ifndef __WINE__
+            /* Pointer into Data field. Contains something like */
+            /* "ACPI\PNP0501\4&2658d0a0&0" */
+            PWSTR pInstancePath;
 #endif
+            /* Pointer into Data field. Contains something like
+            * "\\?\ACPI#PNP0501#4&2658d0a0&0#{GUID}", or
"COMx" for
WINE */
+            PWSTR pSymbolicLink;
+            WCHAR Data[0];
         } Interface;
     };
 } DeviceInfo;
@@ -1152,7 +1157,7 @@
 
     if (MachineName)
         WARN("'MachineName' is ignored on Wine!\n");
-    if (DeviceInstanceW){
+    if (DeviceInstanceW)
         WARN("'DeviceInstanceW' can't be set on Wine!\n");
 
     devices = buf;
@@ -1187,7 +1192,7 @@
             /* We have found a device */
             TRACE("Adding %s to list\n", debugstr_w(ptr));
             deviceInfo = HeapAlloc(GetProcessHeap(), 0,
-                FIELD_OFFSET(DeviceInfo, Interface.InterfaceName) +
strlenW(ptr) * sizeof(WCHAR) + sizeof(UNICODE_NULL));
+                FIELD_OFFSET(DeviceInfo, Interface.Data) + strlenW(ptr)
* sizeof(WCHAR) + sizeof(UNICODE_NULL));
             if (!deviceInfo)
             {
                 if (devices != buf)
@@ -1195,8 +1200,9 @@
                 return ERROR_NO_SYSTEM_RESOURCES;
             }
             deviceInfo->IsDevice = FALSE;
+            deviceInfo->Interface.pSymbolicLink =
&deviceInfo->Interface.Data[0];
             memcpy(&deviceInfo->Interface.InterfaceGuid, InterfaceGuid,
sizeof(GUID));
-            wcscpy(&deviceInfo->Interface.InterfaceName[0], ptr);
+            wcscpy(deviceInfo->Interface.pSymbolicLink, ptr);
             InsertTailList(&list->ListHead, &deviceInfo->ItemEntry);
             list->numberOfEntries++;
         }
@@ -1214,11 +1220,18 @@
        LPGUID InterfaceGuid,
        PCWSTR DeviceInstanceW /* OPTIONAL */)
 {
-    HKEY hInterfaceKey, hEnumKey, hKey;
+    HKEY hInterfaceKey;      /*
HKLM\SYSTEM\CurrentControlSet\Control\DeviceClasses\{GUID} */
+    HKEY hDeviceInstanceKey; /*
HKLM\SYSTEM\CurrentControlSet\Control\DeviceClasses\{GUID}\##?#{Instance
Path} */
+    HKEY hReferenceKey;      /*
HKLM\SYSTEM\CurrentControlSet\Control\DeviceClasses\{GUID}\##?#{Instance
Path}\#{ReferenceString} */
+    HKEY hEnumKey;           /* HKLM\SYSTEM\CurrentControlSet\Enum */
+    HKEY hKey;               /*
HKLM\SYSTEM\CurrentControlSet\Enum\{Instance\Path} */
     LONG rc;
     WCHAR KeyBuffer[max(MAX_PATH, MAX_GUID_STRING_LEN) + 1];
-    DWORD i;
-    DWORD dwLength, dwRegType;
+    PWSTR InstancePath;
+    DWORD i, j;
+    DWORD dwLength, dwInstancePathLength;
+    DWORD dwRegType;
+    GUID ClassGuid;
     DeviceInfo *deviceInfo;
 
     /* Open registry key related to this interface */
@@ -1226,7 +1239,7 @@
     if (hInterfaceKey == INVALID_HANDLE_VALUE)
         return GetLastError();
 
-    /* Enumerate sub keys */
+    /* Enumerate sub keys of hInterfaceKey */
     i = 0;
     while (TRUE)
     {
@@ -1242,54 +1255,52 @@
         i++;
 
         /* Open sub key */
-        rc = RegOpenKeyEx(hInterfaceKey, KeyBuffer, 0, KEY_QUERY_VALUE,
&hKey);
+        rc = RegOpenKeyEx(hInterfaceKey, KeyBuffer, 0, KEY_QUERY_VALUE
| KEY_ENUMERATE_SUB_KEYS, &hDeviceInstanceKey);
         if (rc != ERROR_SUCCESS)
         {
             RegCloseKey(hInterfaceKey);
             return rc;
         }
 
-        /* Read DeviceInstance value */
-        rc = RegQueryValueExW(hKey, DeviceInstance, NULL, &dwRegType,
NULL, &dwLength);
+        /* Read DeviceInstance */
+        rc = RegQueryValueExW(hDeviceInstanceKey, DeviceInstance, NULL,
&dwRegType, NULL, &dwInstancePathLength);
         if (rc != ERROR_SUCCESS )
         {
-            RegCloseKey(hKey);
+            RegCloseKey(hDeviceInstanceKey);
             RegCloseKey(hInterfaceKey);
             return rc;
         }
         if (dwRegType != REG_SZ)
         {
-            RegCloseKey(hKey);
+            RegCloseKey(hDeviceInstanceKey);
             RegCloseKey(hInterfaceKey);
             return ERROR_GEN_FAILURE;
         }
-
-        /* Allocate memory for list entry and read DeviceInstance */
-        deviceInfo = HeapAlloc(GetProcessHeap(), 0,
FIELD_OFFSET(DeviceInfo, Interface.DeviceInstance) + dwLength +
sizeof(UNICODE_NULL));
-        if (!deviceInfo)
+        InstancePath = HeapAlloc(GetProcessHeap(), 0,
dwInstancePathLength + sizeof(UNICODE_NULL));
+        if (!InstancePath)
         {
-            RegCloseKey(hKey);
+            RegCloseKey(hDeviceInstanceKey);
             RegCloseKey(hInterfaceKey);
             return ERROR_NO_SYSTEM_RESOURCES;
         }
-        rc = RegQueryValueExW(hKey, DeviceInstance, NULL, NULL,
(LPBYTE)&deviceInfo->Interface.DeviceInstance[0], &dwLength);
+        rc = RegQueryValueExW(hDeviceInstanceKey, DeviceInstance, NULL,
NULL, (LPBYTE)InstancePath, &dwInstancePathLength);
         if (rc != ERROR_SUCCESS)
         {
-            HeapFree(GetProcessHeap(), 0, deviceInfo);
-            RegCloseKey(hKey);
+            HeapFree(GetProcessHeap(), 0, InstancePath);
+            RegCloseKey(hDeviceInstanceKey);
             RegCloseKey(hInterfaceKey);
             return rc;
         }
-        deviceInfo->Interface.DeviceInstance[dwLength / sizeof(WCHAR)]
= UNICODE_NULL;
-        TRACE("DeviceInstance %s\n",
debugstr_w(deviceInfo->Interface.DeviceInstance));
-        RegCloseKey(hKey);
+        InstancePath[dwInstancePathLength / sizeof(WCHAR)] =
UNICODE_NULL;
+        TRACE("DeviceInstance %s\n", debugstr_w(InstancePath));
 
         if (DeviceInstanceW)
         {
             /* Check if device enumerator is not the right one */
-            if (wcscmp(DeviceInstanceW,
deviceInfo->Interface.DeviceInstance) != 0)
+            if (wcscmp(DeviceInstanceW, InstancePath) != 0)
             {
-                HeapFree(GetProcessHeap(), 0, deviceInfo);;
+                HeapFree(GetProcessHeap(), 0, InstancePath);
+                RegCloseKey(hDeviceInstanceKey);
                 continue;
             }
         }
@@ -1303,58 +1314,133 @@
             &hEnumKey);
         if (rc != ERROR_SUCCESS)
         {
-            HeapFree(GetProcessHeap(), 0, deviceInfo);
+            HeapFree(GetProcessHeap(), 0, InstancePath);
+            RegCloseKey(hDeviceInstanceKey);
             RegCloseKey(hInterfaceKey);
             return rc;
         }
         rc = RegOpenKeyEx(
             hEnumKey,
-            deviceInfo->Interface.DeviceInstance,
+            InstancePath,
             0, /* Options */
             KEY_QUERY_VALUE,
             &hKey);
         RegCloseKey(hEnumKey);
         if (rc != ERROR_SUCCESS)
         {
-            HeapFree(GetProcessHeap(), 0, deviceInfo);
+            HeapFree(GetProcessHeap(), 0, InstancePath);
+            RegCloseKey(hDeviceInstanceKey);
             RegCloseKey(hInterfaceKey);
             return rc;
         }
         dwLength = sizeof(KeyBuffer) - sizeof(UNICODE_NULL);
         rc = RegQueryValueExW(hKey, ClassGUID, NULL, NULL,
(LPBYTE)KeyBuffer, &dwLength);
+        RegCloseKey(hKey);
         if (rc != ERROR_SUCCESS)
         {
-            HeapFree(GetProcessHeap(), 0, deviceInfo);
-            RegCloseKey(hKey);
+            HeapFree(GetProcessHeap(), 0, InstancePath);
+            RegCloseKey(hDeviceInstanceKey);
             RegCloseKey(hInterfaceKey);
             return rc;
         }
         KeyBuffer[dwLength / sizeof(WCHAR)] = UNICODE_NULL;
-        RegCloseKey(hKey);
         KeyBuffer[37] = UNICODE_NULL; /* Replace the } by a NULL
character */
-        if (UuidFromStringW(&KeyBuffer[1],
&deviceInfo->Interface.ClassGuid) != RPC_S_OK)
+        if (UuidFromStringW(&KeyBuffer[1], &ClassGuid) != RPC_S_OK)
         {
-            HeapFree(GetProcessHeap(), 0, deviceInfo);
+            HeapFree(GetProcessHeap(), 0, InstancePath);
+            RegCloseKey(hDeviceInstanceKey);
+            RegCloseKey(hInterfaceKey);
             return ERROR_GEN_FAILURE;
         }
-        TRACE("ClassGUID %s\n",
debugstr_guid(&deviceInfo->Interface.ClassGuid));
+        TRACE("ClassGUID %s\n", debugstr_guid(&ClassGuid));
 
-        /* If current device matches the list GUID (if any), append the
entry to the list */
-        if (IsEqualIID(&list->ClassGuid, &GUID_NULL) ||
IsEqualIID(&list->ClassGuid, &deviceInfo->Interface.ClassGuid))
+        /* If current device doesn't match the list GUID (if any), skip
this entry */
+        if (!IsEqualIID(&list->ClassGuid, &GUID_NULL) &&
!IsEqualIID(&list->ClassGuid, &ClassGuid))
         {
+            HeapFree(GetProcessHeap(), 0, InstancePath);
+            RegCloseKey(hDeviceInstanceKey);
+            continue;
+        }
+        
+        /* Enumerate subkeys of hDeviceInstanceKey (ie
"#ReferenceString" in IoRegisterDeviceInterface). Skip entries that
don't start with '#' */
+        j = 0;
+        while (TRUE)
+        {
+            dwLength = sizeof(KeyBuffer) / sizeof(KeyBuffer[0]);
+            rc = RegEnumKeyExW(hDeviceInstanceKey, j, KeyBuffer,
&dwLength, NULL, NULL, NULL, NULL);
+            if (rc == ERROR_NO_MORE_ITEMS)
+                break;
+            if (rc != ERROR_SUCCESS)
+            {
+                HeapFree(GetProcessHeap(), 0, InstancePath);
+                RegCloseKey(hDeviceInstanceKey);
+                RegCloseKey(hInterfaceKey);
+                return rc;
+            }
+            j++;
+            if (KeyBuffer[0] != '#')
+                /* This entry doesn't represent an interesting entry */
+                continue;
+
+            /* Open sub key */
+            rc = RegOpenKeyEx(hDeviceInstanceKey, KeyBuffer, 0,
KEY_QUERY_VALUE, &hReferenceKey);
+            if (rc != ERROR_SUCCESS)
+            {
+                RegCloseKey(hDeviceInstanceKey);
+                RegCloseKey(hInterfaceKey);
+                return rc;
+            }
+
+            /* Read SymbolicLink value */
+            rc = RegQueryValueExW(hReferenceKey, SymbolicLink, NULL,
&dwRegType, NULL, &dwLength);
+            if (rc != ERROR_SUCCESS )
+            {
+                RegCloseKey(hReferenceKey);
+                RegCloseKey(hDeviceInstanceKey);
+                RegCloseKey(hInterfaceKey);
+                return rc;
+            }
+            if (dwRegType != REG_SZ)
+            {
+                RegCloseKey(hReferenceKey);
+                RegCloseKey(hDeviceInstanceKey);
+                RegCloseKey(hInterfaceKey);
+                return ERROR_GEN_FAILURE;
+            }
+            deviceInfo = HeapAlloc(GetProcessHeap(), 0,
FIELD_OFFSET(DeviceInfo, Interface.Data) + dwInstancePathLength +
sizeof(UNICODE_NULL) + dwLength + sizeof(UNICODE_NULL));
+            if (!deviceInfo)
+            {
+                RegCloseKey(hReferenceKey);
+                RegCloseKey(hDeviceInstanceKey);
+                RegCloseKey(hInterfaceKey);
+                return ERROR_NO_SYSTEM_RESOURCES;
+            }
+            deviceInfo->Interface.pInstancePath =
&deviceInfo->Interface.Data[0];
+            deviceInfo->Interface.pSymbolicLink =
&deviceInfo->Interface.Data[dwInstancePathLength + 1];
+            rc = RegQueryValueExW(hReferenceKey, SymbolicLink, NULL,
NULL, (LPBYTE)deviceInfo->Interface.pSymbolicLink, &dwLength);
+            RegCloseKey(hReferenceKey);
+            if (rc != ERROR_SUCCESS)
+            {
+                HeapFree(GetProcessHeap(), 0, deviceInfo);
+                RegCloseKey(hDeviceInstanceKey);
+                RegCloseKey(hInterfaceKey);
+                return rc;
+            }
+            deviceInfo->Interface.pSymbolicLink[dwLength /
sizeof(WCHAR)] = UNICODE_NULL;
+            TRACE("Symbolic link %s\n",
debugstr_w(deviceInfo->Interface.pSymbolicLink));
+
+            /* Add this entry to the list */
             TRACE("Entry found\n");
             deviceInfo->IsDevice = FALSE;
             memcpy(
                 &deviceInfo->Interface.InterfaceGuid,
                 InterfaceGuid,
                 sizeof(deviceInfo->Interface.InterfaceGuid));
+            wcscpy(deviceInfo->Interface.pInstancePath, InstancePath);
             InsertTailList(&list->ListHead, &deviceInfo->ItemEntry);
             list->numberOfEntries++;
         }
-        else
-        {
-            HeapFree(GetProcessHeap(), 0, deviceInfo);
-        }
+        RegCloseKey(hDeviceInstanceKey);
     }
     RegCloseKey(hInterfaceKey);
     return ERROR_SUCCESS;
@@ -1555,11 +1641,7 @@
                      * expected lifetime of the device data is the same
as the
                      * HDEVINFO; once that is closed, the data are no
longer valid.
                      */
-#ifdef __WINE__
-                    DeviceInterfaceData->Reserved =
(ULONG_PTR)DevInfo->Interface.InterfaceName;
-#else
                     DeviceInterfaceData->Reserved = (ULONG_PTR)DevInfo;
-#endif
                     ret = TRUE;
                 }
                 else
@@ -1619,70 +1701,61 @@
       PDWORD RequiredSize,
       PSP_DEVINFO_DATA DeviceInfoData)
 {
+    PSP_DEVICE_INTERFACE_DETAIL_DATA_W DeviceInterfaceDetailDataW =
NULL;
+    DWORD sizeW = 0, sizeA;
     BOOL ret = FALSE;
 
     TRACE("(%p, %p, %p, %ld, %p, %p)\n", DeviceInfoSet,
-     DeviceInterfaceData, DeviceInterfaceDetailData,
-     DeviceInterfaceDetailDataSize, RequiredSize, DeviceInfoData);
-    if (!DeviceInterfaceData)
+        DeviceInterfaceData, DeviceInterfaceDetailData,
+        DeviceInterfaceDetailDataSize, RequiredSize, DeviceInfoData);
+
+    if (DeviceInterfaceDetailData->cbSize !=
sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A))
+        SetLastError(ERROR_INVALID_USER_BUFFER);
+    else if (DeviceInterfaceDetailData == NULL &&
DeviceInterfaceDetailDataSize != 0)
         SetLastError(ERROR_INVALID_PARAMETER);
-    else if ((DeviceInterfaceDetailDataSize &&
!DeviceInterfaceDetailData) ||
-     (DeviceInterfaceDetailData && !DeviceInterfaceDetailDataSize))
+    else if (DeviceInterfaceDetailData != NULL &&
DeviceInterfaceDetailDataSize <
FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_A, DevicePath) + 1)
         SetLastError(ERROR_INVALID_PARAMETER);
-    else if (DeviceInfoSet && DeviceInfoSet !=
(HDEVINFO)INVALID_HANDLE_VALUE)
+    else
     {
-        DeviceInfoList *list = (DeviceInfoList *)DeviceInfoSet;
-
-        if (list->magic == SETUP_DEV_INFO_LIST_MAGIC)
+        if (DeviceInterfaceDetailData != NULL)
         {
-#ifdef __WINE__
-            /* FIXME: this assumes the only possible enumeration is of
serial
-             * ports.
-             */
-            LPCWSTR devName = (LPCWSTR)DeviceInterfaceData->Reserved;
-            DWORD sizeRequired =
sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A) +
-             lstrlenW(devName);
-
-            if (sizeRequired > DeviceInterfaceDetailDataSize)
+            sizeW = FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_W,
DevicePath)
+                + (DeviceInterfaceDetailDataSize -
FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_A, DevicePath)) *
sizeof(WCHAR);
+            DeviceInterfaceDetailDataW =
(PSP_DEVICE_INTERFACE_DETAIL_DATA_W)HeapAlloc(GetProcessHeap(), 0,
sizeW);
+            if (!DeviceInterfaceDetailDataW)
             {
-                SetLastError(ERROR_INSUFFICIENT_BUFFER);
-                if (RequiredSize)
-                    *RequiredSize = sizeRequired;
+                SetLastError(ERROR_NOT_ENOUGH_MEMORY);
             }
-            else
+        }
+        if (!DeviceInterfaceDetailData || (DeviceInterfaceDetailData &&
DeviceInterfaceDetailDataW))
+        {
+            DeviceInterfaceDetailDataW->cbSize =
sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W);
+            ret = SetupDiGetDeviceInterfaceDetailW(
+                DeviceInfoSet,
+                DeviceInterfaceData,
+                DeviceInterfaceDetailDataW,
+                sizeW,
+                &sizeW,
+                DeviceInfoData);
+            sizeA = (sizeW -
FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_W, DevicePath)) /
sizeof(WCHAR)
+                + FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_A,
DevicePath);
+            if (RequiredSize)
+                *RequiredSize = sizeA;
+            if (ret && DeviceInterfaceDetailData &&
DeviceInterfaceDetailDataSize <= sizeA)
             {
-                LPSTR dst = DeviceInterfaceDetailData->DevicePath;
-                LPCWSTR src = devName;
-
-                /* MSDN claims cbSize must be set by the caller, but it
lies */
-                DeviceInterfaceDetailData->cbSize =
-                 sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A);
-                for ( ; *src; src++, dst++)
-                    *dst = *src;
-                *dst = '\0';
-                TRACE("DevicePath is %s\n",
-                 debugstr_a(DeviceInterfaceDetailData->DevicePath));
-                if (DeviceInfoData)
+                if (!WideCharToMultiByte(
+                    CP_ACP, 0,
+                    DeviceInterfaceDetailDataW->DevicePath, -1,
+                    DeviceInterfaceDetailData->DevicePath,
DeviceInterfaceDetailDataSize -
FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_A, DevicePath),
+                    NULL, NULL))
                 {
-                    DeviceInfoData->cbSize = sizeof(SP_DEVINFO_DATA);
-                    memcpy(&DeviceInfoData->ClassGuid,
-                     &GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR,
-                     sizeof(DeviceInfoData->ClassGuid));
-                    DeviceInfoData->DevInst = 0;
-                    DeviceInfoData->Reserved = (ULONG_PTR)devName;
+                    ret = FALSE;
                 }
-                ret = TRUE;
             }
-#else /* __WINE__ */
-            FIXME("unimplemented\n");
-            ret = FALSE;
-#endif /* __WINE__ */
         }
-        else
-            SetLastError(ERROR_INVALID_HANDLE);
+        HeapFree(GetProcessHeap(), 0, DeviceInterfaceDetailDataW);
     }
-    else
-        SetLastError(ERROR_INVALID_HANDLE);
+
     TRACE("Returning %d\n", ret);
     return ret;
 }
@@ -1698,10 +1771,59 @@
       PDWORD RequiredSize,
       PSP_DEVINFO_DATA DeviceInfoData)
 {
-    FIXME("(%p, %p, %p, %ld, %p, %p): stub\n", DeviceInfoSet,
-     DeviceInterfaceData, DeviceInterfaceDetailData,
-     DeviceInterfaceDetailDataSize, RequiredSize, DeviceInfoData);
-    return FALSE;
+    BOOL ret = FALSE;
+
+    TRACE("(%p, %p, %p, %ld, %p, %p): stub\n", DeviceInfoSet,
+        DeviceInterfaceData, DeviceInterfaceDetailData,
+        DeviceInterfaceDetailDataSize, RequiredSize, DeviceInfoData);
+
+    if (!DeviceInfoSet || !DeviceInterfaceData)
+        SetLastError(ERROR_INVALID_PARAMETER);
+    else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
+        SetLastError(ERROR_INVALID_HANDLE);
+    else if (((DeviceInfoList*)DeviceInfoSet)->magic !=
SETUP_DEV_INFO_LIST_MAGIC)
+        SetLastError(ERROR_INVALID_HANDLE);
+    else if (DeviceInterfaceData->cbSize !=
sizeof(SP_DEVICE_INTERFACE_DATA))
+        SetLastError(ERROR_INVALID_USER_BUFFER);
+    else if (DeviceInterfaceDetailData->cbSize !=
sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W))
+        SetLastError(ERROR_INVALID_USER_BUFFER);
+    else if (DeviceInfoData && DeviceInfoData->cbSize !=
sizeof(SP_DEVINFO_DATA))
+        SetLastError(ERROR_INVALID_USER_BUFFER);
+    else if (DeviceInterfaceDetailData == NULL &&
DeviceInterfaceDetailDataSize != 0)
+        SetLastError(ERROR_INVALID_PARAMETER);
+    else if (DeviceInterfaceDetailData != NULL &&
DeviceInterfaceDetailDataSize <
FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_W, DevicePath) +
sizeof(UNICODE_NULL))
+        SetLastError(ERROR_INVALID_PARAMETER);
+    else
+    {
+        DeviceInfo *deviceInfo = (DeviceInfo
*)DeviceInterfaceData->Reserved;
+        LPCWSTR devName = deviceInfo->Interface.pSymbolicLink;
+        DWORD sizeRequired = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W)
+
+            lstrlenW(devName);
+
+        if (sizeRequired > DeviceInterfaceDetailDataSize)
+        {
+            SetLastError(ERROR_INSUFFICIENT_BUFFER);
+            if (RequiredSize)
+                *RequiredSize = sizeRequired;
+        }
+        else
+        {
+            wcscpy(DeviceInterfaceDetailData->DevicePath, devName);
+            TRACE("DevicePath is %s\n",
debugstr_w(DeviceInterfaceDetailData->DevicePath));
+            if (DeviceInfoData)
+            {
+                memcpy(&DeviceInfoData->ClassGuid,
+                    &deviceInfo->Interface.ClassGuid,
+                    sizeof(GUID));
+                DeviceInfoData->DevInst = 0; /* FIXME */
+                DeviceInfoData->Reserved = (ULONG_PTR)0;
+            }
+            ret = TRUE;
+        }
+    }
+
+    TRACE("Returning %d\n", ret);
+    return ret;
 }
 
 
/***********************************************************************
  _____  

Modified: trunk/reactos/lib/setupapi/setupapi.spec
--- trunk/reactos/lib/setupapi/setupapi.spec	2005-07-17 15:10:03 UTC
(rev 16621)
+++ trunk/reactos/lib/setupapi/setupapi.spec	2005-07-17 15:57:41 UTC
(rev 16622)
@@ -327,7 +327,7 @@

 @ stub SetupDiGetDeviceInstanceIdA
 @ stub SetupDiGetDeviceInstanceIdW
 @ stdcall SetupDiGetDeviceRegistryPropertyA(long ptr long ptr ptr long
ptr)
-@ stub SetupDiGetDeviceRegistryPropertyW
+@ stdcall SetupDiGetDeviceRegistryPropertyW(long ptr long ptr ptr long
ptr)
 @ stub SetupDiGetDriverInfoDetailA
 @ stub SetupDiGetDriverInfoDetailW
 @ stub SetupDiGetDriverInstallParamsA