Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
NT4/private/ole32/com/objact/sobjact.cxx

781 lines
23 KiB
C++
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1993.
//
// File: sobjact.cxx
//
// Contents: Activation Functions used by object servers.
//
// Functions: CoRegisterClassObject
// CoRevokeClassObject
// CoAddRefServerProcess
// CoReleaseServerProcess
// CoSuspendClassObjects
//
// Classes: CObjServer
//
// History: 12-May-93 Ricksa Created
//
//--------------------------------------------------------------------------
#include <ole2int.h>
#include <iface.h>
#include <olerem.h>
#include "..\..\ole232\stdimpl\handler.hxx"
#include "resolver.hxx"
#include "smstg.hxx"
#include "objact.hxx"
#include "service.hxx"
#include <sobjact.hxx>
#include <comsrgt.hxx>
CObjServer *gpMTAObjServer = NULL;
extern INTERNAL CreateCommonDdeWindow(void);
//+-------------------------------------------------------------------------
//
// Function: CoRegisterClassObject, public
//
// Synopsis: Register a class object in the requested context
//
// Arguments: [rclsid] - class ID
// [pUnk] - class object
// [dwContext] - context to register it in
// [flags] - single/multiple use.
// [lpdwRegister] - registration cookie
//
// Returns: S_OK - object is successfully registered
//
// Algorithm: Validate the parmeters. The get the class factory interface.
// Then add the class object to the list and finally notify
// the SCM that the service is started.
//
// History: 12-May-93 Ricksa Created
// 26-Jul-94 AndyH #20843 - restarting OLE in the shared WOW
//
//--------------------------------------------------------------------------
STDAPI CoRegisterClassObject(
REFCLSID rclsid,
IUnknown FAR* pUnk,
DWORD dwContext,
DWORD flags,
LPDWORD lpdwRegister)
{
HRESULT hr;
#ifdef WX86OLE
BOOL fContextArgBad;
#endif
OLETRACEIN((API_CoRegisterClassObject,
PARAMFMT("rclsid= %I, pUnk= %p, dwContext= %x, flags= %x, lpdwRegister= %p"),
&rclsid, pUnk, dwContext, flags, lpdwRegister));
TRACECALL(TRACE_ACTIVATION, "CoRegisterClassObject");
if (!IsApartmentInitialized())
{
hr = CO_E_NOTINITIALIZED;
goto errRtn;
}
// Validate the out parameter
if (!IsValidPtrOut(lpdwRegister, sizeof(DWORD)))
{
CairoleAssert(IsValidPtrOut(lpdwRegister, sizeof(DWORD)) &&
"CoRegisterClassObject invalid registration ptr");
hr = E_INVALIDARG;
goto errRtn;
}
*lpdwRegister = 0;
// Validate the pUnk
if (!IsValidInterface(pUnk))
{
CairoleAssert(IsValidInterface(pUnk) &&
"CoRegisterClassObject invalid pUnk");
hr = E_INVALIDARG;
goto errRtn;
}
// Hook the pUnk
CALLHOOKOBJECT(S_OK,rclsid,IID_IClassFactory,&pUnk);
// Validate context flags
#ifdef WX86OLE
if (gcwx86.IsWx86Enabled())
{
fContextArgBad = (dwContext & (~(CLSCTX_ALL | CLSCTX_INPROC_SERVER16 |
CLSCTX_INPROC_SERVERX86) |
CLSCTX_INPROC_HANDLER |
CLSCTX_INPROC_HANDLERX86));
} else {
fContextArgBad = (dwContext & (~(CLSCTX_ALL | CLSCTX_INPROC_SERVER16)
| CLSCTX_INPROC_HANDLER));
}
if (fContextArgBad)
#else
if ((dwContext & (~(CLSCTX_ALL | CLSCTX_INPROC_SERVER16) |
CLSCTX_INPROC_HANDLER)) != 0)
#endif
{
hr = E_INVALIDARG;
goto errRtn;
}
// Validate flag flags
if (flags > (REGCLS_SUSPENDED | REGCLS_MULTI_SEPARATE | REGCLS_SURROGATE))
{
hr = E_INVALIDARG;
goto errRtn;
}
if ((flags & REGCLS_SURROGATE) && !(dwContext & CLSCTX_LOCAL_SERVER))
{
hr = E_INVALIDARG;
goto errRtn;
}
#ifdef WX86OLE
if (flags & REGCLS_MULTIPLEUSE)
{
if (gcwx86.IsWx86Enabled())
{
if (dwContext & CLSCTX_INPROC_SERVERX86)
{
dwContext |= CLSCTX_INPROC_HANDLERX86 |
CLSCTX_INPROC_HANDLER;
} else {
dwContext |= CLSCTX_INPROC;
}
} else {
dwContext |= CLSCTX_INPROC;
}
}
#else
if (flags & REGCLS_MULTIPLEUSE)
{
dwContext |= CLSCTX_INPROC;
}
#endif
if (dwContext & CLSCTX_LOCAL_SERVER)
{
// thread safe incase we are in MultiThreaded model.
COleStaticLock lck(gmxsOleMisc);
// Make sure an instance of CObjServer exists for this thread.
// The SCM will call back on it to activate objects.
CObjServer *pObjServer = GetObjServer();
if (pObjServer == NULL)
{
COleTls Tls;
// no activation server for this apartment yet, go make one now.
HRESULT hr = E_OUTOFMEMORY;
pObjServer = new CObjServer(hr);
if (FAILED(hr))
{
delete pObjServer;
return hr;
}
// If we want to service OLE1 clients, we need to create the
// common Dde window now if it has not already been done.
if( !(Tls->dwFlags & OLETLS_DISABLE_OLE1DDE) )
{
CreateCommonDdeWindow();
}
}
}
// Put our object in the server table
hr = gdllcacheInprocSrv.RegisterServer(rclsid, pUnk,
flags, dwContext, lpdwRegister);
errRtn:
OLETRACEOUT((API_CoRegisterClassObject, hr));
return hr;
}
//+-------------------------------------------------------------------------
//
// Function: CoRevokeClassObject, public
//
// Synopsis: Revoke a previously registered class object
//
// Arguments: [dwRegister] - registration key returned from CoRegister...
//
// Returns: S_OK - class successfully deregistered.
//
// Algorithm: Ask cache to deregister the class object.
//
// History: 12-May-93 Ricksa Created
//
//--------------------------------------------------------------------------
STDAPI CoRevokeClassObject(DWORD dwRegister)
{
OLETRACEIN((API_CoRevokeClassObject, PARAMFMT("dwRegister= %x"), dwRegister));
TRACECALL(TRACE_ACTIVATION, "CoRevokeClassObject");
HRESULT hr = CO_E_NOTINITIALIZED;
if (IsApartmentInitialized())
{
// Try to revoke the object
hr = gdllcacheInprocSrv.Revoke(dwRegister);
}
OLETRACEOUT((API_CoRevokeClassObject, hr));
return hr;
}
//+-------------------------------------------------------------------------
//
// Function: CoAddRefServerProcess, public
//
// Synopsis: Increments the global per-process server reference count.
// See CDllCache::AddRefServerProcess for more detail.
//
// History: 17-Apr-96 Rickhi Created
//
//--------------------------------------------------------------------------
STDAPI_(ULONG) CoAddRefServerProcess(void)
{
return gdllcacheInprocSrv.AddRefServerProcess();
}
//+-------------------------------------------------------------------------
//
// Function: CoReleaseServerProcess, public
//
// Synopsis: Decrements the global per-process server reference count.
// See CDllCache::ReleaseServerProcess for more detail.
//
// History: 17-Apr-96 Rickhi Created
//
//--------------------------------------------------------------------------
STDAPI_(ULONG) CoReleaseServerProcess(void)
{
return gdllcacheInprocSrv.ReleaseServerProcess();
}
//+-------------------------------------------------------------------------
//
// Function: CoSuspendClassObjects, public
//
// Synopsis: suspends all registered LOCAL_SERVER class objects for this
// process so that no new activation calls from the SCM will
// be accepted.
//
// History: 17-Apr-96 Rickhi Created
//
//--------------------------------------------------------------------------
STDAPI CoSuspendClassObjects(void)
{
return gdllcacheInprocSrv.SuspendProcessClassObjects();
}
//+-------------------------------------------------------------------------
//
// Function: CoResumeClassObjects, public
//
// Synopsis: resumes all registered LOCAL_SERVER class objects for this
// process that are currently marked as SUSPENDED, so that new
// activation calls from the SCM will now be accepted.
//
// History: 17-Apr-96 Rickhi Created
//
//--------------------------------------------------------------------------
STDAPI CoResumeClassObjects(void)
{
return gdllcacheInprocSrv.ResumeProcessClassObjects();
}
//+-------------------------------------------------------------------
//
// Member: CObjServer::CObjServer, public
//
// Synopsis: construction
//
// History: 10 Apr 95 AlexMit Created
//
//--------------------------------------------------------------------
CObjServer::CObjServer(HRESULT &hr)
{
_hr = MarshalInternalObjRef(_objref, IID_IObjServer,
(IObjServer*) this, MSHLFLAGS_NOPING, NULL);
if (SUCCEEDED(_hr))
{
SetObjServer(this);
}
hr = _hr;
ComDebOut((DEB_ACTIVATE, "CObjServer::CObjServer _hr:%x\n", _hr));
}
//+-------------------------------------------------------------------
//
// Member: CObjServer::~CObjServer, public
//
// Synopsis: dtor for activation object
//
// History: 19 Jun 95 Rickhi Created
//
//--------------------------------------------------------------------
CObjServer::~CObjServer()
{
if (SUCCEEDED(_hr))
{
// only do RMD if the marshall was sucessfull
SetObjServer(NULL);
_hr = ReleaseMarshalObjRef(_objref);
Win4Assert(SUCCEEDED(_hr));
FreeObjRef(_objref);
}
ComDebOut((DEB_ACTIVATE, "CObjServer::~CObjServer _hr:%x\n", _hr));
}
//+-------------------------------------------------------------------
//
// Member: CObjServer::AddRef, public
//
// Synopsis: we dont refcnt this object so this is a noop
//
// History: 10 Apr 95 AlexMit Created
//
//--------------------------------------------------------------------
ULONG CObjServer::AddRef(void)
{
return 1;
}
//+-------------------------------------------------------------------
//
// Member: CObjServer::Release, public
//
// Synopsis: we dont refcnt this object so this is a noop
//
// History: 10 Apr 95 AlexMit Created
//
//--------------------------------------------------------------------
ULONG CObjServer::Release(void)
{
return 1;
}
//+-------------------------------------------------------------------
//
// Member: CObjServer::QueryInterface, public
//
// Synopsis: returns supported interfaces
//
// History: 10 Apr 95 AlexMit Created
//
//--------------------------------------------------------------------
STDMETHODIMP CObjServer::QueryInterface(REFIID riid, void **ppv)
{
if (IsEqualIID(riid, IID_IObjServer) || // more common than IUnknown
IsEqualIID(riid, IID_IUnknown))
{
*ppv = (IObjServer *) this;
AddRef();
return S_OK;
}
*ppv = NULL;
return E_NOINTERFACE;
}
//+-------------------------------------------------------------------
//
// Member: ObjactThreadUninitialize
//
// Synopsis: Cleans up the CObjServer object
//
// History: 10 Apr 95 AlexMit Created
//
//--------------------------------------------------------------------
STDAPI_(void) ObjactThreadUninitialize(void)
{
CObjServer *pObjServer = GetObjServer();
if (pObjServer != NULL)
{
delete pObjServer;
}
}
//+-------------------------------------------------------------------------
//
// Member: CObjServer::ObjectServerGetClassObject
//
//--------------------------------------------------------------------------
STDMETHODIMP CObjServer::ObjectServerGetClassObject(
const GUID *guidCLSID,
IID *pIID,
BOOL fSurrogate,
MInterfacePointer **ppIFD,
DWORD * pStatus )
{
ComDebOut((DEB_ACTIVATE,
"CObjServer::ObjectServerGetClassObject clsid:%I\n", &guidCLSID));
*pStatus = RPC_S_OK;
// Check access.
if (!CheckObjactAccess())
{
return HRESULT_FROM_WIN32( ERROR_ACCESS_DENIED );
}
HRESULT hr;
IUnknown *pcf;
// Get the class object
#ifdef WX86OLE
hr = gdllcacheInprocSrv.GetClass(*guidCLSID, *pIID, FALSE, TRUE, fSurrogate, FALSE, &pcf);
#else
hr = gdllcacheInprocSrv.GetClass(*guidCLSID, *pIID, FALSE, TRUE, fSurrogate, &pcf);
#endif
if (pcf)
{
// We got the class object, create a buffer and marshal it for return.
// Marshal it NORMAL and turn on the NotifyActivation flag so we can
// add an implicit LockServer during marshaling to plug inherent races
// in the IClassFactory protocol.
hr = MarshalHelper(pcf, *pIID,
MSHLFLAGS_NORMAL | MSHLFLAGS_NOTIFYACTIVATION,
(InterfaceData**) ppIFD);
}
else
{
// If we get a NULL, this means that we have
// recieved the request after we have decided
// to stop, so we tell the caller we are stopping
// so they can start a new copy of the server.
if ( hr == S_OK )
hr = CO_E_SERVER_STOPPING;
}
ComDebOut((DEB_ACTIVATE,
"CObjServer::ObjectServerGetClassObject hr:%x\n", hr));
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CObjServer::ObjectServerCreateInstance
//
//----------------------------------------------------------------------------
STDMETHODIMP CObjServer::ObjectServerCreateInstance(
/* [in] */ const GUID *rclsid,
/* [in] */ DWORD dwInterfaces,
/* [size_is][in] */ IID *pIIDs,
/* [size_is][out] */ MInterfacePointer **ppIFDs,
/* [size_is][out] */ HRESULT *pResults,
/* [out] */ DWORD * pStatus )
{
ComDebOut((DEB_ACTIVATE,
"CObjServer::ObjectServerCreateInstance clsid:%I\n", rclsid));
*pStatus = RPC_S_OK;
// Check access.
if (!CheckObjactAccess())
{
return HRESULT_FROM_WIN32( ERROR_ACCESS_DENIED );
}
HRESULT hr;
IUnknown *pcf;
// Get the class object
#ifdef WX86OLE
hr = gdllcacheInprocSrv.GetClass(*rclsid, IID_IClassFactory, FALSE, TRUE, FALSE, FALSE, &pcf);
#else
hr = gdllcacheInprocSrv.GetClass(*rclsid, IID_IClassFactory, FALSE, TRUE, FALSE, &pcf);
#endif
if (pcf)
{
// first, check if the server is willing to accept the incoming call
// on IClassFactory. The reason we need this is that EXCEL's message
// filter rejects calls on IID_IClassFactory if it is busy. They dont
// know about IID_IObjServer.
hr = HandleIncomingCall(IID_IClassFactory, 3,
CALLCAT_SYNCHRONOUS,
(void *)pcf);
if (SUCCEEDED(hr))
{
// Load the object
hr = GetInstanceHelperMulti((IClassFactory *)pcf, dwInterfaces, pIIDs,
ppIFDs, pResults, NULL);
}
pcf->Release();
}
else
{
// If we get a NULL, this means that we have
// recieved the request after we have decided
// to stop, so we tell the caller we are stopping
// so they can start a new copy of the server.
if ( hr == S_OK )
hr = CO_E_SERVER_STOPPING;
}
ComDebOut((DEB_ACTIVATE,
"CObjServer::ObjectServerCreateInstance hr:%x\n", hr));
return hr;
}
//+-------------------------------------------------------------------------
//
// Member: CObjServer::ObjectServerGetInstance
//
//--------------------------------------------------------------------------
STDMETHODIMP CObjServer::ObjectServerGetInstance(
/* [in] */ const GUID *rclsid,
/* [in] */ DWORD grfMode,
/* [unique][string][in] */ WCHAR *pwszPath,
/* [unique][in] */ MInterfacePointer *pIFDstg,
/* [in] */ DWORD Interfaces,
/* [size_is][in] */ IID *pIIDs,
/* [unique][in] */ MInterfacePointer *pIFDFromROT,
/* [size_is][out] */ MInterfacePointer **ppIFDs,
/* [size_is][out] */ HRESULT *pResults,
/* [out] */ DWORD * pStatus )
{
HRESULT hr = S_OK;
*pStatus = RPC_S_OK;
// Check access.
if (!CheckObjactAccess())
{
return HRESULT_FROM_WIN32( ERROR_ACCESS_DENIED );
}
if (pIFDFromROT != NULL)
{
// If the SCM has passed us an object from the ROT, we
// try to use that first by unmarshalling it and then
// marshaling it normal.
CXmitRpcStream xrpcForUnmarshal((InterfaceData*)pIFDFromROT);
IUnknown *punk;
hr = CoUnmarshalInterface(&xrpcForUnmarshal, IID_IUnknown,
(void **) &punk);
if (SUCCEEDED(hr))
{
hr = E_NOINTERFACE;
for ( DWORD i = 0; i < Interfaces; i++ )
{
// Stream to put marshaled interface in
CXmitRpcStream xrpc;
HRESULT hr2;
// use DIFFERENTMACHINE so we get the long form OBJREF
hr2 = CoMarshalInterface(&xrpc, pIIDs[i], punk,
MSHCTX_DIFFERENTMACHINE, NULL, MSHLFLAGS_NORMAL);
if (SUCCEEDED(hr2))
{
// Report OK if any interface is found.
hr = hr2;
xrpc.AssignSerializedInterface((InterfaceData **) &ppIFDs[i]);
}
pResults[i] = hr2;
}
// Don't need the unknown ptr any more
punk->Release();
return hr;
}
// Assume any errors are the result of a stale entry in the ROT
// so we just fall into the regular code path from here.
hr = S_OK;
}
CSafeMarshaledStg smstg( (InterfaceData*) pIFDstg, hr);
if (FAILED(hr))
{
return hr;
}
// Get the class object
IUnknown *pcf = NULL;
#ifdef WX86OLE
hr = gdllcacheInprocSrv.GetClass(*rclsid, IID_IClassFactory, FALSE, TRUE, FALSE, FALSE, &pcf);
#else
hr = gdllcacheInprocSrv.GetClass(*rclsid, IID_IClassFactory, FALSE, TRUE, FALSE, &pcf);
#endif
if (pcf)
{
// first, check if the server is willing to accept the incoming call
// on IClassFactory. The reason we need this is that EXCEL's message
// filter rejects calls on IID_IClassFactory if it is busy. They dont
// know about IID_IObjServer.
hr = HandleIncomingCall(IID_IClassFactory, 3,
CALLCAT_SYNCHRONOUS,
(void *)pcf);
if (SUCCEEDED(hr))
{
// Load the object
hr = GetObjectHelperMulti((IClassFactory *)pcf, grfMode, NULL,
pwszPath, smstg, Interfaces, pIIDs, ppIFDs, pResults, NULL);
}
pcf->Release();
}
else
{
// If we get a NULL, this means that we have
// recieved the request after we have decided
// to stop, so we tell the caller we are stopping
// so they can start a new copy of the server.
if ( hr == S_OK )
hr = CO_E_SERVER_STOPPING;
}
return hr;
}
//+-------------------------------------------------------------------------
//
// Member: CObjServer::ObjectServerLoadDll
//
// Synopsis: Loads the requested dll into a surrogate process which
// implements the ISurrogate interface
//
//--------------------------------------------------------------------------
STDMETHODIMP CObjServer::ObjectServerLoadDll(
/* [in] */ const GUID *rclsid,
/* [out] */ DWORD* pStatus)
{
ComDebOut((DEB_ACTIVATE, "ObjectServerLoadDll clsid:%I\n", rclsid));
*pStatus = RPC_S_OK;
HRESULT hr = CCOMSurrogate::LoadDllServer(*rclsid);
ComDebOut((DEB_ACTIVATE, "ObjectServerLoadDll hr:%x\n", hr));
return hr;
}
//+-------------------------------------------------------------------------
//
// Function: NotifyActivation
//
// Synopsis: Add/Remove implicit IClassFactory::LockServer during marshal
// and last external release of an interface pointer.
//
// Arguments: [fLock] - whether to Lock or Unlock
// [pUnk] - ptr to object interface
//
// Returns: TRUE - call again during last release
// FALSE - dont call again during last release
//
// History: 12-May-96 RickHi Created
//
// Notes: there is an inherent race condition in the IClassFactory (and
// derived interfaces) in that between the time a client gets the
// ICF pointer and the time they call LockServer(TRUE), a server could
// shut down. In order to plug this hole, COM's activation code will
// attempt to do an implicit LockServer(TRUE) on the server side of
// CoGetClassObject during the marshaling of the class object
// interface. Since we dont know for sure that it is IClassFactory
// being marshaled, we QI for it here.
//
//--------------------------------------------------------------------------
INTERNAL_(BOOL) NotifyActivation(BOOL fLock, IUnknown *pUnk)
{
ComDebOut((DEB_ACTIVATE, "NotifyActivation fLock:%x pUnk:%x\n", fLock, pUnk));
// If the object supports IClassFactory, do an implicit LockServer(TRUE)
// on behalf of the client when the interface is first marshaled by
// CoGetClassObject. When the last external reference to the interface is
// release, do an implicit LockServer(FALSE).
IClassFactory *pICF = NULL;
if (SUCCEEDED(pUnk->QueryInterface(IID_IClassFactory, (void **)&pICF)))
{
pICF->LockServer(fLock);
pICF->Release();
return TRUE;
}
return FALSE;
}
//+-------------------------------------------------------------------------
//
// Function: CoRegisterSurrogate, public
//
// Synopsis: Register an ISurrogate interface for a surrogate process
//
// Arguments: [pSurrogate] - existing ISurrogate interface ponter
//
// Returns: S_OK - object is successfully registered
//
// Algorithm: Validate the parameter. Then set a global pointer to the
// value of the pSurrogate parameter
//
// History: 2-Jun-96 t-AdamE Created
//
//--------------------------------------------------------------------------
STDAPI CoRegisterSurrogate(ISurrogate* pSurrogate)
{
HRESULT hr;
OLETRACEIN((API_CoRegisterSurrogate,
PARAMFMT("pSurrogate= %p"),
pSurrogate));
TRACECALL(TRACE_ACTIVATION, "CoRegisterSurrogate");
if (!IsApartmentInitialized())
{
hr = CO_E_NOTINITIALIZED;
goto errRtn;
}
// Validate the pSurrogate
if (!IsValidInterface(pSurrogate))
{
CairoleAssert(IsValidInterface(pSurrogate) &&
"CoRegisterSurrogate invalid pSurrogate");
hr = E_INVALIDARG;
goto errRtn;
}
hr = CCOMSurrogate::InitializeISurrogate(pSurrogate);
errRtn:
OLETRACEOUT((API_CoRegisterSurrogate, hr));
return hr;
}
Reference in New Issue Copy Permalink