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.
864 lines
15 KiB
864 lines
15 KiB
/*++
|
|
|
|
© 1998 Seagate Software, Inc. All rights reserved
|
|
|
|
Module Name:
|
|
|
|
RmsObjct.cpp
|
|
|
|
Abstract:
|
|
|
|
Implementation of CRmsComObject
|
|
|
|
Author:
|
|
|
|
Brian Dodd [brian] 15-Nov-1996
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include "RmsObjct.h"
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
|
|
|
|
CRmsComObject::CRmsComObject(void)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
CRmsComObject constructor
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
// Default values
|
|
(void) CoCreateGuid( &m_objectId );
|
|
|
|
m_ObjectType = RmsObjectUnknown;
|
|
m_IsEnabled = TRUE;
|
|
m_State = 0;
|
|
m_StatusCode = S_OK;
|
|
m_Name = OLESTR("Object");
|
|
m_Description = OLESTR("");
|
|
|
|
memset( &m_Permit, 0, sizeof( SECURITY_DESCRIPTOR ) );
|
|
|
|
m_findBy = RmsFindByUnknown;
|
|
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CRmsComObject::CompareTo(
|
|
IN IUnknown *pCollectable,
|
|
OUT SHORT *pResult)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
CRmsComObject::CompareTo
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
SHORT result = 1;
|
|
|
|
WsbTraceIn( OLESTR("CRmsComObject::CompareTo"), OLESTR("") );
|
|
|
|
try {
|
|
|
|
// Validate arguments - Okay if pResult is NULL
|
|
WsbAssertPointer( pCollectable );
|
|
|
|
// We need the IRmsComObject interface to get the value of the object.
|
|
CComQIPtr<IRmsComObject, &IID_IRmsComObject> pObject = pCollectable;
|
|
WsbAssertPointer( pObject );
|
|
|
|
switch ( m_findBy ) {
|
|
|
|
case RmsFindByObjectId:
|
|
default:
|
|
{
|
|
GUID objectId;
|
|
|
|
// Get objectId.
|
|
WsbAffirmHr( pObject->GetObjectId( &objectId ));
|
|
|
|
if ( m_objectId == objectId ) {
|
|
|
|
// Object IDs match
|
|
hr = S_OK;
|
|
result = 0;
|
|
|
|
}
|
|
else {
|
|
hr = S_FALSE;
|
|
result = 1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
WsbCatch( hr );
|
|
|
|
if ( SUCCEEDED(hr) && (0 != pResult) ){
|
|
*pResult = result;
|
|
}
|
|
|
|
WsbTraceOut( OLESTR("CRmsComObject::CompareTo"),
|
|
OLESTR("hr = <%ls>, result = <%ls>"),
|
|
WsbHrAsString( hr ), WsbPtrToShortAsString( pResult ) );
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CRmsComObject::GetSizeMax(
|
|
OUT ULARGE_INTEGER* pcbSize)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistStream::GetSizeMax
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = E_NOTIMPL;
|
|
|
|
WsbTraceIn(OLESTR("CRmsComObject::GetSizeMax"), OLESTR(""));
|
|
|
|
// try {
|
|
// WsbAssert(0 != pcbSize, E_POINTER);
|
|
|
|
// // Get max size
|
|
// pcbSize->QuadPart = WsbPersistSizeOf(GUID) + // m_objectId
|
|
// WsbPersistSizeOf(LONG) + // m_findBy
|
|
// WsbPersistSizeOf(LONG) + // m_state
|
|
// WsbPersistSizeOf(HRESULT); // m_errCode
|
|
|
|
//// WsbPersistSizeOf(SECURITY_DESCRIPTOR); // m_permit
|
|
|
|
// } WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CRmsComObject::GetSizeMax"), OLESTR("hr = <%ls>, Size = <%ls>"), WsbHrAsString(hr), WsbPtrToUliAsString(pcbSize));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CRmsComObject::Load(
|
|
IN IStream* pStream)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistStream::Load
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CRmsComObject::Load"), OLESTR(""));
|
|
|
|
try {
|
|
WsbAssertPointer( pStream );
|
|
|
|
USHORT usTemp;
|
|
ULONG ulTemp;
|
|
|
|
// Read value
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_objectId));
|
|
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &usTemp));
|
|
m_ObjectType = (RmsObject)usTemp;
|
|
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_IsEnabled));
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_State));
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &ulTemp));
|
|
m_StatusCode = (HRESULT)ulTemp;
|
|
|
|
m_Name.Free(); // Clean out any thing previously held
|
|
WsbAffirmHr(WsbBstrFromStream(pStream, &m_Name));
|
|
m_Description.Free();
|
|
WsbAffirmHr(WsbBstrFromStream(pStream, &m_Description));
|
|
|
|
// WsbAffirmHr(WsbLoadFromStream(pStream, &m_permit));
|
|
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &usTemp));
|
|
m_findBy = (RmsFindBy)usTemp;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
|
|
WsbTraceOut(OLESTR("CRmsComObject::Load"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CRmsComObject::Save(
|
|
IN IStream* pStream,
|
|
IN BOOL clearDirty)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistStream::Save
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG ulBytes = 0;
|
|
|
|
WsbTraceIn(OLESTR("CRmsComObject::Save"), OLESTR("clearDirty = <%ls>"), WsbBoolAsString(clearDirty));
|
|
|
|
try {
|
|
WsbAssertPointer( pStream );
|
|
|
|
// Read value
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_objectId));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, (USHORT) m_ObjectType));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_IsEnabled));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_State));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, (ULONG) m_StatusCode));
|
|
WsbAffirmHr(WsbBstrToStream(pStream, m_Name));
|
|
WsbAffirmHr(WsbBstrToStream(pStream, m_Description));
|
|
|
|
// WsbAffirmHr(WsbSaveToStream(pStream, m_permit));
|
|
|
|
WsbAffirmHr(WsbSaveToStream(pStream, (USHORT) m_findBy));
|
|
|
|
} WsbCatch(hr);
|
|
|
|
|
|
WsbTraceOut(OLESTR("CRmsComObject::Save"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CRmsComObject::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 longWork1;
|
|
LONG longWork2;
|
|
|
|
HRESULT hresultVal1 = 11111111;
|
|
HRESULT hresultWork1;
|
|
|
|
// SECURITY_DESCRIPTOR permitVal1;
|
|
// SECURITY_DESCRIPTOR permitWork1;
|
|
|
|
|
|
WsbTraceIn(OLESTR("CRmsComObject::Test"), OLESTR(""));
|
|
|
|
try {
|
|
// Get the MediaSet interface.
|
|
hr = S_OK;
|
|
try {
|
|
WsbAssertHr(((IUnknown*) (IRmsMediaSet*) this)->QueryInterface(IID_IRmsMediaSet, (void**) &pMediaSet1));
|
|
|
|
// Test SetState & GetState
|
|
for (i = RmsStateUnknown; i < RmsStateError; i++){
|
|
|
|
longWork1 = i;
|
|
|
|
SetState (longWork1);
|
|
|
|
GetState (&longWork2);
|
|
|
|
if (longWork1 == longWork2){
|
|
(*pPassed)++;
|
|
} else {
|
|
(*pFailed)++;
|
|
}
|
|
}
|
|
|
|
// Test GetErrCode
|
|
m_StatusCode = hresultVal1;
|
|
|
|
GetStatusCode(&hresultWork1);
|
|
|
|
if(hresultVal1 == hresultWork1){
|
|
(*pPassed)++;
|
|
} else {
|
|
(*pFailed)++;
|
|
}
|
|
|
|
// Test SetPermissions & GetPermissions
|
|
// SetPermissions(permitVal1);
|
|
|
|
// GetPermissions(&permitWork1);
|
|
|
|
// if((permitVal1 == permitWork1)){
|
|
// (*pPassed)++;
|
|
// } else {
|
|
// (*pFailed)++;
|
|
// }
|
|
|
|
} WsbCatch(hr);
|
|
|
|
// Tally up the results
|
|
|
|
hr = S_OK;
|
|
|
|
if (*pFailed) {
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CRmsComObject::Test"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::InterfaceSupportsErrorInfo(
|
|
IN REFIID riid)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
ISupportsErrorInfo::InterfaceSupportsErrorInfo
|
|
|
|
--*/
|
|
{
|
|
static const IID* arr[] =
|
|
{
|
|
&IID_IRmsServer,
|
|
&IID_IRmsLibrary,
|
|
&IID_IRmsDriveClass,
|
|
&IID_IRmsCartridge,
|
|
&IID_IRmsDrive,
|
|
&IID_IRmsStorageSlot,
|
|
&IID_IRmsMediumChanger,
|
|
&IID_IRmsIEPort,
|
|
&IID_IRmsMediaSet,
|
|
&IID_IRmsRequest,
|
|
&IID_IRmsPartition,
|
|
&IID_IRmsComObject,
|
|
&IID_IRmsChangerElement,
|
|
&IID_IRmsDevice,
|
|
&IID_IRmsStorageInfo,
|
|
&IID_IRmsNTMS,
|
|
};
|
|
|
|
for (int i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
|
|
{
|
|
if (InlineIsEqualGUID(*arr[i],riid))
|
|
return S_OK;
|
|
}
|
|
return S_FALSE;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::GetObjectId(
|
|
OUT GUID *pObjectId)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::GetObjectId
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssertPointer( pObjectId );
|
|
|
|
*pObjectId = m_objectId;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::SetObjectId(
|
|
IN GUID objectId)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::SetObjectId
|
|
|
|
--*/
|
|
{
|
|
m_objectId = objectId;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::GetObjectType(
|
|
OUT LONG *pType)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::GetObjectType
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssertPointer( pType );
|
|
|
|
*pType = m_ObjectType;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::SetObjectType(
|
|
IN LONG type)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::SetObjectType
|
|
|
|
--*/
|
|
{
|
|
m_ObjectType = (RmsObject) type;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::IsEnabled(void)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::IsEnabled
|
|
|
|
--*/
|
|
{
|
|
return (m_IsEnabled) ? S_OK : S_FALSE;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::Enable()
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::Enable
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
m_IsEnabled = TRUE;
|
|
WsbAffirmHr(SetStatusCode(S_OK));
|
|
|
|
// Log an Event
|
|
WsbLogEvent(RMS_MESSAGE_OBJECT_ENABLED, 0, NULL, (WCHAR *)m_Name, NULL );
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::Disable(
|
|
IN HRESULT reason)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::Disable
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
m_IsEnabled = FALSE;
|
|
WsbAffirmHr(SetStatusCode(reason));
|
|
|
|
// Log an Event
|
|
WsbLogEvent(RMS_MESSAGE_OBJECT_DISABLED, 0, NULL, (WCHAR *)m_Name, WsbHrAsString(reason), NULL );
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::GetState(
|
|
OUT LONG *pState)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::GetState
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssertPointer( pState );
|
|
|
|
*pState = m_State;
|
|
WsbTrace(OLESTR("GetState: Object <0x%08x> - Enabled = <%ls>; State = <%d>; StatusCode = <%ls>.\n"),
|
|
this, WsbBoolAsString(m_IsEnabled), m_State, WsbHrAsString(m_StatusCode));
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::SetState(
|
|
IN LONG state)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::SetState
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
m_State = state;
|
|
WsbAffirmHr(SetStatusCode(S_OK));
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::GetStatusCode(
|
|
OUT HRESULT *pResult)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::GetStatusCode
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssertPointer( pResult );
|
|
|
|
*pResult = m_StatusCode;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::SetStatusCode(
|
|
IN HRESULT result
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::SetStatusCode
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
m_StatusCode = result;
|
|
WsbAffirmHr(adviseOfStatusChange());
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::GetName(
|
|
OUT BSTR *pName)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::GetName
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssertPointer( pName );
|
|
|
|
WsbAffirmHr( m_Name.CopyToBstr(pName) );
|
|
|
|
} WsbCatch( hr );
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::SetName(
|
|
IN BSTR name)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::SetName
|
|
|
|
--*/
|
|
{
|
|
m_Name = name;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::GetDescription(
|
|
OUT BSTR *pDesc)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::GetDescription
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssertPointer( pDesc );
|
|
|
|
WsbAffirmHr( m_Name.CopyToBstr(pDesc) );
|
|
|
|
} WsbCatch( hr );
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::SetDescription(
|
|
IN BSTR desc)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::SetDescription
|
|
|
|
--*/
|
|
{
|
|
m_Description = desc;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::GetPermissions(
|
|
OUT SECURITY_DESCRIPTOR *lpPermit)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::GetPermissions
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssertPointer( lpPermit );
|
|
|
|
*lpPermit = m_Permit;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::SetPermissions(
|
|
IN SECURITY_DESCRIPTOR permit)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::GetPermissions
|
|
|
|
--*/
|
|
{
|
|
|
|
m_Permit = permit;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::GetFindBy(
|
|
OUT LONG *pFindBy)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::GetFindBy
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssertPointer( pFindBy );
|
|
|
|
*pFindBy = m_findBy;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CRmsComObject::SetFindBy(
|
|
IN LONG findBy)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IRmsComObject::SetFindBy
|
|
|
|
--*/
|
|
{
|
|
m_findBy = (RmsFindBy) findBy;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CRmsComObject::adviseOfStatusChange(void)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Notifies of object state changes.
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
WsbTraceIn( OLESTR("CRmsComObject::adviseOfStatusChange"), OLESTR(""));
|
|
|
|
try {
|
|
CONNECTDATA pConnectData;
|
|
CComPtr<IConnectionPoint> pCP;
|
|
CComPtr<IConnectionPointContainer> pCPC;
|
|
CComPtr<IEnumConnections> pConnection;
|
|
CComPtr<IRmsSinkEveryEvent> pSink;
|
|
|
|
WsbTrace(OLESTR("Object <0x%08x> - Enabled = <%ls>; State = <%d>; StatusCode = <%ls>.\n"),
|
|
this, WsbBoolAsString(m_IsEnabled), m_State, WsbHrAsString(m_StatusCode));
|
|
|
|
// Tell everyone the new state of the object.
|
|
WsbAffirmHr(((IUnknown*)(IRmsComObject*) this)->QueryInterface(IID_IConnectionPointContainer, (void**) &pCPC));
|
|
WsbAffirmHr(pCPC->FindConnectionPoint(IID_IRmsSinkEveryEvent, &pCP));
|
|
WsbAffirmHr(pCP->EnumConnections(&pConnection));
|
|
|
|
while(pConnection->Next(1, &pConnectData, 0) == S_OK) {
|
|
|
|
try {
|
|
WsbAffirmHr((pConnectData.pUnk)->QueryInterface(IID_IRmsSinkEveryEvent, (void**) &pSink));
|
|
WsbAffirmHr(pSink->ProcessObjectStatusChange( m_IsEnabled, m_State, m_StatusCode ));
|
|
} WsbCatch(hr);
|
|
|
|
(pConnectData.pUnk)->Release();
|
|
pSink=0;
|
|
}
|
|
|
|
} WsbCatch(hr);
|
|
|
|
// We don't care if the sink has problems!
|
|
hr = S_OK;
|
|
|
|
WsbTraceOut(OLESTR("CRmsComObject::adviseOfStatusChange"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return hr;
|
|
}
|