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.
650 lines
14 KiB
650 lines
14 KiB
/*++
|
|
|
|
© 1998 Seagate Software, Inc. All rights reserved
|
|
|
|
Module Name:
|
|
|
|
RmsDvice.cpp
|
|
|
|
Abstract:
|
|
|
|
Implementation of CRmsDevice
|
|
|
|
Author:
|
|
|
|
Brian Dodd [brian] 15-Nov-1996
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include "RmsDvice.h"
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IRmsDevice implementation
|
|
//
|
|
|
|
|
|
CRmsDevice::CRmsDevice(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
CRmsDevice constructor
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
|
|
// Initialize values
|
|
m_deviceName = RMS_UNDEFINED_STRING;
|
|
|
|
m_deviceType = RmsDeviceUnknown;
|
|
|
|
m_sizeofDeviceInfo = 0;
|
|
|
|
memset(m_deviceInfo, 0, MaxInfo);
|
|
|
|
m_port = 0xff;
|
|
|
|
m_bus = 0xff;
|
|
|
|
m_targetId = 0xff;
|
|
|
|
m_lun = 0xff;
|
|
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CRmsDevice::CompareTo(
|
|
IN IUnknown *pCollectable,
|
|
OUT SHORT *pResult
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
CRmsDevice::CompareTo
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
SHORT result = 1;
|
|
|
|
WsbTraceIn( OLESTR("CRmsDevice::CompareTo"), OLESTR("") );
|
|
|
|
try {
|
|
|
|
// Validate arguments - Okay if pResult is NULL
|
|
WsbAssertPointer( pCollectable );
|
|
|
|
CComQIPtr<IRmsDevice, &IID_IRmsDevice> pDevice = pCollectable;
|
|
WsbAssertPointer( pDevice );
|
|
|
|
CComQIPtr<IRmsComObject, &IID_IRmsComObject> pObject = pCollectable;
|
|
WsbAssertPointer( pObject );
|
|
|
|
switch ( m_findBy ) {
|
|
|
|
case RmsFindByDeviceInfo:
|
|
{
|
|
//
|
|
// What we really want to do here is compare by
|
|
// a unique device identifier like a serial number.
|
|
//
|
|
// However, since we don't have a serial number for
|
|
// all devices, we'll compare using a best effort
|
|
// strategy using for following criteria:
|
|
//
|
|
// 1) DeviceName, this is unique for fixed drives and
|
|
// floppy drives, and SCSI devices, but may not
|
|
// survive accross reboot, and may not be the same
|
|
// for a device if it's SCSI address is changed.
|
|
//
|
|
// NOTE: We can't tell if the address was changed
|
|
// a device.
|
|
//
|
|
// NOTE: We can't tell if the drive letter was
|
|
// changed for a fixed drive.
|
|
//
|
|
// TODO: Add serial number support.
|
|
//
|
|
|
|
CWsbBstrPtr name;
|
|
|
|
// Get the target device name
|
|
pDevice->GetDeviceName( &name );
|
|
|
|
// Compare the names
|
|
result = (SHORT)wcscmp( m_deviceName, name );
|
|
hr = ( 0 == result ) ? S_OK : S_FALSE;
|
|
|
|
}
|
|
break;
|
|
|
|
case RmsFindByDeviceAddress:
|
|
{
|
|
|
|
BYTE port, bus, targetId, lun;
|
|
|
|
// Get the target device address
|
|
pDevice->GetDeviceAddress(&port, &bus, &targetId, &lun);
|
|
|
|
if( (m_port == port) &&
|
|
(m_bus == bus) &&
|
|
(m_targetId == targetId) &&
|
|
(m_lun == lun) ) {
|
|
|
|
// Device addresses match
|
|
hr = S_OK;
|
|
result = 0;
|
|
|
|
}
|
|
else {
|
|
hr = S_FALSE;
|
|
result = 1;
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case RmsFindByDeviceName:
|
|
{
|
|
|
|
CWsbBstrPtr name;
|
|
|
|
// Get the target device name
|
|
pDevice->GetDeviceName( &name );
|
|
|
|
// Compare the names
|
|
result = (SHORT)wcscmp( m_deviceName, name );
|
|
hr = ( 0 == result ) ? S_OK : S_FALSE;
|
|
|
|
}
|
|
break;
|
|
|
|
case RmsFindByDeviceType:
|
|
{
|
|
|
|
RmsDevice type;
|
|
|
|
// Get the target device name
|
|
pDevice->GetDeviceType( (LONG *) &type );
|
|
|
|
if ( m_deviceType == type ) {
|
|
|
|
// Device types match
|
|
hr = S_OK;
|
|
result = 0;
|
|
|
|
}
|
|
else {
|
|
hr = S_FALSE;
|
|
result = 1;
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
default:
|
|
|
|
//
|
|
// Since devices aren't CWsbCollectables, we should
|
|
// never come here. CRmsDrive, or CRmsChanger will
|
|
// handle the default case.
|
|
//
|
|
|
|
WsbAssertHr( E_UNEXPECTED );
|
|
break;
|
|
}
|
|
|
|
}
|
|
WsbCatch(hr);
|
|
|
|
if (0 != pResult) {
|
|
*pResult = result;
|
|
}
|
|
|
|
WsbTraceOut(OLESTR("CRmsDevice::CompareTo"), OLESTR("hr = <%ls>, result = <%ls>"), WsbHrAsString(hr), WsbPtrToShortAsString(pResult));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CRmsDevice::GetSizeMax(
|
|
OUT ULARGE_INTEGER* pcbSize
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistStream::GetSizeMax
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = E_NOTIMPL;
|
|
|
|
// ULONG deviceNameLen;
|
|
|
|
WsbTraceIn(OLESTR("CRmsDevice::GetSizeMax"), OLESTR(""));
|
|
|
|
// try {
|
|
// WsbAssert(0 != pcbSize, E_POINTER);
|
|
|
|
// deviceNameLen = SysStringByteLen(m_deviceName);
|
|
|
|
// // Get max size
|
|
// pcbSize->QuadPart = WsbPersistSizeOf(LONG) + // length of m_deviceName
|
|
// deviceNameLen + // m_deviceName
|
|
// WsbPersistSizeOf(LONG) + // m_deviceType
|
|
// WsbPersistSizeOf(SHORT) + // m_sizeOfDeviceInfo
|
|
// MaxInfo + // m_deviceInfo
|
|
// WsbPersistSizeOf(BYTE) + // m_port
|
|
// WsbPersistSizeOf(BYTE) + // m_bus
|
|
// WsbPersistSizeOf(BYTE) + // m_targetId
|
|
// WsbPersistSizeOf(BYTE); // m_lun
|
|
|
|
// } WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CRmsDevice::GetSizeMax"), OLESTR("hr = <%ls>, Size = <%ls>"), WsbHrAsString(hr), WsbPtrToUliAsString(pcbSize));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CRmsDevice::Load(
|
|
IN IStream* pStream
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistStream::Load
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG ulBytes = 0;
|
|
|
|
WsbTraceIn(OLESTR("CRmsDevice::Load"), OLESTR(""));
|
|
|
|
try {
|
|
ULONG temp;
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
WsbAffirmHr(CRmsChangerElement::Load(pStream));
|
|
|
|
// Read value
|
|
m_deviceName.Free();
|
|
WsbAffirmHr(WsbBstrFromStream(pStream, &m_deviceName));
|
|
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &temp));
|
|
m_deviceType = (RmsDevice)temp;
|
|
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_sizeofDeviceInfo));
|
|
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &(m_deviceInfo [0]), MaxInfo));
|
|
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_port));
|
|
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_bus));
|
|
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_targetId));
|
|
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_lun));
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CRmsDevice::Load"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CRmsDevice::Save(
|
|
IN IStream* pStream,
|
|
IN BOOL clearDirty
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistStream::Save
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG ulBytes = 0;
|
|
|
|
WsbTraceIn(OLESTR("CRmsDevice::Save"), OLESTR("clearDirty = <%ls>"), WsbBoolAsString(clearDirty));
|
|
|
|
try {
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
WsbAffirmHr(CRmsChangerElement::Save(pStream, clearDirty));
|
|
|
|
// Write value
|
|
WsbAffirmHr(WsbBstrToStream(pStream, m_deviceName));
|
|
|
|
WsbAffirmHr(WsbSaveToStream(pStream, (ULONG) m_deviceType));
|
|
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_sizeofDeviceInfo));
|
|
|
|
WsbAffirmHr(WsbSaveToStream(pStream, &(m_deviceInfo [0]), MaxInfo));
|
|
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_port));
|
|
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_bus));
|
|
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_targetId));
|
|
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_lun));
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CRmsDevice::Save"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CRmsDevice::Test(
|
|
OUT USHORT *pPassed,
|
|
OUT USHORT *pFailed
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTestable::Test
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
CComPtr<IRmsMediaSet> pMediaSet1;
|
|
CComPtr<IRmsMediaSet> pMediaSet2;
|
|
|
|
CComPtr<IPersistFile> pFile1;
|
|
CComPtr<IPersistFile> pFile2;
|
|
|
|
LONG i;
|
|
|
|
LONG passfail = TRUE;
|
|
|
|
CWsbBstrPtr bstrVal1 = OLESTR("5A5A5A");
|
|
CWsbBstrPtr bstrWork1;
|
|
CWsbBstrPtr bstrWork2;
|
|
|
|
SHORT ucharLenVal1 = 10;
|
|
UCHAR ucharVal1[MaxInfo] = {1,2,3,4,5,6,7,8,9,10};
|
|
|
|
SHORT ucharLenWork1;
|
|
UCHAR ucharWork1[MaxInfo];
|
|
|
|
BYTE byteVal1 = 1;
|
|
BYTE byteVal2 = 2;
|
|
BYTE byteVal3 = 3;
|
|
BYTE byteVal4 = 4;
|
|
|
|
BYTE byteWork1;
|
|
BYTE byteWork2;
|
|
BYTE byteWork3;
|
|
BYTE byteWork4;
|
|
|
|
|
|
WsbTraceIn(OLESTR("CRmsDevice::Test"), OLESTR(""));
|
|
|
|
try {
|
|
// Get the MediaSet interface.
|
|
hr = S_OK;
|
|
try {
|
|
WsbAssertHr(((IUnknown*) (IRmsMediaSet*) this)->QueryInterface(IID_IRmsMediaSet, (void**) &pMediaSet1));
|
|
|
|
// Test SetDeviceName & GetDeviceName interface
|
|
bstrWork1 = bstrVal1;
|
|
|
|
SetDeviceName(bstrWork1);
|
|
|
|
GetDeviceName(&bstrWork2);
|
|
|
|
if (bstrWork1 == bstrWork2){
|
|
(*pPassed)++;
|
|
} else {
|
|
(*pFailed)++;
|
|
}
|
|
|
|
// Test SetDeviceInfo & GetDeviceInfo interface
|
|
SetDeviceInfo(ucharVal1, ucharLenVal1);
|
|
|
|
GetDeviceInfo(ucharWork1, &ucharLenWork1);
|
|
|
|
if (ucharLenVal1 == ucharLenWork1){
|
|
(*pPassed)++;
|
|
} else {
|
|
(*pFailed)++;
|
|
}
|
|
|
|
passfail = TRUE;
|
|
|
|
for(i = 0; i < ucharLenVal1; i++){
|
|
if(ucharVal1[i] != ucharWork1[i]){
|
|
passfail = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (passfail == TRUE){
|
|
(*pPassed)++;
|
|
} else {
|
|
(*pFailed)++;
|
|
}
|
|
|
|
// Test SetDeviceAddress & GetDeviceAddress
|
|
SetDeviceAddress(byteVal1, byteVal2, byteVal3, byteVal4);
|
|
|
|
GetDeviceAddress(&byteWork1, &byteWork2, &byteWork3, &byteWork4);
|
|
|
|
if ((byteVal1 == byteWork1) &&
|
|
(byteVal2 == byteWork2) &&
|
|
(byteVal3 == byteWork3) &&
|
|
(byteVal4 == byteWork4)){
|
|
(*pPassed)++;
|
|
} else {
|
|
(*pFailed)++;
|
|
}
|
|
|
|
} WsbCatch(hr);
|
|
|
|
// Tally up the results
|
|
|
|
hr = S_OK;
|
|
|
|
if (*pFailed) {
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CRmsDevice::Test"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsDevice::GetDeviceName(
|
|
BSTR *pName
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsDevice::GetDeviceName
|
|
|
|
--*/
|
|
{
|
|
WsbAssertPointer (pName);
|
|
|
|
m_deviceName. CopyToBstr (pName);
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsDevice::SetDeviceName(
|
|
BSTR name
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsDevice::SetDeviceName
|
|
|
|
--*/
|
|
{
|
|
m_deviceName = name;
|
|
// m_isDirty = TRUE;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsDevice::GetDeviceType(
|
|
LONG *pType
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsDevice::GetDeviceType
|
|
|
|
--*/
|
|
{
|
|
*pType = m_deviceType;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsDevice::SetDeviceType(
|
|
LONG type
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsDevice::SetDeviceType
|
|
|
|
--*/
|
|
{
|
|
m_deviceType = (RmsDevice)type;
|
|
// m_isDirty = TRUE;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsDevice::GetDeviceInfo(
|
|
UCHAR *pId,
|
|
SHORT *pSize
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsDevice::GetDeviceInfo
|
|
|
|
--*/
|
|
{
|
|
memmove (pId, m_deviceInfo, m_sizeofDeviceInfo);
|
|
*pSize = m_sizeofDeviceInfo;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsDevice::SetDeviceInfo(
|
|
UCHAR *pId,
|
|
SHORT size
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsDevice::SetDeviceInfo
|
|
|
|
--*/
|
|
{
|
|
memmove (m_deviceInfo, pId, size);
|
|
m_sizeofDeviceInfo = size;
|
|
// m_isDirty = TRUE;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsDevice::GetDeviceAddress(
|
|
LPBYTE pPort,
|
|
LPBYTE pBus,
|
|
LPBYTE pId,
|
|
LPBYTE pLun
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsDevice::GetDeviceAddress
|
|
|
|
--*/
|
|
{
|
|
*pPort = m_port;
|
|
*pBus = m_bus;
|
|
*pId = m_targetId;
|
|
*pLun = m_lun;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsDevice::SetDeviceAddress(
|
|
BYTE port,
|
|
BYTE bus,
|
|
BYTE id,
|
|
BYTE lun
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsDevice::SetDeviceAddress
|
|
|
|
--*/
|
|
{
|
|
m_port = port;
|
|
m_bus = bus;
|
|
m_targetId = id;
|
|
m_lun = lun;
|
|
|
|
// m_isDirty = TRUE;
|
|
return S_OK;
|
|
}
|
|
|