mirror of https://github.com/tongzx/nt5src
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.
3181 lines
88 KiB
3181 lines
88 KiB
#include "vol.h"
|
|
|
|
#include "hwdev.h"
|
|
#include "hnotif.h"
|
|
#include "mtpts.h"
|
|
#include "regnotif.h"
|
|
#include "drvbase.h"
|
|
#include "dtctreg.h"
|
|
#include "users.h"
|
|
|
|
//
|
|
// ISSUE-2001/01/08-StephStm that's bad, vol should not depend on dtct...
|
|
//
|
|
#include "dtct.h"
|
|
|
|
#include "reg.h"
|
|
#include "sfstr.h"
|
|
#include "misc.h"
|
|
|
|
#pragma warning(disable: 4201)
|
|
#include <winioctl.h>
|
|
#pragma warning(default: 4201)
|
|
|
|
#include <ntddcdrm.h>
|
|
#include <ntddmmc.h>
|
|
#include <ioevent.h>
|
|
#include <shpriv.h>
|
|
|
|
#include <setupapi.h>
|
|
|
|
#include "mischlpr.h"
|
|
#include "dbg.h"
|
|
|
|
#define ARRAYSIZE(a) (sizeof((a))/sizeof((a)[0]))
|
|
|
|
#define STATE_DRIVETYPE 0x00000001
|
|
#define STATE_UPDATECONSTINFO 0x00000002
|
|
#define STATE_DEVICENUMBERINFO 0x00000004
|
|
#define STATE_DEVICEINST 0x00000008
|
|
#define STATE_HWDEVICEINST 0x00000010
|
|
#define STATE_MEDIAINFO 0x00000020
|
|
#define STATE_GVIFAILED 0x10000000
|
|
#define STATE_GFAFAILED 0x20000000
|
|
#define STATE_UPDATEHASMEDIAFAILED 0x40000000
|
|
|
|
#define INVALID_DWORD ((DWORD)-1)
|
|
|
|
#define MPFE_UNDETERMINED ((DWORD)0x0DEF0DEF)
|
|
#define MPFE_FALSE ((DWORD)0)
|
|
#define MPFE_TRUE ((DWORD)1)
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Public
|
|
// No need for the critical section, since it will not be added to the
|
|
// NamedList until init is finsihed and has succeeded. Until it's in the
|
|
// namedlist, no code can grab a pointer to this object and call it.
|
|
HRESULT CVolume::Init(LPCWSTR pszElemName)
|
|
{
|
|
HRESULT hres = _SetName(pszElemName);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
CImpersonateEveryone* pieo;
|
|
|
|
hres = CHWEventDetectorHelper::GetImpersonateEveryone(&pieo);
|
|
|
|
if (SUCCEEDED(hres) && (S_FALSE != hres))
|
|
{
|
|
hres = pieo->Impersonate();
|
|
|
|
if (SUCCEEDED(hres) && (S_FALSE != hres))
|
|
{
|
|
hres = _InitHelper(pszElemName);
|
|
|
|
pieo->RevertToSelf();
|
|
}
|
|
|
|
pieo->RCRelease();
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT _IsDeviceFullyInstalled(LPCWSTR pszDeviceIntfID, BOOL* pfDeviceFullyInstalled)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
HDEVINFO hdevinfo = SetupDiCreateDeviceInfoList(NULL, NULL);
|
|
|
|
*pfDeviceFullyInstalled = FALSE;
|
|
|
|
if (INVALID_HANDLE_VALUE != hdevinfo)
|
|
{
|
|
SP_DEVICE_INTERFACE_DATA sdid = {0};
|
|
|
|
sdid.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
|
|
|
|
if (SetupDiOpenDeviceInterface(hdevinfo, pszDeviceIntfID, 0, &sdid))
|
|
{
|
|
DWORD cbsdidd = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA) +
|
|
(MAX_DEVICE_ID_LEN * sizeof(WCHAR));
|
|
|
|
SP_DEVINFO_DATA sdd = {0};
|
|
SP_DEVICE_INTERFACE_DETAIL_DATA* psdidd =
|
|
(SP_DEVICE_INTERFACE_DETAIL_DATA*)LocalAlloc(LPTR, cbsdidd);
|
|
|
|
if (psdidd)
|
|
{
|
|
psdidd->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
|
|
sdd.cbSize = sizeof(SP_DEVINFO_DATA);
|
|
|
|
// SetupDiGetDeviceInterfaceDetail (below) requires that the
|
|
// cbSize member of SP_DEVICE_INTERFACE_DETAIL_DATA be set
|
|
// to the size of the fixed part of the structure, and to pass
|
|
// the size of the full thing as the 4th param.
|
|
|
|
if (SetupDiGetDeviceInterfaceDetail(hdevinfo, &sdid, psdidd,
|
|
cbsdidd, NULL, &sdd))
|
|
{
|
|
DWORD dw;
|
|
|
|
if (SetupDiGetDeviceRegistryProperty(hdevinfo, &sdd,
|
|
SPDRP_INSTALL_STATE, 0, (PBYTE)&dw, sizeof(dw), NULL))
|
|
{
|
|
TRACE(TF_VOLUME, TEXT(">>>> Got SPDRP_INSTALL_STATE property: 0x%08X"), dw);
|
|
|
|
if (CM_INSTALL_STATE_INSTALLED == dw)
|
|
{
|
|
*pfDeviceFullyInstalled = TRUE;
|
|
}
|
|
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
|
|
LocalFree((HLOCAL)psdidd);
|
|
}
|
|
}
|
|
|
|
SetupDiDestroyDeviceInfoList(hdevinfo);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::_InitHelper(LPCWSTR pszElemName)
|
|
{
|
|
BOOL fDeviceFullyInstalled;
|
|
HRESULT hres = _IsDeviceFullyInstalled(_pszElemName, &fDeviceFullyInstalled);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
if (!fDeviceFullyInstalled)
|
|
{
|
|
TRACE(TF_VOLUME,
|
|
TEXT("!!!!!!!!!!!! Device not fully installed!\n %s"),
|
|
pszElemName);
|
|
|
|
hres = E_FAIL;
|
|
}
|
|
else
|
|
{
|
|
HANDLE hDevice;
|
|
BOOL fCloseHandle = TRUE;
|
|
|
|
hres = _GetDeviceHandleSafe(&hDevice, FALSE);
|
|
|
|
if (SUCCEEDED(hres) && (S_FALSE != hres))
|
|
{
|
|
hres = _InitDriveType(hDevice);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
_dwState |= STATE_DRIVETYPE;
|
|
|
|
hres = S_OK;
|
|
|
|
if ((HWDTS_FIXEDDISK != _dwDriveType) &&
|
|
(HWDTS_FLOPPY35 != _dwDriveType) &&
|
|
(HWDTS_FLOPPY525 != _dwDriveType))
|
|
{
|
|
_CloseDeviceHandleSafe(hDevice);
|
|
|
|
fCloseHandle = FALSE;
|
|
|
|
// Removable disk drives + CD require access to
|
|
// the media to query all the required info
|
|
hres = _GetDeviceHandleSafe(&hDevice, TRUE);
|
|
}
|
|
|
|
if (SUCCEEDED(hres) && (S_FALSE != hres))
|
|
{
|
|
hres = _UpdateConstInfo(hDevice);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
_dwState |= STATE_UPDATECONSTINFO;
|
|
}
|
|
|
|
if ((HWDTS_FLOPPY35 != _dwDriveType) &&
|
|
(HWDTS_FLOPPY525 != _dwDriveType))
|
|
{
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
fCloseHandle = TRUE;
|
|
|
|
hres = _GetDeviceNumberInfoFromHandle(hDevice,
|
|
&_devtype, &_ulDeviceNumber,
|
|
&_ulPartitionNumber);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
if (S_FALSE != hres)
|
|
{
|
|
_dwState |= STATE_DEVICENUMBERINFO;
|
|
}
|
|
|
|
GUID guidDummy;
|
|
|
|
hres = _GetDeviceInstance(pszElemName,
|
|
&_devinst, &guidDummy);
|
|
|
|
if (SUCCEEDED(hres) && (S_FALSE != hres))
|
|
{
|
|
_dwState |= STATE_DEVICEINST;
|
|
|
|
hres = _InitHWDeviceInst();
|
|
|
|
if (SUCCEEDED(hres) && (S_FALSE != hres))
|
|
{
|
|
hres = _UpdateSoftEjectCaps();
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
hres = _UpdateRemovableDevice();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// We need to do this anyway, even if the
|
|
// DeviceNumber stuff and/or the deviceInst stuff
|
|
// fails. Otherwise we'll have a very sorry volume.
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
hres = _UpdateMediaInfo(hDevice, FALSE);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
if (S_FALSE != hres)
|
|
{
|
|
_dwState |= STATE_MEDIAINFO;
|
|
}
|
|
|
|
hres = _RegisterNotif();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
hres = _CreateMountPoints();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_HandleAccessDenied();
|
|
}
|
|
}
|
|
|
|
if (fCloseHandle)
|
|
{
|
|
_CloseDeviceHandleSafe(hDevice);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_HandleAccessDenied();
|
|
}
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
void CVolume::_HandleAccessDenied()
|
|
{
|
|
if (ERROR_ACCESS_DENIED == GetLastError())
|
|
{
|
|
_dwVolumeFlags |= HWDVF_STATE_ACCESSDENIED;
|
|
}
|
|
}
|
|
|
|
// *pdwFloppy
|
|
// 0: not a floppy
|
|
// 35: 3.5" flopy
|
|
// 525: 5.25" floppy
|
|
HRESULT _DeviceIsFloppy(HANDLE hDevice, DWORD* pdwFloppy, BOOL* pfFloppySupportsSoftEject)
|
|
{
|
|
HRESULT hres = S_FALSE;
|
|
DISK_GEOMETRY dg[12] = {0};
|
|
DWORD cbBuf = sizeof(dg);
|
|
DWORD dwReturned;
|
|
|
|
*pdwFloppy = 0;
|
|
*pfFloppySupportsSoftEject = FALSE;
|
|
|
|
// Should be IOCTL_..._DISK_GEOMETRY...
|
|
if (DeviceIoControl(hDevice, IOCTL_DISK_GET_MEDIA_TYPES,
|
|
NULL, 0, dg, cbBuf, &dwReturned, NULL))
|
|
{
|
|
DWORD cMediaInfo = dwReturned / sizeof(DISK_GEOMETRY);
|
|
|
|
for (DWORD dw = 0; !(*pdwFloppy) && (dw < cMediaInfo); ++dw)
|
|
{
|
|
switch (dg[dw].MediaType)
|
|
{
|
|
case F5_1Pt2_512: // Cap: 1200
|
|
case F5_360_512: // Cap: 360
|
|
case F5_320_512: // Cap: 360
|
|
case F5_320_1024: // Cap: 360
|
|
case F5_180_512: // Cap: 360
|
|
case F5_160_512: // Cap: 360
|
|
*pdwFloppy = 525;
|
|
break;
|
|
|
|
case F3_120M_512: // Cap: 120MB
|
|
*pfFloppySupportsSoftEject = TRUE;
|
|
|
|
case F3_1Pt44_512: // Cap: 1440
|
|
case F3_2Pt88_512: // Cap: 2880
|
|
case F3_20Pt8_512: // Cap: 2880
|
|
case F3_720_512: // Cap: 720
|
|
*pdwFloppy = 35;
|
|
break;
|
|
//
|
|
// Japanese specific device types from here.
|
|
//
|
|
case F5_1Pt23_1024: // Cap: 1200
|
|
case F5_640_512: // Cap: 260
|
|
case F5_720_512: // Cap: 360
|
|
*pdwFloppy = 525;
|
|
break;
|
|
|
|
case F3_640_512: // Cap: 720
|
|
case F3_1Pt2_512: // Cap: 1440
|
|
case F3_1Pt23_1024: // Cap: 1440
|
|
*pdwFloppy = 35;
|
|
break;
|
|
|
|
case F3_128Mb_512: // Cap: ?
|
|
case F3_230Mb_512: // Cap: ?
|
|
case F3_200Mb_512:
|
|
*pdwFloppy = 35;
|
|
break;
|
|
}
|
|
|
|
if (*pdwFloppy)
|
|
{
|
|
hres = S_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT _GetDriveTypeInfo(HANDLE hDevice, DWORD* pdwDriveType, BOOL* pfFloppy);
|
|
|
|
HRESULT CVolume::_InitDriveType(HANDLE hDevice)
|
|
{
|
|
BOOL fFloppy = FALSE;
|
|
|
|
HRESULT hr = _GetDriveTypeInfo(hDevice, &_dwDriveType, &fFloppy);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (fFloppy)
|
|
{
|
|
DWORD dwFloppy;
|
|
BOOL fFloppySupportsSoftEject;
|
|
|
|
hr = _DeviceIsFloppy(hDevice, &dwFloppy, &fFloppySupportsSoftEject);
|
|
|
|
if (SUCCEEDED(hr) && (S_FALSE != hr))
|
|
{
|
|
if (fFloppySupportsSoftEject)
|
|
{
|
|
_dwDriveCap |= HWDDC_FLOPPYSOFTEJECT;
|
|
}
|
|
|
|
switch (dwFloppy)
|
|
{
|
|
case 35:
|
|
_dwDriveType = HWDTS_FLOPPY35;
|
|
break;
|
|
case 525:
|
|
_dwDriveType = HWDTS_FLOPPY525;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT _GetRemovableDeviceInstRecurs(DEVINST devinst,
|
|
DEVINST* pdevinst)
|
|
{
|
|
BOOL fRemovable;
|
|
HRESULT hres = _DeviceInstIsRemovable(devinst, &fRemovable);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
if (fRemovable)
|
|
{
|
|
// Found it!
|
|
*pdevinst = devinst;
|
|
}
|
|
else
|
|
{
|
|
// Recurse
|
|
DEVINST devinstParent;
|
|
|
|
CONFIGRET cr = CM_Get_Parent_Ex(&devinstParent, devinst, 0,
|
|
NULL);
|
|
|
|
if (CR_SUCCESS == cr)
|
|
{
|
|
hres = _GetRemovableDeviceInstRecurs(devinstParent, pdevinst);
|
|
}
|
|
else
|
|
{
|
|
hres = S_FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT CVolume::_GetDeviceIDDisk(LPWSTR pszDeviceIDDisk,
|
|
DWORD cchDeviceIDDisk)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (_szDeviceIDDisk[0])
|
|
{
|
|
hr = SafeStrCpyN(pszDeviceIDDisk, _szDeviceIDDisk, cchDeviceIDDisk);
|
|
}
|
|
else
|
|
{
|
|
if (((ULONG)-1) != _ulDeviceNumber)
|
|
{
|
|
CNamedElemList* pnel;
|
|
hr = CHWEventDetectorHelper::GetList(HWEDLIST_DISK, &pnel);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
CNamedElemEnum* penum;
|
|
|
|
hr = pnel->GetEnum(&penum);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CNamedElem* pelem;
|
|
BOOL fFoundIt = FALSE;
|
|
|
|
while (!fFoundIt && SUCCEEDED(hr = penum->Next(&pelem)) &&
|
|
(S_FALSE != hr))
|
|
{
|
|
CDisk* pdisk = (CDisk*)pelem;
|
|
ULONG ulDeviceNumber;
|
|
|
|
hr = pdisk->GetDeviceNumber(&ulDeviceNumber);
|
|
|
|
if (SUCCEEDED(hr) && (S_FALSE != hr))
|
|
{
|
|
if (_ulDeviceNumber == ulDeviceNumber)
|
|
{
|
|
DEVICE_TYPE devtype;
|
|
|
|
hr = pdisk->GetDeviceType(&devtype);
|
|
|
|
if (SUCCEEDED(hr) && (S_FALSE != hr))
|
|
{
|
|
if (_devtype == devtype)
|
|
{
|
|
// Use me!
|
|
DWORD cchReq;
|
|
|
|
hr = pelem->GetName(pszDeviceIDDisk,
|
|
cchDeviceIDDisk, &cchReq);
|
|
|
|
fFoundIt = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pelem->RCRelease();
|
|
}
|
|
|
|
penum->RCRelease();
|
|
}
|
|
|
|
pnel->RCRelease();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && (S_FALSE != hr))
|
|
{
|
|
if (FAILED(SafeStrCpyN(_szDeviceIDDisk, pszDeviceIDDisk,
|
|
ARRAYSIZE(_szDeviceIDDisk))))
|
|
{
|
|
_szDeviceIDDisk[0] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::_InitHWDeviceInst()
|
|
{
|
|
WCHAR szDeviceIDDisk[MAX_DEVICEID];
|
|
|
|
HRESULT hr = _GetDeviceIDDisk(szDeviceIDDisk, ARRAYSIZE(szDeviceIDDisk));
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
DEVINST devinstFinal = 0;
|
|
GUID guidDummy;
|
|
|
|
if (S_FALSE != hr)
|
|
{
|
|
DEVINST devinstDisk;
|
|
|
|
hr = _GetDeviceInstance(szDeviceIDDisk, &devinstDisk, &guidDummy);
|
|
|
|
if (SUCCEEDED(hr) && (S_FALSE != hr))
|
|
{
|
|
hr = _GetRemovableDeviceInstRecurs(devinstDisk, &devinstFinal);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (S_FALSE == hr)
|
|
{
|
|
// Maybe this is not a removable device (not talking
|
|
// about removable disk).
|
|
BOOL fFoundProp;
|
|
WCHAR szProp[1];
|
|
ULONG ulData = sizeof(szProp);
|
|
|
|
// First check if the disk interface has customn properties associated with it.
|
|
CONFIGRET cr = CM_Get_DevNode_Custom_Property(devinstDisk, TEXT("DeviceGroup"),
|
|
NULL, (PBYTE)szProp, &ulData, 0);
|
|
|
|
if ((CR_SUCCESS == cr) || (CR_BUFFER_SMALL == cr))
|
|
{
|
|
fFoundProp = TRUE;
|
|
}
|
|
else
|
|
{
|
|
ulData = sizeof(szProp);
|
|
cr = CM_Get_DevNode_Custom_Property(devinstDisk, TEXT("Icons"),
|
|
NULL, (PBYTE)szProp, &ulData, 0);
|
|
|
|
if ((CR_SUCCESS == cr) || (CR_BUFFER_SMALL == cr))
|
|
{
|
|
fFoundProp = TRUE;
|
|
}
|
|
else
|
|
{
|
|
fFoundProp = FALSE;
|
|
}
|
|
}
|
|
|
|
if (fFoundProp)
|
|
{
|
|
devinstFinal = devinstDisk;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
// Let's get the parent devinst of this devinst.
|
|
if (CR_SUCCESS == CM_Get_Parent_Ex(&devinstFinal,
|
|
devinstDisk, 0, NULL))
|
|
{
|
|
hr = S_OK;
|
|
DIAGNOSTIC((TEXT("[0303]Got DeviceInst from parent of disk")));
|
|
|
|
TRACE(TF_VOLUME,
|
|
TEXT("HWDevInst: Got devinst from parent of Disk for Disk\n %s"),
|
|
_pszElemName);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DIAGNOSTIC((TEXT("[0302]Got DeviceInst from Removable Device")));
|
|
|
|
TRACE(TF_VOLUME,
|
|
TEXT("HWDevInst: Got devinst from Removable Device for Volume\n %s"),
|
|
_pszElemName);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DIAGNOSTIC((TEXT("[0304]Did NOT get DeviceInst from the disk")));
|
|
|
|
TRACE(TF_VOLUME,
|
|
TEXT("HWDevInst: Did not get a devinst from the Disk for Volume\n %s"),
|
|
_pszElemName);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DIAGNOSTIC((TEXT("[0305]Got DeviceInst from Volume itself")));
|
|
|
|
TRACE(TF_VOLUME,
|
|
TEXT("HWDevInst: Did not get a Disk, get devinst from Volume itself for Volume\n (%s)"),
|
|
_pszElemName);
|
|
|
|
// We did not get a device number for the volume
|
|
// Let's get the device instance from the volume then, maybe there's no
|
|
// volume-disk-device hierarchy
|
|
hr = _GetDeviceInstance(_pszElemName, &devinstFinal, &guidDummy);
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && (S_FALSE != hr))
|
|
{
|
|
hr = _hwdevinst.Init(devinstFinal);
|
|
|
|
if (SUCCEEDED(hr) && (S_FALSE != hr))
|
|
{
|
|
hr = _hwdevinst.InitInterfaceGUID(&guidVolumeClass);
|
|
|
|
if (SUCCEEDED(hr) && (S_FALSE != hr))
|
|
{
|
|
_fHWDevInstInited = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::GetHWDeviceInst(CHWDeviceInst** pphwdevinst)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (_fHWDevInstInited)
|
|
{
|
|
*pphwdevinst = &_hwdevinst;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
*pphwdevinst = NULL;
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::GetDeviceNumber(ULONG* puldeviceNumber)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (((DEVICE_TYPE)-1) != _devtype)
|
|
{
|
|
*puldeviceNumber = _ulDeviceNumber;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::GetDeviceType(DEVICE_TYPE* pdevtype)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (((DEVICE_TYPE)-1) != _devtype)
|
|
{
|
|
*pdevtype = _devtype;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::_ShouldTryAutoplay(BOOL* pfTry)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (_dwMediaState & HWDMS_PRESENT)
|
|
{
|
|
if (_dwMediaState & HWDMS_FORMATTED)
|
|
{
|
|
if (!(_dwMediaCap & HWDMC_HASDVDMOVIE))
|
|
{
|
|
if (!(_dwMediaCap & HWDMC_HASAUTORUNINF) ||
|
|
(_dwMediaCap & HWDMC_HASUSEAUTOPLAY))
|
|
{
|
|
WCHAR szVolumeGUID[MAX_PATH + 50];
|
|
LPWSTR pszFile;
|
|
|
|
if (_dwMediaCap & HWDMC_HASUSEAUTOPLAY)
|
|
{
|
|
DIAGNOSTIC((TEXT("[0316]Autorun.inf, BUT as a UseAutoPLAY entry -> try Autoplay!")));
|
|
}
|
|
|
|
hr = SafeStrCpyN(szVolumeGUID, _szVolumeGUID,
|
|
ARRAYSIZE(szVolumeGUID));
|
|
|
|
*pfTry = TRUE;
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
HKEY hkey;
|
|
pszFile = szVolumeGUID + lstrlen(szVolumeGUID);
|
|
|
|
TRACE(TF_LEAK, TEXT("Special files - BEGIN"));
|
|
|
|
hr = _RegOpenKey(HKEY_LOCAL_MACHINE,
|
|
TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\AutoplayHandlers\\CancelAutoplay\\Files"),
|
|
&hkey);
|
|
|
|
if (SUCCEEDED(hr) && (S_FALSE != hr))
|
|
{
|
|
DWORD dwIndex = 0;
|
|
|
|
while ((*pfTry) && SUCCEEDED(hr = _RegEnumStringValue(hkey, dwIndex, pszFile,
|
|
(DWORD)(ARRAYSIZE(szVolumeGUID) - (pszFile - szVolumeGUID)))) &&
|
|
(S_FALSE != hr))
|
|
{
|
|
WIN32_FIND_DATA w32fd;
|
|
HANDLE h;
|
|
|
|
h = FindFirstFile(szVolumeGUID, &w32fd);
|
|
|
|
if (INVALID_HANDLE_VALUE != h)
|
|
{
|
|
FindClose(h);
|
|
|
|
*pfTry = FALSE;
|
|
|
|
DIAGNOSTIC((TEXT("[0307]Detected special file : '%s' (%s) -> No Autoplay!"),
|
|
w32fd.cFileName, pszFile));
|
|
|
|
TRACE(TF_VOLUME,
|
|
TEXT("Detected %s (%s) -> No Autoplay!"),
|
|
w32fd.cFileName , pszFile);
|
|
}
|
|
|
|
++dwIndex;
|
|
}
|
|
|
|
_RegCloseKey(hkey);
|
|
}
|
|
|
|
TRACE(TF_LEAK, TEXT("Special files - END"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DIAGNOSTIC((TEXT("[0313]Autorun.inf -> No Content Autoplay!")));
|
|
hr = S_OK;
|
|
*pfTry = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DIAGNOSTIC((TEXT("[0312]DVD Movie -> No Content Autoplay!")));
|
|
hr = S_OK;
|
|
*pfTry = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DIAGNOSTIC((TEXT("[0317]Media *NOT* formatted -> No Content Autoplay!")));
|
|
hr = S_OK;
|
|
*pfTry = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DIAGNOSTIC((TEXT("[0306]NO media -> No Content Autoplay!")));
|
|
hr = S_OK;
|
|
*pfTry = FALSE;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::_HandleMediaArrival()
|
|
{
|
|
HANDLE hDevice;
|
|
|
|
DIAGNOSTIC((TEXT("[0002]Processing Media Arrival Event: %s"), _pszElemName));
|
|
|
|
HRESULT hr = _GetDeviceHandleSafe(&hDevice, TRUE);
|
|
|
|
if (SUCCEEDED(hr) && (S_FALSE != hr))
|
|
{
|
|
_dwMediaPresentFromEvent = MPFE_TRUE;
|
|
|
|
_cs.Enter();
|
|
|
|
hr = _UpdateMediaInfo(hDevice, TRUE);
|
|
|
|
_cs.Leave();
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (_fHWDevInstInited)
|
|
{
|
|
// Try Autoplay?
|
|
BOOL fTryAutoplay;
|
|
|
|
hr = _ShouldTryAutoplay(&fTryAutoplay);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (fTryAutoplay)
|
|
{
|
|
BOOL fHasHandler;
|
|
|
|
hr = CHWEventDetectorImpl::HandleVolumeMediaEvent(
|
|
_pszElemName, &_hwdevinst, TEXT("MediaArrival"),
|
|
&fHasHandler);
|
|
|
|
if (SUCCEEDED(hr) && fHasHandler)
|
|
{
|
|
_dwVolumeFlags |= HWDVF_STATE_HASAUTOPLAYHANDLER;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_dwVolumeFlags |= HWDVF_STATE_DONOTSNIFFCONTENT;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DIAGNOSTIC((TEXT("[0308]Cannot find hardware device for this volume -> No Autoplay!")));
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_AdviseVolumeChangeHelper(FALSE);
|
|
}
|
|
}
|
|
|
|
_CloseDeviceHandleSafe(hDevice);
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::_AdviseVolumeMountingEvent(DWORD dwEvent)
|
|
{
|
|
return CHardwareDevicesImpl::_AdviseVolumeMountingEvent(_pszElemName,
|
|
dwEvent);
|
|
}
|
|
|
|
HRESULT CVolume::_AdviseVolumeChangeHelper(BOOL fAdded)
|
|
{
|
|
HRESULT hr;
|
|
VOLUMEINFO2* pvolinfo2;
|
|
|
|
_cs.Enter();
|
|
|
|
hr = _GetVOLUMEINFO2(&pvolinfo2);
|
|
|
|
_cs.Leave();
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPWSTR pszMtPts;
|
|
DWORD cchMtPts;
|
|
hr = _GetMountPoints(&pszMtPts, &cchMtPts);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CHardwareDevicesImpl::_AdviseVolumeArrivedOrUpdated(pvolinfo2,
|
|
pszMtPts, cchMtPts, fAdded);
|
|
|
|
if (S_FALSE != hr)
|
|
{
|
|
LocalFree((HLOCAL)pszMtPts);
|
|
}
|
|
}
|
|
|
|
_FreeMemoryChunk<VOLUMEINFO2*>(pvolinfo2);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::_HandleMediaRemoval()
|
|
{
|
|
HRESULT hr;
|
|
|
|
DIAGNOSTIC((TEXT("[0003]Processing Media Removal Event: %s"), _pszElemName));
|
|
|
|
_dwMediaPresentFromEvent = MPFE_FALSE;
|
|
|
|
_cs.Enter();
|
|
|
|
hr = _UpdateMediaInfoOnRemove();
|
|
|
|
_cs.Leave();
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_AdviseVolumeChangeHelper(FALSE);
|
|
|
|
if (_fHWDevInstInited)
|
|
{
|
|
// Useless in this case, since there's no content, so we won't sniff
|
|
BOOL fHasHandler;
|
|
|
|
hr = CHWEventDetectorImpl::HandleVolumeMediaEvent(_pszElemName,
|
|
&_hwdevinst, TEXT("MediaRemoval"), &fHasHandler);
|
|
}
|
|
else
|
|
{
|
|
DIAGNOSTIC((TEXT("[0309]Cannot find hardware device for this volume -> No Autoplay!")));
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::_HandleVolumeChange()
|
|
{
|
|
HANDLE hDevice;
|
|
HRESULT hr = _GetDeviceHandleSafe(&hDevice, TRUE);
|
|
|
|
if (SUCCEEDED(hr) && (S_FALSE != hr))
|
|
{
|
|
_cs.Enter();
|
|
|
|
hr = _UpdateMediaInfo(hDevice, TRUE);
|
|
|
|
_cs.Leave();
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_AdviseVolumeChangeHelper(FALSE);
|
|
}
|
|
|
|
_CloseDeviceHandleSafe(hDevice);
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::HNTHandleEvent(DEV_BROADCAST_HANDLE* pdbh,
|
|
DWORD dwEventType)
|
|
{
|
|
HRESULT hres = S_OK;
|
|
|
|
if (DBT_CUSTOMEVENT == dwEventType)
|
|
{
|
|
if (GUID_IO_MEDIA_ARRIVAL == pdbh->dbch_eventguid)
|
|
{
|
|
// This notification arrive very soon when the media is inserted
|
|
// in the device. Often the Volume driver has not been loaded on
|
|
// the drive and calls like GetVolumeInformation will fail.
|
|
// Instead of doing something right now, flag the event, and
|
|
// process on the first GUID_IO_VOLUME_MOUNT below.
|
|
TRACE(TF_SHHWDTCTDTCT,
|
|
TEXT("****CVolume GUID_IO_MEDIA_ARRIVAL"));
|
|
|
|
hres = _HandleMediaArrival();
|
|
_fProcessMediaArrived = TRUE;
|
|
}
|
|
else if (GUID_IO_MEDIA_REMOVAL == pdbh->dbch_eventguid)
|
|
{
|
|
TRACE(TF_SHHWDTCTDTCT,
|
|
TEXT("****CVolume GUID_IO_MEDIA_REMOVAL"));
|
|
|
|
hres = _HandleMediaRemoval();
|
|
}
|
|
else if (GUID_IO_VOLUME_MOUNT == pdbh->dbch_eventguid)
|
|
{
|
|
TRACE(TF_SHHWDTCTDTCT,
|
|
TEXT("****CVolume GUID_IO_VOLUME_MOUNT"));
|
|
|
|
if (_fProcessMediaArrived)
|
|
{
|
|
_fProcessMediaArrived = FALSE;
|
|
|
|
// hres = _HandleMediaArrival();
|
|
}
|
|
|
|
if (_dwVolumeFlags & HWDVF_STATE_DISMOUNTED)
|
|
{
|
|
_dwVolumeFlags &= ~HWDVF_STATE_DISMOUNTED;
|
|
|
|
hres = _AdviseVolumeMountingEvent(
|
|
SHHARDWAREEVENT_VOLUMEMOUNTED);
|
|
}
|
|
}
|
|
else if (GUID_IO_VOLUME_NAME_CHANGE == pdbh->dbch_eventguid)
|
|
{
|
|
TRACE(TF_SHHWDTCTDTCT,
|
|
TEXT("****CVolume GUID_IO_VOLUME_NAME_CHANGE"));
|
|
|
|
_cs.Enter();
|
|
|
|
hres = _UpdateMountPoints();
|
|
|
|
_cs.Leave();
|
|
}
|
|
else if (GUID_IO_VOLUME_CHANGE == pdbh->dbch_eventguid)
|
|
{
|
|
TRACE(TF_SHHWDTCTDTCT,
|
|
TEXT("****CVolume GUID_IO_VOLUME_CHANGE"));
|
|
|
|
hres = _HandleVolumeChange();
|
|
}
|
|
else if (GUID_IO_VOLUME_DISMOUNT == pdbh->dbch_eventguid)
|
|
{
|
|
_dwVolumeFlags |= HWDVF_STATE_DISMOUNTED;
|
|
|
|
hres = _AdviseVolumeMountingEvent(
|
|
SHHARDWAREEVENT_VOLUMEDISMOUNTED);
|
|
}
|
|
else if (GUID_IO_VOLUME_DISMOUNT_FAILED == pdbh->dbch_eventguid)
|
|
{
|
|
_dwVolumeFlags &= ~HWDVF_STATE_DISMOUNTED;
|
|
|
|
hres = _AdviseVolumeMountingEvent(
|
|
SHHARDWAREEVENT_VOLUMEMOUNTED);
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT CVolume::_GetDeviceHandleSafe(HANDLE* phDevice,
|
|
BOOL fGenericReadRequired)
|
|
{
|
|
ASSERT(!_hdevnotify);
|
|
HRESULT hr;
|
|
HANDLE hDevice = _GetDeviceHandle(_pszElemName,
|
|
fGenericReadRequired ? GENERIC_READ : FILE_READ_ATTRIBUTES);
|
|
|
|
*phDevice = INVALID_HANDLE_VALUE;
|
|
|
|
if (INVALID_HANDLE_VALUE != hDevice)
|
|
{
|
|
DEV_BROADCAST_HANDLE dbhNotifFilter = {0};
|
|
|
|
dbhNotifFilter.dbch_size = sizeof(DEV_BROADCAST_HANDLE);
|
|
dbhNotifFilter.dbch_devicetype = DBT_DEVTYP_HANDLE;
|
|
dbhNotifFilter.dbch_handle = hDevice;
|
|
|
|
hr = CHWEventDetectorHelper::RegisterDeviceNotification(
|
|
&dbhNotifFilter, &_hdevnotify, FALSE);
|
|
|
|
if (SUCCEEDED(hr) && (S_FALSE != hr))
|
|
{
|
|
*phDevice = hDevice;
|
|
|
|
#ifdef DEBUG
|
|
_fGenericReadRequired = fGenericReadRequired;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
_CloseDeviceHandle(hDevice);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::_CloseDeviceHandleSafe(HANDLE hDevice)
|
|
{
|
|
ASSERT(_hdevnotify);
|
|
|
|
_CloseDeviceHandle(hDevice);
|
|
UnregisterDeviceNotification(_hdevnotify);
|
|
|
|
_hdevnotify = NULL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CVolume::_UnregisterNotif()
|
|
{
|
|
CNamedElemList* pnel;
|
|
HRESULT hres = CHWEventDetectorHelper::GetList(HWEDLIST_HANDLENOTIF,
|
|
&pnel);
|
|
|
|
if (S_OK == hres)
|
|
{
|
|
hres = pnel->Remove(_pszElemName);
|
|
|
|
if (_szDeviceIDDisk[0])
|
|
{
|
|
hres = pnel->Remove(_szDeviceIDDisk);
|
|
}
|
|
|
|
pnel->RCRelease();
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT CVolume::_RegisterNotif()
|
|
{
|
|
CNamedElemList* pnel;
|
|
|
|
HRESULT hres = CHWEventDetectorHelper::GetList(HWEDLIST_HANDLENOTIF,
|
|
&pnel);
|
|
|
|
if (S_OK == hres)
|
|
{
|
|
CNamedElem* pelem;
|
|
|
|
// register for handle notification
|
|
hres = pnel->GetOrAdd(_pszElemName, &pelem);
|
|
|
|
// Was it already there or added?
|
|
if (SUCCEEDED(hres) && (S_FALSE == hres))
|
|
{
|
|
// Added. Initialize it.
|
|
CHandleNotif* phnotif = (CHandleNotif*)pelem;
|
|
|
|
hres = phnotif->InitNotif(this);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
if (HWDTS_REMOVABLEDISK == _dwDriveType)
|
|
{
|
|
// Removable disk drives receive their notifications for
|
|
// media arrival/removal on the disk interface, not the
|
|
// volume one, so register for this too.
|
|
WCHAR szDeviceIDDisk[MAX_DEVICEID];
|
|
|
|
hres = _GetDeviceIDDisk(szDeviceIDDisk,
|
|
ARRAYSIZE(szDeviceIDDisk));
|
|
|
|
if (SUCCEEDED(hres) && (S_FALSE != hres))
|
|
{
|
|
CNamedElem* pelem2;
|
|
|
|
// register for handle notification
|
|
hres = pnel->GetOrAdd(szDeviceIDDisk, &pelem2);
|
|
|
|
// Was it already there or added?
|
|
if (SUCCEEDED(hres) && (S_FALSE == hres))
|
|
{
|
|
// Added. Initialize it.
|
|
CHandleNotif* phnotif2 = (CHandleNotif*)pelem2;
|
|
|
|
hres = phnotif2->InitNotif(this);
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
pnel->Remove(szDeviceIDDisk);
|
|
}
|
|
|
|
pelem2->RCRelease();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
pnel->Remove(_pszElemName);
|
|
}
|
|
|
|
pelem->RCRelease();
|
|
}
|
|
|
|
pnel->RCRelease();
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT CVolume::_RemoveMtPt(LPWSTR pszMtPt)
|
|
{
|
|
CNamedElemList* pnel;
|
|
HRESULT hr = CHWEventDetectorHelper::GetList(HWEDLIST_MTPT, &pnel);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
hr = pnel->Remove(pszMtPt);
|
|
|
|
pnel->RCRelease();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::_CreateMtPt(LPWSTR pszMtPt)
|
|
{
|
|
CNamedElemList* pnel;
|
|
HRESULT hres = CHWEventDetectorHelper::GetList(HWEDLIST_MTPT, &pnel);
|
|
|
|
if (S_OK == hres)
|
|
{
|
|
CNamedElem* pelem;
|
|
hres = pnel->GetOrAdd(pszMtPt, &pelem);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
// Init one way or the other
|
|
CMtPt* pmtpt = (CMtPt*)pelem;
|
|
|
|
hres = pmtpt->InitVolume(_pszElemName);
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
pnel->Remove(pszMtPt);
|
|
}
|
|
|
|
pelem->RCRelease();
|
|
}
|
|
|
|
pnel->RCRelease();
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT CVolume::_AdviseMountPointHelper(LPCWSTR pszMountPoint, BOOL fAdded)
|
|
{
|
|
// I'd like to not call this from outside the crit sect
|
|
ASSERT(_cs.IsInside());
|
|
|
|
WCHAR szDeviceIDVolume[MAX_DEVICEID];
|
|
DWORD cchReq;
|
|
|
|
HRESULT hr = GetName(szDeviceIDVolume, ARRAYSIZE(szDeviceIDVolume), &cchReq);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CHardwareDevicesImpl::_AdviseMountPointHelper(pszMountPoint,
|
|
szDeviceIDVolume, fAdded);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::_UpdateMountPoints()
|
|
{
|
|
LPWSTR pszMtPtNew;
|
|
DWORD cchMtPtNew;
|
|
HRESULT hr = _GetMountPoints(&pszMtPtNew, &cchMtPtNew);
|
|
|
|
#ifdef DEBUG
|
|
if (_pszMountPoints)
|
|
{
|
|
TRACE(TF_VOLUME, TEXT("_UpdateMountPoints: OLD mountPoints for %s:"), _pszElemName);
|
|
|
|
for (LPWSTR psz = _pszMountPoints; *psz; psz += lstrlen(psz) + 1)
|
|
{
|
|
TRACE(TF_VOLUME, TEXT(" %s"), psz);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (S_FALSE != hr)
|
|
{
|
|
#ifdef DEBUG
|
|
TRACE(TF_VOLUME, TEXT("_UpdateMountPoints: NEW mountPoints:"));
|
|
|
|
for (LPWSTR psz = pszMtPtNew; *psz; psz += lstrlen(psz) + 1)
|
|
{
|
|
TRACE(TF_VOLUME, TEXT(" %s"), psz);
|
|
}
|
|
#endif
|
|
// Was there at least one?
|
|
if (_pszMountPoints)
|
|
{
|
|
// Yep, find the removed ones
|
|
for (LPWSTR pszOld = _pszMountPoints; *pszOld;
|
|
pszOld += lstrlen(pszOld) + 1)
|
|
{
|
|
BOOL fFoundInNew = FALSE;
|
|
|
|
for (LPWSTR pszNew = pszMtPtNew; !fFoundInNew && *pszNew;
|
|
pszNew += lstrlen(pszNew) + 1)
|
|
{
|
|
if (!lstrcmpi(pszNew, pszOld))
|
|
{
|
|
fFoundInNew = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!fFoundInNew)
|
|
{
|
|
TRACE(TF_VOLUME, TEXT("_UpdateMountPoints: Found DELETED one: %s"), pszOld);
|
|
|
|
// That's a deleted one
|
|
_RemoveMtPt(pszOld);
|
|
|
|
_AdviseMountPointHelper(pszOld, FALSE);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TRACE(TF_VOLUME, TEXT("_UpdateMountPoints: There was NO mountpoints before"));
|
|
}
|
|
|
|
// Find the new ones
|
|
for (LPWSTR pszNew = pszMtPtNew; *pszNew;
|
|
pszNew += lstrlen(pszNew) + 1)
|
|
{
|
|
BOOL fFoundInOld = FALSE;
|
|
|
|
if (_pszMountPoints)
|
|
{
|
|
for (LPWSTR pszOld = _pszMountPoints;
|
|
!fFoundInOld && *pszOld; pszOld += lstrlen(pszOld) + 1)
|
|
{
|
|
if (!lstrcmpi(pszNew, pszOld))
|
|
{
|
|
fFoundInOld = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!fFoundInOld)
|
|
{
|
|
TRACE(TF_VOLUME, TEXT("_UpdateMountPoints: Found ADDED one: %s"), pszNew);
|
|
|
|
// That's a new one
|
|
_CreateMtPt(pszNew);
|
|
|
|
_AdviseMountPointHelper(pszNew, TRUE);
|
|
}
|
|
}
|
|
|
|
LocalFree(_pszMountPoints);
|
|
_pszMountPoints = pszMtPtNew;
|
|
_cchMountPoints = cchMtPtNew;
|
|
}
|
|
else
|
|
{
|
|
TRACE(TF_VOLUME, TEXT("_UpdateMountPoints: NO MountPoints left, remove all old ones"));
|
|
|
|
if (_pszMountPoints && *_pszMountPoints)
|
|
{
|
|
for (LPWSTR pszOld = _pszMountPoints; *pszOld;
|
|
pszOld += lstrlen(pszOld) + 1)
|
|
{
|
|
_RemoveMtPt(pszOld);
|
|
|
|
_AdviseMountPointHelper(pszOld, FALSE);
|
|
}
|
|
|
|
LocalFree(_pszMountPoints);
|
|
_pszMountPoints = NULL;
|
|
_cchMountPoints = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::GetAllMountPoints(LPWSTR* ppsz)
|
|
{
|
|
HRESULT hr;
|
|
|
|
_cs.Enter();
|
|
|
|
if (_cchMountPoints && _pszMountPoints)
|
|
{
|
|
*ppsz = (LPWSTR)LocalAlloc(LPTR, _cchMountPoints * sizeof(WCHAR));
|
|
|
|
if (*ppsz)
|
|
{
|
|
CopyMemory(*ppsz, _pszMountPoints, _cchMountPoints * sizeof(WCHAR));
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
_cs.Leave();
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::_CreateMountPoints()
|
|
{
|
|
HRESULT hr = _GetMountPoints(&_pszMountPoints, &_cchMountPoints);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (S_FALSE != hr)
|
|
{
|
|
for (LPWSTR psz = _pszMountPoints; *psz;
|
|
psz += lstrlen(psz) + 1)
|
|
{
|
|
_CreateMtPt(psz);
|
|
// go on even if error
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// Caller must free returned data using LocalFree
|
|
HRESULT CVolume::_GetMountPoints(LPWSTR* ppsz, DWORD* pcch)
|
|
{
|
|
HRESULT hr;
|
|
LPWSTR psz = NULL;
|
|
DWORD cch;
|
|
|
|
*ppsz = NULL;
|
|
*pcch = 0;
|
|
|
|
if (GetVolumePathNamesForVolumeName(_szVolumeGUID, NULL, 0, &cch))
|
|
{
|
|
// no mountpoint, we're done
|
|
hr = S_FALSE;
|
|
}
|
|
else
|
|
{
|
|
// Expected, even wanted...
|
|
if (ERROR_MORE_DATA == GetLastError())
|
|
{
|
|
psz = (LPWSTR)LocalAlloc(LPTR, cch * sizeof(WCHAR));
|
|
|
|
if (psz)
|
|
{
|
|
if (GetVolumePathNamesForVolumeName(_szVolumeGUID,
|
|
psz, cch, &cch))
|
|
{
|
|
*ppsz = psz;
|
|
*pcch = cch;
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
LocalFree(psz);
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT _DeviceMediaIsAccessible(HANDLE hDevice, BOOL* pfAccessible)
|
|
{
|
|
HRESULT hres = S_FALSE;
|
|
DWORD dwDummy;
|
|
|
|
*pfAccessible = FALSE;
|
|
|
|
// requires GENERIC_READ access on the handle
|
|
BOOL b = DeviceIoControl(hDevice, IOCTL_STORAGE_CHECK_VERIFY, NULL, 0, NULL, 0, &dwDummy, NULL);
|
|
if (ERROR_MEDIA_CHANGED == GetLastError())
|
|
{
|
|
// try one more time, ERROR_MEDIA_CHANGED means it's still pending for a little bit.
|
|
b = DeviceIoControl(hDevice, IOCTL_STORAGE_CHECK_VERIFY, NULL, 0, NULL, 0, &dwDummy, NULL);
|
|
}
|
|
|
|
if (b)
|
|
{
|
|
*pfAccessible = TRUE;
|
|
hres = S_OK;
|
|
}
|
|
else
|
|
{
|
|
// ERROR_NOT_READY == GetLastError() means no media
|
|
if (ERROR_NOT_READY == GetLastError())
|
|
{
|
|
hres = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hres = S_FALSE;
|
|
}
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
HRESULT CVolume::_UpdateHasMedia(HANDLE hDevice)
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
|
|
switch (_dwDriveType)
|
|
{
|
|
case HWDTS_FIXEDDISK:
|
|
_dwMediaState |= HWDMS_PRESENT;
|
|
hr = S_OK;
|
|
break;
|
|
|
|
case HWDTS_REMOVABLEDISK:
|
|
case HWDTS_CDROM:
|
|
{
|
|
#if 0
|
|
This does not work on my laptop
|
|
if (_dwDriveCap & HWDDC_CAPABILITY_SUPPORTDETECTION)
|
|
{
|
|
// It's MMC2
|
|
if (_dwMediaCap & (HWDMC_CDROM | HWDMC_CDRECORDABLE |
|
|
HWDMC_CDREWRITABLE | HWDMC_DVDROM | HWDMC_DVDRECORDABLE |
|
|
HWDMC_DVDRAM))
|
|
{
|
|
_dwMediaState |= HWDMS_PRESENT;
|
|
}
|
|
else
|
|
{
|
|
_dwMediaState &= ~HWDMS_PRESENT;
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
if (MPFE_UNDETERMINED != _dwMediaPresentFromEvent)
|
|
{
|
|
hr = S_OK;
|
|
|
|
if (MPFE_TRUE == _dwMediaPresentFromEvent)
|
|
{
|
|
_dwMediaState |= HWDMS_PRESENT;
|
|
}
|
|
else
|
|
{
|
|
_dwMediaState &= ~HWDMS_PRESENT;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BOOL fAccessible;
|
|
|
|
ASSERT(_fGenericReadRequired);
|
|
|
|
hr = _DeviceMediaIsAccessible(hDevice, &fAccessible);
|
|
|
|
if (SUCCEEDED(hr) && (S_FALSE != hr))
|
|
{
|
|
if (fAccessible)
|
|
{
|
|
_dwMediaState |= HWDMS_PRESENT;
|
|
}
|
|
else
|
|
{
|
|
_dwMediaState &= ~HWDMS_PRESENT;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_dwMediaState &= ~HWDMS_PRESENT;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
// ISSUE-2000/10/23-StephStm: We do not handle CD Changer, maybe we should
|
|
//
|
|
// case HWDTS_CDCHANGER:
|
|
case HWDTS_FLOPPY35:
|
|
case HWDTS_FLOPPY525:
|
|
_dwMediaState &= ~HWDMS_PRESENT;
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::_ExtractAutorunIconAndLabel()
|
|
{
|
|
WCHAR szInfFile[MAX_PATH + 50];
|
|
LPWSTR pszNext;
|
|
DWORD cchLeft;
|
|
|
|
HRESULT hr = SafeStrCpyNEx(szInfFile, _szVolumeGUID, ARRAYSIZE(szInfFile),
|
|
&pszNext, &cchLeft);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SafeStrCpyN(pszNext, TEXT("Autorun.inf"), cchLeft);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
WCHAR szDummy[4];
|
|
#if defined(_X86_)
|
|
LPWSTR pszSection = TEXT("AutoRun.x86");
|
|
#elif defined(_AMD64_)
|
|
LPWSTR pszSection = TEXT("AutoRun.Amd64");
|
|
#elif defined(_IA64_)
|
|
LPWSTR pszSection = TEXT("AutoRun.Ia64");
|
|
#else
|
|
#error "No Target Architecture"
|
|
#endif
|
|
|
|
// Flush some buffer somewhere
|
|
WritePrivateProfileString(NULL, NULL, NULL, szInfFile);
|
|
|
|
if (!GetPrivateProfileString(pszSection, TEXT("Icon"), TEXT(""),
|
|
_szAutorunIconLocation, ARRAYSIZE(_szAutorunIconLocation),
|
|
szInfFile))
|
|
{
|
|
pszSection = TEXT("AutoRun");
|
|
|
|
_HandleAccessDenied();
|
|
|
|
if (!GetPrivateProfileString(pszSection, TEXT("Icon"),
|
|
TEXT(""), _szAutorunIconLocation,
|
|
ARRAYSIZE(_szAutorunIconLocation), szInfFile))
|
|
{
|
|
_szAutorunIconLocation[0] = 0;
|
|
_HandleAccessDenied();
|
|
}
|
|
}
|
|
|
|
if (!GetPrivateProfileString(pszSection, TEXT("Label"), TEXT(""),
|
|
_szAutorunLabel, ARRAYSIZE(_szAutorunLabel), szInfFile))
|
|
{
|
|
_szAutorunLabel[0] = 0;
|
|
_HandleAccessDenied();
|
|
}
|
|
|
|
if (GetPrivateProfileString(pszSection, TEXT("Open"), TEXT(""),
|
|
szDummy, ARRAYSIZE(szDummy), szInfFile) ||
|
|
GetPrivateProfileString(pszSection, TEXT("ShellExecute"), TEXT(""),
|
|
szDummy, ARRAYSIZE(szDummy), szInfFile))
|
|
{
|
|
_dwMediaCap |= HWDMC_HASAUTORUNCOMMAND;
|
|
}
|
|
else
|
|
{
|
|
_HandleAccessDenied();
|
|
}
|
|
|
|
if (GetPrivateProfileString(pszSection, TEXT("UseAutoPLAY"), TEXT(""),
|
|
szDummy, ARRAYSIZE(szDummy), szInfFile))
|
|
{
|
|
_dwMediaCap |= HWDMC_HASUSEAUTOPLAY;
|
|
}
|
|
else
|
|
{
|
|
_HandleAccessDenied();
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::_UpdateSpecialFilePresence()
|
|
{
|
|
struct SPECIALFILEINFO
|
|
{
|
|
LPCWSTR pszFile;
|
|
DWORD dwCapBit;
|
|
};
|
|
|
|
HRESULT hr;
|
|
WCHAR szPath[50 + 1 + ARRAYSIZE(TEXT("video_ts\\video_ts.ifo"))];
|
|
|
|
static const SPECIALFILEINFO rgsfi[] =
|
|
{
|
|
{ TEXT("autorun.inf"), HWDMC_HASAUTORUNINF },
|
|
{ TEXT("desktop.ini"), HWDMC_HASDESKTOPINI },
|
|
{ TEXT("video_ts\\video_ts.ifo"), HWDMC_HASDVDMOVIE },
|
|
};
|
|
|
|
LPWSTR pszNext;
|
|
DWORD cchLeft;
|
|
|
|
hr = SafeStrCpyNEx(szPath, _szVolumeGUID,
|
|
ARRAYSIZE(szPath), &pszNext, &cchLeft);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
for (DWORD dw = 0; dw < ARRAYSIZE(rgsfi); ++dw)
|
|
{
|
|
hr = SafeStrCpyN(pszNext, rgsfi[dw].pszFile, cchLeft);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
DWORD dwGFA = GetFileAttributes(szPath);
|
|
|
|
if (-1 != dwGFA)
|
|
{
|
|
_dwMediaCap |= (rgsfi[dw].dwCapBit);
|
|
}
|
|
else
|
|
{
|
|
_HandleAccessDenied();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// To fix bug 425431
|
|
if (HWDMC_HASDVDMOVIE & _dwMediaCap)
|
|
{
|
|
// This better be a CD/DVD drive.
|
|
if (HWDTS_CDROM != _dwDriveType)
|
|
{
|
|
// No. Remove the flag otherwise, Hard Disks get a Play verb
|
|
// when they have the ts_video\video_ts.ifo file in their root.
|
|
_dwMediaCap &= ~HWDMC_HASDVDMOVIE;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
#define TRACK_TYPE_MASK 0x04
|
|
#define AUDIO_TRACK 0x00
|
|
#define DATA_TRACK 0x04
|
|
|
|
HRESULT CVolume::_UpdateTrackInfo(HANDLE hDevice)
|
|
{
|
|
HRESULT hr;
|
|
|
|
ASSERT(!(_dwMediaCap & (HWDMC_HASDATATRACKS | HWDMC_HASAUDIOTRACKS)));
|
|
|
|
hr = S_OK;
|
|
// To be compatible with Win95, we'll only return TRUE from this
|
|
// function if the disc has ONLY audio tracks (and NO data tracks).
|
|
|
|
// FEATURE: Post NT-SUR beta 1, we should consider adding a new
|
|
// DriveType flag for "contains data tracks" and revamp the commands
|
|
// available on a CD-ROM drive. The current code doesn't handle
|
|
// mixed audio/data and audio/autorun discs very usefully. --JonBe
|
|
|
|
// First try the new IOCTL which gives us a ULONG with bits indicating
|
|
// the presence of either/both data & audio tracks
|
|
|
|
CDROM_DISK_DATA data;
|
|
DWORD dwDummy;
|
|
|
|
// Requires GENERIC_READ access on the handle
|
|
if (DeviceIoControl(hDevice, IOCTL_CDROM_DISK_TYPE, NULL, 0, &data,
|
|
sizeof(data), &dwDummy, NULL))
|
|
{
|
|
if (data.DiskData & CDROM_DISK_AUDIO_TRACK)
|
|
{
|
|
_dwMediaCap |= HWDMC_HASAUDIOTRACKS;
|
|
}
|
|
|
|
if (data.DiskData & CDROM_DISK_DATA_TRACK)
|
|
{
|
|
_dwMediaCap |= HWDMC_HASDATATRACKS;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// else that failed, so try to look for audio tracks the old way, by
|
|
// looking throught the table of contents manually. Note that data tracks
|
|
// are supposed to be hidden in the TOC by CDFS now on mixed audio/data
|
|
// discs (at least if the data tracks follow the audio tracks).
|
|
CDROM_TOC toc = {0};
|
|
|
|
if (!DeviceIoControl(hDevice, IOCTL_CDROM_READ_TOC, NULL, 0, &toc,
|
|
sizeof(toc), &dwDummy, NULL))
|
|
{
|
|
SUB_Q_CHANNEL_DATA subq = {0};
|
|
CDROM_SUB_Q_DATA_FORMAT df = {0};
|
|
|
|
// We might not have been able to read the TOC because the drive
|
|
// was busy playing audio. Lets try querying the audio position.
|
|
df.Format = IOCTL_CDROM_CURRENT_POSITION;
|
|
df.Track = 0;
|
|
|
|
if (DeviceIoControl(hDevice, IOCTL_CDROM_READ_Q_CHANNEL, &df,
|
|
sizeof(df), &subq, sizeof(subq), &dwDummy, NULL))
|
|
{
|
|
if (AUDIO_DATA_TRACK & subq.CurrentPosition.Control)
|
|
{
|
|
_dwMediaCap |= HWDMC_HASDATATRACKS;
|
|
}
|
|
else
|
|
{
|
|
_dwMediaCap |= HWDMC_HASAUDIOTRACKS;
|
|
}
|
|
}
|
|
|
|
// Is there the equivalent of IOCTL_CDROM_READ_Q_CHANNEL for data?
|
|
_dwMediaCap |= HWDMC_HASDATATRACKS_UNDETERMINED;
|
|
}
|
|
else
|
|
{
|
|
int nTracks = (toc.LastTrack - toc.FirstTrack) + 1;
|
|
int iTrack = 0;
|
|
|
|
// Now iterate through the tracks looking for Audio data
|
|
while ((iTrack < nTracks) &&
|
|
((_dwMediaCap & (HWDMC_HASDATATRACKS | HWDMC_HASDATATRACKS)) !=
|
|
(HWDMC_HASDATATRACKS | HWDMC_HASDATATRACKS))
|
|
)
|
|
{
|
|
if ((toc.TrackData[iTrack].Control & TRACK_TYPE_MASK) == AUDIO_TRACK)
|
|
{
|
|
_dwMediaCap |= HWDMC_HASAUDIOTRACKS;
|
|
}
|
|
else
|
|
{
|
|
if ((toc.TrackData[iTrack].Control & TRACK_TYPE_MASK) == DATA_TRACK)
|
|
{
|
|
_dwMediaCap |= HWDMC_HASDATATRACKS;
|
|
}
|
|
}
|
|
++iTrack;
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::_UpdateMediaInfoOnRemove()
|
|
{
|
|
_dwMediaCap = 0;
|
|
_dwMediaState = 0;
|
|
|
|
_szAutorunIconLocation[0] = 0;
|
|
_szAutorunLabel[0] = 0;
|
|
_dwSerialNumber = 0xBADBADBD;
|
|
|
|
SafeStrCpyN(_szLabel, TEXT("Invalid"), ARRAYSIZE(_szLabel));
|
|
SafeStrCpyN(_szFileSystem, TEXT("Invalid"), ARRAYSIZE(_szFileSystem));
|
|
_dwRootAttributes = 0xBADBADBD;
|
|
_dwMaxFileNameLen = 0xBADBADBD;
|
|
_dwFileSystemFlags = 0xBADBADBD;
|
|
|
|
_dwVolumeFlags &= ~(HWDVF_STATE_HASAUTOPLAYHANDLER |
|
|
HWDVF_STATE_DONOTSNIFFCONTENT | HWDVF_STATE_JUSTDOCKED);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CVolume::_UpdateMediaInfo(HANDLE hDevice, BOOL fImpersonate)
|
|
{
|
|
HRESULT hr;
|
|
CImpersonateEveryone* pieo = NULL;
|
|
|
|
if (fImpersonate)
|
|
{
|
|
hr = CHWEventDetectorHelper::GetImpersonateEveryone(&pieo);
|
|
|
|
if (SUCCEEDED(hr) && (S_FALSE != hr))
|
|
{
|
|
hr = pieo->Impersonate();
|
|
|
|
if (FAILED(hr) || (S_FALSE == hr))
|
|
{
|
|
pieo->RCRelease();
|
|
pieo = NULL;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
|
|
_dwVolumeFlags &= ~(HWDVF_STATE_HASAUTOPLAYHANDLER |
|
|
HWDVF_STATE_DONOTSNIFFCONTENT | HWDVF_STATE_JUSTDOCKED);
|
|
|
|
if (SUCCEEDED(hr) && (S_FALSE != hr))
|
|
{
|
|
if (HWDTS_CDROM == _dwDriveType)
|
|
{
|
|
ASSERT(_fGenericReadRequired);
|
|
|
|
// optimization
|
|
if (_fFirstTime)
|
|
{
|
|
// already updated by _UpdateConstInfo
|
|
_fFirstTime = FALSE;
|
|
}
|
|
else
|
|
{
|
|
_dwMediaCap = 0;
|
|
|
|
hr = _UpdateMMC2CDInfo(hDevice);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_dwMediaCap = 0;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = _UpdateHasMedia(hDevice);
|
|
|
|
if (SUCCEEDED(hr) && (_dwMediaState & HWDMS_PRESENT))
|
|
{
|
|
if (GetVolumeInformation(_szVolumeGUID, _szLabel,
|
|
ARRAYSIZE(_szLabel), &_dwSerialNumber,
|
|
&_dwMaxFileNameLen, &_dwFileSystemFlags, _szFileSystem,
|
|
ARRAYSIZE(_szFileSystem)))
|
|
{
|
|
// use this?
|
|
// UINT err = SetErrorMode(SEM_FAILCRITICALERRORS);
|
|
|
|
// Root folder attributes
|
|
_dwRootAttributes = GetFileAttributes(_szVolumeGUID);
|
|
|
|
if (-1 != _dwRootAttributes)
|
|
{
|
|
// File presence
|
|
hr = _UpdateSpecialFilePresence();
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (HWDTS_CDROM == _dwDriveType)
|
|
{
|
|
hr = _UpdateTrackInfo(hDevice);
|
|
}
|
|
|
|
if (HWDMC_HASAUTORUNINF & _dwMediaCap)
|
|
{
|
|
hr = _ExtractAutorunIconAndLabel();
|
|
|
|
// not critical
|
|
if (FAILED(hr))
|
|
{
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_HandleAccessDenied();
|
|
_dwState |= STATE_GFAFAILED;
|
|
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
_dwMediaState |= HWDMS_FORMATTED;
|
|
}
|
|
else
|
|
{
|
|
_HandleAccessDenied();
|
|
// To help us debug, even in retail
|
|
_dwState |= STATE_GVIFAILED;
|
|
_dwSerialNumber = GetLastError();
|
|
|
|
_dwMediaState &= ~HWDMS_FORMATTED;
|
|
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_dwState |= STATE_UPDATEHASMEDIAFAILED;
|
|
|
|
_dwMediaCap = 0;
|
|
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
|
|
if (S_FALSE == hr)
|
|
{
|
|
// We don't care if they fail
|
|
SafeStrCpyN(_szLabel, TEXT("Invalid"), ARRAYSIZE(_szLabel));
|
|
SafeStrCpyN(_szFileSystem, TEXT("Invalid"), ARRAYSIZE(_szFileSystem));
|
|
_dwRootAttributes = 0xBADBADBD;
|
|
_dwMaxFileNameLen = 0xBADBADBD;
|
|
_dwFileSystemFlags = 0xBADBADBD;
|
|
}
|
|
|
|
if (fImpersonate)
|
|
{
|
|
pieo->RevertToSelf();
|
|
pieo->RCRelease();
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
const FEATURE_NUMBER _rgfnInteresting[] =
|
|
{
|
|
// FeatureProfileList needs to remain the first one
|
|
FeatureProfileList, // = 0x0000,
|
|
FeatureCdRead, // = 0x001e,
|
|
FeatureDvdRead, // = 0x001f,
|
|
FeatureRandomWritable, // = 0x0020,
|
|
FeatureIncrementalStreamingWritable, // = 0x0021,
|
|
FeatureFormattable, // = 0x0023,
|
|
FeatureDefectManagement, // = 0x0024,
|
|
FeatureRestrictedOverwrite, // = 0x0026,
|
|
FeatureCdTrackAtOnce, // = 0x002d,
|
|
FeatureCdMastering, // = 0x002e,
|
|
FeatureDvdRecordableWrite, // = 0x002f,
|
|
FeatureCDAudioAnalogPlay, // = 0x0103,
|
|
};
|
|
|
|
struct CAPABILITYFEATURESMAP
|
|
{
|
|
DWORD dwCapability;
|
|
DWORD dwCapabilityDependent;
|
|
const FEATURE_NUMBER* prgFeature;
|
|
DWORD cFeature;
|
|
};
|
|
|
|
const FEATURE_NUMBER rgfnWRITECAP[] =
|
|
{
|
|
FeatureProfileList,
|
|
};
|
|
|
|
const FEATURE_NUMBER rgfnCDROM[] =
|
|
{
|
|
FeatureCdRead,
|
|
};
|
|
|
|
const FEATURE_NUMBER rgfnCDRECORDABLE[] =
|
|
{
|
|
FeatureIncrementalStreamingWritable,
|
|
FeatureCdTrackAtOnce,
|
|
FeatureCdMastering,
|
|
};
|
|
|
|
const FEATURE_NUMBER rgfnCDREWRITABLE[] =
|
|
{
|
|
FeatureFormattable,
|
|
};
|
|
|
|
const FEATURE_NUMBER rgfnDVDROM[] =
|
|
{
|
|
FeatureDvdRead,
|
|
};
|
|
|
|
const FEATURE_NUMBER rgfnDVDRECORDABLE[] =
|
|
{
|
|
FeatureDvdRecordableWrite,
|
|
};
|
|
|
|
const FEATURE_NUMBER rgfnDVDREWRITABLE[] =
|
|
{
|
|
FeatureFormattable,
|
|
};
|
|
|
|
const FEATURE_NUMBER rgfnDVDRAM[] =
|
|
{
|
|
FeatureRandomWritable,
|
|
FeatureDefectManagement,
|
|
};
|
|
|
|
const FEATURE_NUMBER rgfnANALOGAUDIOOUT[] =
|
|
{
|
|
FeatureCDAudioAnalogPlay,
|
|
};
|
|
|
|
const CAPABILITYFEATURESMAP _rgcapfeaturemap[] =
|
|
{
|
|
{
|
|
HWDMC_WRITECAPABILITY_SUPPORTDETECTION,
|
|
0,
|
|
rgfnWRITECAP,
|
|
ARRAYSIZE(rgfnWRITECAP),
|
|
},
|
|
{
|
|
HWDMC_CDROM,
|
|
HWDMC_WRITECAPABILITY_SUPPORTDETECTION,
|
|
rgfnCDROM,
|
|
ARRAYSIZE(rgfnCDROM),
|
|
},
|
|
{
|
|
HWDMC_CDRECORDABLE,
|
|
HWDMC_WRITECAPABILITY_SUPPORTDETECTION,
|
|
rgfnCDRECORDABLE,
|
|
ARRAYSIZE(rgfnCDRECORDABLE),
|
|
},
|
|
{
|
|
HWDMC_CDREWRITABLE,
|
|
HWDMC_CDRECORDABLE,
|
|
rgfnCDREWRITABLE,
|
|
ARRAYSIZE(rgfnCDREWRITABLE),
|
|
},
|
|
{
|
|
HWDMC_DVDROM,
|
|
HWDMC_WRITECAPABILITY_SUPPORTDETECTION,
|
|
rgfnDVDROM,
|
|
ARRAYSIZE(rgfnDVDROM),
|
|
},
|
|
{
|
|
HWDMC_DVDRECORDABLE,
|
|
HWDMC_WRITECAPABILITY_SUPPORTDETECTION,
|
|
rgfnDVDRECORDABLE,
|
|
ARRAYSIZE(rgfnDVDRECORDABLE),
|
|
},
|
|
{
|
|
HWDMC_DVDREWRITABLE,
|
|
HWDMC_DVDRECORDABLE,
|
|
rgfnDVDREWRITABLE,
|
|
ARRAYSIZE(rgfnDVDREWRITABLE),
|
|
},
|
|
{
|
|
HWDMC_DVDRAM,
|
|
HWDMC_DVDROM,
|
|
rgfnDVDRAM,
|
|
ARRAYSIZE(rgfnDVDRAM),
|
|
},
|
|
{
|
|
HWDMC_ANALOGAUDIOOUT,
|
|
HWDMC_WRITECAPABILITY_SUPPORTDETECTION,
|
|
rgfnANALOGAUDIOOUT,
|
|
ARRAYSIZE(rgfnANALOGAUDIOOUT),
|
|
},
|
|
};
|
|
|
|
#define MMC2_NOTSUPPORTED 0
|
|
#define MMC2_DRIVESUPPORTED 1
|
|
#define MMC2_MEDIASUPPORTED 2
|
|
|
|
HRESULT CVolume::_FillMMC2CD(HANDLE hDevice)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (!_prgMMC2Features)
|
|
{
|
|
_prgMMC2Features = (DWORD*)LocalAlloc(LPTR,
|
|
ARRAYSIZE(_rgfnInteresting) * sizeof(DWORD));
|
|
}
|
|
|
|
if (_prgMMC2Features)
|
|
{
|
|
DWORD cbHeader = sizeof(GET_CONFIGURATION_HEADER) +
|
|
sizeof(FEATURE_HEADER);
|
|
GET_CONFIGURATION_HEADER* pheader = (GET_CONFIGURATION_HEADER*)
|
|
LocalAlloc(LPTR, cbHeader);
|
|
|
|
if (pheader)
|
|
{
|
|
GET_CONFIGURATION_IOCTL_INPUT gcii;
|
|
|
|
gcii.RequestType = SCSI_GET_CONFIGURATION_REQUEST_TYPE_ONE;
|
|
gcii.Reserved[0] = NULL;
|
|
gcii.Reserved[1] = NULL;
|
|
|
|
for (DWORD dw = 0; dw < ARRAYSIZE(_rgfnInteresting); ++dw)
|
|
{
|
|
FEATURE_HEADER* pfh;
|
|
|
|
DWORD cbReturned;
|
|
gcii.Feature = _rgfnInteresting[dw];
|
|
|
|
_prgMMC2Features[dw] = MMC2_NOTSUPPORTED;
|
|
|
|
// Requires GENERIC_READ access on the handle
|
|
if (DeviceIoControl(hDevice, IOCTL_CDROM_GET_CONFIGURATION,
|
|
&gcii, sizeof(GET_CONFIGURATION_IOCTL_INPUT), pheader,
|
|
cbHeader, &cbReturned, NULL))
|
|
{
|
|
pfh = (FEATURE_HEADER*)(pheader->Data);
|
|
|
|
WORD w = (pfh->FeatureCode[0]) << 8 | (pfh->FeatureCode[1]);
|
|
|
|
if (w == _rgfnInteresting[dw])
|
|
{
|
|
_prgMMC2Features[dw] = MMC2_DRIVESUPPORTED;
|
|
|
|
if (pfh->Current)
|
|
{
|
|
_prgMMC2Features[dw] |= MMC2_MEDIASUPPORTED;
|
|
}
|
|
else
|
|
{
|
|
_prgMMC2Features[dw] &= ~MMC2_MEDIASUPPORTED;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
LocalFree(pheader);
|
|
}
|
|
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// Rainier drive exposes features which perfectly matches DVD-RAM
|
|
// required feature set. But they are CD-R/RW. For drives
|
|
// we think are DVD-RAM, check if they also expose a DVD_RAM profile.
|
|
// We cannot use profiles all the way because they are not reliable.
|
|
// The same Rainier drive that expose bug 446652 exposes only
|
|
// the CDRewritable profile but it does support CDRecordable and
|
|
// CD-ROM.
|
|
|
|
HRESULT CVolume::_DVDRAMHack(HANDLE hDevice)
|
|
{
|
|
BOOL fSupported = FALSE;
|
|
BOOL fCurrent = FALSE;
|
|
|
|
if (HWDDC_DVDRAM & _dwDriveCap)
|
|
{
|
|
// Do the check
|
|
const DWORD cbHeaderInitial = sizeof(GET_CONFIGURATION_HEADER) + sizeof(FEATURE_HEADER);
|
|
|
|
DWORD cbReturned;
|
|
DWORD cbHeader = cbHeaderInitial;
|
|
BYTE rgbBuffer[cbHeaderInitial];
|
|
GET_CONFIGURATION_IOCTL_INPUT input;
|
|
GET_CONFIGURATION_HEADER* pheader = (GET_CONFIGURATION_HEADER*)rgbBuffer;
|
|
|
|
ZeroMemory(&input, sizeof(GET_CONFIGURATION_IOCTL_INPUT));
|
|
ZeroMemory(rgbBuffer, sizeof(rgbBuffer));
|
|
|
|
// Ask for the profile list
|
|
input.Feature = FeatureProfileList;
|
|
|
|
// We want only this feature back
|
|
input.RequestType = SCSI_GET_CONFIGURATION_REQUEST_TYPE_ALL;
|
|
|
|
BOOL f = DeviceIoControl(hDevice,
|
|
IOCTL_CDROM_GET_CONFIGURATION,
|
|
&input,
|
|
sizeof(GET_CONFIGURATION_IOCTL_INPUT),
|
|
pheader,
|
|
cbHeader,
|
|
&cbReturned,
|
|
NULL);
|
|
|
|
if (f)
|
|
{
|
|
cbHeader = pheader->DataLength[0] << 24 |
|
|
pheader->DataLength[1] << 16 |
|
|
pheader->DataLength[2] << 8 |
|
|
pheader->DataLength[3] << 0;
|
|
|
|
GET_CONFIGURATION_HEADER* pheader2 = (GET_CONFIGURATION_HEADER*)LocalAlloc(LPTR,
|
|
cbHeader);
|
|
|
|
if (pheader2)
|
|
{
|
|
// We want all the profiles back
|
|
input.RequestType = SCSI_GET_CONFIGURATION_REQUEST_TYPE_ALL;
|
|
|
|
f = DeviceIoControl(hDevice,
|
|
IOCTL_CDROM_GET_CONFIGURATION,
|
|
&input,
|
|
sizeof(GET_CONFIGURATION_IOCTL_INPUT),
|
|
pheader2,
|
|
cbHeader,
|
|
&cbReturned,
|
|
NULL);
|
|
|
|
if (f)
|
|
{
|
|
FEATURE_DATA_PROFILE_LIST* pproflist =
|
|
(FEATURE_DATA_PROFILE_LIST*)pheader2->Data;
|
|
|
|
for (DWORD dw = 0; dw < (DWORD)(pproflist->Header.AdditionalLength / 4); ++dw)
|
|
{
|
|
FEATURE_DATA_PROFILE_LIST_EX* pprofile = &(pproflist->Profiles[dw]);
|
|
|
|
if (ProfileDvdRam == (pprofile->ProfileNumber[0] << 8 |
|
|
pprofile->ProfileNumber[1] << 0))
|
|
{
|
|
// It does support it! Is it current?
|
|
fSupported = TRUE;
|
|
|
|
if (pprofile->Current)
|
|
{
|
|
fCurrent = TRUE;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
LocalFree(pheader2);
|
|
}
|
|
}
|
|
|
|
if (fSupported)
|
|
{
|
|
if (!fCurrent)
|
|
{
|
|
_dwMediaCap &= ~HWDMC_DVDRAM;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_dwDriveCap &= ~HWDDC_DVDRAM;
|
|
_dwMediaCap &= ~HWDMC_DVDRAM;
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// Not worth updating only Const Info vs Media Info, do both
|
|
HRESULT CVolume::_UpdateMMC2CDInfo(HANDLE hDevice)
|
|
{
|
|
HRESULT hr = _FillMMC2CD(hDevice);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
for (DWORD dwCap = 0; dwCap < ARRAYSIZE(_rgcapfeaturemap); ++dwCap)
|
|
{
|
|
DWORD dwGoOn = MMC2_NOTSUPPORTED;
|
|
|
|
if (_rgcapfeaturemap[dwCap].dwCapabilityDependent)
|
|
{
|
|
// This capability is dependent on another one, let's
|
|
// check if the other is on
|
|
if (_dwDriveCap &
|
|
_rgcapfeaturemap[dwCap].dwCapabilityDependent)
|
|
{
|
|
dwGoOn |= MMC2_DRIVESUPPORTED;
|
|
|
|
if (_dwMediaCap &
|
|
_rgcapfeaturemap[dwCap].dwCapabilityDependent)
|
|
{
|
|
dwGoOn |= MMC2_MEDIASUPPORTED;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dwGoOn = MMC2_DRIVESUPPORTED | MMC2_MEDIASUPPORTED;
|
|
}
|
|
|
|
for (DWORD dwFeature = 0;
|
|
dwFeature < (_rgcapfeaturemap[dwCap].cFeature);
|
|
++dwFeature)
|
|
{
|
|
for (DWORD dwFeatureOn = 0; (MMC2_DRIVESUPPORTED & dwGoOn) &&
|
|
(dwFeatureOn < ARRAYSIZE(_rgfnInteresting));
|
|
++dwFeatureOn)
|
|
{
|
|
if (_rgfnInteresting[dwFeatureOn] ==
|
|
_rgcapfeaturemap[dwCap].prgFeature[dwFeature])
|
|
{
|
|
if (_prgMMC2Features[dwFeatureOn] &
|
|
MMC2_DRIVESUPPORTED)
|
|
{
|
|
if (!(dwGoOn & MMC2_MEDIASUPPORTED) ||
|
|
!(_prgMMC2Features[dwFeatureOn] &
|
|
MMC2_MEDIASUPPORTED))
|
|
{
|
|
dwGoOn &= ~MMC2_MEDIASUPPORTED;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dwGoOn = MMC2_NOTSUPPORTED;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (MMC2_DRIVESUPPORTED & dwGoOn)
|
|
{
|
|
_dwDriveCap |= _rgcapfeaturemap[dwCap].dwCapability;
|
|
|
|
if (MMC2_MEDIASUPPORTED & dwGoOn)
|
|
{
|
|
_dwMediaCap |= _rgcapfeaturemap[dwCap].
|
|
dwCapability;
|
|
}
|
|
else
|
|
{
|
|
_dwMediaCap &= ~(_rgcapfeaturemap[dwCap].
|
|
dwCapability);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_dwDriveCap &= ~(_rgcapfeaturemap[dwCap].dwCapability);
|
|
_dwMediaCap &= ~(_rgcapfeaturemap[dwCap].dwCapability);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
_DVDRAMHack(hDevice);
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::MediaIsAccessible(BOOL* pfAccessible)
|
|
{
|
|
*pfAccessible = !!(_dwMediaState & HWDMS_PRESENT);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CVolume::_UpdateRemovableDevice()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (_fHWDevInstInited)
|
|
{
|
|
BOOL fRemovable;
|
|
|
|
hr = _hwdevinst.IsRemovableDevice(&fRemovable);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (fRemovable)
|
|
{
|
|
_dwDriveCap |= HWDDC_REMOVABLEDEVICE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::_UpdateSoftEjectCaps()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (_fHWDevInstInited)
|
|
{
|
|
DWORD dw;
|
|
DWORD dwType;
|
|
|
|
hr = _GetDevicePropertyGeneric(&_hwdevinst, TEXT("NoSoftEject"),
|
|
FALSE, &dwType, (PBYTE)&dw, sizeof(dw));
|
|
|
|
if (SUCCEEDED(hr) && (S_FALSE != hr))
|
|
{
|
|
hr = S_OK;
|
|
|
|
if (REG_DWORD == dwType)
|
|
{
|
|
if (1 == dw)
|
|
{
|
|
_dwDriveCap |= HWDDC_NOSOFTEJECT;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::_UpdateConstInfo(HANDLE hDevice)
|
|
{
|
|
HRESULT hr;
|
|
|
|
_dwVolumeFlags = 0;
|
|
|
|
if (HWDTS_CDROM == _dwDriveType)
|
|
{
|
|
_dwVolumeFlags = HWDVF_STATE_SUPPORTNOTIFICATION;
|
|
|
|
hr = _UpdateMMC2CDInfo(hDevice);
|
|
}
|
|
else
|
|
{
|
|
if (HWDTS_REMOVABLEDISK == _dwDriveType)
|
|
{
|
|
_dwVolumeFlags = HWDVF_STATE_SUPPORTNOTIFICATION;
|
|
}
|
|
else
|
|
{
|
|
if ((HWDTS_FLOPPY35 != _dwDriveType) &&
|
|
(HWDTS_FLOPPY525 != _dwDriveType))
|
|
{
|
|
// Do something for the 120MB floppy
|
|
_dwVolumeFlags = HWDVF_STATE_SUPPORTNOTIFICATION;
|
|
}
|
|
}
|
|
|
|
hr = S_OK;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = _GetVolumeName(_pszElemName, _szVolumeGUID,
|
|
ARRAYSIZE(_szVolumeGUID));
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (HWDTS_CDROM != _dwDriveType)
|
|
{
|
|
_dwDriveCap |= HWDMC_WRITECAPABILITY_SUPPORTDETECTION |
|
|
HWDDC_RANDOMWRITE;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::GetVolumeConstInfo(LPWSTR pszVolumeGUID, DWORD cchVolumeGUID,
|
|
DWORD* pdwVolumeFlags, DWORD* pdwDriveType, DWORD* pdwDriveCap)
|
|
{
|
|
HRESULT hr;
|
|
|
|
_cs.Enter();
|
|
|
|
hr = SafeStrCpyN(pszVolumeGUID, _szVolumeGUID, cchVolumeGUID);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (!(_dwVolumeFlags & HWDVF_STATE_ACCESSDENIED))
|
|
{
|
|
*pdwVolumeFlags = _dwVolumeFlags;
|
|
*pdwDriveType = _dwDriveType;
|
|
*pdwDriveCap = _dwDriveCap;
|
|
}
|
|
else
|
|
{
|
|
*pdwVolumeFlags = HWDVF_STATE_ACCESSDENIED;
|
|
*pdwDriveType = 0xBADBADBD;
|
|
*pdwDriveCap = 0xBADBADBD;
|
|
}
|
|
}
|
|
|
|
_cs.Leave();
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::GetVolumeMediaInfo(LPWSTR pszLabel, DWORD cchLabel,
|
|
LPWSTR pszFileSystem, DWORD cchFileSystem, DWORD* pdwFileSystemFlags,
|
|
DWORD* pdwMaxFileNameLen, DWORD* pdwRootAttributes, DWORD* pdwSerialNumber,
|
|
DWORD* pdwDriveState, DWORD* pdwMediaState, DWORD* pdwMediaCap)
|
|
{
|
|
HRESULT hr;
|
|
|
|
_cs.Enter();
|
|
|
|
if (!(_dwVolumeFlags & HWDVF_STATE_ACCESSDENIED))
|
|
{
|
|
if (_dwMediaState & HWDMS_PRESENT)
|
|
{
|
|
hr = SafeStrCpyN(pszLabel, _szLabel, cchLabel);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SafeStrCpyN(pszFileSystem, _szFileSystem, cchFileSystem);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
*pdwFileSystemFlags = _dwFileSystemFlags;
|
|
*pdwMaxFileNameLen = _dwMaxFileNameLen;
|
|
*pdwRootAttributes = _dwRootAttributes;
|
|
*pdwSerialNumber = _dwSerialNumber;
|
|
|
|
*pdwDriveState = _dwDriveState;
|
|
|
|
*pdwMediaState = _dwMediaState;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*pdwMediaState = _dwMediaState;
|
|
|
|
// We don't care if they fail
|
|
SafeStrCpyN(pszLabel, TEXT("Invalid"), cchLabel);
|
|
SafeStrCpyN(pszFileSystem, TEXT("Invalid"), cchFileSystem);
|
|
*pdwSerialNumber = 0xBADBADBD;
|
|
*pdwMaxFileNameLen = 0xBADBADBD;
|
|
*pdwFileSystemFlags = 0xBADBADBD;
|
|
*pdwRootAttributes = 0xBADBADBD;
|
|
*pdwDriveState = 0xBADBADBD;
|
|
|
|
hr = S_OK;
|
|
}
|
|
|
|
*pdwMediaCap = _dwMediaCap;
|
|
}
|
|
else
|
|
{
|
|
*pdwMediaState = 0xBADBADBD;
|
|
|
|
// We don't care if they fail
|
|
SafeStrCpyN(pszLabel, TEXT("Access Denied"), cchLabel);
|
|
SafeStrCpyN(pszFileSystem, TEXT("Access Denied"), cchFileSystem);
|
|
*pdwSerialNumber = 0xBADBADBD;
|
|
*pdwMaxFileNameLen = 0xBADBADBD;
|
|
*pdwFileSystemFlags = 0xBADBADBD;
|
|
*pdwRootAttributes = 0xBADBADBD;
|
|
*pdwDriveState = 0xBADBADBD;
|
|
*pdwMediaCap = 0xBADBADBD;
|
|
|
|
hr = S_OK;
|
|
}
|
|
|
|
_cs.Leave();
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::GetIconAndLabelInfo(LPWSTR pszAutorunIconLocation,
|
|
DWORD cchAutorunIconLocation, LPWSTR pszAutorunLabel, DWORD cchAutorunLabel,
|
|
LPWSTR pszIconLocationFromService, DWORD cchIconLocationFromService,
|
|
LPWSTR pszNoMediaIconLocationFromService, DWORD cchNoMediaIconLocationFromService,
|
|
LPWSTR pszLabelFromService, DWORD cchLabelFromService)
|
|
{
|
|
HRESULT hrTmp;
|
|
|
|
*pszAutorunIconLocation = NULL;
|
|
*pszAutorunLabel = NULL;
|
|
*pszIconLocationFromService = NULL;
|
|
*pszNoMediaIconLocationFromService = NULL;
|
|
*pszLabelFromService = NULL;
|
|
|
|
_cs.Enter();
|
|
|
|
if (!(_dwVolumeFlags & HWDVF_STATE_ACCESSDENIED))
|
|
{
|
|
if (_dwMediaCap & HWDMC_HASAUTORUNINF)
|
|
{
|
|
if (_szAutorunIconLocation[0])
|
|
{
|
|
hrTmp = SafeStrCpyN(pszAutorunIconLocation, _szAutorunIconLocation,
|
|
cchAutorunIconLocation);
|
|
|
|
if (FAILED(hrTmp))
|
|
{
|
|
*pszAutorunIconLocation = 0;
|
|
}
|
|
}
|
|
|
|
if (_szAutorunLabel[0])
|
|
{
|
|
hrTmp = SafeStrCpyN(pszAutorunLabel, _szAutorunLabel,
|
|
cchAutorunLabel);
|
|
|
|
if (FAILED(hrTmp))
|
|
{
|
|
*pszAutorunLabel = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (_fHWDevInstInited)
|
|
{
|
|
WORD_BLOB* pblob;
|
|
|
|
hrTmp = _GetDevicePropertyGenericAsMultiSz(&_hwdevinst, TEXT("Icons"),
|
|
TRUE, &pblob);
|
|
|
|
if (SUCCEEDED(hrTmp) && (S_FALSE != hrTmp))
|
|
{
|
|
hrTmp = SafeStrCpyN(pszIconLocationFromService, pblob->asData,
|
|
cchIconLocationFromService);
|
|
|
|
if (FAILED(hrTmp))
|
|
{
|
|
*pszIconLocationFromService = 0;
|
|
}
|
|
|
|
CoTaskMemFree(pblob);
|
|
}
|
|
else
|
|
{
|
|
*pszIconLocationFromService = 0;
|
|
hrTmp = S_FALSE;
|
|
}
|
|
|
|
hrTmp = _GetDevicePropertyGenericAsMultiSz(&_hwdevinst, TEXT("NoMediaIcons"),
|
|
TRUE, &pblob);
|
|
|
|
if (SUCCEEDED(hrTmp) && (S_FALSE != hrTmp))
|
|
{
|
|
hrTmp = SafeStrCpyN(pszNoMediaIconLocationFromService, pblob->asData,
|
|
cchNoMediaIconLocationFromService);
|
|
|
|
if (FAILED(hrTmp))
|
|
{
|
|
*pszNoMediaIconLocationFromService = 0;
|
|
}
|
|
|
|
CoTaskMemFree(pblob);
|
|
}
|
|
else
|
|
{
|
|
*pszNoMediaIconLocationFromService = 0;
|
|
hrTmp = S_FALSE;
|
|
}
|
|
|
|
if (SUCCEEDED(hrTmp))
|
|
{
|
|
hrTmp = _GetDevicePropertyAsString(&_hwdevinst, TEXT("Label"),
|
|
pszLabelFromService, cchLabelFromService);
|
|
|
|
if (FAILED(hrTmp) || (S_FALSE == hrTmp))
|
|
{
|
|
*pszLabelFromService = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
_cs.Leave();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CVolume::_GetVOLUMEINFO2(VOLUMEINFO2** ppvolinfo2)
|
|
{
|
|
ASSERT(_cs.IsInside());
|
|
|
|
DWORD cchReq;
|
|
|
|
// We allocate this buffer just to be stack friendly, otherwise it could
|
|
// have been on the stack
|
|
VOLUMEINFO2* pvolinfo2;
|
|
|
|
HRESULT hr = _AllocMemoryChunk<VOLUMEINFO2*>(MAX_VOLUMEINFO2, &pvolinfo2);
|
|
|
|
*ppvolinfo2 = NULL;
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pvolinfo2->cbSize = MAX_VOLUMEINFO2;
|
|
|
|
hr = GetName(pvolinfo2->szDeviceIDVolume,
|
|
ARRAYSIZE(pvolinfo2->szDeviceIDVolume), &cchReq);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Const info
|
|
hr = SafeStrCpyN(pvolinfo2->szVolumeGUID, _szVolumeGUID,
|
|
ARRAYSIZE(pvolinfo2->szVolumeGUID));
|
|
|
|
if (_dwVolumeFlags & HWDVF_STATE_ACCESSDENIED)
|
|
{
|
|
pvolinfo2->dwVolumeFlags = HWDVF_STATE_ACCESSDENIED;
|
|
}
|
|
else
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pvolinfo2->dwVolumeFlags = _dwVolumeFlags;
|
|
pvolinfo2->dwDriveType = _dwDriveType;
|
|
pvolinfo2->dwDriveCapability = _dwDriveCap;
|
|
}
|
|
|
|
pvolinfo2->dwState = _dwState;
|
|
|
|
// Media info
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// This fct should be called from within the Volume critsect
|
|
if (_dwMediaState & HWDMS_PRESENT)
|
|
{
|
|
hr = SafeStrCpyN(pvolinfo2->szLabel, _szLabel,
|
|
ARRAYSIZE(pvolinfo2->szLabel));
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = SafeStrCpyN(pvolinfo2->szFileSystem, _szFileSystem,
|
|
ARRAYSIZE(pvolinfo2->szFileSystem));
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pvolinfo2->dwFileSystemFlags = _dwFileSystemFlags;
|
|
pvolinfo2->dwMaxFileNameLen = _dwMaxFileNameLen;
|
|
pvolinfo2->dwRootAttributes = _dwRootAttributes;
|
|
pvolinfo2->dwSerialNumber = _dwSerialNumber;
|
|
|
|
pvolinfo2->dwDriveState = _dwDriveState;
|
|
pvolinfo2->dwMediaCap = _dwMediaCap;
|
|
|
|
pvolinfo2->dwMediaState = _dwMediaState;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pvolinfo2->dwMediaState = _dwMediaState;
|
|
|
|
// We don't care if they fail
|
|
SafeStrCpyN(pvolinfo2->szLabel, TEXT("Invalid"),
|
|
ARRAYSIZE(pvolinfo2->szLabel));
|
|
SafeStrCpyN(pvolinfo2->szFileSystem, TEXT("Invalid"),
|
|
ARRAYSIZE(pvolinfo2->szFileSystem));
|
|
pvolinfo2->dwSerialNumber = 0xBADBADBD;
|
|
pvolinfo2->dwMaxFileNameLen = 0xBADBADBD;
|
|
pvolinfo2->dwFileSystemFlags = 0xBADBADBD;
|
|
pvolinfo2->dwRootAttributes = 0xBADBADBD;
|
|
pvolinfo2->dwDriveState = 0xBADBADBD;
|
|
|
|
hr = S_OK;
|
|
}
|
|
|
|
pvolinfo2->dwMediaCap = _dwMediaCap;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
DWORD offset = 0;
|
|
WCHAR szAutorunIconLocation[MAX_ICONLOCATION];
|
|
WCHAR szAutorunLabel[MAX_LABEL];
|
|
WCHAR szIconLocationFromService[MAX_ICONLOCATION];
|
|
WCHAR szNoMediaIconLocationFromService[MAX_ICONLOCATION];
|
|
// We can now have a @%SystemRoot%\system32\shell32.dll,-1785 for MUI stuff
|
|
WCHAR szLabelFromService[MAX_ICONLOCATION];
|
|
|
|
pvolinfo2->oAutorunIconLocation = INVALID_DWORD;
|
|
pvolinfo2->oAutorunLabel = INVALID_DWORD;
|
|
pvolinfo2->oIconLocationFromService = INVALID_DWORD;
|
|
pvolinfo2->oNoMediaIconLocationFromService = INVALID_DWORD;
|
|
pvolinfo2->oLabelFromService = INVALID_DWORD;
|
|
|
|
hr = GetIconAndLabelInfo(szAutorunIconLocation,
|
|
ARRAYSIZE(szAutorunIconLocation), szAutorunLabel,
|
|
ARRAYSIZE(szAutorunLabel), szIconLocationFromService,
|
|
ARRAYSIZE(szIconLocationFromService), szNoMediaIconLocationFromService,
|
|
ARRAYSIZE(szNoMediaIconLocationFromService), szLabelFromService,
|
|
ARRAYSIZE(szLabelFromService));
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// The following five strings are optional
|
|
if (*szAutorunIconLocation)
|
|
{
|
|
pvolinfo2->oAutorunIconLocation = offset;
|
|
|
|
offset += lstrlen(szAutorunIconLocation) + 1;
|
|
|
|
lstrcpy(pvolinfo2->szOptionalStrings + pvolinfo2->oAutorunIconLocation,
|
|
szAutorunIconLocation);
|
|
}
|
|
|
|
if (*szAutorunLabel)
|
|
{
|
|
pvolinfo2->oAutorunIconLocation = offset;
|
|
|
|
offset += lstrlen(szAutorunLabel) + 1;
|
|
|
|
lstrcpy(pvolinfo2->szOptionalStrings + pvolinfo2->oAutorunIconLocation,
|
|
szAutorunLabel);
|
|
}
|
|
|
|
if (*szIconLocationFromService)
|
|
{
|
|
pvolinfo2->oIconLocationFromService = offset;
|
|
|
|
offset += lstrlen(szIconLocationFromService) + 1;
|
|
|
|
lstrcpy(pvolinfo2->szOptionalStrings + pvolinfo2->oIconLocationFromService,
|
|
szIconLocationFromService);
|
|
}
|
|
|
|
if (*szNoMediaIconLocationFromService)
|
|
{
|
|
pvolinfo2->oNoMediaIconLocationFromService = offset;
|
|
|
|
offset += lstrlen(szNoMediaIconLocationFromService) + 1;
|
|
|
|
lstrcpy(pvolinfo2->szOptionalStrings + pvolinfo2->oNoMediaIconLocationFromService,
|
|
szNoMediaIconLocationFromService);
|
|
}
|
|
|
|
if (*szLabelFromService)
|
|
{
|
|
pvolinfo2->oLabelFromService = offset;
|
|
|
|
offset += lstrlen(szLabelFromService) + 1;
|
|
|
|
lstrcpy(pvolinfo2->szOptionalStrings + pvolinfo2->oLabelFromService,
|
|
szLabelFromService);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
*ppvolinfo2 = pvolinfo2;
|
|
}
|
|
else
|
|
{
|
|
_FreeMemoryChunk<VOLUMEINFO2*>(pvolinfo2);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::HandleRemoval()
|
|
{
|
|
WCHAR szDeviceIDVolume[MAX_DEVICEID];
|
|
DWORD cchReq;
|
|
|
|
HRESULT hr = GetName(szDeviceIDVolume, ARRAYSIZE(szDeviceIDVolume), &cchReq);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// This will launch a thread
|
|
CHardwareDevicesImpl::_AdviseVolumeRemoved(szDeviceIDVolume,
|
|
_pszMountPoints, _cchMountPoints);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CVolume::HandleArrival()
|
|
{
|
|
BOOL fJustDocked = FALSE;
|
|
|
|
HRESULT hr = CHWEventDetectorHelper::DockStateChanged(&fJustDocked);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// ISSUE-2001/01/13-StephStm Pass the Docking change in there so
|
|
// that the Shell knows if it should
|
|
// Autorun or not.
|
|
//
|
|
if (_fHWDevInstInited)
|
|
{
|
|
BOOL fTryAutoplay = TRUE;
|
|
|
|
if ((_dwDriveType & HWDTS_CDROM) ||
|
|
(_dwDriveType & HWDTS_REMOVABLEDISK))
|
|
{
|
|
if (_dwMediaState & HWDMS_PRESENT)
|
|
{
|
|
// Not removable disk, but device
|
|
BOOL fRemovable;
|
|
|
|
hr = _hwdevinst.IsRemovableDevice(&fRemovable);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (fRemovable)
|
|
{
|
|
// We need to Autoplay these since cameras
|
|
// are removable-disk devices. And we want
|
|
// to autorun them when they come in.
|
|
fTryAutoplay = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// For removable-disk drives/CD drives with
|
|
// media inserted when they are plugged,
|
|
// we do not Autoplay.
|
|
fTryAutoplay = FALSE;
|
|
|
|
DIAGNOSTIC((TEXT("[0311]Non removable device plugged with media in it -> No Autoplay!")));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!fJustDocked && fTryAutoplay)
|
|
{
|
|
HANDLE hDevice;
|
|
|
|
// Get a handle to regsiter for notification so that the
|
|
// FindFirstFile does not veto a PnP/Driver transition
|
|
hr = _GetDeviceHandleSafe(&hDevice, FALSE);
|
|
|
|
if (SUCCEEDED(hr) && (S_FALSE != hr))
|
|
{
|
|
hr = _ShouldTryAutoplay(&fTryAutoplay);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (fTryAutoplay)
|
|
{
|
|
BOOL fHasHandler;
|
|
|
|
hr = CHWEventDetectorImpl::HandleVolumeMediaEvent(
|
|
_pszElemName, &_hwdevinst, TEXT("DeviceArrival"),
|
|
&fHasHandler);
|
|
|
|
if (SUCCEEDED(hr) && fHasHandler)
|
|
{
|
|
_dwVolumeFlags |= HWDVF_STATE_HASAUTOPLAYHANDLER;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_dwVolumeFlags |= HWDVF_STATE_DONOTSNIFFCONTENT;
|
|
}
|
|
}
|
|
|
|
_CloseDeviceHandleSafe(hDevice);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (fJustDocked)
|
|
{
|
|
DIAGNOSTIC((TEXT("[0301]Just docked -> No Autoplay!")));
|
|
TRACE(TF_VOLUME, TEXT("Just docked -> No Autoplay!"));
|
|
|
|
_dwVolumeFlags |= HWDVF_STATE_JUSTDOCKED;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DIAGNOSTIC((TEXT("[0310]Cannot find hardware device for this volume -> No Autoplay!")));
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_AdviseVolumeChangeHelper(TRUE);
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
CVolume::CVolume() : _dwMediaState(0),
|
|
_devtype((DEVICE_TYPE)-1), _ulDeviceNumber((ULONG)-1),
|
|
_ulPartitionNumber((ULONG)-1), _fHWDevInstInited(FALSE), _dwDriveType(0),
|
|
_dwDriveCap(0), _dwVolumeFlags(0), _prgMMC2Features(NULL),
|
|
_fFirstTime(TRUE), _dwMediaCap(0), _pszMountPoints(NULL), _dwDriveState(0),
|
|
_fProcessMediaArrived(FALSE), _hdevnotify(NULL), _dwState(0),
|
|
_dwMediaPresentFromEvent(MPFE_UNDETERMINED)
|
|
{
|
|
_szVolumeGUID[0] = 0;
|
|
_szDeviceIDDisk[0] = 0;
|
|
|
|
_cs.Init();
|
|
}
|
|
|
|
CVolume::~CVolume()
|
|
{
|
|
_UnregisterNotif();
|
|
|
|
if (_pszMountPoints)
|
|
{
|
|
CNamedElemList* pnel;
|
|
HRESULT hres = CHWEventDetectorHelper::GetList(HWEDLIST_MTPT, &pnel);
|
|
|
|
if (S_OK == hres)
|
|
{
|
|
for (LPWSTR psz = _pszMountPoints; *psz; psz += (lstrlen(psz) + 1))
|
|
{
|
|
hres = pnel->Remove(psz);
|
|
}
|
|
|
|
pnel->RCRelease();
|
|
}
|
|
|
|
LocalFree(_pszMountPoints);
|
|
}
|
|
|
|
if (_prgMMC2Features)
|
|
{
|
|
LocalFree(_prgMMC2Features);
|
|
}
|
|
|
|
_cs.Delete();
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
//static
|
|
HRESULT CVolume::Create(CNamedElem** ppelem)
|
|
{
|
|
HRESULT hres = S_OK;
|
|
|
|
*ppelem = new CVolume();
|
|
|
|
if (!(*ppelem))
|
|
{
|
|
hres = E_OUTOFMEMORY;
|
|
}
|
|
|
|
return hres;
|
|
}
|
|
|
|
//static
|
|
HRESULT CVolume::GetFillEnum(CFillEnum** ppfillenum)
|
|
{
|
|
HRESULT hres;
|
|
|
|
CVolumeFillEnum* pfillenum = new CVolumeFillEnum();
|
|
|
|
if (pfillenum)
|
|
{
|
|
hres = pfillenum->_Init();
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
delete pfillenum;
|
|
pfillenum = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hres = E_OUTOFMEMORY;
|
|
}
|
|
|
|
*ppfillenum = pfillenum;
|
|
|
|
return hres;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
HRESULT CVolumeFillEnum::Next(LPWSTR pszElemName, DWORD cchElemName,
|
|
DWORD* pcchRequired)
|
|
{
|
|
return _intffillenum.Next(pszElemName, cchElemName, pcchRequired);
|
|
}
|
|
|
|
HRESULT CVolumeFillEnum::_Init()
|
|
{
|
|
return _intffillenum._Init(&guidVolumeClass, NULL);
|
|
}
|