able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/fs/hsm/rms/server/rmscartg.cpp

2610 lines
53 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
<EFBFBD> 1998 Seagate Software, Inc. All rights reserved
Module Name:
RmsCartg.cpp
Abstract:
Implementation of CRmsCartridge
Author:
Brian Dodd [brian] 15-Nov-1996
Revision History:
--*/
#include "stdafx.h"
#include "RmsCartg.h"
#include "RmsNTMS.h"
#include "RmsServr.h"
int CRmsCartridge::s_InstanceCount = 0;
#define RMS_USE_ACTIVE_COLLECTION 1
////////////////////////////////////////////////////////////////////////////////
//
// Base class implementations
//
STDMETHODIMP
CRmsCartridge::CompareTo(
IN IUnknown *pCollectable,
OUT SHORT *pResult
)
/*++
Implements:
IWsbCollectable::CompareTo
--*/
{
HRESULT hr = E_FAIL;
SHORT result = 1;
WsbTraceIn( OLESTR("CRmsCartridge::CompareTo"), OLESTR("") );
try {
// Validate arguments - Okay if pResult is NULL
WsbAssertPointer( pCollectable );
// We need the IRmsCartridge interface to get the value of the object.
CComQIPtr<IRmsCartridge, &IID_IRmsCartridge> pCartridge = pCollectable;
WsbAssertPointer( pCartridge );
// Get find by option
CComQIPtr<IRmsComObject, &IID_IRmsComObject> pObject = pCollectable;
WsbAssertPointer( pObject );
switch ( m_findBy ) {
case RmsFindByName:
{
CWsbBstrPtr name;
// Get name
WsbAffirmHr( pCartridge->GetName( &name ) );
// Compare the names
result = (USHORT)wcscmp( m_Name, name );
hr = ( 0 == result ) ? S_OK : S_FALSE;
}
break;
case RmsFindByExternalLabel:
{
CWsbBstrPtr externalLabel;
LONG externalNumber;
// Get external label
WsbAffirmHr( pCartridge->GetTagAndNumber(&externalLabel, &externalNumber) );
// Compare the label
result = (SHORT)wcscmp( m_externalLabel, externalLabel );
hr = ( 0 == result ) ? S_OK : S_FALSE;
}
break;
case RmsFindByExternalNumber:
{
CWsbBstrPtr externalLabel;
LONG externalNumber;
// Get external number
WsbAffirmHr( pCartridge->GetTagAndNumber(&externalLabel, &externalNumber) );
if( m_externalNumber == externalNumber ) {
// External numbers match
hr = S_OK;
result = 0;
}
else {
hr = S_FALSE;
result = 1;
}
}
break;
case RmsFindByScratchMediaCriteria:
{
RmsStatus status;
GUID mediaSetIdToFind, mediaSetId;
WsbAssertHr(pCartridge->GetStatus((LONG *)&status));
WsbAssertHr(pCartridge->GetMediaSetId(&mediaSetId));
WsbAssertHr(GetMediaSetId(&mediaSetIdToFind));
if ( (RmsStatusScratch == status) && (mediaSetIdToFind == mediaSetId)) {
// Status is scratch
hr = S_OK;
result = 0;
}
else {
hr = S_FALSE;
result = 1;
}
}
break;
case RmsFindByCartridgeId:
case RmsFindByObjectId:
default:
// Do CompareTo for object
hr = CRmsComObject::CompareTo( pCollectable, &result );
break;
}
}
WsbCatch( hr );
if ( SUCCEEDED(hr) && (0 != pResult) ) {
*pResult = result;
}
WsbTraceOut( OLESTR("CRmsCartridge::CompareTo"),
OLESTR("hr = <%ls>, result = <%ls>"),
WsbHrAsString( hr ), WsbPtrToShortAsString( pResult ) );
return hr;
}
HRESULT
CRmsCartridge::FinalConstruct(
void
)
/*++
Implements:
CComObjectRoot::FinalConstruct
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CRmsCartridge::FinalConstruct"), OLESTR("this = %p"),
static_cast<void *>(this));
try {
WsbAssertHr(CWsbObject::FinalConstruct());
// Initialize fields
m_Name = OLESTR("");
m_Description = OLESTR("");
m_externalLabel = OLESTR("");
m_externalNumber = 0;
m_sizeofOnMediaId = 0;
m_typeofOnMediaId = 0;
m_pOnMediaId = 0;
m_onMediaLabel = RMS_UNDEFINED_STRING;
m_status = RmsStatusUnknown;
m_type = RmsMediaUnknown;
m_BlockSize = 0;
m_isTwoSided = 0;
m_isMounted = 0;
m_isInTransit = 0;
m_isAvailable = 0;
m_isMountedSerialized = 0;
m_home.SetLocation(0,GUID_NULL,GUID_NULL,0,0,0,0,0);
m_location.SetLocation(0,GUID_NULL,GUID_NULL,0,0,0,0,0);
m_destination.SetLocation(0,GUID_NULL,GUID_NULL,0,0,0,0,0);
m_mailStop = RMS_UNDEFINED_STRING;
m_pDrive = 0;
m_sizeofInfo = 0;
for (int i = 0; i < RMS_STR_MAX_CARTRIDGE_INFO; i++){
m_info[i] = 0;
}
m_ownerClassId = GUID_NULL;
m_pParts = 0;
m_verifierClass = GUID_NULL;
m_portalClass = GUID_NULL;
m_pDataCache = NULL;
m_DataCacheSize = 0;
m_DataCacheUsed = 0;
m_DataCacheStartPBA.QuadPart = 0;
m_ManagedBy = RmsMediaManagerUnknown;
} WsbCatch(hr);
s_InstanceCount++;
WsbTraceAlways(OLESTR("CRmsCartridge::s_InstanceCount += %d\n"), s_InstanceCount);
WsbTraceOut(OLESTR("CRmsCartridge::FinalConstruct"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
STDMETHODIMP
CRmsCartridge::FinalRelease(void)
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CRmsCartridge::FinalRelease"), OLESTR("this = %p"),
static_cast<void *>(this));
try {
if (m_pOnMediaId) {
WsbFree(m_pOnMediaId);
m_pOnMediaId = NULL;
m_sizeofOnMediaId = 0;
m_typeofOnMediaId = 0;
}
if (m_pDataCache) {
WsbFree(m_pDataCache);
m_pDataCache = NULL;
m_DataCacheSize = 0;
m_DataCacheUsed = 0;
m_DataCacheStartPBA.QuadPart = 0;
}
CWsbObject::FinalRelease();
} WsbCatch(hr);
s_InstanceCount--;
WsbTraceAlways(OLESTR("CRmsCartridge::s_InstanceCount -= %d\n"), s_InstanceCount);
WsbTraceOut(OLESTR("CRmsCartridge::FinalRelease"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
STDMETHODIMP
CRmsCartridge::GetClassID(
OUT CLSID* pClsid
)
/*++
Implements:
IPersist::GetClassId
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CRmsCartridge::GetClassID"), OLESTR(""));
try {
WsbAssertPointer(pClsid);
*pClsid = CLSID_CRmsCartridge;
} WsbCatch(hr);
WsbTraceOut(OLESTR("CRmsCartridge::GetClassID"), OLESTR("hr = <%ls>, CLSID = <%ls>"), WsbHrAsString(hr), WsbGuidAsString(*pClsid));
return(hr);
}
STDMETHODIMP
CRmsCartridge::GetSizeMax(
OUT ULARGE_INTEGER* pcbSize
)
/*++
Implements:
IPersistStream::GetSizeMax
--*/
{
HRESULT hr = E_NOTIMPL;
// ULONG nameLen;
// ULONG externalLabelLen;
// ULONG mailStopLen;
// WsbTraceIn(OLESTR("CRmsCartridge::GetSizeMax"), OLESTR(""));
// try {
// WsbAssert(0 != pcbSize, E_POINTER);
// nameLen = SysStringByteLen(m_name);
// externalLabelLen = SysStringByteLen(m_externalLabel);
// mailStopLen = SysStringByteLen(m_mailStop);
// // set up size of CRmsCartridge
// pcbSize->QuadPart = WsbPersistSizeOf(GUID) + // m_cartridgeId
// WsbPersistSizeOf(ULONG) + // length of m_name
// nameLen + // m_name
// WsbPersistSizeOf(ULONG) + // length of m_externalLabel
// externalLabelLen + // m_externalLabel
// WsbPersistSizeOf(LONG) + // m_externalNumber
// WsbPersistSizeOf(LONG) + // m_status
// WsbPersistSizeOf(LONG) + // m_type
// WsbPersistSizeOf(BOOL) + // m_isTwoSided
// WsbPersistSizeOf(CRmsLocator) + // m_home
// WsbPersistSizeOf(CRmsLocator) + // m_location
// WsbPersistSizeOf(ULONG) + // size of m_mailStop
// mailStopLen + // m_mailStop
// WsbPersistSizeOf(SHORT) + // m_sizeofInfo
// RMS_STR_MAX_CARTRIDGE_INFO + // m_Info
// WsbPersistSizeOf(CLSID) + // m_ownerClassId
// // m_pParts
//// WsbPersistSizeOf(CComPtr<IWsbIndexedCollection>) +
// WsbPersistSizeOf(CLSID) + // m_verifierClass
// WsbPersistSizeOf(CLSID); // m_portalClass
// } WsbCatch(hr);
WsbTraceOut(OLESTR("CRmsCartridge::GetSizeMax"), OLESTR("hr = <%ls>, Size = <%ls>"), WsbHrAsString(hr), WsbPtrToUliAsString(pcbSize));
return(hr);
}
STDMETHODIMP
CRmsCartridge::Load(
IN IStream* pStream
)
/*++
Implements:
IPersistStream::Load
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CRmsCartridge::Load"), OLESTR(""));
try {
ULONG temp;
WsbAssert(0 != pStream, E_POINTER);
WsbAffirmHr(CRmsStorageInfo::Load(pStream));
WsbAffirmHr(WsbLoadFromStream(pStream, &m_objectId));
m_externalLabel.Free();
WsbAffirmHr(WsbBstrFromStream(pStream, &m_externalLabel));
WsbAffirmHr(WsbLoadFromStream(pStream, &m_externalNumber));
WsbAffirmHr(WsbLoadFromStream(pStream, &temp));
m_status = (RmsStatus)temp;
WsbAffirmHr(WsbLoadFromStream(pStream, &temp));
m_type = (RmsMedia)temp;
WsbAffirmHr(WsbLoadFromStream(pStream, &m_BlockSize));
WsbAffirmHr(WsbLoadFromStream(pStream, &m_isTwoSided));
WsbAffirmHr(m_home.Load(pStream));
WsbAffirmHr(m_location.Load(pStream));
m_mailStop.Free();
WsbAffirmHr(WsbBstrFromStream(pStream, &m_mailStop));
// WsbAffirmHr(m_pParts->Load(pStream));
WsbAffirmHr(WsbLoadFromStream(pStream, &m_sizeofInfo));
WsbAffirmHr(WsbLoadFromStream(pStream, &m_info[0], MaxInfo));
WsbAffirmHr(WsbLoadFromStream(pStream, &m_ownerClassId));
WsbAffirmHr(WsbLoadFromStream(pStream, &m_verifierClass));
WsbAffirmHr(WsbLoadFromStream(pStream, &m_portalClass));
} WsbCatch(hr);
WsbTraceOut(OLESTR("CRmsCartridge::Load"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
STDMETHODIMP
CRmsCartridge::Save(
IN IStream* pStream,
IN BOOL clearDirty
)
/*++
Implements:
IPersistStream::Save
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CRmsCartridge::Save"), OLESTR("clearDirty = <%ls>"), WsbBoolAsString(clearDirty));
try {
WsbAssert(0 != pStream, E_POINTER);
WsbAffirmHr(CRmsStorageInfo::Save(pStream, clearDirty));
WsbAffirmHr(WsbSaveToStream(pStream, m_objectId));
WsbAffirmHr(WsbBstrToStream(pStream, m_externalLabel));
WsbAffirmHr(WsbSaveToStream(pStream, m_externalNumber));
WsbAffirmHr(WsbSaveToStream(pStream, (ULONG) m_status));
WsbAffirmHr(WsbSaveToStream(pStream, (ULONG) m_type));
WsbAffirmHr(WsbSaveToStream(pStream, m_BlockSize));
WsbAffirmHr(WsbSaveToStream(pStream, m_isTwoSided));
WsbAffirmHr(m_home.Save(pStream, clearDirty));
WsbAffirmHr(m_location.Save(pStream, clearDirty));
WsbAffirmHr(WsbBstrToStream(pStream, m_mailStop));
// WsbAffirmHr(m_pParts->Save(pStream, clearDirty));
WsbAffirmHr(WsbSaveToStream(pStream, m_sizeofInfo));
WsbAffirmHr(WsbSaveToStream(pStream, &m_info [0], MaxInfo));
WsbAffirmHr(WsbSaveToStream(pStream, m_ownerClassId));
WsbAffirmHr(WsbSaveToStream(pStream, m_verifierClass));
WsbAffirmHr(WsbSaveToStream(pStream, m_portalClass));
// Do we need to clear the dirty bit?
if (clearDirty) {
m_isDirty = FALSE;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("CRmsCartridge::Save"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
STDMETHODIMP
CRmsCartridge::Test(
OUT USHORT *pPassed,
OUT USHORT *pFailed
)
/*++
Implements:
IWsbTestable::Test
--*/
{
HRESULT hr = S_OK;
CComPtr<IRmsCartridge> pCartridge1;
CComPtr<IRmsCartridge> pCartridge2;
CComPtr<IPersistFile> pFile1;
CComPtr<IPersistFile> pFile2;
LONG passFail;
LONG i;
CWsbBstrPtr bstrVal1 = OLESTR("5A5A5A");
CWsbBstrPtr bstrVal2 = OLESTR("A5A5A5");
CWsbBstrPtr bstrWork1;
CWsbBstrPtr bstrWork2;
LONG longVal1 = 0x11111111;
LONG longVal2 = 0x22222222;
LONG longVal3 = 0x33333333;
LONG longVal4 = 0x44444444;
LONG longWork0;
LONG longWork1;
LONG longWork2;
LONG longWork3;
LONG longWork4;
LONG mediaTable [RMSMAXMEDIATYPES] = { RmsMediaUnknown,
RmsMedia8mm,
RmsMedia4mm,
RmsMediaDLT,
RmsMediaOptical,
RmsMediaMO35,
RmsMediaWORM,
RmsMediaCDR,
RmsMediaDVD,
RmsMediaDisk,
RmsMediaFixed,
RmsMediaTape };
GUID guidVal1 = { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0};
GUID guidVal2 = { 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1};
GUID guidWork1;
GUID guidWork2;
BOOL boolTrue = TRUE;
BOOL boolFalse = FALSE;
BOOL boolWork1;
WsbTraceIn(OLESTR("CRmsCartridge::Test"), OLESTR(""));
try {
// Get the Cartridge interface.
hr = S_OK;
try {
WsbAssertHr(((IUnknown*) (IRmsCartridge*) this)->QueryInterface(IID_IRmsCartridge, (void**) &pCartridge1));
// Test SetName & GetName interface
bstrWork1 = bstrVal1;
SetName(bstrWork1);
GetName(&bstrWork2);
if (bstrWork1 == bstrWork2){
(*pPassed)++;
} else {
(*pFailed)++;
}
// Test SetTagAndNumber & GetTagAndNumber
bstrWork1 = bstrVal2;
longWork1 = 99;
SetTagAndNumber(bstrWork1, longWork1);
GetTagAndNumber(&bstrWork2, &longWork2);
if ((bstrWork1 == bstrWork2) && (longWork1 == longWork2)){
(*pPassed)++;
} else {
(*pFailed)++;
}
// Test SetIsTwoSided & IsTwoSided to True
hr = S_OK;
try{
WsbAffirmHr(SetIsTwoSided (TRUE));
WsbAffirmHr(IsTwoSided ());
} WsbCatch (hr);
if (hr == S_OK){
(*pPassed)++;
} else {
(*pFailed)++;
}
// Test SetTwoSided & IsTwoSided to FALSE
hr = S_OK;
try{
WsbAffirmHr(SetIsTwoSided (FALSE));
WsbAffirmHr(IsTwoSided ());
} WsbCatch (hr);
if (hr == S_OK){
(*pFailed)++;
} else {
(*pPassed)++;
}
// Test SetStatus & GetStatus
for (i = RmsStatusUnknown; i < RmsStatusCleaning; i++){
longWork1 = i;
SetStatus (longWork1);
GetStatus (&longWork2);
if (longWork1 == longWork2){
(*pPassed)++;
} else {
(*pFailed)++;
}
}
// Test SetType & GetType
for (i = RmsMediaUnknown; i < RMSMAXMEDIATYPES; i++){
longWork1 = mediaTable[i];
SetType (longWork1);
GetType (&longWork2);
if (longWork1 == longWork2){
(*pPassed)++;
} else {
(*pFailed)++;
}
}
// Test SetHome & GetHome
SetHome (RmsMediaOptical, guidVal1, guidVal2, longVal1, longVal2,
longVal3, longVal4, boolTrue);
GetHome (&longWork0, &guidWork1, &guidWork2, &longWork1, &longWork2,
&longWork3, &longWork4, &boolWork1);
passFail = 0;
if (longWork0 == RmsMediaOptical){
passFail++;
}
if (guidWork1 == guidVal1){
passFail++;
}
if (guidWork2 == guidVal2){
passFail++;
}
if (longWork1 == longVal1){
passFail++;
}
if (longWork2 == longVal2){
passFail++;
}
if (longWork3 == longVal3){
passFail++;
}
if (longWork4 == longVal4){
passFail++;
}
if (boolWork1 == TRUE){
passFail++;
}
if (passFail == 8){
(*pPassed)++;
} else {
(*pFailed)++;
}
// Test SetLocation & GetLocation
SetLocation (RmsMediaOptical, guidVal1, guidVal2, longVal1, longVal2,
longVal3, longVal4, boolTrue);
GetLocation (&longWork0, &guidWork1, &guidWork2, &longWork1, &longWork2,
&longWork3, &longWork4, &boolWork1);
passFail = 0;
if (longWork0 == RmsMediaOptical){
passFail++;
}
if (guidWork1 == guidVal1){
passFail++;
}
if (guidWork2 == guidVal2){
passFail++;
}
if (longWork1 == longVal1){
passFail++;
}
if (longWork2 == longVal2){
passFail++;
}
if (longWork3 == longVal3){
passFail++;
}
if (longWork4 == longVal4){
passFail++;
}
if (boolWork1 == TRUE){
passFail++;
}
if (passFail == 8){
(*pPassed)++;
} else {
(*pFailed)++;
}
// Test SetMailStop & GetMailStop interface
SetName(bstrVal1);
GetName(&bstrWork1);
if ((bstrWork1 = bstrVal1) == 0){
(*pPassed)++;
} else {
(*pFailed)++;
}
} WsbCatch(hr);
// Tally up the results
hr = S_OK;
if (*pFailed) {
hr = S_FALSE;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("CRmsCartridge::Test"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
////////////////////////////////////////////////////////////////////////////////
//
// IRmsCartridge implementation
//
STDMETHODIMP
CRmsCartridge::GetCartridgeId(
GUID *pCartId
)
/*++
Implements:
IRmsCartridge::GetCartridgeId
--*/
{
HRESULT hr = E_FAIL;
try {
WsbAssertPointer( pCartId );
*pCartId = m_objectId;
hr = S_OK;
}
WsbCatch(hr)
return hr;
}
STDMETHODIMP
CRmsCartridge::SetCartridgeId(
GUID cartId
)
/*++
Implements:
IRmsCartridge::SetMediaSetId
--*/
{
m_objectId = cartId;
m_isDirty = TRUE;
return S_OK;
}
STDMETHODIMP
CRmsCartridge::GetMediaSetId(
GUID *pMediaSetId
)
/*++
Implements:
IRmsCartridge::GetMediaSetId
--*/
{
HRESULT hr = E_FAIL;
try {
WsbAssertPointer( pMediaSetId );
*pMediaSetId = m_location.m_mediaSetId;
hr = S_OK;
}
WsbCatch(hr)
return hr;
}
STDMETHODIMP
CRmsCartridge::SetMediaSetId(
GUID mediaSetId
)
/*++
Implements:
IRmsCartridge::SetMediaSetId
--*/
{
m_location.m_mediaSetId = mediaSetId;
m_isDirty = TRUE;
return S_OK;
}
STDMETHODIMP
CRmsCartridge::GetName(
BSTR *pName
)
/*++
Implements:
IRmsCartridge::GetName
--*/
{
HRESULT hr = E_FAIL;
try {
WsbAssertPointer(pName);
WsbAffirmHr( m_Name.CopyToBstr(pName) );
hr = S_OK;
}
WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::SetName(
BSTR name
)
/*++
Implements:
IRmsCartridge::SetName
--*/
{
m_Name = name;
m_isDirty = TRUE;
return S_OK;
}
STDMETHODIMP
CRmsCartridge::GetDescription(
BSTR *pDescription
)
/*++
Implements:
IRmsCartridge::GetDescription
--*/
{
HRESULT hr = E_FAIL;
try {
WsbAssertPointer(pDescription);
WsbAffirmHr( m_Description.CopyToBstr(pDescription) );
hr = S_OK;
}
WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::SetDescription(
BSTR description
)
/*++
Implements:
IRmsCartridge::SetDescription
--*/
{
m_Description = description;
m_isDirty = TRUE;
return S_OK;
}
STDMETHODIMP
CRmsCartridge::GetTagAndNumber(
BSTR *pTag,
LONG *pNumber
)
/*++
Implements:
IRmsCartridge::GetTagAndNumber
--*/
{
HRESULT hr = E_FAIL;
try {
WsbAssertPointer(pTag);
WsbAssertPointer(pNumber);
WsbAffirmHr( m_externalLabel.CopyToBstr(pTag) );
*pNumber = m_externalNumber;
hr = S_OK;
}
WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::SetTagAndNumber(
BSTR tag,
LONG number
)
/*++
Implements:
IRmsCartridge::SetTagAndNumber
--*/
{
m_externalLabel = tag;
m_externalNumber = number;
m_isDirty = TRUE;
return S_OK;
}
STDMETHODIMP
CRmsCartridge::GetBarcode(
BSTR *pBarcode
)
/*++
Implements:
IRmsCartridge::GetBarcode
--*/
{
HRESULT hr = S_OK;
try {
WsbAssertPointer(pBarcode);
WsbAffirm(wcslen((WCHAR*)m_externalLabel) > 0, E_FAIL);
WsbAffirmHr(m_externalLabel.CopyToBstr(pBarcode));
} WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::GetOnMediaIdentifier(
BYTE *pIdentifier,
LONG *pSize,
LONG *pType
)
/*++
Implements:
IRmsCartridge::GetOnMediaIdentifier
--*/
{
HRESULT hr = E_FAIL;
try {
WsbAssertPointer( pIdentifier );
WsbAssertPointer( pSize );
WsbAssertPointer( pType );
memmove (pIdentifier, m_pOnMediaId, m_sizeofOnMediaId);
*pSize = m_sizeofOnMediaId;
*pType = m_typeofOnMediaId;
hr = S_OK;
}
WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::SetOnMediaIdentifier(
BYTE *pIdentifier,
LONG size,
LONG type
)
/*++
Implements:
IRmsCartridge::SetOnMediaIdentifier
--*/
{
HRESULT hr = E_FAIL;
try {
WsbAssertPointer( pIdentifier );
CComPtr<IRmsNTMS> pNtms;
if ( m_pOnMediaId ) {
WsbFree( m_pOnMediaId );
m_pOnMediaId = 0;
}
m_pOnMediaId = (BYTE *)WsbAlloc( size );
WsbAffirmPointer(m_pOnMediaId);
memset(m_pOnMediaId, 0, size);
memmove (m_pOnMediaId, pIdentifier, size);
m_sizeofOnMediaId = size;
m_typeofOnMediaId = type;
m_isDirty = TRUE;
if (RmsMediaManagerNTMS == m_ManagedBy) {
// Now update any external database
CComQIPtr<IRmsServer, &IID_IRmsServer> pServer = g_pServer;
WsbAffirmHr( pServer->GetNTMS( &pNtms ) );
WsbAffirmHr( pNtms->UpdateOmidInfo( m_objectId, pIdentifier, size, type ) );
}
hr = S_OK;
} WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::GetOnMediaLabel(
BSTR *pLabel
)
/*++
Implements:
IRmsCartridge::GetOnMediaLabel
--*/
{
HRESULT hr = E_FAIL;
try {
WsbAssertPointer(pLabel);
WsbAffirmHr( m_onMediaLabel.CopyToBstr(pLabel) );
hr = S_OK;
}
WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::SetOnMediaLabel(
BSTR label
)
/*++
Implements:
IRmsCartridge::SetOnMediaLabel
--*/
{
m_onMediaLabel = label;
m_isDirty = TRUE;
return S_OK;
}
STDMETHODIMP CRmsCartridge::GetStatus(
LONG *pStatus
)
/*++
Implements:
IRmsCartridge::GetStatus
--*/
{
*pStatus = m_status;
return S_OK;
}
STDMETHODIMP CRmsCartridge::SetStatus(
LONG status
)
/*++
Implements:
IRmsCartridge::SetStatus
--*/
{
m_status = (RmsStatus)status;
m_isDirty = TRUE;
return S_OK;
}
STDMETHODIMP
CRmsCartridge::GetType(
LONG *pType
)
/*++
Implements:
IRmsCartridge::GetType
--*/
{
*pType = (LONG) m_type;
return S_OK;
}
STDMETHODIMP
CRmsCartridge::SetType(
LONG type
)
/*++
Implements:
IRmsCartridge::SetType
--*/
{
m_type = (RmsMedia) type;
m_isDirty = TRUE;
return S_OK;
}
STDMETHODIMP
CRmsCartridge::GetBlockSize(
LONG *pBlockSize
)
/*++
Implements:
IRmsCartridge::GetBlockSize
--*/
{
HRESULT hr = S_OK;
try {
if (!m_BlockSize) {
if (RmsMediaManagerNTMS == m_ManagedBy) {
LONG blockSize;
CComPtr<IRmsNTMS> pNtms;
CComQIPtr<IRmsServer, &IID_IRmsServer> pServer = g_pServer;
WsbAffirmHr(pServer->GetNTMS(&pNtms));
if (S_OK == pNtms->GetBlockSize(m_objectId, &blockSize)) {
m_BlockSize = blockSize;
}
}
}
*pBlockSize = m_BlockSize;
} WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::SetBlockSize(
LONG blockSize
)
/*++
Implements:
IRmsCartridge::SetBlockSize
--*/
{
HRESULT hr = S_OK;
try {
if (RmsMediaManagerNTMS == m_ManagedBy) {
// Update external database
CComPtr<IRmsNTMS> pNtms;
CComQIPtr<IRmsServer, &IID_IRmsServer> pServer = g_pServer;
WsbAffirmHr(pServer->GetNTMS(&pNtms));
WsbAffirmHr(pNtms->SetBlockSize(m_objectId, blockSize));
}
m_BlockSize = blockSize;
m_isDirty = TRUE;
} WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::SetIsTwoSided(
BOOL flag
)
/*++
Implements:
IRmsCartridge::SetTwoSided
--*/
{
m_isTwoSided = flag;
m_isDirty = TRUE;
return S_OK;
}
STDMETHODIMP
CRmsCartridge::IsTwoSided(
VOID
)
/*++
Implements:
IRmsCartridge::IsTwoSided
--*/
{
HRESULT hr = E_FAIL;
hr = m_isTwoSided ? S_OK : S_FALSE;
return (hr);
}
STDMETHODIMP
CRmsCartridge::SetIsMounted(
BOOL flag
)
/*++
Implements:
IRmsCartridge::SetMounted
--*/
{
m_isMounted = flag;
if ( FALSE == m_isMounted ) {
m_pDrive = 0;
}
return S_OK;
}
STDMETHODIMP
CRmsCartridge::IsMounted(
VOID
)
/*++
Implements:
IRmsCartridge::IsMounted
--*/
{
HRESULT hr = E_FAIL;
hr = m_isMounted ? S_OK : S_FALSE;
return (hr);
}
STDMETHODIMP CRmsCartridge::GetHome(
LONG *pType,
GUID *pLibId,
GUID *pMediaSetId,
LONG *pPos,
LONG *pAlt1,
LONG *pAlt2,
LONG *pAlt3,
BOOL *pInvert
)
/*++
Implements:
IRmsCartridge::GetHome
--*/
{
return m_home.GetLocation(pType,
pLibId,
pMediaSetId,
pPos,
pAlt1,
pAlt2,
pAlt3,
pInvert);
}
STDMETHODIMP CRmsCartridge::SetHome(
LONG type,
GUID libId,
GUID mediaSetId,
LONG pos,
LONG alt1,
LONG alt2,
LONG alt3,
BOOL invert
)
/*++
Implements:
IRmsCartridge::SetHome
--*/
{
return m_home.SetLocation(type,
libId,
mediaSetId,
pos,
alt1,
alt2,
alt3,
invert);
}
STDMETHODIMP
CRmsCartridge::GetLocation(
LONG *pType,
GUID *pLibId,
GUID *pMediaSetId,
LONG *pPos,
LONG *pAlt1,
LONG *pAlt2,
LONG *pAlt3,
BOOL *pInvert)
/*++
Implements:
IRmsCartridge::GetLocation
--*/
{
return m_location.GetLocation(pType,
pLibId,
pMediaSetId,
pPos,
pAlt1,
pAlt2,
pAlt3,
pInvert);
}
STDMETHODIMP
CRmsCartridge::SetLocation(
LONG type,
GUID libId,
GUID mediaSetId,
LONG pos,
LONG alt1,
LONG alt2,
LONG alt3,
BOOL invert)
/*++
Implements:
IRmsCartridge::SetLocation
--*/
{
return m_location.SetLocation(type,
libId,
mediaSetId,
pos,
alt1,
alt2,
alt3,
invert);
}
STDMETHODIMP
CRmsCartridge::GetMailStop(
BSTR *pMailStop
)
/*++
Implements:
IRmsCartridge::GetMailStop
--*/
{
HRESULT hr = E_FAIL;
try {
WsbAssertPointer (pMailStop);
WsbAffirmHr( m_mailStop.CopyToBstr(pMailStop) );
hr = S_OK;
}
WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::SetMailStop(
BSTR mailStop
)
/*++
Implements:
IRmsCartridge::SetMailStop
--*/
{
m_mailStop = mailStop;
m_isDirty = TRUE;
return S_OK;
}
STDMETHODIMP
CRmsCartridge::GetDrive(
IRmsDrive **ptr
)
/*++
Implements:
IRmsCartridge::GetDrive
--*/
{
HRESULT hr = E_FAIL;
try {
WsbAssertPointer( ptr );
WsbAffirmPointer(m_pDrive);
*ptr = m_pDrive;
m_pDrive->AddRef();
hr = S_OK;
} WsbCatch( hr );
return(hr);
}
STDMETHODIMP
CRmsCartridge::SetDrive(
IRmsDrive *ptr
)
/*++
Implements:
IRmsChangerElement::SetCartridge
--*/
{
HRESULT hr = E_FAIL;
try {
WsbAssertPointer( ptr );
CComQIPtr<IRmsChangerElement, &IID_IRmsChangerElement> pElmt = ptr;
WsbAffirmHr( pElmt->SetCartridge( this ) );
if ( m_pDrive )
m_pDrive = 0;
m_pDrive = ptr;
m_isMounted = TRUE;
hr = S_OK;
} WsbCatch( hr );
return(hr);
}
STDMETHODIMP
CRmsCartridge::GetInfo(
UCHAR *pInfo,
SHORT *pSize
)
/*++
Implements:
IRmsCartridge::GetInfo
--*/
{
HRESULT hr = E_FAIL;
try {
WsbAssertPointer( pInfo );
WsbAssertPointer( pSize );
memmove (pInfo, m_info, m_sizeofInfo);
*pSize = m_sizeofInfo;
hr = S_OK;
}
WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::SetInfo(
UCHAR *pInfo,
SHORT size
)
/*++
Implements:
IRmsCartridge::SetInfo
--*/
{
HRESULT hr = E_FAIL;
try {
WsbAssertPointer( pInfo );
memmove (m_info, pInfo, size);
m_sizeofInfo = size;
m_isDirty = TRUE;
hr = S_OK;
}
WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::GetOwnerClassId(
CLSID *pClassId
)
/*++
Implements:
IRmsCartridge::GetOwnerClassId
--*/
{
HRESULT hr = E_FAIL;
try {
WsbAssertPointer( pClassId );
*pClassId = m_ownerClassId;
hr = S_OK;
}
WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::SetOwnerClassId(
CLSID classId
)
/*++
Implements:
IRmsCartridge::SetOwnerClassId
--*/
{
m_ownerClassId = classId;
m_isDirty = TRUE;
return S_OK;
}
STDMETHODIMP
CRmsCartridge::GetPartitions(
IWsbIndexedCollection **ptr
)
/*++
Implements:
IRmsCartridge::GetPartitions
--*/
{
HRESULT hr = E_FAIL;
try {
WsbAssertPointer( ptr );
*ptr = m_pParts;
m_pParts->AddRef();
hr = S_OK;
}
WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::GetVerifierClass(
CLSID *pClassId
)
/*++
Implements:
IRmsCartridge::GetVerifierClass
--*/
{
HRESULT hr = E_FAIL;
try {
WsbAssertPointer( pClassId );
*pClassId = m_verifierClass;
hr = S_OK;
}
WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::SetVerifierClass(
CLSID classId
)
/*++
Implements:
IRmsCartridge::SetVerifierClass
--*/
{
m_verifierClass = classId;
m_isDirty = TRUE;
return S_OK;
}
STDMETHODIMP
CRmsCartridge::GetPortalClass(
CLSID *pClassId
)
/*++
Implements:
IRmsCartridge::GetPortalClass
--*/
{
HRESULT hr = E_FAIL;
try {
WsbAssertPointer( pClassId );
*pClassId = m_portalClass;
hr = S_OK;
}
WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::SetPortalClass(
CLSID classId
)
/*++
Implements:
IRmsCartridge::SetPortalClass
--*/
{
m_portalClass = classId;
m_isDirty = TRUE;
return S_OK;
}
STDMETHODIMP
CRmsCartridge::LoadDataCache(
OUT BYTE *pCache,
IN OUT ULONG *pSize,
OUT ULONG *pUsed,
OUT ULARGE_INTEGER *pStartPBA)
/*++
Implements:
IRmsCartridge::LoadDataCache
--*/
{
HRESULT hr = S_OK;
try {
WsbAssertPointer( pCache );
WsbAssertPointer( pSize );
WsbAssertPointer( pUsed );
WsbAssertPointer( pStartPBA );
if (m_pDataCache) {
// The saved cache size must match the target
WsbAssert(*pSize == m_DataCacheSize, E_INVALIDARG);
memmove (pCache, m_pDataCache, m_DataCacheUsed);
*pSize = m_DataCacheSize;
*pUsed = m_DataCacheUsed;
*pStartPBA = m_DataCacheStartPBA;
}
else {
hr = E_FAIL;
}
} WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::SaveDataCache(
IN BYTE *pCache,
IN ULONG size,
IN ULONG used,
IN ULARGE_INTEGER startPBA)
/*++
Implements:
IRmsCartridge::SaveDataCache
--*/
{
HRESULT hr = S_OK;
try {
WsbAssertPointer( pCache );
WsbAssert(size > 0, E_INVALIDARG);
WsbAssert(used <= size, E_INVALIDARG);
// Check that the current cache is big enough
// to handle the incomming buffer.
if (m_pDataCache && used > m_DataCacheSize) {
WsbFree(m_pDataCache);
m_pDataCache = NULL;
m_DataCacheSize = 0;
m_DataCacheUsed = 0;
m_DataCacheStartPBA.QuadPart = 0;
}
if (!m_pDataCache) {
m_pDataCache = (BYTE *) WsbAlloc(size);
WsbAssertPointer(m_pDataCache);
memset(m_pDataCache, 0, size);
m_DataCacheSize = size;
}
WsbAssert(used <= m_DataCacheSize, E_INVALIDARG);
memmove (m_pDataCache, pCache, used);
m_DataCacheUsed = used;
m_DataCacheStartPBA = startPBA;
m_isDirty = TRUE;
} WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::GetManagedBy(
OUT LONG *pManagedBy
)
/*++
Implements:
IRmsCartridge::GetManagedBy
--*/
{
HRESULT hr = S_OK;
try {
WsbAssertPointer( pManagedBy );
*pManagedBy = (LONG) m_ManagedBy;
} WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::SetManagedBy(
IN LONG managedBy
)
/*++
Implements:
IRmsCartridge::SetManagedBy
--*/
{
m_ManagedBy = (RmsMediaManager) managedBy;
return S_OK;
}
STDMETHODIMP
CRmsCartridge::Mount(
OUT IRmsDrive **ppDrive,
IN DWORD dwOptions,
IN DWORD threadId)
/*++
Implements:
IRmsCartridge::Mount
--*/
{
HRESULT hr = E_FAIL;
WsbTraceIn(OLESTR("CRmsCartridge::Mount"), OLESTR(""));
try {
CComPtr<IRmsDrive> pDrive;
// first check if the cartridge is already mounted
if ( S_OK == IsMounted() ) {
LONG refs;
WsbAffirmHr( m_pDrive->GetMountReference( &refs ) );
if ( refs ) {
// Does media type support concurrent mounts?
switch ( m_type ) {
case RmsMedia8mm:
case RmsMedia4mm:
case RmsMediaDLT:
case RmsMediaTape:
// Tape doesn't support concurrent access - queue another mount
if (RmsMediaManagerNTMS == m_ManagedBy) {
CComPtr<IRmsNTMS> pNtms;
CComQIPtr<IRmsServer, &IID_IRmsServer> pServer = g_pServer;
WsbAffirmHr(pServer->GetNTMS(&pNtms));
WsbAffirmHr(pNtms->Mount(this, &pDrive, dwOptions, threadId));
// We've successfully mounted the cartridge, so
// add it the the active cartridge list.
#if RMS_USE_ACTIVE_COLLECTION
CComPtr<IWsbIndexedCollection> pActiveCartridges;
WsbAffirmHr(pServer->GetActiveCartridges(&pActiveCartridges));
WsbAffirmHr(pActiveCartridges->Add((IRmsCartridge *)this));
#else
WsbAffirmHr(pServer->SetActiveCartridge((IRmsCartridge *)this));
#endif
} else {
WsbAffirmHr( RMS_E_CARTRIDGE_BUSY );
}
break;
case RmsMediaWORM:
WsbAssertHr( E_NOTIMPL );
break;
case RmsMediaMO35:
case RmsMediaCDR:
case RmsMediaDVD:
case RmsMediaOptical:
case RmsMediaDisk:
case RmsMediaFixed:
// Optical media and fixed disks supports concurrent access
if (m_isMountedSerialized && (dwOptions & RMS_SERIALIZE_MOUNT)) {
// If the media is already mounted for serialized operation, then we need
// to serialize the mount despite the media supporting concurrent mounts.
// For fixed disk (where we cannot serialize by issuing another RSM mount) -
// we fail the mount with RMS_E_CARTRIDGE_BUSY
if (RmsMediaManagerNTMS == m_ManagedBy) {
CComPtr<IRmsNTMS> pNtms;
CComQIPtr<IRmsServer, &IID_IRmsServer> pServer = g_pServer;
WsbAffirmHr(pServer->GetNTMS(&pNtms));
WsbAffirmHr(pNtms->Mount(this, &pDrive, dwOptions, threadId));
// We've successfully mounted the cartridge, so
// add it the the active cartridge list.
#if RMS_USE_ACTIVE_COLLECTION
CComPtr<IWsbIndexedCollection> pActiveCartridges;
WsbAffirmHr(pServer->GetActiveCartridges(&pActiveCartridges));
WsbAffirmHr(pActiveCartridges->Add((IRmsCartridge *)this));
#else
WsbAffirmHr(pServer->SetActiveCartridge((IRmsCartridge *)this));
#endif
} else {
WsbAffirmHr( RMS_E_CARTRIDGE_BUSY );
}
}
break;
default:
WsbAssertHr( E_UNEXPECTED );
break;
}
}
}
if ( S_FALSE == IsMounted() ) {
CComQIPtr<IRmsServer, &IID_IRmsServer> pServer = g_pServer;
if (RmsMediaManagerNTMS == m_ManagedBy) {
CComPtr<IRmsNTMS> pNtms;
WsbAffirmHr(pServer->GetNTMS(&pNtms));
WsbAffirmHr(pNtms->Mount(this, &pDrive, dwOptions, threadId));
}
else {
LONG type;
GUID libId, mediaSetId;
LONG pos, alt1, alt2, alt3;
BOOL invert;
WsbAssertHr( m_location.GetLocation( &type, &libId, &mediaSetId, &pos, &alt1, &alt2, &alt3, &invert ));
switch ( (RmsElement) type ) {
case RmsElementStage:
case RmsElementStorage:
{
CComPtr<IRmsLibrary> pLib;
CComPtr<IWsbIndexedCollection> pDrives;
WsbAffirmHr( pServer->FindLibraryById( libId, &pLib ));
// Select a drive
// TODO: This code will be added to the the library interface as a drive
// slection method. For now, if one is free we use it.
WsbAffirmHr( pLib->GetDrives( &pDrives ));
CComPtr<IWsbEnum> pEnumDrives;
WsbAffirmHr( pDrives->Enum( &pEnumDrives ));
WsbAssertPointer( pEnumDrives );
hr = pEnumDrives->First( IID_IRmsDrive, (void **)&pDrive );
// Search for a drive to mount to
while ( S_OK == hr ) {
hr = pDrive->SelectForMount();
if ( S_OK == hr ) {
CComPtr<IWsbIndexedCollection> pChangers;
CComPtr<IRmsMediumChanger> pChanger;
CComPtr<IWsbEnum> pEnumChangers;
WsbAffirmHr( pLib->GetChangers( &pChangers ));
WsbAssertHr( pChangers->Enum( &pEnumChangers ));
WsbAssertPointer( pEnumChangers );
// we'll just use the first changer for the move.
WsbAssertHr( pEnumChangers->First( IID_IRmsMediumChanger, (void **)&pChanger ));
WsbAffirmHr( pChanger->MoveCartridge( this, pDrive ));
WsbAffirmHr( SetIsMounted( TRUE ));
WsbAffirmHr( SetDrive( pDrive ));
break;
}
hr = pEnumDrives->Next( IID_IRmsDrive, (void **)&pDrive );
}
}
break;
case RmsElementShelf:
case RmsElementOffSite:
WsbAssertHr( E_NOTIMPL );
break;
case RmsElementDrive:
WsbAssertHr( E_UNEXPECTED );
break;
case RmsElementChanger:
case RmsElementIEPort:
WsbAssertHr( E_NOTIMPL );
break;
} // switch
}
if ( S_OK == IsMounted() ) {
// We've successfully mounted the cartridge, so
// add it the the active cartridge list.
#if RMS_USE_ACTIVE_COLLECTION
CComPtr<IWsbIndexedCollection> pActiveCartridges;
WsbAffirmHr(pServer->GetActiveCartridges(&pActiveCartridges));
WsbAffirmHr(pActiveCartridges->Add((IRmsCartridge *)this));
#else
WsbAffirmHr(pServer->SetActiveCartridge((IRmsCartridge *)this));
#endif
}
}
if ( S_OK == IsMounted() ) {
// Update serialization flag if needed
if (dwOptions & RMS_SERIALIZE_MOUNT) {
// This signals to serialize next mount for the same media
m_isMountedSerialized = TRUE;
}
// Final updates
switch ( m_type ) {
case RmsMedia8mm:
case RmsMedia4mm:
case RmsMediaDLT:
case RmsMediaTape:
// increment the object reference counter.
*ppDrive = m_pDrive;
WsbAffirmHr( m_pDrive->AddRef() );
// increment the mount reference counter.
WsbAffirmHr( m_pDrive->AddMountReference() );
// update stats
WsbAffirmHr( updateMountStats( TRUE, TRUE ) );
hr = S_OK;
break;
case RmsMediaWORM:
WsbAssertHr( E_NOTIMPL );
break;
case RmsMediaMO35:
case RmsMediaCDR:
case RmsMediaDVD:
case RmsMediaOptical:
case RmsMediaDisk:
case RmsMediaFixed:
// increment the object reference counter.
*ppDrive = m_pDrive;
WsbAffirmHr( m_pDrive->AddRef() );
// increment the mount reference counter.
WsbAffirmHr( m_pDrive->AddMountReference() );
// update stats
WsbAffirmHr( updateMountStats( TRUE, TRUE ) );
hr = S_OK;
break;
default:
WsbAssertHr( E_UNEXPECTED );
break;
}
}
} WsbCatch(hr)
WsbTraceOut(OLESTR("CRmsCartridge::Mount"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr;
}
STDMETHODIMP
CRmsCartridge::Dismount(
IN DWORD dwOptions
)
/*++
Implements:
IRmsCartridge::Dismount
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CRmsCartridge::Dismount"), OLESTR("<%ld>"), dwOptions);
try {
// Update stats
WsbAffirmHr(updateMountStats(FALSE, FALSE));
// Decrement the mount reference counter.
//
// When the reference count for the cartridge goes to zero,
// and the dismount wait time has expired, we physically
// move the cartridge back to it's storage location.
WsbAssert(m_pDrive != 0, RMS_E_CARTRIDGE_NOT_MOUNTED);
WsbAffirmHr(m_pDrive->ReleaseMountReference(dwOptions));
} WsbCatch(hr)
WsbTraceOut(OLESTR("CRmsCartridge::Dismount"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr;
}
HRESULT
CRmsCartridge::Home(IN DWORD dwOptions)
/*++
Implements:
IRmsDrive::Home
--*/
{
HRESULT hr S_OK;
WsbTraceIn(OLESTR("CRmsCartridge::Home"), OLESTR(""));
try {
CComQIPtr<IRmsServer, &IID_IRmsServer> pServer = g_pServer;
try {
/*
Tracking DataMovers is only partially implemented.
//
// Cleanup...
// Release all DataMovers that reference this cartridge.
//
CComPtr<IWsbEnum> pEnumDataMovers;
CComPtr<IWsbIndexedCollection> pDataMovers;
CComPtr<IRmsCartridge> pCart;
CComPtr<IDataMover> pMover;
WsbAffirmHr(pServer->GetDataMovers(&pDataMovers));
WsbAffirmHr(pDataMovers->Enum(&pEnumDataMovers));
WsbAssertPointer(pEnumDataMovers);
hr = pEnumDataMovers->First(IID_IDataMover, (void **)&pMover);
while (S_OK == hr) {
try {
GUID cartIdOfMover = GUID_NULL;
GUID cartId = GUID_NULL;
WsbAffirmHr(pMover->GetCartridge(&pCart));
WsbAffirmPointer(pCart);
WsbAffirmHr(pCart->GetCartridgeId(&cartIdOfMover));
WsbAffirmHr(GetCartridgeId(&cartId));
WsbAssert(cartId != GUID_NULL, E_UNEXPECTED);
//
// Does this mover reference this cartridge?
//
if (cartIdOfMover == cartId) {
//
// Cancel any outstanding I/O, and remove the mover
// from the list of active movers.
//
WsbAffirmHr(pMover->Cancel());
WsbAffirmHr(ReleaseDataMover(pMover));
}
} WsbCatch(hr);
pCart = 0;
pMover = 0;
hr = pEnumDataMovers->Next( IID_IDataMover, (void **)&pMover );
}
hr = S_OK;
*/
LONG type;
GUID libId, mediaSetId;
LONG pos, alt1, alt2, alt3;
BOOL invert;
// We're physically moving the cartridge back to it's storage
// location.
WsbAssertHr( m_location.GetLocation( &type, &libId, &mediaSetId, &pos, &alt1, &alt2, &alt3, &invert ));
WsbAffirmHr(SetIsMounted(FALSE));
if (RmsMediaManagerNTMS == m_ManagedBy) {
CComPtr<IRmsNTMS> pNtms;
WsbAffirmHr(pServer->GetNTMS(&pNtms));
WsbAffirmHr(pNtms->Dismount(this, dwOptions));
}
else {
CComPtr<IRmsLibrary> pLib;
CComPtr<IWsbIndexedCollection> pChangers;
CComPtr<IRmsMediumChanger> pChanger;
CComPtr<IWsbEnum> pEnumChangers;
WsbAffirmHr(pServer->FindLibraryById(libId, &pLib));
WsbAffirmHr(pLib->GetChangers(&pChangers));
WsbAssertHr(pChangers->Enum( &pEnumChangers));
WsbAssertPointer(pEnumChangers);
// we'll just use the first changer for the move.
WsbAffirmHr(pEnumChangers->First(IID_IRmsMediumChanger, (void **)&pChanger));
WsbAffirmHr(pChanger->HomeCartridge(this));
}
} WsbCatch(hr)
#if RMS_USE_ACTIVE_COLLECTION
CComPtr<IWsbIndexedCollection> pActiveCartridges;
WsbAffirmHr(pServer->GetActiveCartridges(&pActiveCartridges));
WsbAffirmHr(pActiveCartridges->RemoveAndRelease((IRmsCartridge *)this));
ULONG activeCartridges;
WsbAffirmHr(pActiveCartridges->GetEntries( &activeCartridges));
WsbTrace(OLESTR("activeCartridges = <%u>\n"), activeCartridges);
#else
WsbAffirmHr(pServer->SetActiveCartridge(NULL));
#endif
} WsbCatch(hr)
WsbTraceOut(OLESTR("CRmsCartridge::Home"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr;
}
HRESULT
CRmsCartridge::updateMountStats(
IN BOOL bRead,
IN BOOL bWrite
)
/*++
Updates storage info for the mounted partition
--*/
{
HRESULT hr = E_FAIL;
WsbTraceIn(OLESTR("CRmsCartridge::updateMountStats"), OLESTR(""));
try {
// We have not implemented partitions yet, everything
// is single sided... eventually the following need to be added to
// the correct partition. Should this be in a separate function?.
// For now we don't distinguish between reads and writes
if ( bRead ) m_readMountCounter++;
if ( bWrite ) m_writeMountCounter++;
// Update the read/write timestamps
// if ( bRead ) m_lastReadTimestamp;
// if ( bWrite ) m_lastWriteTimestamp;
hr = S_OK;
} WsbCatch(hr)
WsbTraceOut(OLESTR("CRmsCartridge::updateMountStats"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr;
}
STDMETHODIMP
CRmsCartridge::CreateDataMover(
IDataMover **ptr
)
/*++
Implements:
IRmsDrive::CreateDataMover
--*/
{
HRESULT hr = S_OK;
try {
WsbAssertPointer(ptr);
if ( S_OK == IsMounted() ) {
WsbAssertPointer(m_pDrive );
WsbAffirmHr(m_pDrive->CreateDataMover(ptr));
}
else {
hr = RMS_E_RESOURCE_UNAVAILABLE;
}
} WsbCatch( hr );
return hr;
}
STDMETHODIMP
CRmsCartridge::ReleaseDataMover(
IN IDataMover *ptr
)
/*++
Implements:
IRmsCartridge::ReleaseDataMover
--*/
{
HRESULT hr = S_OK;
try {
WsbAssertPointer(ptr);
WsbAffirmPointer(m_pDrive);
WsbAffirmHr(m_pDrive->ReleaseDataMover(ptr));
} WsbCatch(hr);
return hr;
}
STDMETHODIMP
CRmsCartridge::SetIsAvailable(
BOOL flag
)
/*++
Implements:
IRmsCartridge::SetIsAvailable
--*/
{
m_isAvailable = flag;
return S_OK;
}
STDMETHODIMP
CRmsCartridge::IsAvailable(
VOID
)
/*++
Implements:
IRmsCartridge::IsAvailable
--*/
{
HRESULT hr = E_FAIL;
hr = m_isAvailable ? S_OK : S_FALSE;
return (hr);
}
STDMETHODIMP
CRmsCartridge::IsFixedBlockSize(void)
/*++
Implements:
IRmsCartridge::IsFixedBlockSize
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CRmsCartridge::IsFixedBlockSize"), OLESTR(""));
try {
switch ( m_type ) {
case RmsMedia8mm:
case RmsMedia4mm:
case RmsMediaDLT:
case RmsMediaTape:
hr = S_FALSE;
break;
case RmsMediaMO35:
case RmsMediaCDR:
case RmsMediaDVD:
case RmsMediaOptical:
case RmsMediaDisk:
case RmsMediaFixed:
hr = S_OK;
break;
default:
WsbAssertHr( E_UNEXPECTED );
break;
}
} WsbCatch(hr)
WsbTraceOut(OLESTR("CRmsCartridge::IsFixedBlockSize"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr;
}
Reference in a new issue Copy permalink