//+-------------------------------------------------------------------------
//
//  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;
}