847 lines
24 KiB
C++
847 lines
24 KiB
C++
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (c) 1999 - 2000 Microsoft Corporation
|
|
//
|
|
// Module Name:
|
|
// CITracker.CPP
|
|
//
|
|
// Description:
|
|
// Implementation of a COM interface tracker.
|
|
//
|
|
// [Documentation:]
|
|
// Debugging.PPT - A power-point presentation of the debug utilities.
|
|
//
|
|
// Maintained By:
|
|
// Geoffrey Pease (gpease) 19-NOV-1999
|
|
//
|
|
// Notes:
|
|
// This is X86 specific for now. It can be adapted for other platforms
|
|
// as required. Since today, most of our developement is done on the
|
|
// X86 platform, there is not a need to do this.
|
|
//
|
|
// Define NO_TRACE_INTERFACES to disable interface tracking in DEBUG
|
|
// builds.
|
|
//
|
|
// Define TRACE_INTERFACES_ENABLED to enable interface tracking in RETAIL
|
|
// builds.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "pch.h"
|
|
#include <shlwapi.h>
|
|
|
|
#if defined( _X86_ )
|
|
///////////////////////////////////////
|
|
//
|
|
// BEGIN _X86_
|
|
//
|
|
|
|
#if defined( TRACE_INTERFACES_ENABLED )
|
|
///////////////////////////////////////
|
|
//
|
|
// BEGIN TRACE_INTERFACES_ENABLED
|
|
//
|
|
|
|
//
|
|
// Globals
|
|
//
|
|
static IDeadObjTracker * g_pidoTracker = NULL; // dead object - there is only one.
|
|
|
|
#ifndef NOISY_TRACE_INTERFACES
|
|
///////////////////////////////////////
|
|
//
|
|
// DEBUG !NOISY_TRACE_INTERFACES
|
|
//
|
|
|
|
//
|
|
// Undefining these macros to make the CITracker quiet.
|
|
//
|
|
#undef TraceFunc
|
|
#define TraceFunc 1 ? (void)0 : (void)
|
|
#undef TraceFunc1
|
|
#define TraceFunc1 1 ? (void)0 : (void)
|
|
#undef TraceFunc2
|
|
#define TraceFunc2 1 ? (void)0 : (void)
|
|
#undef TraceFunc3
|
|
#define TraceFunc3 1 ? (void)0 : (void)
|
|
#undef TraceClsFunc
|
|
#define TraceClsFunc 1 ? (void)0 : (void)
|
|
#undef TraceClsFunc1
|
|
#define TraceClsFunc1 1 ? (void)0 : (void)
|
|
#undef TraceClsFunc2
|
|
#define TraceClsFunc2 1 ? (void)0 : (void)
|
|
#undef TraceClsFunc3
|
|
#define TraceClsFunc3 1 ? (void)0 : (void)
|
|
#undef TraceClsFunc4
|
|
#define TraceClsFunc4 1 ? (void)0 : (void)
|
|
#undef TraceClsFunc5
|
|
#define TraceClsFunc5 1 ? (void)0 : (void)
|
|
#undef TraceFuncExit
|
|
#define TraceFuncExit()
|
|
#undef FRETURN
|
|
#define FRETURN( _u )
|
|
#undef HRETURN
|
|
#define HRETURN(_hr) return(_hr)
|
|
#undef RETURN
|
|
#define RETURN(_fn) return(_fn)
|
|
#undef RRETURN
|
|
#define RRETURN( _fn ) return(_fn)
|
|
|
|
//
|
|
// END !NOISY_TRACE_INTERFACES
|
|
//
|
|
///////////////////////////////////////
|
|
#endif // NOISY_TRACE_INTERFACES
|
|
|
|
#if defined( DEBUG )
|
|
|
|
//
|
|
// These are internal to debug.cpp but not published in debug.h.
|
|
//
|
|
BOOL
|
|
IsDebugFlagSet(
|
|
TRACEFLAG tfIn
|
|
);
|
|
|
|
void
|
|
DebugOutputString(
|
|
LPCTSTR pszIn
|
|
);
|
|
|
|
void
|
|
DebugInitializeBuffer(
|
|
LPCTSTR pszFileIn,
|
|
const int nLineIn,
|
|
LPCTSTR pszModuleIn,
|
|
LPTSTR pszBufIn,
|
|
INT * pcchInout,
|
|
LPTSTR * ppszBufOut
|
|
);
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// LPCTSTR
|
|
// DebugInterface(
|
|
// REFIID riidIn,
|
|
// LPTSTR pszBufOut
|
|
// )
|
|
//
|
|
// Description:
|
|
// Uses the Interface Tracking Table (g_itTable) to lookup a human
|
|
// readable name for the riidIn. If no matching interface is found. it
|
|
// will use the pszBufOut to format a GUID string and return it.
|
|
//
|
|
// Arguments:
|
|
// riidIn - The interface ID to lookup.
|
|
// pszBufOut - Buffer to use if interface not found to format GUID.
|
|
//
|
|
// Return Value:
|
|
// Never NULL. It will always a valid string pointer to either the
|
|
// interface name or to pszBufOut.
|
|
//
|
|
// Notes:
|
|
// pszBufOut must be at least cchGUID_STRING_SIZE in size.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
LPCTSTR
|
|
PszDebugFindInterface(
|
|
REFIID riidIn,
|
|
LPTSTR pszBufOut
|
|
)
|
|
{
|
|
if ( IsTraceFlagSet( mtfQUERYINTERFACE )
|
|
)
|
|
{
|
|
int idx;
|
|
|
|
for ( idx = 0; g_itTable[ idx ].riid != NULL; idx++ )
|
|
{
|
|
if ( riidIn == *g_itTable[ idx ].riid
|
|
)
|
|
{
|
|
return g_itTable[ idx ].pszName;
|
|
|
|
} // if: found interface
|
|
|
|
} // for: searching for interface
|
|
|
|
wnsprintf( pszBufOut,
|
|
cchGUID_STRING_SIZE,
|
|
TEXT("{%08x-%04x-%04x-%02x%02x%02x%02x%02x%02x%02x%02x}"),
|
|
riidIn.Data1,
|
|
riidIn.Data2,
|
|
riidIn.Data3,
|
|
riidIn.Data4[0],
|
|
riidIn.Data4[1],
|
|
riidIn.Data4[2],
|
|
riidIn.Data4[3],
|
|
riidIn.Data4[4],
|
|
riidIn.Data4[5],
|
|
riidIn.Data4[6],
|
|
riidIn.Data4[7]
|
|
);
|
|
} // if: query interface is on
|
|
else
|
|
{
|
|
return TEXT("riid");
|
|
} // else: just print riid
|
|
|
|
return pszBufOut;
|
|
|
|
} //*** DebugInterface( )
|
|
#endif // DEBUG
|
|
|
|
///////////////////////////////////////
|
|
//
|
|
// CITracker Definition
|
|
//
|
|
//
|
|
|
|
DEFINE_THISCLASS("CITracker");
|
|
#define THISCLASS CITracker
|
|
#define LPTHISCLASS CITracker*
|
|
|
|
// ************************************************************************
|
|
//
|
|
// Constructor / Destructor
|
|
//
|
|
// ************************************************************************
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Special new( ) for CITracker
|
|
//
|
|
// Description:
|
|
// Creates an object the size of the object plus nExtraIn bytes. This
|
|
// allows the Vtable that the CITracker object is tracking to be
|
|
// appended to the end of the CITracker object.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
#ifdef new
|
|
#undef new
|
|
#endif
|
|
void*
|
|
__cdecl
|
|
operator new(
|
|
unsigned int nSizeIn,
|
|
LPCTSTR pszFileIn,
|
|
const int nLineIn,
|
|
LPCTSTR pszModuleIn,
|
|
UINT nExtraIn,
|
|
LPCTSTR pszNameIn
|
|
)
|
|
{
|
|
HGLOBAL hGlobal = GlobalAlloc( GPTR, nSizeIn + nExtraIn );
|
|
|
|
return TraceMemoryAdd( mmbtOBJECT, hGlobal, pszFileIn, nLineIn, pszModuleIn, GPTR, nSizeIn + nExtraIn, TEXT("CITracker") );
|
|
|
|
} //*** operator new( )
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// LPUNKNOWN
|
|
// DebugTrackInterface(
|
|
// LPCTSTR pszNameIn,
|
|
// REFIID riidIn,
|
|
// LPUNKNOWN punkIn,
|
|
// LONG cRefIn
|
|
// )
|
|
//
|
|
// Description:
|
|
// Create an interface tracker for the given interface.
|
|
//
|
|
// Arguments:
|
|
// pszNameIn - Name to associate with object that the punk references.
|
|
// riidIn - Interface IID of the interface to be tracked.
|
|
// punkIn - Interface pointer to track.
|
|
// cRefIn - Initialize ref count on the interface.
|
|
//
|
|
// Return Type:
|
|
// On failure, this will be punkIn.
|
|
// On success, pointer to an object that implements the interface to
|
|
// be tracked.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
LPUNKNOWN
|
|
DebugTrackInterface(
|
|
LPCTSTR pszFileIn,
|
|
const int nLineIn,
|
|
LPCTSTR pszModuleIn,
|
|
LPCTSTR pszNameIn,
|
|
REFIID riidIn,
|
|
LPUNKNOWN punkIn,
|
|
LONG cRefIn
|
|
)
|
|
{
|
|
TraceFunc3( "DebugTrackInterface( ... pszNameIn = '%s', riidIn, punkIn = 0x%08x, cRefIn = %u )\n",
|
|
pszNameIn,
|
|
punkIn,
|
|
cRefIn
|
|
);
|
|
|
|
UINT nEntry = 0;
|
|
LPUNKNOWN punkOut = punkIn;
|
|
|
|
//
|
|
// Scan the table looking for the matching interface definition.
|
|
//
|
|
for( nEntry = 0; g_itTable[ nEntry ].riid != NULL; nEntry++ )
|
|
{
|
|
if ( riidIn == *g_itTable[ nEntry ].riid )
|
|
{
|
|
//
|
|
// Figure out how much "extra" to allocate onto the CITracker.
|
|
//
|
|
UINT nExtra = ( 3 + g_itTable[ nEntry ].cFunctions ) * sizeof(LPVOID);
|
|
|
|
//
|
|
// Create a name for the tracker.
|
|
//
|
|
// TODO: gpease 19-NOV-1999
|
|
// Maybe merge this in with the nExtra(??).
|
|
//
|
|
LPTSTR psz;
|
|
LPTSTR pszName =
|
|
(LPTSTR) LocalAlloc( LMEM_FIXED,
|
|
( lstrlen( g_itTable[ nEntry ].pszName ) + lstrlen( pszNameIn ) + 3 + 2 ) * sizeof(TCHAR) );
|
|
|
|
psz = StrCpy( pszName, pszNameIn ); // object name
|
|
psz = StrCat( psz, TEXT("::[") ); // + 3
|
|
psz = StrCat( psz, g_itTable[ nEntry ].pszName ); // + interface name
|
|
psz = StrCat( psz, TEXT("]") ); // + 2
|
|
|
|
//
|
|
// Create the tracker.
|
|
//
|
|
LPTHISCLASS pc = new( pszFileIn, nLineIn, pszModuleIn, nExtra, pszName ) THISCLASS( );
|
|
if ( pc != NULL )
|
|
{
|
|
HRESULT hr;
|
|
|
|
//
|
|
// Initialize the tracker.
|
|
//
|
|
hr = THR( pc->Init( &punkOut, punkIn, &g_itTable[ nEntry ], pszName, cRefIn ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
//
|
|
// If it failed, delete it.
|
|
//
|
|
delete pc;
|
|
|
|
} // if: failed to initialize
|
|
|
|
} // if: got memory
|
|
|
|
break; // exit loop
|
|
|
|
} // if: matched interface
|
|
|
|
} // for: more entries in table
|
|
|
|
RETURN( punkOut );
|
|
|
|
} //*** DebugTrackInterface( )
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CITracker::CITracker( )
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
THISCLASS::THISCLASS( )
|
|
{
|
|
TraceClsFunc1( "%s()\n", __THISCLASS__ );
|
|
|
|
//
|
|
// KB: gpease 10-OCT-1998
|
|
// This class will leak objects to help catch bad components
|
|
// that call back into released interfaces therefore this
|
|
// DLL will not be able to be released.
|
|
//
|
|
InterlockedIncrement( &g_cObjects );
|
|
|
|
TraceFuncExit();
|
|
} //*** CITracker::ctor( )
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// STDMETHODIMP
|
|
// CITracker::Init(
|
|
// LPUNKNOWN * ppunkOut,
|
|
// LPUNKNOWN punkIn,
|
|
// const INTERFACE_TABLE_ENTRY * piteIn,
|
|
// LPCTSTR pszNameIn,
|
|
// BOOL fAddRefIn
|
|
// )
|
|
//
|
|
// Description:
|
|
// Initializes the CITracker object. It creates a copy of the VTable
|
|
// of the interface to be tracked replacing the QI, AddRef and Release
|
|
// methods with its own IUnknown. This allows CITracker to be "in the
|
|
// loop" for those calls.
|
|
//
|
|
// Arguments:
|
|
// ppunkOut - The "punk" to be passed around.
|
|
// punkIn - The interface to be copied and tracked.
|
|
// piteIn - The interface table entry for the interface.
|
|
// pszNameIn - The name to be given to this CITracker.
|
|
// fAddRefIn - TRUE is the CITracker should start with a Ref Count of 1.
|
|
//
|
|
// Return Value:
|
|
// S_OK - Success.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
THISCLASS::Init(
|
|
LPUNKNOWN * ppunkOut,
|
|
LPUNKNOWN punkIn,
|
|
const INTERFACE_TABLE_ENTRY * piteIn,
|
|
LPCTSTR pszNameIn,
|
|
LONG cRefIn
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
TraceClsFunc5( "Init( ppunkOut = 0x%08x, punkIn = 0x%08x, iteIn = %s, pszNameIn = '%s', cRefIn = %u )\n",
|
|
ppunkOut,
|
|
punkIn,
|
|
piteIn->pszName,
|
|
pszNameIn,
|
|
cRefIn
|
|
);
|
|
|
|
//
|
|
// Generate new Vtbls for each interface
|
|
//
|
|
LPVOID * pthisVtbl = (LPVOID*) (IUnknownTracker *) this;
|
|
LPVOID * ppthatVtbl = (LPVOID*) punkIn;
|
|
DWORD dwSize = ( 3 + piteIn->cFunctions ) * sizeof(LPVOID);
|
|
|
|
AssertMsg( dwSize < 30 * sizeof(LPVOID), "Need to make Dead Obj and IUnknownTracker larger!" );
|
|
|
|
//
|
|
// Interface tracking information initialization
|
|
//
|
|
m_vtbl.cRef = cRefIn;
|
|
m_vtbl.pszInterface = pszNameIn;
|
|
m_vtbl.dwSize = dwSize;
|
|
|
|
//
|
|
// Copy our IUnknownTracker vtbl to our "fix-up-able" vtbl
|
|
//
|
|
CopyMemory( &m_vtbl.lpfnQueryInterface, *pthisVtbl, dwSize );
|
|
|
|
//
|
|
// Remember the "punk" pointer so we can pass it back in when
|
|
// we jump to the orginal objects IUnknown functions.
|
|
//
|
|
m_vtbl.punk = (LPUNKNOWN) punkIn;
|
|
|
|
//
|
|
// And finally, point the objects vtbl for this interface to
|
|
// our newly created vtbl.
|
|
//
|
|
m_vtbl.pNewVtbl = (VTBL *) &m_vtbl.lpfnQueryInterface;
|
|
*pthisVtbl = m_vtbl.pNewVtbl;
|
|
*ppunkOut = (LPUNKNOWN) (IUnknownTracker *) this;
|
|
|
|
TraceMsg( mtfCITRACKERS, L"TRACK: Tracking %s Interface (0x%08x)\n", m_vtbl.pszInterface, punkIn );
|
|
|
|
HRETURN(hr);
|
|
|
|
} //*** CITracker::Init( )
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CITracker::~CITracker( )
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
THISCLASS::~THISCLASS( )
|
|
{
|
|
TraceClsFunc2( "~%s() for %s\n", __THISCLASS__, m_vtbl.pszInterface );
|
|
|
|
if ( m_vtbl.pszInterface != NULL )
|
|
{
|
|
LocalFree( (LPVOID) m_vtbl.pszInterface );
|
|
} // if: have interface pointer
|
|
|
|
InterlockedDecrement( &g_cObjects );
|
|
|
|
TraceFuncExit();
|
|
|
|
} //*** CITracker::dtor( )
|
|
|
|
// ************************************************************************
|
|
//
|
|
// IUnknownTracker
|
|
//
|
|
// ************************************************************************
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// STDMETHODIMP
|
|
// CITracker::QueryInterface()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
THISCLASS::QueryInterface(
|
|
REFIID riid,
|
|
LPVOID *ppv
|
|
)
|
|
{
|
|
TraceClsFunc1( "{%s} QueryInterface( ... )\n", m_vtbl.pszInterface );
|
|
TraceMsg( mtfCITRACKERS, "TRACK: + %s QueryInterface( )\n", m_vtbl.pszInterface );
|
|
|
|
//
|
|
// Call the punk's QueryInterface( ).
|
|
//
|
|
HRESULT hr = m_vtbl.punk->QueryInterface( riid, ppv );
|
|
|
|
//
|
|
// KB: TRACK_ALL_QIED_INTERFACES gpease 25-NOV-1999
|
|
// Thinking out loud, should we track all interfaces QI'ed from
|
|
// a tracked interface auto-magically? If so, turn this #define
|
|
// on.
|
|
//
|
|
// #define TRACK_ALL_QIED_INTERFACES
|
|
#if defined( TRACK_ALL_QIED_INTERFACES )
|
|
if ( !IsEqualIID( riid, IID_IUnknown )
|
|
)
|
|
{
|
|
*ppv = DebugTrackInterface( TEXT("<Unknown>"),
|
|
0,
|
|
__MODULE__,
|
|
m_vtbl.pszInterface,
|
|
riid,
|
|
(IUnknown*) *ppv,
|
|
TRUE
|
|
);
|
|
} // if: not the IUnknown
|
|
#endif
|
|
|
|
TraceMsg( mtfCITRACKERS,
|
|
"TRACK: V %s QueryInterface( ) [ *ppv = 0x%08x ]\n",
|
|
m_vtbl.pszInterface,
|
|
*ppv
|
|
);
|
|
|
|
HRETURN(hr);
|
|
} //** CITracker::QueryInterface( )
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// STDMETHODIMP_(ULONG)
|
|
// CITracker::AddRef()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP_(ULONG)
|
|
THISCLASS::AddRef( void )
|
|
{
|
|
TraceClsFunc1( "{%s} AddRef( )\n", m_vtbl.pszInterface );
|
|
TraceMsg( mtfCITRACKERS, "TRACK: + %s AddRef( )\n", m_vtbl.pszInterface );
|
|
|
|
//
|
|
// Call the punk's AddRef( ).
|
|
//
|
|
ULONG ul = m_vtbl.punk->AddRef( );
|
|
|
|
//
|
|
// Increment our counter.
|
|
//
|
|
ULONG ulvtbl = InterlockedIncrement( (LONG *) &m_vtbl.cRef );
|
|
|
|
TraceMsg( mtfCITRACKERS,
|
|
"TRACK: V %s AddRef( ) [ I = %u, O = %u ]\n",
|
|
m_vtbl.pszInterface,
|
|
ulvtbl,
|
|
ul
|
|
);
|
|
|
|
AssertMsg( ul >= ulvtbl, "The objects ref should be higher than the interfaces." );
|
|
|
|
RETURN(ul);
|
|
} //*** CITracker::AddRef( )
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// STDMETHODIMP_(ULONG)
|
|
// CITracker::Release()
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP_(ULONG)
|
|
THISCLASS::Release( void )
|
|
{
|
|
TraceClsFunc1( "{%s} Release( )\n", m_vtbl.pszInterface );
|
|
TraceMsg( mtfCITRACKERS, "TRACK: + %s Release( )\n", m_vtbl.pszInterface );
|
|
|
|
//
|
|
// Call the punk's Release( ).
|
|
//
|
|
ULONG ul = m_vtbl.punk->Release( );
|
|
|
|
//
|
|
// Decrement our counter.
|
|
//
|
|
ULONG ulvtbl = InterlockedDecrement( (LONG *) &m_vtbl.cRef );
|
|
|
|
TraceMsg( mtfCITRACKERS,
|
|
"TRACK: V %s Release( ) [ I = %u, O = %u ]\n",
|
|
m_vtbl.pszInterface,
|
|
ulvtbl,
|
|
ul
|
|
);
|
|
|
|
//
|
|
// Our ref count should always be less than the punk's ref count.
|
|
//
|
|
AssertMsg( ul >= ulvtbl, "The objects ref should be higher than the interfaces." );
|
|
|
|
if ( ulvtbl )
|
|
{
|
|
RETURN( ulvtbl );
|
|
} // if: we still have a ref
|
|
|
|
if ( g_pidoTracker == NULL )
|
|
{
|
|
//
|
|
// Create a dead object - if more than one is created at a time, we might leak it.
|
|
//
|
|
// TODO: gpease 19-NOV-1999
|
|
// Work on not leaking "extra" dead objects.
|
|
//
|
|
g_pidoTracker = new( TEXT(__FILE__), __LINE__, __MODULE__, 0, TEXT("Dead Object") ) IDeadObjTracker( );
|
|
|
|
// Don't track this object
|
|
TraceMemoryDelete( g_pidoTracker, FALSE );
|
|
|
|
} // if: no dead object
|
|
|
|
Assert( g_pidoTracker != NULL );
|
|
if ( g_pidoTracker != NULL )
|
|
{
|
|
LPVOID *pthisVtbl = (LPVOID*) (IUnknownTracker *) this;
|
|
LPVOID *ppthatVtbl = (LPVOID*) (IDeadObjTracker *) g_pidoTracker;
|
|
|
|
// Copy the DeadObj vtbl.
|
|
CopyMemory( &m_vtbl.lpfnQueryInterface, *ppthatVtbl, m_vtbl.dwSize );
|
|
|
|
//
|
|
// Don't really delete it, but fake the debug output as if we did.
|
|
//
|
|
TraceClsFunc2( "~%s() for %s\n", __THISCLASS__, m_vtbl.pszInterface );
|
|
TraceMsg( mtfCITRACKERS, "TRACK: # %s set to dead object [ punk = 0x%08x ]\n", m_vtbl.pszInterface, pthisVtbl );
|
|
FRETURN( 0 );
|
|
|
|
// Stop tracking this object.
|
|
TraceMemoryDelete( this, FALSE );
|
|
|
|
} // if: dead object created
|
|
else
|
|
{
|
|
//
|
|
// No dead object; nuke ourselves. This will at least cause an AV if
|
|
// the program tries to call on our interface alerting the programmer
|
|
// that somethings wrong.
|
|
//
|
|
delete this;
|
|
|
|
} // else: no dead object
|
|
|
|
RETURN(0);
|
|
|
|
} //*** CITracker::Release( )
|
|
|
|
//****************************************************************************
|
|
//
|
|
// IDeadObjTracker - The dead interface object tracker.
|
|
//
|
|
// This object is shunted into release interfaces that were being tracked by
|
|
// the CITracker class. Any calls to a released interface will end up causing
|
|
// an Assert and if execution continues it will return E_FAIL.
|
|
//
|
|
//****************************************************************************
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IDeadObjTracker:Stub(x)
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
#define IDeadObjTrackerStub( i ) \
|
|
STDMETHODIMP \
|
|
IDeadObjTracker::Stub##i( LPVOID* punk ) \
|
|
{ \
|
|
const int cchDebugMessageSize = 255; \
|
|
TCHAR szMessage[ cchDebugMessageSize ]; \
|
|
LRESULT lResult;\
|
|
\
|
|
DebugMsg( "*ERROR* %s: Entered %s (0x%08x) after it was released. Returning E_FAIL.\n", \
|
|
__MODULE__, \
|
|
m_vtbl.pszInterface, \
|
|
this \
|
|
); \
|
|
\
|
|
wnsprintf( szMessage, \
|
|
cchDebugMessageSize, \
|
|
TEXT("Entered %s (0x%08x) after it was released.\n\nDo you want to break here?\n\n(If you do not break, E_FAIL will be returned.)"), \
|
|
m_vtbl.pszInterface, \
|
|
this \
|
|
);\
|
|
\
|
|
lResult = MessageBox( NULL, szMessage, TEXT("Dead Interface"), MB_YESNO | MB_ICONWARNING );\
|
|
if ( lResult == IDYES \
|
|
) \
|
|
{ \
|
|
DEBUG_BREAK; \
|
|
} \
|
|
\
|
|
return E_FAIL; \
|
|
}
|
|
|
|
IDeadObjTrackerStub(0);
|
|
IDeadObjTrackerStub(1);
|
|
IDeadObjTrackerStub(2);
|
|
IDeadObjTrackerStub(3);
|
|
IDeadObjTrackerStub(4);
|
|
IDeadObjTrackerStub(5);
|
|
IDeadObjTrackerStub(6);
|
|
IDeadObjTrackerStub(7);
|
|
IDeadObjTrackerStub(8);
|
|
IDeadObjTrackerStub(9);
|
|
IDeadObjTrackerStub(10);
|
|
IDeadObjTrackerStub(11);
|
|
IDeadObjTrackerStub(12);
|
|
IDeadObjTrackerStub(13);
|
|
IDeadObjTrackerStub(14);
|
|
IDeadObjTrackerStub(15);
|
|
IDeadObjTrackerStub(16);
|
|
IDeadObjTrackerStub(17);
|
|
IDeadObjTrackerStub(18);
|
|
IDeadObjTrackerStub(19);
|
|
IDeadObjTrackerStub(20);
|
|
IDeadObjTrackerStub(21);
|
|
IDeadObjTrackerStub(22);
|
|
IDeadObjTrackerStub(23);
|
|
IDeadObjTrackerStub(24);
|
|
IDeadObjTrackerStub(25);
|
|
IDeadObjTrackerStub(26);
|
|
IDeadObjTrackerStub(27);
|
|
IDeadObjTrackerStub(28);
|
|
IDeadObjTrackerStub(29);
|
|
IDeadObjTrackerStub(30);
|
|
|
|
//****************************************************************************
|
|
//
|
|
// IUnknownTracker stub
|
|
//
|
|
// This merely directs the incoming call back to the orginal object. The
|
|
// IUnknown methods will be remapped the the CITracker methods.
|
|
//
|
|
//****************************************************************************
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// STDMETHODIMP
|
|
// IUnknownTracker::QueryInterface()
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
IUnknownTracker::QueryInterface(
|
|
REFIID riid,
|
|
LPVOID *ppv )
|
|
{
|
|
ErrorMsg( "IUnknownTracker::QueryInterface( ): How did you get here?\n", 0 );
|
|
AssertMsg( 0, "You shouldn't be here!" );
|
|
return E_FAIL;
|
|
} //*** IUnknownTracker::QueryInterface( )
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// STDMETHODIMP_(ULONG)
|
|
// IUnknownTracker::AddRef()
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP_(ULONG)
|
|
IUnknownTracker::AddRef( void )
|
|
{
|
|
ErrorMsg( "IUnknownTracker::AddRef( ): How did you get here?\n", 0 );
|
|
AssertMsg( 0, "You shouldn't be here!" );
|
|
return -1;
|
|
} //*** IUnknownTracker::AddRef( )
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// STDMETHODIMP_(ULONG)
|
|
// IUnknownTracker::Release()
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP_(ULONG)
|
|
IUnknownTracker::Release( void )
|
|
{
|
|
ErrorMsg( "IUnknownTracker::Release( ): How did you get here?\n", 0 );
|
|
AssertMsg( 0, "You shouldn't be here!" );
|
|
return -1;
|
|
} //*** IUnknownTracker::Release( )
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// STDMETHODIMP_(void)
|
|
// IUnknownTracker::Stub(x)
|
|
//
|
|
// These are just stubs to redirect the call to the "real" method on the punk.
|
|
// We actually dissappear from the call stack.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
#define IUnknownTrackerStub( i ) \
|
|
void \
|
|
_declspec(naked) \
|
|
IUnknownTracker::Stub##i() \
|
|
{ \
|
|
_asm mov eax, ss:4[esp] \
|
|
_asm mov ecx, 8[eax] \
|
|
_asm mov eax, [ecx] \
|
|
_asm mov ss:4[esp], ecx \
|
|
_asm jmp dword ptr cs:(4*i)[eax] \
|
|
}
|
|
|
|
IUnknownTrackerStub(3);
|
|
IUnknownTrackerStub(4);
|
|
IUnknownTrackerStub(5);
|
|
IUnknownTrackerStub(6);
|
|
IUnknownTrackerStub(7);
|
|
IUnknownTrackerStub(8);
|
|
IUnknownTrackerStub(9);
|
|
IUnknownTrackerStub(10);
|
|
IUnknownTrackerStub(11);
|
|
IUnknownTrackerStub(12);
|
|
IUnknownTrackerStub(13);
|
|
IUnknownTrackerStub(14);
|
|
IUnknownTrackerStub(15);
|
|
IUnknownTrackerStub(16);
|
|
IUnknownTrackerStub(17);
|
|
IUnknownTrackerStub(18);
|
|
IUnknownTrackerStub(19);
|
|
IUnknownTrackerStub(20);
|
|
IUnknownTrackerStub(21);
|
|
IUnknownTrackerStub(22);
|
|
IUnknownTrackerStub(23);
|
|
IUnknownTrackerStub(24);
|
|
IUnknownTrackerStub(25);
|
|
IUnknownTrackerStub(26);
|
|
IUnknownTrackerStub(27);
|
|
IUnknownTrackerStub(28);
|
|
IUnknownTrackerStub(29);
|
|
IUnknownTrackerStub(30);
|
|
|
|
|
|
//
|
|
// END TRACE_INTERFACES_ENABLED
|
|
//
|
|
///////////////////////////////////////
|
|
#endif // TRACE_INTERFACES_ENABLED
|
|
|
|
//
|
|
// END _X86_
|
|
//
|
|
///////////////////////////////////////
|
|
#endif // _X86_
|