archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 827363a95b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '827363a95b'
${ noResults }
windows-server-2003/sdktools/verifier/disk.cpp

1866 lines
47 KiB
Raw Blame History

/*++
Copyright (C) Microsoft Corporation, 2001
Module Name:
disk.c
Abstract:
This utility adds and removes lower filter drivers
for a given disk
Author:
Sidhartha
Environment:
User mode only
Notes:
- the filter is not checked for validity before it is added to the driver
stack; if an invalid filter is added, the device may no longer be
accessible.
- all code works irrespective of character set (ANSI, Unicode, ...)
Revision History:
--*/
#include <stdafx.h>
#include <setupapi.h>
#include <initguid.h>
#include <ntddstor.h>
#include <ntddvol.h>
#include "verifier.h"
#include "disk.h"
#include "VrfUtil.h"
#define GETVOLUMEPATH_MAX_LEN_RETRY 1000
#ifdef __cplusplus
extern "C"
{
#endif //#ifdef __cplusplus
typedef
BOOLEAN
(*DISK_ENUMERATE_CALLBACK)(
PVOID,
HDEVINFO,
SP_DEVINFO_DATA*
);
BOOLEAN
AddFilterDriver(
IN HDEVINFO DeviceInfoSet,
IN PSP_DEVINFO_DATA DeviceInfoData,
IN LPTSTR Filter,
IN BOOLEAN UpperFilter
);
BOOLEAN
RemoveFilterDriver(
IN HDEVINFO DeviceInfoSet,
IN PSP_DEVINFO_DATA DeviceInfoData,
IN LPTSTR Filter,
IN BOOLEAN UpperFilter
);
BOOLEAN
PrintFilters(
IN HDEVINFO DeviceInfoSet,
IN PSP_DEVINFO_DATA DeviceInfoData,
IN BOOLEAN UpperFilters,
IN LPTSTR FilterDriver,
IN OUT LPTSTR *VerifierEnabled
);
LPTSTR
GetFilters(
IN HDEVINFO DeviceInfoSet,
IN PSP_DEVINFO_DATA DeviceInfoData,
IN BOOLEAN UpperFilters
);
BOOLEAN
PrintDeviceName(
IN HDEVINFO DeviceInfoSet,
IN PSP_DEVINFO_DATA DeviceInfoData,
IN OUT LPTSTR *DiskDevicesForDisplay,
IN OUT LPTSTR *DiskDevicesPDOName
);
BOOLEAN
DeviceNameMatches(
IN HDEVINFO DeviceInfoSet,
IN PSP_DEVINFO_DATA DeviceInfoData,
IN LPTSTR DeviceName
);
PBYTE
GetDeviceRegistryProperty(
IN HDEVINFO DeviceInfoSet,
IN PSP_DEVINFO_DATA DeviceInfoData,
IN DWORD Property,
OUT PDWORD PropertyRegDataType
);
BOOLEAN
PrependSzToMultiSz(
IN LPTSTR SzToPrepend,
IN OUT LPTSTR *MultiSz
);
SIZE_T
GetMultiSzLength(
IN LPTSTR MultiSz
);
SIZE_T
MultiSzSearchAndDeleteCaseInsensitive(
IN LPTSTR FindThis,
IN LPTSTR FindWithin,
OUT SIZE_T *NewStringLength
);
BOOLEAN
DiskVerify(
DISK_ENUMERATE_CALLBACK CallBack,
PVOID Context,
LPTSTR deviceName
);
BOOLEAN
DiskEnumerateCallback (
PVOID Context,
HDEVINFO DevInfo,
SP_DEVINFO_DATA *DevInfoData
);
BOOLEAN
AddCallback (
PVOID Context,
HDEVINFO DevInfo,
SP_DEVINFO_DATA *DevInfoData
);
BOOLEAN
DelCallback (
PVOID Context,
HDEVINFO DevInfo,
SP_DEVINFO_DATA *DevInfoData
);
LPTSTR
GetDriveLetters (
IN HDEVINFO DeviceInfoSet,
IN PSP_DEVINFO_DATA DeviceInfoData
);
LPTSTR
GetDriveLettersFromVolume (
IN ULONG DeviceNumber
);
LPTSTR
PrintDriveLetters(
IN PTSTR VolumeName
);
BOOLEAN
StrConcatWithSpace(
IN LPTSTR SzToAppend,
IN OUT LPTSTR *drives
);
typedef struct _DISPLAY_STRUCT{
LPTSTR Filter;
LPTSTR* DiskDevicesForDisplay;
LPTSTR* DiskDevicesPDOName;
LPTSTR* VerifierEnabled;
}DISPLAY_STRUCT,
*PDISPLAY_STRUCT;
typedef struct _ADD_REMOVE_STRUCT{
LPTSTR Filter;
}ADD_REMOVE_STRUCT,
*PADD_REMOVE_STRUCT;
BOOLEAN
DiskEnumerate(
IN LPTSTR Filter,
OUT LPTSTR* DiskDevicesForDisplayP,
OUT LPTSTR* DiskDevicesPDONameP,
OUT LPTSTR* VerifierEnabledP
)
/*++
Routine Description:
This function enumerates all disk drives present on the systen.
Arguments:
Filter - The name of the filter drver whose presence we want to
check on any disk
DiskDevicesForDisplayP - Placeholder for User Friendly Disk names
DiskDevicesPDONameP - Placeholder for PDO device names
VerifierEnabledP - Placeholder for Information regarding presence
of Filter on a particular disk
Return Value:
Returns TRUE if successful, FALSE otherwise
--*/
{
DISPLAY_STRUCT Display;
DISK_ENUMERATE_CALLBACK CallBack;
BOOLEAN Status;
LPTSTR DiskDevicesForDisplay = NULL;
LPTSTR DiskDevicesPDOName = NULL;
LPTSTR VerifierEnabled = NULL;
//
//Initialize the Multisz strings with \0 (i.e. an empty MultiSz String)
//
DiskDevicesForDisplay = (LPTSTR)malloc(sizeof(TCHAR));
if(DiskDevicesForDisplay == NULL ){
VrfErrorResourceFormat( IDS_NOT_ENOUGH_MEMORY );
goto ErrorReturn;
}
DiskDevicesForDisplay[0] = 0;
DiskDevicesPDOName = (LPTSTR)malloc(sizeof(TCHAR));
if( DiskDevicesPDOName == NULL ){
VrfErrorResourceFormat( IDS_NOT_ENOUGH_MEMORY );
goto ErrorReturn;
}
DiskDevicesPDOName[0] = 0;
VerifierEnabled = (LPTSTR)malloc(sizeof(TCHAR));
if( VerifierEnabled == NULL ){
VrfErrorResourceFormat( IDS_NOT_ENOUGH_MEMORY );
goto ErrorReturn;
}
VerifierEnabled[0] = 0;
CallBack = DiskEnumerateCallback;
Display.Filter = Filter;
Display.DiskDevicesForDisplay = &DiskDevicesForDisplay;
Display.DiskDevicesPDOName = &DiskDevicesPDOName;
Display.VerifierEnabled = &VerifierEnabled;
Status = DiskVerify(CallBack,(PVOID) &Display,NULL);
if( !Status ) {
goto ErrorReturn;
}
*DiskDevicesForDisplayP = DiskDevicesForDisplay;
*DiskDevicesPDONameP = DiskDevicesPDOName;
*VerifierEnabledP = VerifierEnabled;
return TRUE;
ErrorReturn:
if(DiskDevicesForDisplay != NULL) {
free( DiskDevicesForDisplay );
}
if(DiskDevicesPDOName != NULL) {
free( DiskDevicesPDOName );
}
if(VerifierEnabled != NULL) {
free(VerifierEnabled);
}
return FALSE;
}
BOOLEAN
DiskEnumerateCallback (
PVOID Context,
HDEVINFO DevInfo,
SP_DEVINFO_DATA *DevInfoData
)
/*++
Routine Description:
This function is a callback to be executed whenever a disk is discovered
Arguments:
Context - Points to all the relevant information needed to succesfully enumerate the disk
DevInfo - The device information set which contains DeviceInfoData
DevInfoData - Information needed to deal with the given device
Return Value:
Returns TRUE if successful, FALSE otherwise
--*/
{
PDISPLAY_STRUCT PDisplay;
BOOLEAN Status;
PDisplay = (PDISPLAY_STRUCT) Context;
//
//Add newly discoverd disks to the list
//
Status = PrintDeviceName(DevInfo,
DevInfoData,
PDisplay->DiskDevicesForDisplay,
PDisplay->DiskDevicesPDOName);
if(!Status) {
return Status;
}
Status = PrintFilters(DevInfo,
DevInfoData,FALSE,
PDisplay->Filter,
PDisplay->VerifierEnabled);
return Status;
}
BOOLEAN
AddFilter(
IN LPTSTR Filter,
IN LPTSTR DiskDevicesPDONameP
)
/*++
Routine Description:
This function adds the filter on the specified disk device
Arguments:
Filter - Name of the filter to be added
DiskDevicesPDONameP - PDO device name of the disk
Return Value:
Returns TRUE if successful, FALSE otherwise
--*/
{
ADD_REMOVE_STRUCT AddRemove;
DISK_ENUMERATE_CALLBACK CallBack;
BOOLEAN Status;
AddRemove.Filter = Filter;
CallBack = AddCallback;
Status = DiskVerify(CallBack,(PVOID) &AddRemove,DiskDevicesPDONameP);
return Status;
}
BOOLEAN
DelFilter(
IN LPTSTR Filter,
IN LPTSTR DiskDevicesPDONameP
)
/*++
Routine Description:
This function removes the filter on the specified disk device
Arguments:
Filter - Name of the filter to be added
DiskDevicesPDONameP - PDO device name of the disk
Return Value:
Returns TRUE if successful, FALSE otherwise
--*/
{
ADD_REMOVE_STRUCT AddRemove;
DISK_ENUMERATE_CALLBACK CallBack;
BOOLEAN Status;
AddRemove.Filter = Filter;
CallBack = DelCallback;
Status = DiskVerify(CallBack,(PVOID) &AddRemove,DiskDevicesPDONameP);
return Status;
}
BOOLEAN
AddCallback (
PVOID Context,
HDEVINFO DevInfo,
SP_DEVINFO_DATA *DevInfoData
)
/*++
Routine Description:
This function is a callback to be executed whenever a disk is matched, and
a filter needs to be added/deleted
Arguments:
Context - Points to all the relevant information needed to succesfully identify the disk
DevInfo - The device information set which contains DeviceInfoData
DevInfoData - Information needed to deal with the given device
Return Value:
Returns TRUE if successful, FALSE otherwise
--*/
{
PADD_REMOVE_STRUCT PAddRemove;
BOOLEAN Status;
PAddRemove = (PADD_REMOVE_STRUCT) Context;
Status = AddFilterDriver(DevInfo,
DevInfoData,
PAddRemove->Filter,
FALSE);
if( !Status ) {
return FALSE;
}
return TRUE;
}
BOOLEAN
DelCallback (
PVOID Context,
HDEVINFO DevInfo,
SP_DEVINFO_DATA *DevInfoData
)
/*++
Routine Description:
This function is a callback to be executed whenever a disk is matched, and
a filter needs to be added/deleted
Arguments:
Context - Points to all the relevant information needed to succesfully identify the disk
DevInfo - The device information set which contains DeviceInfoData
DevInfoData - Information needed to deal with the given device
Return Value:
Returns TRUE if successful, FALSE otherwise
--*/
{
PADD_REMOVE_STRUCT PAddRemove;
BOOLEAN Status;
PAddRemove = (PADD_REMOVE_STRUCT) Context;
Status = RemoveFilterDriver(DevInfo,
DevInfoData,
PAddRemove->Filter,
FALSE);
if( !Status ){
return FALSE;
}
return TRUE;
}
BOOLEAN
DiskVerify(
DISK_ENUMERATE_CALLBACK CallBack,
PVOID Context,
LPTSTR deviceName
)
/*++
Routine Description:
This function enumerates all disk drives. It also is used to add/remove
filter drivers. It triggers callbacks upon detecting a disk.
Arguments:
CallBack - The routine to be executed upon succesfull detection of a disk
Context - Points to all the relevant information needed to succesfully identify the disk
Return Value:
Returns TRUE if successful, FALSE otherwise
--*/
{
//
// these two constants are used to help enumerate through the list of all
// disks and volumes on the system. Adding another GUID should "just work"
//
const GUID * deviceGuids[] = {
&DiskClassGuid,
};
HDEVINFO devInfo = INVALID_HANDLE_VALUE;
SP_DEVINFO_DATA devInfoData;
int deviceIndex;
BOOLEAN upperFilter = FALSE;
BOOLEAN deviceMatch = FALSE;
BOOLEAN Status;
BOOLEAN Sucess;
//
// get a list of devices which support the given interface
//
devInfo = SetupDiGetClassDevs( deviceGuids[0],
NULL,
NULL,
DIGCF_PROFILE |
DIGCF_DEVICEINTERFACE |
DIGCF_PRESENT );
if( devInfo == INVALID_HANDLE_VALUE ) {
VrfErrorResourceFormat( IDS_CANNOT_GET_DEVICES_LIST );
return FALSE;
}
//
// step through the list of devices for this handle
// get device info at index deviceIndex, the function returns FALSE
// when there is no device at the given index.
//
deviceIndex=0;
do{
//
// if a device name was specified, and it doesn't match this one,
// stop. If there is a match (or no name was specified), mark that
// there was a match.
//
devInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
Sucess = (SetupDiEnumDeviceInfo( devInfo, deviceIndex++, &devInfoData ) != FALSE);
if( !Sucess ) {
break;
}
if( deviceName != NULL && !DeviceNameMatches( devInfo, &devInfoData, deviceName )) {
continue;
} else {
deviceMatch = TRUE;
}
Status = (*CallBack)(Context,devInfo,&devInfoData);
if( !Status ){
return FALSE;
}
}while(Sucess);
if( devInfo != INVALID_HANDLE_VALUE ) {
Status = ( SetupDiDestroyDeviceInfoList( devInfo ) != FALSE );
}
if( !deviceMatch ) {
VrfErrorResourceFormat( IDS_NO_DEVICES_MATCH_NAME,
deviceName );
return FALSE;
}
return TRUE;
}
BOOLEAN
AddFilterDriver(
IN HDEVINFO DeviceInfoSet,
IN PSP_DEVINFO_DATA DeviceInfoData,
IN LPTSTR Filter,
IN BOOLEAN UpperFilter
)
/*++
Routine Description:
Adds the given filter driver to the list of lower filter drivers for the
disk. Note: The filter is prepended to the list of drivers, which will put
it at the bottom of the filter driver stack
Arguments:
DeviceInfoSet - The device information set which contains DeviceInfoData
DeviceInfoData - Information needed to deal with the given device
Filter - The filter to add
Return Value:
If we are successful in adding the driver, as a lower driver to disk, returns
TRUE, FALSE otherwise
--*/
{
SIZE_T length;
SIZE_T size;
LPTSTR buffer = NULL;
BOOLEAN SetupDiSetDeviceRegistryPropertyReturn;
BOOLEAN Success;
ASSERT(DeviceInfoData != NULL);
ASSERT(Filter != NULL);
Success = TRUE;
length = 0;
size = 0;
buffer = GetFilters( DeviceInfoSet, DeviceInfoData, UpperFilter );
if( buffer == NULL ){
//
// if there is no such value in the registry, then there are no upper
// filter drivers loaded, and we can just put one there
// make room for the string, string null terminator, and multisz null
// terminator
//
length = _tcslen(Filter)+1;
size = (length+1)*sizeof(_TCHAR);
buffer = (LPTSTR)malloc( size );
if( buffer == NULL ){
VrfErrorResourceFormat( IDS_NOT_ENOUGH_MEMORY );
Success = FALSE;
goto Done;
}
memset(buffer, 0, size);
memcpy(buffer, Filter, length*sizeof(_TCHAR));
} else {
LPTSTR buffer2;
//
// remove all instances of filter from driver list
//
MultiSzSearchAndDeleteCaseInsensitive( Filter, buffer, &length );
//
// allocate a buffer large enough to add the new filter
// GetMultiSzLength already includes length of terminating NULL
// determing the new length of the string
//
length = GetMultiSzLength(buffer) + _tcslen(Filter) + 1;
size = length*sizeof(_TCHAR);
buffer2 = (LPTSTR)malloc( size );
if (buffer2 == NULL) {
VrfErrorResourceFormat( IDS_NOT_ENOUGH_MEMORY );
Success = FALSE;
goto Done;
}
memset(buffer2, 0, size);
memcpy(buffer2, buffer, GetMultiSzLength(buffer)*sizeof(_TCHAR));
free(buffer);
buffer = buffer2;
//
// add the driver to the driver list
//
PrependSzToMultiSz(Filter, &buffer);
}
//
// set the new list of filters in place
//
SetupDiSetDeviceRegistryPropertyReturn = (
SetupDiSetDeviceRegistryProperty( DeviceInfoSet,
DeviceInfoData,
(UpperFilter ? SPDRP_UPPERFILTERS : SPDRP_LOWERFILTERS),
(PBYTE)buffer,
((ULONG) GetMultiSzLength(buffer)*sizeof(_TCHAR))) != FALSE );
if(!SetupDiSetDeviceRegistryPropertyReturn){
TRACE(_T("in AddUpperFilterDriver(): ")
_T("couldn't set registry value! error: %u\n"),
GetLastError());
VrfErrorResourceFormat( IDS_CANNOT_SET_DEVICE_REGISTRY_PROPERTY );
Success = FALSE;
goto Done;
}
Done:
if(buffer != NULL) {
free( buffer );
}
return Success;
}
BOOLEAN
RemoveFilterDriver(
IN HDEVINFO DeviceInfoSet,
IN PSP_DEVINFO_DATA DeviceInfoData,
IN LPTSTR Filter,
IN BOOLEAN UpperFilter
)
/*++
Routine Description:
Removes all instances of the given filter driver from the list of lower
filter drivers for the device.
Arguments:
DeviceInfoSet - The device information set which contains DeviceInfoData
DeviceInfoData - Information needed to deal with the given device
Filter - The filter to remove
Return Value:
returns TRUE if successful, FALSE otherwise
--*/
{
SIZE_T length;
SIZE_T size;
LPTSTR buffer;
BOOL success;
ASSERT(DeviceInfoData != NULL);
ASSERT(Filter != NULL);
success = FALSE;
length = 0;
size = 0;
buffer = GetFilters( DeviceInfoSet, DeviceInfoData, UpperFilter );
if( buffer == NULL ){
return (TRUE);
} else {
//
// remove all instances of filter from driver list
//
MultiSzSearchAndDeleteCaseInsensitive( Filter, buffer, &length );
}
length = GetMultiSzLength(buffer);
ASSERT ( length > 0 );
if( length == 1 ){
//
// if the length of the list is 1, the return value from
// GetMultiSzLength() was just accounting for the trailing '\0', so we can
// delete the registry key, by setting it to NULL.
//
success = SetupDiSetDeviceRegistryProperty( DeviceInfoSet,
DeviceInfoData,
(UpperFilter ? SPDRP_UPPERFILTERS : SPDRP_LOWERFILTERS),
NULL,
0 );
} else {
//
// set the new list of drivers into the registry
//
size = length*sizeof(_TCHAR);
success = SetupDiSetDeviceRegistryProperty( DeviceInfoSet,
DeviceInfoData,
(UpperFilter ? SPDRP_UPPERFILTERS : SPDRP_LOWERFILTERS),
(PBYTE)buffer,
(ULONG)size );
}
free( buffer );
if( !success ){
TRACE(_T("in RemoveUpperFilterDriver(): ")
_T("couldn't set registry value! error: %i\n"),
GetLastError());
VrfErrorResourceFormat( IDS_CANNOT_SET_DEVICE_REGISTRY_PROPERTY );
return FALSE;
}
return TRUE;
}
BOOLEAN
PrintFilters(
IN HDEVINFO DeviceInfoSet,
IN PSP_DEVINFO_DATA DeviceInfoData,
IN BOOLEAN UpperFilters,
IN LPTSTR FilterDriver,
IN OUT LPTSTR *VerifierEnabled
)
/*++
Routine Description:
Looks at all the lower filters installed for the disk. It tells us if
DiskVerifier is installed for that particular disk.
Arguments:
DeviceInfoSet - The device information set which contains
DeviceInfoData
DeviceInfoData - Information needed to deal with the given device
FilterDriver - The name of the Filter driver for Disk Verifier
DiskDevices - MultiSZ style string listing all devices
VerifierEnabled - MultiSZ style string indicating if Verifier Enabled
Return Value:
Returns TRUE if successful, FALSE otherwise
--*/
{
LPTSTR buffer;
SIZE_T filterPosition;
LPTSTR temp;
int StrCmpReturn;
buffer = GetFilters( DeviceInfoSet, DeviceInfoData, UpperFilters );
if ( buffer != NULL ) {
//
// go through the multisz and print out each driver
//
temp=buffer;
filterPosition=0;
while( *temp != _T('\0') ){
StrCmpReturn = _tcsicmp(FilterDriver,temp);
if(StrCmpReturn == 0 ){
PrependSzToMultiSz( _T("1"),VerifierEnabled);
free( buffer );
return TRUE;
}
temp = temp+_tcslen(temp)+1;
filterPosition++;
}
free( buffer );
}
PrependSzToMultiSz( _T("0"),VerifierEnabled);
return TRUE;
}
BOOLEAN PrintDeviceName(
IN HDEVINFO DeviceInfoSet,
IN PSP_DEVINFO_DATA DeviceInfoData,
IN OUT LPTSTR *DiskDevicesForDisplay,
IN OUT LPTSTR *DiskDevicesPDOName
)
/*++
Routine Description:
Looks up the PDO device name, and user friendly name for disk.
Arguments:
DeviceInfoSet - The device information set which contains
DeviceInfoData
DeviceInfoData - Information needed to deal with the given device
DiskDevicesForDisplay - User Friendly Names for Disk
DiskDevicesPDOName - PDO specified device names for disk
Return Value:
Returns TRUE if successful, FALSE otherwise
--*/
{
DWORD regDataType;
LPTSTR deviceName;
LPTSTR driveLetters;
int StrCmpReturned;
BOOL bResult;
deviceName = (LPTSTR) GetDeviceRegistryProperty( DeviceInfoSet,
DeviceInfoData,
SPDRP_PHYSICAL_DEVICE_OBJECT_NAME,
&regDataType );
if( deviceName == NULL ) {
TRACE(_T("in PrintDeviceName(): registry key is NULL! error: %u\n"),
GetLastError());
VrfErrorResourceFormat( IDS_CANNOT_GET_DEVICE_REGISTRY_PROPERTY );
return FALSE;
}
if( regDataType != REG_SZ ){
TRACE(_T("in PrintDeviceName(): registry key is not an SZ!\n"));
return FALSE;
} else {
//
// if the device name starts with \Device, cut that off (all
// devices will start with it, so it is redundant)
//
StrCmpReturned = _tcsncmp(deviceName, _T("\\Device"), 7);
if( StrCmpReturned == 0 ){
memmove(deviceName,
deviceName+7,
(_tcslen(deviceName)-6)*sizeof(_TCHAR) );
}
PrependSzToMultiSz(deviceName,DiskDevicesPDOName);
free( deviceName );
}
deviceName = (LPTSTR) GetDeviceRegistryProperty( DeviceInfoSet,
DeviceInfoData,
SPDRP_FRIENDLYNAME ,
&regDataType );
if( deviceName == NULL ){
TRACE(_T("in PrintDeviceName(): registry key is NULL! error: %u\n"),
GetLastError());
//
//We could not obtain the friendly name for disk, setting it to Unknown.
//
deviceName = (LPTSTR)malloc(sizeof(TCHAR) * 64);
if ( !deviceName ) {
VrfErrorResourceFormat( IDS_NOT_ENOUGH_MEMORY );
return FALSE;
}
bResult = VrfLoadString(IDS_UNKNOWN,
deviceName,
64 );
if ( !bResult ) {
VrfErrorResourceFormat( IDS_NOT_ENOUGH_MEMORY );
return FALSE;
}
}
//
// just to make sure we are getting the expected type of buffer
//
if( regDataType != REG_SZ ){
TRACE(_T("in PrintDeviceName(): registry key is not an SZ!\n"));
return FALSE;
}else{
driveLetters = GetDriveLetters( DeviceInfoSet,
DeviceInfoData);
if(driveLetters){
StrConcatWithSpace(driveLetters,&deviceName);
}
PrependSzToMultiSz(deviceName,DiskDevicesForDisplay);
free( deviceName );
}
return TRUE;
}
LPTSTR
GetFilters(
IN HDEVINFO DeviceInfoSet,
IN PSP_DEVINFO_DATA DeviceInfoData,
IN BOOLEAN UpperFilters
)
/*++
Routine Description:
Returns a buffer containing the list of lower filters for the device.The
buffer must be freed by the caller.
Arguments:
DeviceInfoSet - The device information set which contains DeviceInfoData
DeviceInfoData - Information needed to deal with the given device
UpperFilters - Switch to select Upper/Lower filter. Currently we
use Lower.
Return Value:
MultiSz style string containing all lower Filters for the disk is
returned. NULL is returned if there is no buffer, or an error occurs.
--*/
{
DWORD regDataType;
LPTSTR buffer;
buffer = (LPTSTR) GetDeviceRegistryProperty( DeviceInfoSet,
DeviceInfoData,
(UpperFilters ? SPDRP_UPPERFILTERS : SPDRP_LOWERFILTERS),
&regDataType );
if( buffer != NULL && regDataType != REG_MULTI_SZ ){
TRACE(_T("in GetUpperFilters(): ")
_T("registry key is not a MULTI_SZ!\n"));
free( buffer );
return (NULL);
}
return (buffer);
}
BOOLEAN
DeviceNameMatches(
IN HDEVINFO DeviceInfoSet,
IN PSP_DEVINFO_DATA DeviceInfoData,
IN LPTSTR DeviceName
)
/*++
Routine Description:
Searches if DeviceName matches the name of the device specified by
DeviceInfoData
Arguments:
DeviceInfoSet - The device information set which contains DeviceInfoData
DeviceInfoData - Information needed to deal with the given device
DeviceName - the name to try to match
Return Value:
Returns TRUE if successful, FALSE otherwise
--*/
{
BOOLEAN matching = FALSE;
DWORD regDataType;
LPTSTR deviceName;
int StrCmpReturn;
deviceName = (LPTSTR) GetDeviceRegistryProperty( DeviceInfoSet,
DeviceInfoData,
SPDRP_PHYSICAL_DEVICE_OBJECT_NAME,
&regDataType );
if( deviceName != NULL) {
if( regDataType != REG_SZ ){
TRACE(_T("in DeviceNameMatches(): registry key is not an SZ!\n"));
matching = FALSE;
}else{
//
// if the device name starts with \Device, cut that off (all
// devices will start with it, so it is redundant)
//
StrCmpReturn = _tcsncmp(deviceName, _T("\\Device"), 7);
if( StrCmpReturn == 0 ){
memmove(deviceName,
deviceName+7,
(_tcslen(deviceName)-6)*sizeof(_TCHAR) );
}
matching = (_tcscmp(deviceName, DeviceName) == 0);
}
free( deviceName );
} else {
TRACE(_T("in DeviceNameMatches(): registry key is NULL!\n"));
VrfErrorResourceFormat( IDS_CANNOT_GET_DEVICE_REGISTRY_PROPERTY );
matching = FALSE;
}
return (matching);
}
PBYTE
GetDeviceRegistryProperty(
IN HDEVINFO DeviceInfoSet,
IN PSP_DEVINFO_DATA DeviceInfoData,
IN DWORD Property,
OUT PDWORD PropertyRegDataType
)
/*++
Routine Description:
A wrapper around SetupDiGetDeviceRegistryProperty, so that I don't have to
deal with memory allocation anywhere else.
Arguments:
DeviceInfoSet - The device information set which contains DeviceInfoData
DeviceInfoData - Information needed to deal with the given device
Property - which property to get (SPDRP_XXX)
PropertyRegDataType - the type of registry property
Return Value:
Returns buffer for Registery property
--*/
{
DWORD length = 0;
PBYTE buffer = NULL;
BOOL SetupDiGetDeviceRegistryPropertyReturn;
SetupDiGetDeviceRegistryPropertyReturn = SetupDiGetDeviceRegistryProperty(
DeviceInfoSet,
DeviceInfoData,
Property,
NULL,
NULL,
0,
&length);
if( SetupDiGetDeviceRegistryPropertyReturn ){
//
// we should not be successful at this point, so this call succeeding
// is an error condition
//
TRACE(_T("in GetDeviceRegistryProperty(): ")
_T("call SetupDiGetDeviceRegistryProperty did not fail\n"),
GetLastError());
VrfErrorResourceFormat( IDS_CANNOT_GET_DEVICE_REGISTRY_PROPERTY );
return (NULL);
}
if( GetLastError() != ERROR_INSUFFICIENT_BUFFER ){
//
// this means there are no upper filter drivers loaded, so we can just
// return.
//
return (NULL);
}
//
// since we don't have a buffer yet, it is "insufficient"; we allocate
// one and try again.
//
buffer = (PBYTE)malloc( length );
if( buffer == NULL ) {
VrfErrorResourceFormat( IDS_NOT_ENOUGH_MEMORY );
return (NULL);
}
SetupDiGetDeviceRegistryPropertyReturn = SetupDiGetDeviceRegistryProperty(
DeviceInfoSet,
DeviceInfoData,
Property,
PropertyRegDataType,
buffer,
length,
NULL);
if( !SetupDiGetDeviceRegistryPropertyReturn) {
TRACE(_T("in GetDeviceRegistryProperty(): ")
_T("couldn't get registry property! error: %i\n"),
GetLastError());
VrfErrorResourceFormat( IDS_CANNOT_GET_DEVICE_REGISTRY_PROPERTY );
free( buffer );
return (NULL);
}
return (buffer);
}
BOOLEAN
PrependSzToMultiSz(
IN LPTSTR SzToPrepend,
IN OUT LPTSTR *MultiSz
)
/*++
Routine Description:
Prepends the given string to a MultiSz.Note: This WILL allocate and free
memory, so don't keep pointers to the MultiSz passed in.
Arguments:
SzToPrepend - string to prepend
MultiSz - pointer to a MultiSz which will be prepended-to
Return Value:
Returns true if successful, false if not (will only fail in memory
allocation)
--*/
{
SIZE_T szLen;
SIZE_T multiSzLen;
LPTSTR newMultiSz = NULL;
ASSERT(SzToPrepend != NULL);
ASSERT(MultiSz != NULL);
szLen = (_tcslen(SzToPrepend)+1)*sizeof(_TCHAR);
multiSzLen = GetMultiSzLength(*MultiSz)*sizeof(_TCHAR);
newMultiSz = (LPTSTR)malloc( szLen+multiSzLen );
if( newMultiSz == NULL ){
return (FALSE);
}
//
// recopy the old MultiSz into proper position into the new buffer.
// the (char*) cast is necessary, because newMultiSz may be a wchar*, and
// szLen is in bytes.
//
memcpy( ((char*)newMultiSz) + szLen, *MultiSz, multiSzLen );
_tcscpy( newMultiSz, SzToPrepend );
free( *MultiSz );
*MultiSz = newMultiSz;
return (TRUE);
}
SIZE_T
GetMultiSzLength(
IN LPTSTR MultiSz
)
/*++
Routine Description:
Calculates the size of the buffer required to hold a particular MultiSz
Arguments:
MultiSz - the MultiSz to get the length of
Return Value:
Returns the length (in characters) of the buffer required to hold this
MultiSz, INCLUDING the trailing null.
example: GetMultiSzLength("foo\0bar\0") returns 9
note: since MultiSz cannot be null, a number >= 1 will always be returned
--*/
{
SIZE_T len = 0;
SIZE_T totalLen = 0;
ASSERT( MultiSz != NULL );
while( *MultiSz != _T('\0') ){
len = _tcslen(MultiSz)+1;
MultiSz += len;
totalLen += len;
}
return (totalLen+1);
}
SIZE_T
MultiSzSearchAndDeleteCaseInsensitive(
IN LPTSTR FindThis,
IN LPTSTR FindWithin,
OUT SIZE_T *NewLength
)
/*++
Routine Description:
Deletes all instances of a string from within a multi-sz.
Arguments:
FindThis - the string to find and remove
FindWithin - the string having the instances removed
NewStringLength - the new string length
Return Value:
Returns the no. of string occurences deleted from MultiSz
--*/
{
LPTSTR search;
SIZE_T currentOffset;
DWORD instancesDeleted;
SIZE_T searchLen;
ASSERT(FindThis != NULL);
ASSERT(FindWithin != NULL);
ASSERT(NewLength != NULL);
currentOffset = 0;
instancesDeleted = 0;
search = FindWithin;
*NewLength = GetMultiSzLength(FindWithin);
//
// loop while the multisz null terminator is not found
//
while ( *search != _T('\0') ){
//
// length of string + null char; used in more than a couple places
//
searchLen = _tcslen(search) + 1;
if( _tcsicmp(search, FindThis) == 0 ){
//
// they match, shift the contents of the multisz, to overwrite the
// string (and terminating null), and update the length
//
instancesDeleted++;
*NewLength -= searchLen;
memmove( search,
search + searchLen,
(*NewLength - currentOffset) * sizeof(TCHAR) );
} else {
currentOffset += searchLen;
search += searchLen;
}
}
return instancesDeleted;
}
BOOLEAN
FreeDiskMultiSz(
IN LPTSTR MultiSz
)
{
ASSERT( MultiSz != NULL );
free( MultiSz );
return TRUE;
}
LPTSTR
GetDriveLetters (
IN HDEVINFO DeviceInfoSet,
IN PSP_DEVINFO_DATA DeviceInfoData
)
/*++
Routine Description:
Looks up the drive letters for the specified disk. Finds the
device number of the disk, and passes it on to the volume code
Arguments:
DeviceInfoSet - The device information set which contains
DeviceInfoData
DeviceInfoData - Information needed to deal with the given device
Return Value:
Returns the list of drives present on the disk if successful,
NULL otherwise
--*/
{
SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;
ULONG cbDetail;
PSP_DEVICE_INTERFACE_DETAIL_DATA pDetail;
BOOL Status;
HANDLE hDisk;
STORAGE_DEVICE_NUMBER devNumber;
DWORD cbBytes;
DeviceInterfaceData.cbSize = sizeof(DeviceInterfaceData);
cbDetail = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA) +
MAX_PATH * sizeof(WCHAR);
pDetail = (PSP_DEVICE_INTERFACE_DETAIL_DATA)LocalAlloc(LMEM_FIXED, cbDetail);
if (pDetail == NULL) {
return NULL;
}
pDetail->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
Status = SetupDiEnumDeviceInterfaces (DeviceInfoSet,
DeviceInfoData,
&DiskClassGuid,
0,
&DeviceInterfaceData);
if (! Status) {
LocalFree(pDetail);
return NULL;
}
Status = SetupDiGetDeviceInterfaceDetail(DeviceInfoSet,
&DeviceInterfaceData,
pDetail,
cbDetail,
NULL,
NULL);
if (! Status) {
LocalFree(pDetail);
return NULL;
}
hDisk = CreateFile(pDetail->DevicePath,
GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hDisk == INVALID_HANDLE_VALUE) {
LocalFree(pDetail);
return NULL;
}
Status = DeviceIoControl(hDisk,
IOCTL_STORAGE_GET_DEVICE_NUMBER,
NULL,
0,
&devNumber,
sizeof(devNumber),
&cbBytes,
NULL);
if (!Status) {
LocalFree(pDetail);
return NULL;
}
LocalFree(pDetail);
return GetDriveLettersFromVolume (devNumber.DeviceNumber);
}
LPTSTR
GetDriveLettersFromVolume (
IN ULONG DeviceNumber
)
/*++
Routine Description:
Looks up the drive letter(s) and volume_label(s) for the specified
disk(device number) by parsing the volumes.
Arguments:
DeviceNumber - Unique Number identifying the physical disk
Return Value:
Returns the list of drives present on the disk if successful,
NULL otherwise
--*/
{
HANDLE h = INVALID_HANDLE_VALUE;
HANDLE hVol;
TCHAR volumeName[MAX_PATH];
TCHAR originalVolumeName[MAX_PATH];
DWORD cbBytes;
PVOLUME_DISK_EXTENTS PVolDiskExtent;
LPTSTR drives;
LPTSTR temp;
BOOL b;
BOOL First;
int maxDisks;
int i;
int j;
size_t tempLen;
TCHAR OpenParan[] = TEXT(" ( ");
TCHAR CloseParan[] = TEXT(")");
drives = NULL;
First = TRUE;
StrConcatWithSpace(OpenParan,&drives);
for (;;) {
if(First) {
//
//Using FindFirstVolumeA, as it is the Non-Unicode version
//of FindFirstVolume
//
h = FindFirstVolume(volumeName, MAX_PATH);
if (h == INVALID_HANDLE_VALUE) {
return NULL;
}
First = FALSE;
b = TRUE;
} else {
b = FindNextVolume(h, volumeName, MAX_PATH);
}
if (!b) {
break;
}
tempLen = _tcslen(volumeName);
_tcsncpy(originalVolumeName,
volumeName,
tempLen - 1);
_tcscpy(originalVolumeName + tempLen - 1,
volumeName + tempLen);
//
//To open a handle correctly, CreateFile expects the name
//of the Volume without the trailing \ returned by
//FindFirstVolume / FindNextVolume
//
hVol = CreateFile(originalVolumeName,
GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hVol == INVALID_HANDLE_VALUE) {
continue;
}
PVolDiskExtent = (PVOLUME_DISK_EXTENTS) LocalAlloc(LMEM_FIXED, sizeof(VOLUME_DISK_EXTENTS));
if(!PVolDiskExtent) {
continue;
}
//
//This IOCTL has to be called with a minimum of
//size VOLUME_DISK_EXTENTS. If more entries are present
//it can be obtained by PVolDiskExtent->NumberOfDiskExtents
//
b = DeviceIoControl(hVol,
IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
NULL,
0,
PVolDiskExtent,
sizeof(VOLUME_DISK_EXTENTS),
&cbBytes,
NULL);
if (!b) {
//
//Now, we can read how much memory is actually required
//to read in the disk info
//
if(GetLastError() == ERROR_MORE_DATA){
maxDisks = PVolDiskExtent->NumberOfDiskExtents;
LocalFree(PVolDiskExtent);
PVolDiskExtent = (PVOLUME_DISK_EXTENTS) LocalAlloc(LMEM_FIXED, sizeof(VOLUME_DISK_EXTENTS) + (sizeof(DISK_EXTENT) * maxDisks));
if(!PVolDiskExtent) {
continue;
}
b = DeviceIoControl(hVol,
IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
NULL,
0,
PVolDiskExtent,
sizeof(VOLUME_DISK_EXTENTS) + (sizeof(DISK_EXTENT) * maxDisks),
&cbBytes,
NULL);
if (!b) {
continue;
}
for(j=0;j<maxDisks;j++){
if(PVolDiskExtent->Extents[j].DiskNumber == DeviceNumber) {
temp = PrintDriveLetters(volumeName);
if(temp) {
StrConcatWithSpace(temp,&drives);
FreeDiskMultiSz(temp);
}
}
}
} else {
continue;
}
} else {
if(PVolDiskExtent->Extents[0].DiskNumber == DeviceNumber) {
temp = PrintDriveLetters(volumeName);
if(temp) {
StrConcatWithSpace(temp,&drives);
FreeDiskMultiSz(temp);
}
}
}
CloseHandle(hVol);
LocalFree(PVolDiskExtent);
}
if(h != INVALID_HANDLE_VALUE) {
FindVolumeClose(h);
}
StrConcatWithSpace(CloseParan,&drives);
return drives;
}
LPTSTR
PrintDriveLetters(
IN PTSTR VolumeName
)
/*++
Routine Description:
Looks up the drive letters for the specified Volume
Arguments:
VolumeName - Name of the Volume
Return Value:
A list of drive letter(s) for the specified volume
--*/
{
BOOL b;
DWORD len;
LPTSTR volumePaths, p;
LPTSTR drives;
TCHAR volumeName1[MAX_PATH];
DWORD lpVolumeSerialNumber;
DWORD lpMaximumComponentLength;
DWORD lpFileSystemFlags;
drives = NULL;
b = GetVolumePathNamesForVolumeName(VolumeName,
NULL,
0,
&len);
if (!b) {
if(GetLastError() != ERROR_MORE_DATA) {
return NULL;
}
}
volumePaths = (LPTSTR) LocalAlloc(LMEM_FIXED, len*sizeof(TCHAR));
if (!volumePaths) {
return NULL;
}
b = GetVolumePathNamesForVolumeName(VolumeName,
volumePaths,
len,
NULL);
if (!b ) {
if( GetLastError() != ERROR_MORE_DATA) {
LocalFree(volumePaths);
return NULL;
} else {
//
//Warning - This is a hack. For some reason the non-unicode
//version of GetVolumePathNamesForVolumeNameA does not return
//the correct length to be used. So we hope it will not be
//greater then GETVOLUMEPATH_MAX_LEN_RETRY. But if the correct len is
//returned, we used that previosly
//
LocalFree(volumePaths);
len = GETVOLUMEPATH_MAX_LEN_RETRY;
volumePaths = (LPTSTR) LocalAlloc(LMEM_FIXED, GETVOLUMEPATH_MAX_LEN_RETRY*sizeof(TCHAR));
if (!volumePaths) {
return NULL;
}
b = GetVolumePathNamesForVolumeName(VolumeName,
volumePaths,
len,
NULL);
if (!b ) {
LocalFree(volumePaths);
return NULL;
}
}
}
if (!volumePaths[0]) {
return NULL;
}
p = volumePaths;
for (;;) {
if(_tcslen(p) > 2) {
p[_tcslen(p) - 1] = _T(' ');
}
StrConcatWithSpace(p,&drives);
while (*p++);
//
//The drive letters returned are a collection of strings,
//and the end is marked with \0\0. If we reached the end,
//stop, else traverse the string list
//
if (*p == 0) {
break;
}
}
LocalFree(volumePaths);
return drives;
}
BOOLEAN
StrConcatWithSpace(
IN LPTSTR SzToAppend,
IN OUT LPTSTR *drives
)
/*++
Routine Description:
Concatenates the given string to the drive list. Note: This WILL
allocate and free memory, so don't keep pointers to the drives
passed in. Do no pass uninitialized pointers. *drives should
be NULL if empty
Arguments:
SzToAppend - string to prepend
drives - pointer to the existing drive list
Return Value:
Returns true if successful, false if not (will only fail in memory
allocation)
--*/
{
SIZE_T szLen;
SIZE_T driveLen;
LPTSTR newdrives = NULL;
ASSERT(SzToAppend != NULL);
ASSERT(drives != NULL);
szLen = (_tcslen(SzToAppend))*sizeof(_TCHAR);
if(*drives == NULL) {
driveLen = sizeof(_TCHAR) ;
} else {
driveLen = (_tcslen(*drives) + 1)*sizeof(_TCHAR);
}
newdrives = (LPTSTR)malloc(szLen+driveLen);
if( newdrives == NULL ){
return (FALSE);
}
if(*drives == NULL){
_tcscpy( newdrives, SzToAppend);
} else {
_tcscpy(newdrives, *drives);
//_tcscat(newdrives, _T(" "));
_tcscat(newdrives, SzToAppend);
}
free( *drives );
*drives = newdrives;
return (TRUE);
}
#ifdef __cplusplus
}; //extern "C"
#endif //#ifdef __cplusplus