Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-07-30 09:41:47 +00:00
Code Issues Projects Releases Packages Wiki Activity

Simplify SetupDiSetDeviceRegistryPropertyW/SetupDiGetDeviceRegistryPropertyW

Browse source 
Misc cleanup

svn path=/trunk/; revision=32265
This commit is contained in:
Hervé Poussineau 2008-02-10 14:37:19 +00:00
parent df50719664
commit 8b072734a8
5 changed files with 157 additions and 307 deletions
Download patch file Download diff file Expand all files Collapse all files

410
reactos/dll/win32/setupapi/devinst.c
View file

@ -1235,7 +1235,7 @@ SetupDiCreateDeviceInfoListExA(const GUID *ClassGuid,
{ {
MachineNameW = MultiByteToUnicode(MachineName, CP_ACP); MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
if (MachineNameW == NULL) if (MachineNameW == NULL)
return (HDEVINFO)INVALID_HANDLE_VALUE; return INVALID_HANDLE_VALUE;
} }
hDevInfo = SetupDiCreateDeviceInfoListExW(ClassGuid, hwndParent, hDevInfo = SetupDiCreateDeviceInfoListExW(ClassGuid, hwndParent,
@ -1273,7 +1273,7 @@ SetupDiCreateDeviceInfoListExW(const GUID *ClassGuid,
DWORD size = FIELD_OFFSET(struct DeviceInfoSet, szData); DWORD size = FIELD_OFFSET(struct DeviceInfoSet, szData);
DWORD rc; DWORD rc;
CONFIGRET cr; CONFIGRET cr;
HDEVINFO ret = (HDEVINFO)INVALID_HANDLE_VALUE; HDEVINFO ret = INVALID_HANDLE_VALUE;
TRACE("%s %p %s %p\n", debugstr_guid(ClassGuid), hwndParent, TRACE("%s %p %s %p\n", debugstr_guid(ClassGuid), hwndParent,
debugstr_w(MachineName), Reserved); debugstr_w(MachineName), Reserved);
@ -1292,14 +1292,14 @@ SetupDiCreateDeviceInfoListExW(const GUID *ClassGuid,
if (Reserved != NULL) if (Reserved != NULL)
{ {
SetLastError(ERROR_INVALID_PARAMETER); SetLastError(ERROR_INVALID_PARAMETER);
return (HDEVINFO)INVALID_HANDLE_VALUE; return INVALID_HANDLE_VALUE;
} }
list = MyMalloc(size); list = MyMalloc(size);
if (!list) if (!list)
{ {
SetLastError(ERROR_NOT_ENOUGH_MEMORY); SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return (HDEVINFO)INVALID_HANDLE_VALUE; return INVALID_HANDLE_VALUE;
} }
ZeroMemory(list, FIELD_OFFSET(struct DeviceInfoSet, szData)); ZeroMemory(list, FIELD_OFFSET(struct DeviceInfoSet, szData));
@ -1413,7 +1413,7 @@ HKEY WINAPI SetupDiCreateDevRegKeyW(
TRACE("%p %p %lu %lu %lu %p %s\n", DeviceInfoSet, DeviceInfoData, Scope, TRACE("%p %p %lu %lu %lu %p %s\n", DeviceInfoSet, DeviceInfoData, Scope,
HwProfile, KeyType, InfHandle, debugstr_w(InfSectionName)); HwProfile, KeyType, InfHandle, debugstr_w(InfSectionName));
if (!DeviceInfoSet || DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE) if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
{ {
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
return INVALID_HANDLE_VALUE; return INVALID_HANDLE_VALUE;
@ -1680,7 +1680,7 @@ BOOL WINAPI SetupDiCreateDeviceInfoW(
SetLastError(ERROR_INVALID_DEVINST_NAME); SetLastError(ERROR_INVALID_DEVINST_NAME);
return FALSE; return FALSE;
} }
if (!DeviceInfoSet || DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE) if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
{ {
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;
@ -1784,7 +1784,7 @@ BOOL WINAPI SetupDiRegisterDeviceInfo(
TRACE("%p %p %08x %p %p %p\n", DeviceInfoSet, DeviceInfoData, Flags, TRACE("%p %p %08x %p %p %p\n", DeviceInfoSet, DeviceInfoData, Flags,
CompareProc, CompareContext, DupDeviceInfoData); CompareProc, CompareContext, DupDeviceInfoData);
if (!DeviceInfoSet || DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE) if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
{ {
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;
@ -1823,7 +1823,7 @@ BOOL WINAPI SetupDiEnumDeviceInfo(
SetLastError(ERROR_INVALID_PARAMETER); SetLastError(ERROR_INVALID_PARAMETER);
return FALSE; return FALSE;
} }
if (devinfo && devinfo != (HDEVINFO)INVALID_HANDLE_VALUE) if (devinfo && devinfo != INVALID_HANDLE_VALUE)
{ {
struct DeviceInfoSet *list = (struct DeviceInfoSet *)devinfo; struct DeviceInfoSet *list = (struct DeviceInfoSet *)devinfo;
if (list->magic == SETUP_DEVICE_INFO_SET_MAGIC) if (list->magic == SETUP_DEVICE_INFO_SET_MAGIC)
@ -1887,7 +1887,7 @@ BOOL WINAPI SetupDiGetDeviceInstanceIdA(
&size); &size);
if (!ret && GetLastError() != ERROR_INSUFFICIENT_BUFFER) if (!ret && GetLastError() != ERROR_INSUFFICIENT_BUFFER)
return FALSE; return FALSE;
instanceId = MyMalloc(DeviceInstanceIdSize * sizeof(WCHAR)); instanceId = MyMalloc(size * sizeof(WCHAR));
if (instanceId) if (instanceId)
{ {
ret = SetupDiGetDeviceInstanceIdW(DeviceInfoSet, ret = SetupDiGetDeviceInstanceIdW(DeviceInfoSet,
@ -2275,7 +2275,7 @@ HDEVINFO WINAPI SetupDiGetClassDevsExA(
enumstrW = MultiByteToUnicode(enumstr, CP_ACP); enumstrW = MultiByteToUnicode(enumstr, CP_ACP);
if (!enumstrW) if (!enumstrW)
{ {
ret = (HDEVINFO)INVALID_HANDLE_VALUE; ret = INVALID_HANDLE_VALUE;
goto end; goto end;
} }
} }
@ -2285,7 +2285,7 @@ HDEVINFO WINAPI SetupDiGetClassDevsExA(
if (!machineW) if (!machineW)
{ {
MyFree(enumstrW); MyFree(enumstrW);
ret = (HDEVINFO)INVALID_HANDLE_VALUE; ret = INVALID_HANDLE_VALUE;
goto end; goto end;
} }
} }
@ -2446,7 +2446,7 @@ BOOL WINAPI SetupDiGetDeviceInfoListDetailA(
TRACE("%p %p\n", DeviceInfoSet, DevInfoData); TRACE("%p %p\n", DeviceInfoSet, DevInfoData);
if (!DeviceInfoSet || DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE) if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
{ {
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;
@ -2487,7 +2487,7 @@ BOOL WINAPI SetupDiGetDeviceInfoListDetailW(
TRACE("%p %p\n", DeviceInfoSet, DevInfoData); TRACE("%p %p\n", DeviceInfoSet, DevInfoData);
if (!DeviceInfoSet || DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE) if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
{ {
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;
@ -2562,7 +2562,7 @@ BOOL WINAPI SetupDiCreateDeviceInterfaceW(
debugstr_guid(InterfaceClassGuid), debugstr_w(ReferenceString), debugstr_guid(InterfaceClassGuid), debugstr_w(ReferenceString),
CreationFlags, DeviceInterfaceData); CreationFlags, DeviceInterfaceData);
if (!DeviceInfoSet || DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE) if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
{ {
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;
@ -2640,7 +2640,7 @@ HKEY WINAPI SetupDiCreateDeviceInterfaceRegKeyW(
TRACE("%p %p %d %08x %p %p\n", DeviceInfoSet, DeviceInterfaceData, Reserved, TRACE("%p %p %d %08x %p %p\n", DeviceInfoSet, DeviceInterfaceData, Reserved,
samDesired, InfHandle, InfSectionName); samDesired, InfHandle, InfSectionName);
if (!DeviceInfoSet || DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE || if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
set->magic != SETUP_DEVICE_INFO_SET_MAGIC) set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
{ {
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
@ -2678,7 +2678,7 @@ BOOL WINAPI SetupDiDeleteDeviceInterfaceRegKey(
TRACE("%p %p %d\n", DeviceInfoSet, DeviceInterfaceData, Reserved); TRACE("%p %p %d\n", DeviceInfoSet, DeviceInterfaceData, Reserved);
if (!DeviceInfoSet || DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE || if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
set->magic != SETUP_DEVICE_INFO_SET_MAGIC) set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
{ {
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
@ -2733,7 +2733,7 @@ BOOL WINAPI SetupDiEnumDeviceInterfaces(
TRACE("%p, %p, %s, %d, %p\n", DeviceInfoSet, DeviceInfoData, TRACE("%p, %p, %s, %d, %p\n", DeviceInfoSet, DeviceInfoData,
debugstr_guid(InterfaceClassGuid), MemberIndex, DeviceInterfaceData); debugstr_guid(InterfaceClassGuid), MemberIndex, DeviceInterfaceData);
if (!DeviceInfoSet || DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE || if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
set->magic != SETUP_DEVICE_INFO_SET_MAGIC) set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
{ {
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
@ -2838,7 +2838,7 @@ BOOL WINAPI SetupDiDestroyDeviceInfoList(HDEVINFO devinfo)
BOOL ret = FALSE; BOOL ret = FALSE;
TRACE("%p\n", devinfo); TRACE("%p\n", devinfo);
if (devinfo && devinfo != (HDEVINFO)INVALID_HANDLE_VALUE) if (devinfo && devinfo != INVALID_HANDLE_VALUE)
{ {
struct DeviceInfoSet *list = (struct DeviceInfoSet *)devinfo; struct DeviceInfoSet *list = (struct DeviceInfoSet *)devinfo;
@ -2874,7 +2874,7 @@ BOOL WINAPI SetupDiGetDeviceInterfaceDetailA(
DeviceInterfaceData, DeviceInterfaceDetailData, DeviceInterfaceData, DeviceInterfaceDetailData,
DeviceInterfaceDetailDataSize, RequiredSize, DeviceInfoData); DeviceInterfaceDetailDataSize, RequiredSize, DeviceInfoData);
if (!DeviceInfoSet || DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE || if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
set->magic != SETUP_DEVICE_INFO_SET_MAGIC) set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
{ {
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
@ -2960,7 +2960,7 @@ BOOL WINAPI SetupDiGetDeviceInterfaceDetailW(
DeviceInterfaceData, DeviceInterfaceDetailData, DeviceInterfaceData, DeviceInterfaceDetailData,
DeviceInterfaceDetailDataSize, RequiredSize, DeviceInfoData); DeviceInterfaceDetailDataSize, RequiredSize, DeviceInfoData);
if (!DeviceInfoSet || DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE || if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
set->magic != SETUP_DEVICE_INFO_SET_MAGIC) set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
{ {
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
@ -3024,6 +3024,51 @@ BOOL WINAPI SetupDiGetDeviceInterfaceDetailW(
return ret; return ret;
} }
struct PropertyMapEntry
{
DWORD regType;
LPCSTR nameA;
LPCWSTR nameW;
};
static struct PropertyMapEntry PropertyMap[] = {
{ REG_SZ, "DeviceDesc", REGSTR_VAL_DEVDESC },
{ REG_MULTI_SZ, "HardwareId", REGSTR_VAL_HARDWAREID },
{ REG_MULTI_SZ, "CompatibleIDs", REGSTR_VAL_COMPATIBLEIDS },
{ 0, NULL, NULL }, /* SPDRP_UNUSED0 */
{ REG_SZ, "Service", REGSTR_VAL_SERVICE },
{ 0, NULL, NULL }, /* SPDRP_UNUSED1 */
{ 0, NULL, NULL }, /* SPDRP_UNUSED2 */
{ REG_SZ, "Class", REGSTR_VAL_CLASS },
{ REG_SZ, "ClassGUID", REGSTR_VAL_CLASSGUID },
{ REG_SZ, "Driver", REGSTR_VAL_DRIVER },
{ REG_DWORD, "ConfigFlags", REGSTR_VAL_CONFIGFLAGS },
{ REG_SZ, "Mfg", REGSTR_VAL_MFG },
{ REG_SZ, "FriendlyName", REGSTR_VAL_FRIENDLYNAME },
{ REG_SZ, "LocationInformation", REGSTR_VAL_LOCATION_INFORMATION },
{ 0, NULL, NULL }, /* SPDRP_PHYSICAL_DEVICE_OBJECT_NAME */
{ REG_DWORD, "Capabilities", REGSTR_VAL_CAPABILITIES },
{ REG_DWORD, "UINumber", REGSTR_VAL_UI_NUMBER },
{ REG_MULTI_SZ, "UpperFilters", REGSTR_VAL_UPPERFILTERS },
{ REG_MULTI_SZ, "LowerFilters", REGSTR_VAL_LOWERFILTERS },
{ 0, NULL, NULL }, /* SPDRP_BUSTYPEGUID */
{ 0, NULL, NULL }, /* SPDRP_LEGACYBUSTYPE */
{ 0, NULL, NULL }, /* SPDRP_BUSNUMBER */
{ 0, NULL, NULL }, /* SPDRP_ENUMERATOR_NAME */
{ REG_BINARY, "Security", REGSTR_SECURITY },
{ 0, NULL, NULL }, /* SPDRP_SECURITY_SDS */
{ 0, NULL, NULL }, /* SPDRP_DEVTYPE */
{ 0, NULL, NULL }, /* SPDRP_EXCLUSIVE */
{ 0, NULL, NULL }, /* SPDRP_CHARACTERISTICS */
{ 0, NULL, NULL }, /* SPDRP_ADDRESS */
{ REG_SZ, "UINumberDescFormat", REGSTR_UI_NUMBER_DESC_FORMAT },
{ 0, NULL, NULL }, /* SPDRP_DEVICE_POWER_DATA */
{ 0, NULL, NULL }, /* SPDRP_REMOVAL_POLICY */
{ 0, NULL, NULL }, /* SPDRP_REMOVAL_POLICY_HW_DEFAULT */
{ 0, NULL, NULL }, /* SPDRP_REMOVAL_POLICY_OVERRIDE */
{ 0, NULL, NULL }, /* SPDRP_INSTALL_STATE */
};
/*********************************************************************** /***********************************************************************
* SetupDiGetDeviceRegistryPropertyA (SETUPAPI.@) * SetupDiGetDeviceRegistryPropertyA (SETUPAPI.@)
*/ */
@ -3122,8 +3167,6 @@ BOOL WINAPI SetupDiGetDeviceRegistryPropertyW(
DWORD PropertyBufferSize, DWORD PropertyBufferSize,
PDWORD RequiredSize) PDWORD RequiredSize)
{ {
HKEY hEnumKey, hKey;
DWORD rc;
BOOL ret = FALSE; BOOL ret = FALSE;
struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet; struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
struct DeviceInfo *devInfo; struct DeviceInfo *devInfo;
@ -3148,172 +3191,57 @@ BOOL WINAPI SetupDiGetDeviceRegistryPropertyW(
SetLastError(ERROR_INVALID_PARAMETER); SetLastError(ERROR_INVALID_PARAMETER);
return FALSE; return FALSE;
} }
if (Property >= SPDRP_MAXIMUM_PROPERTY)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved; devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
if (Property < sizeof(PropertyMap) / sizeof(PropertyMap[0])
&& PropertyMap[Property].nameW)
{ {
switch (Property) DWORD size = PropertyBufferSize;
{ HKEY hKey;
case SPDRP_CAPABILITIES: LONG l;
case SPDRP_CLASS: hKey = SetupDiOpenDevRegKey(DeviceInfoSet, DeviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_QUERY_VALUE);
case SPDRP_CLASSGUID: if (hKey == INVALID_HANDLE_VALUE)
case SPDRP_COMPATIBLEIDS: return FALSE;
case SPDRP_CONFIGFLAGS: l = RegQueryValueExW(hKey, PropertyMap[Property].nameW,
case SPDRP_DEVICEDESC: NULL, PropertyRegDataType, PropertyBuffer, &size);
case SPDRP_DRIVER: RegCloseKey(hKey);
case SPDRP_FRIENDLYNAME:
case SPDRP_HARDWAREID:
case SPDRP_LOCATION_INFORMATION:
case SPDRP_LOWERFILTERS:
case SPDRP_MFG:
case SPDRP_SECURITY:
case SPDRP_SERVICE:
case SPDRP_UI_NUMBER:
case SPDRP_UI_NUMBER_DESC_FORMAT:
case SPDRP_UPPERFILTERS:
{
LPCWSTR RegistryPropertyName;
DWORD BufferSize;
switch (Property) if (RequiredSize)
{ *RequiredSize = size;
case SPDRP_CAPABILITIES: switch(l) {
RegistryPropertyName = REGSTR_VAL_CAPABILITIES; break; case ERROR_SUCCESS:
case SPDRP_CLASS: if (PropertyBuffer != NULL || size == 0)
RegistryPropertyName = REGSTR_VAL_CLASS; break;
case SPDRP_CLASSGUID:
RegistryPropertyName = REGSTR_VAL_CLASSGUID; break;
case SPDRP_COMPATIBLEIDS:
RegistryPropertyName = REGSTR_VAL_COMPATIBLEIDS; break;
case SPDRP_CONFIGFLAGS:
RegistryPropertyName = REGSTR_VAL_CONFIGFLAGS; break;
case SPDRP_DEVICEDESC:
RegistryPropertyName = REGSTR_VAL_DEVDESC; break;
case SPDRP_DRIVER:
RegistryPropertyName = REGSTR_VAL_DRIVER; break;
case SPDRP_FRIENDLYNAME:
RegistryPropertyName = REGSTR_VAL_FRIENDLYNAME; break;
case SPDRP_HARDWAREID:
RegistryPropertyName = REGSTR_VAL_HARDWAREID; break;
case SPDRP_LOCATION_INFORMATION:
RegistryPropertyName = REGSTR_VAL_LOCATION_INFORMATION; break;
case SPDRP_LOWERFILTERS:
RegistryPropertyName = REGSTR_VAL_LOWERFILTERS; break;
case SPDRP_MFG:
RegistryPropertyName = REGSTR_VAL_MFG; break;
case SPDRP_SECURITY:
RegistryPropertyName = REGSTR_SECURITY; break;
case SPDRP_SERVICE:
RegistryPropertyName = REGSTR_VAL_SERVICE; break;
case SPDRP_UI_NUMBER:
RegistryPropertyName = REGSTR_VAL_UI_NUMBER; break;
case SPDRP_UI_NUMBER_DESC_FORMAT:
RegistryPropertyName = REGSTR_UI_NUMBER_DESC_FORMAT; break;
case SPDRP_UPPERFILTERS:
RegistryPropertyName = REGSTR_VAL_UPPERFILTERS; break;
default:
/* Should not happen */
RegistryPropertyName = NULL; break;
}
/* Open registry key name */
rc = RegOpenKeyExW(
set->HKLM,
REGSTR_PATH_SYSTEMENUM,
0, /* Options */
0,
&hEnumKey);
if (rc != ERROR_SUCCESS)
{
SetLastError(rc);
break;
}
rc = RegOpenKeyExW(
hEnumKey,
devInfo->Data,
0, /* Options */
KEY_QUERY_VALUE,
&hKey);
RegCloseKey(hEnumKey);
if (rc != ERROR_SUCCESS)
{
SetLastError(rc);
break;
}
/* Read registry entry */
BufferSize = PropertyBufferSize;
rc = RegQueryValueExW(
hKey,
RegistryPropertyName,
NULL, /* Reserved */
PropertyRegDataType,
PropertyBuffer,
&BufferSize);
if (RequiredSize)
*RequiredSize = BufferSize;
switch(rc) {
case ERROR_SUCCESS:
if (PropertyBuffer != NULL || BufferSize == 0)
ret = TRUE;
else
SetLastError(ERROR_INSUFFICIENT_BUFFER);
break;
case ERROR_MORE_DATA:
SetLastError(ERROR_INSUFFICIENT_BUFFER);
break;
default:
SetLastError(rc);
}
RegCloseKey(hKey);
break;
}
case SPDRP_PHYSICAL_DEVICE_OBJECT_NAME:
{
DWORD required = (strlenW(devInfo->Data) + 1) * sizeof(WCHAR);
if (PropertyRegDataType)
*PropertyRegDataType = REG_SZ;
if (RequiredSize)
*RequiredSize = required;
if (PropertyBufferSize >= required)
{
strcpyW((LPWSTR)PropertyBuffer, devInfo->Data);
ret = TRUE; ret = TRUE;
}
else else
SetLastError(ERROR_INSUFFICIENT_BUFFER); SetLastError(ERROR_INSUFFICIENT_BUFFER);
break; break;
} case ERROR_MORE_DATA:
SetLastError(ERROR_INSUFFICIENT_BUFFER);
/*case SPDRP_BUSTYPEGUID: break;
case SPDRP_LEGACYBUSTYPE:
case SPDRP_BUSNUMBER:
case SPDRP_ENUMERATOR_NAME:
case SPDRP_SECURITY_SDS:
case SPDRP_DEVTYPE:
case SPDRP_EXCLUSIVE:
case SPDRP_CHARACTERISTICS:
case SPDRP_ADDRESS:
case SPDRP_DEVICE_POWER_DATA:*/
#if (WINVER >= 0x501)
/*case SPDRP_REMOVAL_POLICY:
case SPDRP_REMOVAL_POLICY_HW_DEFAULT:
case SPDRP_REMOVAL_POLICY_OVERRIDE:
case SPDRP_INSTALL_STATE:*/
#endif
default: default:
{ SetLastError(l);
ERR("Property 0x%lx not implemented\n", Property);
SetLastError(ERROR_NOT_SUPPORTED);
}
} }
} }
else if (Property == SPDRP_PHYSICAL_DEVICE_OBJECT_NAME)
{
DWORD required = (strlenW(devInfo->Data) + 1) * sizeof(WCHAR);
if (PropertyRegDataType)
*PropertyRegDataType = REG_SZ;
if (RequiredSize)
*RequiredSize = required;
if (PropertyBufferSize >= required)
{
strcpyW((LPWSTR)PropertyBuffer, devInfo->Data);
ret = TRUE;
}
else
SetLastError(ERROR_INSUFFICIENT_BUFFER);
}
else
{
ERR("Property 0x%lx not implemented\n", Property);
SetLastError(ERROR_NOT_SUPPORTED);
}
return ret; return ret;
} }
@ -3388,107 +3316,29 @@ BOOL WINAPI SetupDiSetDeviceRegistryPropertyW(
SetLastError(ERROR_INVALID_PARAMETER); SetLastError(ERROR_INVALID_PARAMETER);
return FALSE; return FALSE;
} }
if (Property < sizeof(PropertyMap) / sizeof(PropertyMap[0])
switch (Property) && PropertyMap[Property].nameW)
{ {
case SPDRP_COMPATIBLEIDS: HKEY hKey;
case SPDRP_CONFIGFLAGS: LONG l;
case SPDRP_FRIENDLYNAME: hKey = SetupDiOpenDevRegKey(DeviceInfoSet, DeviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_SET_VALUE);
case SPDRP_HARDWAREID: if (hKey == INVALID_HANDLE_VALUE)
case SPDRP_LOCATION_INFORMATION: return FALSE;
case SPDRP_LOWERFILTERS: /* Write new data */
case SPDRP_SECURITY: l = RegSetValueExW(
case SPDRP_SERVICE: hKey, PropertyMap[Property].nameW, 0,
case SPDRP_UI_NUMBER_DESC_FORMAT: PropertyMap[Property].regType, PropertyBuffer,
case SPDRP_UPPERFILTERS: PropertyBufferSize);
{ if (!l)
LPCWSTR RegistryPropertyName; ret = TRUE;
DWORD RegistryDataType; else
HKEY hKey; SetLastError(l);
LONG rc; RegCloseKey(hKey);
}
switch (Property) else
{ {
case SPDRP_COMPATIBLEIDS: ERR("Property 0x%lx not implemented\n", Property);
RegistryPropertyName = REGSTR_VAL_COMPATIBLEIDS; SetLastError(ERROR_NOT_SUPPORTED);
RegistryDataType = REG_MULTI_SZ;
break;
case SPDRP_CONFIGFLAGS:
RegistryPropertyName = REGSTR_VAL_CONFIGFLAGS;
RegistryDataType = REG_DWORD;
break;
case SPDRP_FRIENDLYNAME:
RegistryPropertyName = REGSTR_VAL_FRIENDLYNAME;
RegistryDataType = REG_SZ;
break;
case SPDRP_HARDWAREID:
RegistryPropertyName = REGSTR_VAL_HARDWAREID;
RegistryDataType = REG_MULTI_SZ;
break;
case SPDRP_LOCATION_INFORMATION:
RegistryPropertyName = REGSTR_VAL_LOCATION_INFORMATION;
RegistryDataType = REG_SZ;
break;
case SPDRP_LOWERFILTERS:
RegistryPropertyName = REGSTR_VAL_LOWERFILTERS;
RegistryDataType = REG_MULTI_SZ;
break;
case SPDRP_SECURITY:
RegistryPropertyName = REGSTR_SECURITY;
RegistryDataType = REG_BINARY;
break;
case SPDRP_SERVICE:
RegistryPropertyName = REGSTR_VAL_SERVICE;
RegistryDataType = REG_SZ;
break;
case SPDRP_UI_NUMBER_DESC_FORMAT:
RegistryPropertyName = REGSTR_UI_NUMBER_DESC_FORMAT;
RegistryDataType = REG_SZ;
break;
case SPDRP_UPPERFILTERS:
RegistryPropertyName = REGSTR_VAL_UPPERFILTERS;
RegistryDataType = REG_MULTI_SZ;
break;
default:
/* Should not happen */
RegistryPropertyName = NULL;
RegistryDataType = REG_BINARY;
break;
}
/* Open device registry key */
hKey = SetupDiOpenDevRegKey(DeviceInfoSet, DeviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_SET_VALUE);
if (hKey != INVALID_HANDLE_VALUE)
{
/* Write new data */
rc = RegSetValueExW(
hKey,
RegistryPropertyName,
0, /* Reserved */
RegistryDataType,
PropertyBuffer,
PropertyBufferSize);
if (rc == ERROR_SUCCESS)
ret = TRUE;
else
SetLastError(rc);
RegCloseKey(hKey);
}
break;
}
/*case SPDRP_CHARACTERISTICS:
case SPDRP_DEVTYPE:
case SPDRP_EXCLUSIVE:*/
#if (WINVER >= 0x501)
//case SPDRP_REMOVAL_POLICY_OVERRIDE:
#endif
//case SPDRP_SECURITY_SDS:
default:
{
ERR("Property 0x%lx not implemented\n", Property);
SetLastError(ERROR_NOT_SUPPORTED);
}
} }
TRACE("Returning %d\n", ret); TRACE("Returning %d\n", ret);
@ -5457,7 +5307,7 @@ HKEY WINAPI SetupDiOpenDevRegKey(
TRACE("%p %p %d %d %d %x\n", DeviceInfoSet, DeviceInfoData, TRACE("%p %p %d %d %d %x\n", DeviceInfoSet, DeviceInfoData,
Scope, HwProfile, KeyType, samDesired); Scope, HwProfile, KeyType, samDesired);
if (!DeviceInfoSet || DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE) if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
{ {
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
return INVALID_HANDLE_VALUE; return INVALID_HANDLE_VALUE;
@ -5543,7 +5393,7 @@ BOOL WINAPI SetupDiDeleteDevRegKey(
TRACE("%p %p %d %d %d\n", DeviceInfoSet, DeviceInfoData, Scope, HwProfile, TRACE("%p %p %d %d %d\n", DeviceInfoSet, DeviceInfoData, Scope, HwProfile,
KeyType); KeyType);
if (!DeviceInfoSet || DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE) if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
{ {
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;

4
reactos/dll/win32/setupapi/misc.c
View file

@ -787,7 +787,7 @@ DWORD WINAPI RetreiveFileSecurity(LPCWSTR lpFileName,
TRACE("%s %p\n", debugstr_w(lpFileName), pSecurityDescriptor); TRACE("%s %p\n", debugstr_w(lpFileName), pSecurityDescriptor);
SecDesc = (PSECURITY_DESCRIPTOR)MyMalloc(dwSize); SecDesc = MyMalloc(dwSize);
if (SecDesc == NULL) if (SecDesc == NULL)
return ERROR_NOT_ENOUGH_MEMORY; return ERROR_NOT_ENOUGH_MEMORY;
@ -806,7 +806,7 @@ DWORD WINAPI RetreiveFileSecurity(LPCWSTR lpFileName,
return dwError; return dwError;
} }
SecDesc = (PSECURITY_DESCRIPTOR)MyRealloc(SecDesc, dwSize); SecDesc = MyRealloc(SecDesc, dwSize);
if (SecDesc == NULL) if (SecDesc == NULL)
return ERROR_NOT_ENOUGH_MEMORY; return ERROR_NOT_ENOUGH_MEMORY;

34
reactos/dll/win32/setupapi/parser.c
View file

@ -243,7 +243,7 @@ static struct line *add_line( struct inf_file *file, int section_index )
/* retrieve a given line from section/line index */ /* retrieve a given line from section/line index */
inline static struct line *get_line( struct inf_file *file, unsigned int section_index, static inline struct line *get_line( struct inf_file *file, unsigned int section_index,
unsigned int line_index ) unsigned int line_index )
{ {
struct section *section; struct section *section;
@ -433,7 +433,7 @@ static WCHAR *push_string( struct inf_file *file, const WCHAR *string )
/* push the current state on the parser stack */ /* push the current state on the parser stack */
inline static void push_state( struct parser *parser, enum parser_state state ) static inline void push_state( struct parser *parser, enum parser_state state )
{ {
ASSERT( parser->stack_pos < sizeof(parser->stack)/sizeof(parser->stack[0]) ); ASSERT( parser->stack_pos < sizeof(parser->stack)/sizeof(parser->stack[0]) );
parser->stack[parser->stack_pos++] = state; parser->stack[parser->stack_pos++] = state;
@ -441,7 +441,7 @@ inline static void push_state( struct parser *parser, enum parser_state state )
/* pop the current state */ /* pop the current state */
inline static void pop_state( struct parser *parser ) static inline void pop_state( struct parser *parser )
{ {
ASSERT( parser->stack_pos ); ASSERT( parser->stack_pos );
parser->state = parser->stack[--parser->stack_pos]; parser->state = parser->stack[--parser->stack_pos];
@ -449,7 +449,7 @@ inline static void pop_state( struct parser *parser )
/* set the parser state and return the previous one */ /* set the parser state and return the previous one */
inline static enum parser_state set_state( struct parser *parser, enum parser_state state ) static inline enum parser_state set_state( struct parser *parser, enum parser_state state )
{ {
enum parser_state ret = parser->state; enum parser_state ret = parser->state;
parser->state = state; parser->state = state;
@ -458,14 +458,14 @@ inline static enum parser_state set_state( struct parser *parser, enum parser_st
/* check if the pointer points to an end of file */ /* check if the pointer points to an end of file */
inline static int is_eof( const struct parser *parser, const WCHAR *ptr ) static inline int is_eof( const struct parser *parser, const WCHAR *ptr )
{ {
return (ptr >= parser->end || *ptr == CONTROL_Z); return (ptr >= parser->end || *ptr == CONTROL_Z);
} }
/* check if the pointer points to an end of line */ /* check if the pointer points to an end of line */
inline static int is_eol( const struct parser *parser, const WCHAR *ptr ) static inline int is_eol( const struct parser *parser, const WCHAR *ptr )
{ {
return (ptr >= parser->end || *ptr == CONTROL_Z || *ptr == '\n'); return (ptr >= parser->end || *ptr == CONTROL_Z || *ptr == '\n');
} }
@ -1067,7 +1067,7 @@ WCHAR *PARSER_get_dest_dir( INFCONTEXT *context )
HINF WINAPI SetupOpenInfFileA( PCSTR name, PCSTR class, DWORD style, UINT *error ) HINF WINAPI SetupOpenInfFileA( PCSTR name, PCSTR class, DWORD style, UINT *error )
{ {
UNICODE_STRING nameW, classW; UNICODE_STRING nameW, classW;
HINF ret = (HINF)INVALID_HANDLE_VALUE; HINF ret = INVALID_HANDLE_VALUE;
classW.Buffer = NULL; classW.Buffer = NULL;
if (class && !RtlCreateUnicodeStringFromAsciiz( &classW, class )) if (class && !RtlCreateUnicodeStringFromAsciiz( &classW, class ))
@ -1171,11 +1171,11 @@ HINF WINAPI SetupOpenInfFileW( PCWSTR name, PCWSTR class, DWORD style, UINT *err
if (strchrW( name, '\\' ) || strchrW( name, '/' )) if (strchrW( name, '\\' ) || strchrW( name, '/' ))
{ {
if (!(len = GetFullPathNameW( name, 0, NULL, NULL ))) return (HINF)INVALID_HANDLE_VALUE; if (!(len = GetFullPathNameW( name, 0, NULL, NULL ))) return INVALID_HANDLE_VALUE;
if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
{ {
SetLastError( ERROR_NOT_ENOUGH_MEMORY ); SetLastError( ERROR_NOT_ENOUGH_MEMORY );
return (HINF)INVALID_HANDLE_VALUE; return INVALID_HANDLE_VALUE;
} }
GetFullPathNameW( name, len, path, NULL ); GetFullPathNameW( name, len, path, NULL );
handle = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 ); handle = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
@ -1189,7 +1189,7 @@ HINF WINAPI SetupOpenInfFileW( PCWSTR name, PCWSTR class, DWORD style, UINT *err
if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
{ {
SetLastError( ERROR_NOT_ENOUGH_MEMORY ); SetLastError( ERROR_NOT_ENOUGH_MEMORY );
return (HINF)INVALID_HANDLE_VALUE; return INVALID_HANDLE_VALUE;
} }
GetWindowsDirectoryW( path, len ); GetWindowsDirectoryW( path, len );
p = path + strlenW(path); p = path + strlenW(path);
@ -1212,7 +1212,7 @@ HINF WINAPI SetupOpenInfFileW( PCWSTR name, PCWSTR class, DWORD style, UINT *err
if (!file) if (!file)
{ {
HeapFree( GetProcessHeap(), 0, path ); HeapFree( GetProcessHeap(), 0, path );
return (HINF)INVALID_HANDLE_VALUE; return INVALID_HANDLE_VALUE;
} }
TRACE( "%s -> %p\n", debugstr_w(path), file ); TRACE( "%s -> %p\n", debugstr_w(path), file );
file->filename = path; file->filename = path;
@ -1226,7 +1226,7 @@ HINF WINAPI SetupOpenInfFileW( PCWSTR name, PCWSTR class, DWORD style, UINT *err
/* Not enough memory */ /* Not enough memory */
SetLastError(ERROR_NOT_ENOUGH_MEMORY); SetLastError(ERROR_NOT_ENOUGH_MEMORY);
SetupCloseInfFile((HINF)file); SetupCloseInfFile((HINF)file);
return (HINF)INVALID_HANDLE_VALUE; return INVALID_HANDLE_VALUE;
} }
else if (!PARSER_GetInfClassW((HINF)file, &ClassGuid, ClassName, strlenW(class) + 1, NULL)) else if (!PARSER_GetInfClassW((HINF)file, &ClassGuid, ClassName, strlenW(class) + 1, NULL))
{ {
@ -1234,7 +1234,7 @@ HINF WINAPI SetupOpenInfFileW( PCWSTR name, PCWSTR class, DWORD style, UINT *err
HeapFree(GetProcessHeap(), 0, ClassName); HeapFree(GetProcessHeap(), 0, ClassName);
SetLastError(ERROR_CLASS_MISMATCH); SetLastError(ERROR_CLASS_MISMATCH);
SetupCloseInfFile((HINF)file); SetupCloseInfFile((HINF)file);
return (HINF)INVALID_HANDLE_VALUE; return INVALID_HANDLE_VALUE;
} }
else if (strcmpW(class, ClassName) != 0) else if (strcmpW(class, ClassName) != 0)
{ {
@ -1242,7 +1242,7 @@ HINF WINAPI SetupOpenInfFileW( PCWSTR name, PCWSTR class, DWORD style, UINT *err
HeapFree(GetProcessHeap(), 0, ClassName); HeapFree(GetProcessHeap(), 0, ClassName);
SetLastError(ERROR_CLASS_MISMATCH); SetLastError(ERROR_CLASS_MISMATCH);
SetupCloseInfFile((HINF)file); SetupCloseInfFile((HINF)file);
return (HINF)INVALID_HANDLE_VALUE; return INVALID_HANDLE_VALUE;
} }
HeapFree(GetProcessHeap(), 0, ClassName); HeapFree(GetProcessHeap(), 0, ClassName);
} }
@ -1261,7 +1261,7 @@ BOOL WINAPI SetupOpenAppendInfFileA( PCSTR name, HINF parent_hinf, UINT *error )
if (!name) return SetupOpenAppendInfFileW( NULL, parent_hinf, error ); if (!name) return SetupOpenAppendInfFileW( NULL, parent_hinf, error );
child_hinf = SetupOpenInfFileA( name, NULL, INF_STYLE_WIN4, error ); child_hinf = SetupOpenInfFileA( name, NULL, INF_STYLE_WIN4, error );
if (child_hinf == (HINF)INVALID_HANDLE_VALUE) return FALSE; if (child_hinf == INVALID_HANDLE_VALUE) return FALSE;
append_inf_file( parent_hinf, child_hinf ); append_inf_file( parent_hinf, child_hinf );
TRACE( "%p: appended %s (%p)\n", parent_hinf, debugstr_a(name), child_hinf ); TRACE( "%p: appended %s (%p)\n", parent_hinf, debugstr_a(name), child_hinf );
return TRUE; return TRUE;
@ -1286,14 +1286,14 @@ BOOL WINAPI SetupOpenAppendInfFileW( PCWSTR name, HINF parent_hinf, UINT *error
sizeof(filename)/sizeof(WCHAR), NULL )) sizeof(filename)/sizeof(WCHAR), NULL ))
{ {
child_hinf = SetupOpenInfFileW( filename, NULL, INF_STYLE_WIN4, error ); child_hinf = SetupOpenInfFileW( filename, NULL, INF_STYLE_WIN4, error );
if (child_hinf == (HINF)INVALID_HANDLE_VALUE) return FALSE; if (child_hinf == INVALID_HANDLE_VALUE) return FALSE;
append_inf_file( parent_hinf, child_hinf ); append_inf_file( parent_hinf, child_hinf );
TRACE( "%p: appended %s (%p)\n", parent_hinf, debugstr_w(filename), child_hinf ); TRACE( "%p: appended %s (%p)\n", parent_hinf, debugstr_w(filename), child_hinf );
} }
return TRUE; return TRUE;
} }
child_hinf = SetupOpenInfFileW( name, NULL, INF_STYLE_WIN4, error ); child_hinf = SetupOpenInfFileW( name, NULL, INF_STYLE_WIN4, error );
if (child_hinf == (HINF)INVALID_HANDLE_VALUE) return FALSE; if (child_hinf == INVALID_HANDLE_VALUE) return FALSE;
append_inf_file( parent_hinf, child_hinf ); append_inf_file( parent_hinf, child_hinf );
TRACE( "%p: appended %s (%p)\n", parent_hinf, debugstr_w(name), child_hinf ); TRACE( "%p: appended %s (%p)\n", parent_hinf, debugstr_w(name), child_hinf );
return TRUE; return TRUE;

8
reactos/dll/win32/setupapi/queue.c
View file

@ -63,7 +63,7 @@ struct file_queue
}; };
inline static WCHAR *strdupW( const WCHAR *str ) static inline WCHAR *strdupW( const WCHAR *str )
{ {
WCHAR *ret = NULL; WCHAR *ret = NULL;
if (str) if (str)
@ -74,7 +74,7 @@ inline static WCHAR *strdupW( const WCHAR *str )
return ret; return ret;
} }
inline static char *strdupWtoA( const WCHAR *str ) static inline char *strdupWtoA( const WCHAR *str )
{ {
char *ret = NULL; char *ret = NULL;
if (str) if (str)
@ -87,7 +87,7 @@ inline static char *strdupWtoA( const WCHAR *str )
} }
/* append a file operation to a queue */ /* append a file operation to a queue */
inline static void queue_file_op( struct file_op_queue *queue, struct file_op *op ) static inline void queue_file_op( struct file_op_queue *queue, struct file_op *op )
{ {
op->next = NULL; op->next = NULL;
if (queue->tail) queue->tail->next = op; if (queue->tail) queue->tail->next = op;
@ -417,7 +417,7 @@ HSPFILEQ WINAPI SetupOpenFileQueue(void)
struct file_queue *queue; struct file_queue *queue;
if (!(queue = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*queue)))) if (!(queue = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*queue))))
return (HSPFILEQ)INVALID_HANDLE_VALUE; return INVALID_HANDLE_VALUE;
return queue; return queue;
} }

8
reactos/dll/win32/setupapi/setupapi_private.h
View file

@ -241,11 +241,11 @@ inline static WCHAR *strdupAtoW( const char *str )
struct inf_file; struct inf_file;
extern const WCHAR *DIRID_get_string( int dirid ); extern const WCHAR *DIRID_get_string( int dirid );
extern unsigned int PARSER_string_substA( const struct inf_file *file, const WCHAR *text,
char *buffer, unsigned int size );
extern unsigned int PARSER_string_substW( const struct inf_file *file, const WCHAR *text,
WCHAR *buffer, unsigned int size );
extern const WCHAR *PARSER_get_inf_filename( HINF hinf ); extern const WCHAR *PARSER_get_inf_filename( HINF hinf );
extern unsigned int PARSER_string_substA( const struct inf_file *file, const WCHAR *text, char *buffer,
unsigned int size );
extern unsigned int PARSER_string_substW( const struct inf_file *file, const WCHAR *text, WCHAR *buffer,
unsigned int size );
extern WCHAR *PARSER_get_src_root( HINF hinf ); extern WCHAR *PARSER_get_src_root( HINF hinf );
extern WCHAR *PARSER_get_dest_dir( INFCONTEXT *context ); extern WCHAR *PARSER_get_dest_dir( INFCONTEXT *context );