836 lines
23 KiB
C++
836 lines
23 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1993.
|
|
//
|
|
// File: actprops.hxx
|
|
//
|
|
// Contents: Common definitions for object activation.
|
|
//
|
|
// Classes:
|
|
// ActivationProperties
|
|
// ActivationPropertiesIn
|
|
// ActivationPropertiesOut
|
|
//
|
|
// History: 24-Jan-98 Vinaykr Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
#ifndef __ACTPROPS_HXX__
|
|
#define __ACTPROPS_HXX__
|
|
|
|
#include <custmact.h>
|
|
#include <privact.h>
|
|
#include <catalog.h>
|
|
#include <serial.hxx>
|
|
#include <propifs.hxx>
|
|
#include <partitions.h>
|
|
#include <ole2com.h>
|
|
|
|
//---------------------------------------------------------------------
|
|
// Helper to find the end of delegation chain at each activation stage
|
|
//----------------------------------------------------------------------
|
|
ISystemActivator *GetComActivatorForStage(ACTIVATION_STAGE);
|
|
|
|
//----------------------------------------------------------------------
|
|
// Forward References
|
|
//----------------------------------------------------------------------
|
|
class ActivationPropertiesIn;
|
|
class ActivationPropertiesOut;
|
|
|
|
//----------------------------------------------------------------------
|
|
// Macros for Stages
|
|
//----------------------------------------------------------------------
|
|
#define CLIENT_STAGE(stage) (stage==CLIENT_CONTEXT_STAGE)
|
|
|
|
#define SERVER_STAGE(stage) ((stage==SERVER_PROCESS_STAGE) || \
|
|
(stage==SERVER_CONTEXT_STAGE))
|
|
|
|
#define SCM_STAGE(stage) ((stage==SERVER_MACHINE_STAGE) || \
|
|
(stage==CLIENT_MACHINE_STAGE))
|
|
|
|
//----------------------------------------------------------------------
|
|
// Macros for context
|
|
//----------------------------------------------------------------------
|
|
#define MARSHALCTX_WITHIN_PROCESS(ctx) ((ctx == MSHCTX_CROSSCTX) || \
|
|
(ctx == MSHCTX_INPROC))
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
// Base Class that provides Serialization support and some private
|
|
// Methods via IActivationProperties for both in In and Out objects
|
|
//----------------------------------------------------------------------
|
|
class ActivationProperties : public IActivationProperties,
|
|
public ISerializableParent,
|
|
public IGetCatalogObject
|
|
{
|
|
public:
|
|
ActivationProperties();
|
|
virtual ~ActivationProperties();
|
|
|
|
// Methods from IUnknown
|
|
STDMETHOD (QueryInterface) ( REFIID riid, LPVOID* ppvObj);
|
|
STDMETHOD_(ULONG,AddRef) ( void );
|
|
STDMETHOD_(ULONG,Release) ( void );
|
|
|
|
// Methods from IActivationProperties
|
|
|
|
//-----------------------------------------------------------------
|
|
//Remembers the maximum destination context.
|
|
//-----------------------------------------------------------------
|
|
inline DWORD SetUpMarshallingDistance(DWORD dwDestCtx)
|
|
{
|
|
static DWORD distance[5] = { MSHCTX_CROSSCTX,
|
|
MSHCTX_INPROC,
|
|
MSHCTX_LOCAL,
|
|
MSHCTX_NOSHAREDMEM,
|
|
MSHCTX_DIFFERENTMACHINE
|
|
};
|
|
|
|
int newind=-1;
|
|
int oldind=-1;
|
|
for (int i=0; i<5; i++)
|
|
{
|
|
if (distance[i] == dwDestCtx)
|
|
{
|
|
newind = i;
|
|
if (oldind != -1)
|
|
break;
|
|
}
|
|
|
|
if (distance[i] == _serHeader.destCtx)
|
|
{
|
|
oldind = i;
|
|
if (newind != -1)
|
|
break;
|
|
}
|
|
}
|
|
|
|
ASSERT(newind != -1);
|
|
ASSERT(oldind != -1);
|
|
|
|
if (oldind < newind)
|
|
_serHeader.destCtx = distance[newind];
|
|
|
|
return _serHeader.destCtx;
|
|
}
|
|
|
|
// Sets up Destination context for marshalling and storage
|
|
// for maximum distance
|
|
STDMETHOD(SetDestCtx)(IN DWORD dwDestCtx)
|
|
{
|
|
SetUpMarshallingDistance(dwDestCtx);
|
|
return S_OK;
|
|
}
|
|
|
|
inline HRESULT GetPropertyInfo(REFIID riid, void** ppv)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if ((hr = QueryInterface(riid, ppv))==S_OK)
|
|
Release();
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHOD(SetMarshalFlags)(IN DWORD marshalFlags)
|
|
{
|
|
_marshalFlags = marshalFlags;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHOD(GetMarshalFlags)(OUT DWORD *pdwMarshalFlags)
|
|
{
|
|
*pdwMarshalFlags = _marshalFlags;
|
|
return S_OK;
|
|
}
|
|
|
|
//-----------------------------------------------------------------
|
|
// Used to store\retrieve a COM private blob for retrieval. Currently
|
|
// only used in the SCM. Ownership of the blob remains with the caller.
|
|
//-----------------------------------------------------------------
|
|
STDMETHOD(SetLocalBlob)(void* blob)
|
|
{
|
|
_blob = blob;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHOD(GetLocalBlob)(void** pBlob)
|
|
{
|
|
*pBlob = _blob;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT Serialize(Serializer &pSer);
|
|
HRESULT GetSize(Serializer &pSer, DWORD *pSize);
|
|
|
|
// methods from IMarshal
|
|
STDMETHOD (GetUnmarshalClass)(
|
|
REFIID riid,
|
|
void *pv,
|
|
DWORD dwDestContext,
|
|
void *pvDestContext,
|
|
DWORD mshlflags,
|
|
CLSID *pCid);
|
|
|
|
STDMETHOD (GetMarshalSizeMax)(
|
|
REFIID riid,
|
|
void *pv,
|
|
DWORD dwDestContext,
|
|
void *pvDestContext,
|
|
DWORD mshlflags,
|
|
DWORD *pSize);
|
|
|
|
STDMETHOD (MarshalInterface)(
|
|
IStream *pStm,
|
|
REFIID riid,
|
|
void *pv,
|
|
DWORD dwDestContext,
|
|
void *pvDestContext,
|
|
DWORD mshlflags);
|
|
|
|
STDMETHOD (UnmarshalInterface)(IStream *pStm,REFIID riid,void **ppv);
|
|
|
|
STDMETHOD (ReleaseMarshalData)(IStream *pStm);
|
|
|
|
STDMETHOD (DisconnectObject)(DWORD dwReserved);
|
|
|
|
void SetSerializableIfs(DWORD index, SerializableProperty *pSer);
|
|
void AddSerializableIfs(SerializableProperty *pSer);
|
|
|
|
inline HRESULT UnSerializeCallBack(REFCLSID clsid, SerializableProperty **ppSer=0);
|
|
HRESULT ReturnClass(REFIID iid, SerializableProperty *pSer);
|
|
STDMETHOD(GetUnserialized)(REFCLSID clsid, void **ppISer,
|
|
DWORD *pSize, DWORD *pPos);
|
|
|
|
virtual HRESULT GetClass(REFIID iid,
|
|
SerializableProperty **ppSer,
|
|
BOOL forQI,
|
|
BOOL *pbZeroSizeOk=NULL) = 0;
|
|
|
|
HRESULT SetupForUnserializing(Serializer *pSer);
|
|
|
|
// IGetCatalogObject
|
|
STDMETHOD(GetCatalogObject)(REFIID riid, void **ppv)
|
|
{
|
|
HRESULT hr = InitializeCatalogIfNecessary();
|
|
|
|
if (hr != S_OK)
|
|
return hr;
|
|
|
|
return gpCatalog->QueryInterface(riid, ppv);
|
|
}
|
|
|
|
//-----------------------------------------------------------------
|
|
//Used to indicate whether heap allocation took place
|
|
//-----------------------------------------------------------------
|
|
inline void SetNotDelete(BOOL fDestruct=FALSE)
|
|
{
|
|
_toDelete = FALSE;
|
|
_fDestruct = fDestruct;
|
|
}
|
|
|
|
// Sets opaque data -- actprops now responsible for freeing
|
|
inline HRESULT SetOpaqueDataInfo(DWORD dwSize, OpaqueData *pData)
|
|
{
|
|
_serHeader.cOpaqueData = dwSize;
|
|
_serHeader.opaqueData = (tagCustomOpaqueData*) pData;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// Gets opaque data -- actprops no longer responsible for freeing
|
|
inline HRESULT GetOpaqueDataInfo(DWORD *pdwSize, OpaqueData **ppData)
|
|
{
|
|
*pdwSize = _serHeader.cOpaqueData;
|
|
_serHeader.cOpaqueData = 0;
|
|
*ppData = (OpaqueData*) _serHeader.opaqueData;
|
|
_serHeader.opaqueData = NULL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
enum {NOT_MARSHALLED=1, SIZED=2, MARSHALLED=3, UNMARSHALLED=4} _marshalState;
|
|
protected:
|
|
#ifndef MAX_ACTARRAY_SIZE
|
|
#define MAX_ACTARRAY_SIZE 10
|
|
#endif
|
|
|
|
CLSID _actCLSID;
|
|
BOOL _unSerialized;
|
|
BOOL _unSerializedInproc;
|
|
LONG _refCount;
|
|
CustomHeader _serHeader;
|
|
CustomHeader _unSerHeader;
|
|
DWORD _marshalFlags;
|
|
DWORD _size;
|
|
BOOL _toDelete;
|
|
BOOL _fDestruct;
|
|
BOOL _fInprocSerializationRequired;
|
|
|
|
private:
|
|
DWORD _totalSize;
|
|
SerializableProperty * serializableIfsCollection[MAX_ACTARRAY_SIZE];
|
|
DWORD _ifsIndex;
|
|
CLSID _clsidArray[MAX_ACTARRAY_SIZE];
|
|
DWORD _sizeArray[MAX_ACTARRAY_SIZE];
|
|
DWORD _headerSize;
|
|
Serializer *_pUnSer;
|
|
void* _blob;
|
|
};
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
// This is the "Out" object that is sent back on the return path
|
|
// of an activation containing results.
|
|
//----------------------------------------------------------------------
|
|
class ActivationPropertiesOut: public ActivationProperties,
|
|
public IPrivActivationPropertiesOut
|
|
{
|
|
public:
|
|
ActivationPropertiesOut(BOOL fBrokenRefCount=FALSE);
|
|
virtual ~ActivationPropertiesOut();
|
|
|
|
void SetClientCOMVersion(COMVERSION &version)
|
|
{
|
|
_clientCOMVersion = version;
|
|
}
|
|
|
|
inline BOOL Initialize()
|
|
{
|
|
_pOutSer=0;
|
|
_refCount = 1;
|
|
_actCLSID=CLSID_ActivationPropertiesOut;
|
|
_fInprocSerializationRequired = TRUE;
|
|
return TRUE;
|
|
}
|
|
|
|
inline IClassFactory *GetCF()
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
inline void SetCF(IClassFactory* pCF)
|
|
{
|
|
}
|
|
|
|
// Methods from IUnknown
|
|
STDMETHOD (QueryInterface) ( REFIID riid, LPVOID* ppvObj);
|
|
STDMETHOD_(ULONG,AddRef) ( void );
|
|
STDMETHOD_(ULONG,Release) ( void );
|
|
|
|
|
|
// Methods from IActivationPropertyOut
|
|
STDMETHOD(GetActivationID) (OUT GUID *pActivationID);
|
|
|
|
STDMETHOD(SetObjectInterfaces) (
|
|
IN DWORD cIfs,
|
|
IN IID *pIID,
|
|
IN IUnknown *pUnk);
|
|
|
|
STDMETHOD(GetObjectInterface) (
|
|
IN REFIID riid,
|
|
IN DWORD actvflags,
|
|
OUT void **ppv);
|
|
|
|
STDMETHOD(GetObjectInterfaces) (
|
|
IN DWORD pcIfs,
|
|
IN DWORD actvflags,
|
|
IN MULTI_QI *pMultiQi);
|
|
|
|
STDMETHOD(RemoveRequestedIIDs) (IN DWORD cIfs,
|
|
IN IID *pIID);
|
|
|
|
//Methods from IPrivActivationPropertiesOut
|
|
STDMETHOD(SetMarshalledResults)(IN DWORD cIfs,
|
|
IN IID *pIID,
|
|
IN HRESULT *pHr,
|
|
IN MInterfacePointer **pIntfData);
|
|
|
|
STDMETHOD(GetMarshalledResults)(OUT DWORD *pcIfs,
|
|
OUT IID **pIID,
|
|
OUT HRESULT **pHr,
|
|
OUT MInterfacePointer ***pIntfData);
|
|
|
|
virtual HRESULT GetClass(REFIID iid,
|
|
SerializableProperty **ppSer,
|
|
BOOL forQI,
|
|
BOOL *pbZeroSizeOk=NULL);
|
|
|
|
//-----------------------------------------------------------------
|
|
// This is a serializable object that has marshalling logic for
|
|
// results of an activation
|
|
//-----------------------------------------------------------------
|
|
class OutSerializer:public SerializableProperty
|
|
{
|
|
public:
|
|
OutSerializer(BOOL fBrokenRefcount=FALSE);
|
|
~OutSerializer();
|
|
// Methods from IUnknown
|
|
STDMETHOD (QueryInterface) ( REFIID riid, LPVOID* ppvObj);
|
|
STDMETHOD_(ULONG,AddRef) ( void );
|
|
STDMETHOD_(ULONG,Release) ( void );
|
|
STDMETHOD(Serialize)(IN void *pSer);
|
|
STDMETHOD(UnSerialize)(IN void *pSer);
|
|
STDMETHOD(GetSize)(IN void *pSer, OUT DWORD *pdwSize);
|
|
STDMETHOD(GetCLSID)(OUT CLSID *pclsid);
|
|
STDMETHOD(SerializableQueryInterface) ( REFIID riid, LPVOID* ppvObj);
|
|
|
|
void UnmarshalAtIndex(DWORD index);
|
|
void SetBrokenRefCoun();
|
|
|
|
PropsOutInfo _info;
|
|
IUnknown *_pUnk;
|
|
void **_ppvObj;
|
|
DWORD _size;
|
|
COMVERSION *_pClientCOMVersion;
|
|
IID _pIIDs[MAX_ACTARRAY_SIZE];
|
|
BOOL _fBrokenRefCount;
|
|
BOOL _fToReleaseIFD;
|
|
};
|
|
|
|
private:
|
|
OutSerializer *_pOutSer;
|
|
OutSerializer _outSer;
|
|
ScmReplyInfo _scmReplyInfo;
|
|
COMVERSION _clientCOMVersion;
|
|
BOOL _fBrokenRefCount;
|
|
};
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
// This is the "In" object that is used in the "request" direction of
|
|
// an activation and contains all parameters necessary for an activation
|
|
//----------------------------------------------------------------------
|
|
class ActivationPropertiesIn: public ActivationProperties,
|
|
public IPrivActivationPropertiesIn,
|
|
public IActivationStageInfo,
|
|
public IInitActivationPropertiesIn
|
|
{
|
|
public:
|
|
ActivationPropertiesIn();
|
|
virtual ~ActivationPropertiesIn();
|
|
|
|
// Methods from IUnknown
|
|
STDMETHOD (QueryInterface) ( REFIID riid, LPVOID* ppvObj);
|
|
STDMETHOD_(ULONG,AddRef) ( void );
|
|
STDMETHOD_(ULONG,Release) ( void );
|
|
|
|
STDMETHOD (UnmarshalInterface)(IStream *pStm,REFIID riid,void **ppv);
|
|
|
|
// Methods from IInitActivationPropertiesIn
|
|
STDMETHOD(SetClsctx) (IN DWORD clsctx);
|
|
STDMETHOD(SetActivationFlags) (IN DWORD actvflags);
|
|
STDMETHOD(SetClassInfo) (IN IUnknown* pUnkClassInfo);
|
|
STDMETHOD(SetContextInfo) (IN IContext* pClientContext,
|
|
IN IContext* pPrototypeContext);
|
|
STDMETHOD(SetConstructFromStorage) (IN IStorage* pStorage);
|
|
STDMETHOD(SetConstructFromFile) (IN WCHAR* wszFileName, IN DWORD dwMode);
|
|
|
|
|
|
//Methods from IActivationPropertiesIn
|
|
|
|
STDMETHOD(GetClassInfo) (REFIID riid, void **ppv)
|
|
{
|
|
return _pClassInfo->QueryInterface(riid,ppv);
|
|
}
|
|
|
|
inline IComClassInfo *GetComClassInfo()
|
|
{
|
|
return _pClassInfo;
|
|
}
|
|
|
|
STDMETHOD(GetClsid)(OUT CLSID *pClsid)
|
|
{
|
|
return GetInstantiationInfo()->GetClsid(pClsid);
|
|
}
|
|
|
|
STDMETHOD(GetClsctx) (OUT DWORD *pdwClsctx);
|
|
STDMETHOD(GetActivationFlags) (OUT DWORD* pactvflags);
|
|
|
|
STDMETHOD(AddRequestedIIDs) (IN DWORD cIfs,
|
|
IN IID *pIID);
|
|
|
|
STDMETHOD(GetRequestedIIDs)(OUT DWORD *pcIfs,
|
|
OUT IID **ppIID);
|
|
|
|
|
|
STDMETHOD(GetActivationID) (OUT GUID *pActivationID);
|
|
|
|
STDMETHOD(DelegateGetClassObject) (
|
|
OUT IActivationPropertiesOut **pActPropsOut);
|
|
|
|
STDMETHOD(DelegateCreateInstance) (
|
|
IN IUnknown *pUnkOuter,
|
|
OUT IActivationPropertiesOut **pActPropsOut);
|
|
|
|
STDMETHOD(DelegateCIAndGetCF) (
|
|
IN IUnknown *pUnkOuter,
|
|
OUT IActivationPropertiesOut **ppActPropsOut,
|
|
OUT IClassFactory **ppCF);
|
|
|
|
|
|
STDMETHOD(GetReturnActivationProperties)(
|
|
IUnknown *pUnk,
|
|
OUT IActivationPropertiesOut **ppActOut);
|
|
|
|
//Methods from IPrivActivationPropertiesIn
|
|
STDMETHOD(PrivGetReturnActivationProperties)(
|
|
IPrivActivationPropertiesOut **ppActOut);
|
|
|
|
inline HRESULT GetReturnActivationPropertiesWithCF(
|
|
IUnknown *pUnk,
|
|
IClassFactory *pCF,
|
|
OUT IActivationPropertiesOut **ppActOut)
|
|
{
|
|
return GetReturnActivationProperties(pUnk, ppActOut);
|
|
}
|
|
|
|
STDMETHOD(GetCOMVersion)(COMVERSION *pVersion)
|
|
{
|
|
COMVERSION *pver;
|
|
GetInstantiationInfo()->GetClientCOMVersion(&pver);
|
|
*pVersion = *pver;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHOD(GetClientToken)(OUT HANDLE *pHandle)
|
|
{
|
|
*pHandle = _clientToken;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHOD(GetDestCtx)(OUT DWORD *pdwDestCtx)
|
|
{
|
|
*pdwDestCtx = _serHeader.destCtx;
|
|
return S_OK;
|
|
}
|
|
|
|
//Non interface Methods
|
|
inline void SetClientToken(HANDLE token)
|
|
{
|
|
_clientToken = token;
|
|
}
|
|
|
|
inline void GetRemoteActivationFlags(BOOL *pfComplusOnly,
|
|
BOOL *pfUseSystemIdentity)
|
|
{
|
|
*pfComplusOnly = _fComplusOnly;
|
|
*pfUseSystemIdentity = _fUseSystemIdentity;
|
|
}
|
|
|
|
// Used by SCM for down-level interop where we have
|
|
// theoretically delegated but the activation object
|
|
// is not unmarshalled
|
|
inline void SetDelegated()
|
|
{
|
|
_delegated = TRUE;
|
|
}
|
|
|
|
STDMETHOD(GetReturnActivationProperties)(
|
|
ActivationPropertiesOut **ppActOut);
|
|
|
|
// Methods from IActivationStageInfo
|
|
STDMETHOD(SetStageAndIndex) (IN ACTIVATION_STAGE stage, IN int index);
|
|
|
|
STDMETHOD(GetStage) (OUT ACTIVATION_STAGE* pstage)
|
|
{
|
|
*pstage = _stage;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHOD(GetIndex) (OUT int* pindex)
|
|
{
|
|
*pindex = _customIndex;
|
|
return S_OK;
|
|
}
|
|
|
|
virtual HRESULT GetClass(REFIID iid,
|
|
SerializableProperty **ppSer,
|
|
BOOL forQI,
|
|
BOOL *pbZeroSizeOk=NULL);
|
|
|
|
inline InstantiationInfo *GetInstantiationInfo()
|
|
{
|
|
if (!_pinst)
|
|
{
|
|
_pinst = &_instantiationInfo;
|
|
|
|
if (!_unSerialized)
|
|
AddSerializableIfs(_pinst);
|
|
else
|
|
UnSerializeCallBack(IID_IInstantiationInfo, NULL);
|
|
}
|
|
|
|
return _pinst;
|
|
}
|
|
|
|
inline ContextInfo *GetContextInfo()
|
|
{
|
|
if (!_pContextInfo)
|
|
{
|
|
_pContextInfo = &_contextInfo;
|
|
|
|
if (!_unSerialized)
|
|
AddSerializableIfs(_pContextInfo);
|
|
else
|
|
UnSerializeCallBack(IID_IActivationContextInfo, NULL);
|
|
}
|
|
|
|
return _pContextInfo;
|
|
}
|
|
|
|
inline ServerLocationInfo *GetServerLocationInfo()
|
|
{
|
|
if (!_pServerLocationInfo)
|
|
{
|
|
_pServerLocationInfo = &_serverLocationInfo;
|
|
|
|
if (!_unSerialized)
|
|
AddSerializableIfs(_pServerLocationInfo);
|
|
else
|
|
UnSerializeCallBack(IID_IServerLocationInfo, NULL);
|
|
}
|
|
|
|
return _pServerLocationInfo;
|
|
}
|
|
|
|
inline SpecialProperties *GetSpecialProperties()
|
|
{
|
|
if (!_pSpecialProperties)
|
|
{
|
|
_pSpecialProperties = &_specialProperties;
|
|
|
|
if (!_unSerialized)
|
|
AddSerializableIfs(_pSpecialProperties);
|
|
else
|
|
UnSerializeCallBack(IID_ISpecialSystemProperties, NULL);
|
|
}
|
|
|
|
return _pSpecialProperties;
|
|
}
|
|
|
|
inline SecurityInfo *GetSecurityInfo()
|
|
{
|
|
if (!_pSecurityInfo)
|
|
{
|
|
_pSecurityInfo = &_securityInfo;
|
|
|
|
if (!_unSerialized)
|
|
AddSerializableIfs(_pSecurityInfo);
|
|
else
|
|
UnSerializeCallBack(IID_IActivationSecurityInfo, NULL);
|
|
}
|
|
|
|
return _pSecurityInfo;
|
|
}
|
|
|
|
inline InstanceInfo *GetPersistInfo()
|
|
{
|
|
if (!_pPersist)
|
|
{
|
|
_pPersist = &_instanceInfo;
|
|
|
|
if (!_unSerialized)
|
|
AddSerializableIfs(_pPersist);
|
|
else
|
|
UnSerializeCallBack(IID_IInstanceInfo, NULL);
|
|
}
|
|
|
|
|
|
|
|
return _pPersist;
|
|
}
|
|
|
|
inline void SetDip(void *pDip)
|
|
{
|
|
_pDip = pDip;
|
|
}
|
|
|
|
inline void *GetDip()
|
|
{
|
|
return _pDip;
|
|
}
|
|
|
|
// FIXFIX (johnstra): InstanceInfo may hold onto an IStorage proxy.
|
|
// If we don't Release it before going back across, we try to release
|
|
// it from on a dispatch thread after the activation is done. This
|
|
// causes us to possibly call the proxy from the wrong apartment.
|
|
|
|
inline void CleanupLocalState(void)
|
|
{
|
|
_instanceInfo.CleanupLocalState();
|
|
}
|
|
|
|
private:
|
|
ACTIVATION_STAGE _stage;
|
|
DWORD _cCustomAct;
|
|
DWORD _customIndex;
|
|
DWORD _dwInitialContext;
|
|
BOOL _delegated;
|
|
|
|
// Used in the SCM by LBA
|
|
HANDLE _clientToken;
|
|
BOOL _fUseSystemIdentity;
|
|
BOOL _fComplusOnly;
|
|
|
|
|
|
// class info object and custom activators
|
|
IComClassInfo * _pClassInfo;
|
|
ISystemActivator ** _customActList;
|
|
|
|
//Fast cached copies of objects
|
|
InstantiationInfo *_pinst;
|
|
InstanceInfo *_pPersist;
|
|
ContextInfo *_pContextInfo;
|
|
ServerLocationInfo *_pServerLocationInfo;
|
|
SecurityInfo *_pSecurityInfo;
|
|
SpecialProperties *_pSpecialProperties;
|
|
|
|
// Locally allocated objects for efficiency
|
|
ActivationPropertiesOut _actOut;
|
|
SecurityInfo _securityInfo;
|
|
ServerLocationInfo _serverLocationInfo;
|
|
InstantiationInfo _instantiationInfo;
|
|
ContextInfo _contextInfo;
|
|
InstanceInfo _instanceInfo;
|
|
ScmRequestInfo _scmRequestInfo;
|
|
SpecialProperties _specialProperties;
|
|
void *_pDip;
|
|
IClassFactory *_pCF;
|
|
};
|
|
|
|
//----------------------------------------------------------------------
|
|
// Inproc unmarshalling class
|
|
// NOTE: Assumption is that this is stateless so can use a singleton
|
|
// in the internal instance creation
|
|
//----------------------------------------------------------------------
|
|
class InprocActpropsUnmarshaller:public IMarshal
|
|
{
|
|
public:
|
|
|
|
// Methods from IUnknown
|
|
STDMETHOD (QueryInterface) ( REFIID riid, LPVOID* ppv)
|
|
{
|
|
if (IsEqualIID(riid, IID_IUnknown))
|
|
*ppv = (IUnknown*) this;
|
|
else
|
|
if (IsEqualIID(riid, IID_IMarshal))
|
|
*ppv = (IMarshal*) this;
|
|
else
|
|
return E_NOINTERFACE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHOD_(ULONG,AddRef) ( void )
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
STDMETHOD_(ULONG,Release) ( void )
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
|
|
// Methods from IMarshal
|
|
STDMETHOD (GetUnmarshalClass)(
|
|
REFIID riid,
|
|
void *pv,
|
|
DWORD dwDestContext,
|
|
void *pvDestContext,
|
|
DWORD mshlflags,
|
|
CLSID *pCid)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDMETHOD (GetMarshalSizeMax)(
|
|
REFIID riid,
|
|
void *pv,
|
|
DWORD dwDestContext,
|
|
void *pvDestContext,
|
|
DWORD mshlflags,
|
|
DWORD *pSize)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDMETHOD (MarshalInterface)(
|
|
IStream *pStm,
|
|
REFIID riid,
|
|
void *pv,
|
|
DWORD dwDestContext,
|
|
void *pvDestContext,
|
|
DWORD mshlflags)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDMETHOD (UnmarshalInterface)(IStream *pStm,REFIID riid,void **ppv);
|
|
|
|
|
|
STDMETHOD (ReleaseMarshalData)(IStream *pStm)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDMETHOD (DisconnectObject)(DWORD dwReserved)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static InprocActpropsUnmarshaller *GetInstance()
|
|
{
|
|
return &_InprocActUnmarshaller;
|
|
}
|
|
|
|
private:
|
|
|
|
InprocActpropsUnmarshaller()
|
|
{
|
|
}
|
|
|
|
static InprocActpropsUnmarshaller _InprocActUnmarshaller;
|
|
|
|
};
|
|
|
|
//----------------------------------------------------------------------
|
|
// Definitions of functions used for marshalling the above objects
|
|
//----------------------------------------------------------------------
|
|
|
|
extern HRESULT ActPropsMarshalHelper(IActivationProperties *pact,
|
|
REFIID riid,
|
|
DWORD destCtx,
|
|
DWORD mshlflags,
|
|
MInterfacePointer **ppIRD);
|
|
|
|
extern HRESULT ActPropsUnMarshalHelper(IActivationProperties *pAct,
|
|
MInterfacePointer *pIFP,
|
|
REFIID riid,
|
|
void **ppv
|
|
);
|
|
|
|
//----------------------------------------------------------------------
|
|
// Miscellaneous helper functions
|
|
//----------------------------------------------------------------------
|
|
extern HRESULT LoadPersistentObject(IUnknown *, IInstanceInfo *);
|
|
|
|
extern HRESULT GetIFDFromInterface(
|
|
IUnknown *pUnk,
|
|
REFIID riid,
|
|
DWORD destCtx,
|
|
DWORD mshlflags,
|
|
MInterfacePointer **ppIRD);
|
|
|
|
extern HRESULT ReleaseIFD(
|
|
MInterfacePointer *pIRD);
|
|
|
|
extern void *GetDestCtxPtr(COMVERSION *pComVersion);
|
|
|
|
extern BOOL IsBrokenRefCount(CLSID *pClsId);
|
|
|
|
#endif //__ACTPROPS_HXX__
|