path: root/private/ole32/ole232/base/ole2.cpp

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1993.
//
//  File:       ole2.cpp
//
//  Contents:   LibMain and initialization routines
//
//  Classes:
//
//  Functions:  LibMain
//              OleInitialize
//              OleInitializeWOW
//              OleInitializeEx
//              OleUnitialize
//              OleBuildVersion - !WIN32
//
//
//  History:    dd-mmm-yy Author    Comment
//              16-Feb-94 AlexT     alias OleBuildVersion, remove OleGetMalloc
//                                  remove DisableThreadLibaryCalls
//              11-Jan-94 alexgo    added VDATEHEAP macros to every function
//              10-Dec-93 alexgo    added support for LEDebugOut
//              06-Dec-93 ChrisWe   remove declaration of ClipboardInitialize()
//                      and ClipboardUninitialize(), which are declared in
//                      clipbrd.h; include that instead
//              15-Mar-94 KevinRo   Added OleInitializeWOW();
//
//--------------------------------------------------------------------------


#include <le2int.h>
#include <clipbrd.h>
#include <dragopt.h>
#include <drag.h>

#pragma SEG(ole)

#include <olerem.h>
#include <ole2ver.h>
#include <thunkapi.hxx>
#include <ddesrvr.h>
#include <perfmnce.hxx>
#include <olesem.hxx>

//
// DECLARE_INFOLEVEL is a macro used with cairo-style debugging output.
// it creates a global variable LEInfoLevel which contains bits flags
// of the various debugging output that should be sent to the debugger.
//
// Note that info level may be set within the debugger once ole232.dll
// has loaded.
//
// Currently LEInfoLevel defaults to DEB_WARN | DEB_ERROR
//
DECLARE_INFOLEVEL(LE);
DECLARE_INFOLEVEL(Ref);
DECLARE_INFOLEVEL(DD);
DECLARE_INFOLEVEL(VDATE);

NAME_SEG(Ole2Main)
// these are globals

HMODULE         g_hmodOLE2 = NULL;
HINSTANCE	g_hinst = NULL;
ULONG		g_cOleProcessInits = 0;

CLIPFORMAT      g_cfObjectLink = NULL;
CLIPFORMAT      g_cfOwnerLink = NULL;
CLIPFORMAT      g_cfNative = NULL;
CLIPFORMAT      g_cfLink = NULL;
CLIPFORMAT      g_cfBinary = NULL;
CLIPFORMAT      g_cfFileName = NULL;
CLIPFORMAT      g_cfFileNameW = NULL;
CLIPFORMAT      g_cfNetworkName = NULL;
CLIPFORMAT      g_cfDataObject = NULL;
CLIPFORMAT      g_cfEmbeddedObject = NULL;
CLIPFORMAT      g_cfEmbedSource = NULL;
CLIPFORMAT      g_cfCustomLinkSource = NULL;
CLIPFORMAT      g_cfLinkSource = NULL;
CLIPFORMAT      g_cfLinkSrcDescriptor = NULL;
CLIPFORMAT      g_cfObjectDescriptor = NULL;
CLIPFORMAT      g_cfOleDraw = NULL;
CLIPFORMAT      g_cfPBrush = NULL;
CLIPFORMAT      g_cfMSDraw = NULL;
CLIPFORMAT      g_cfOlePrivateData = NULL;
CLIPFORMAT      g_cfScreenPicture = NULL;

ATOM            g_aDropTarget = NULL;

ASSERTDATA

ASSERTOUTDATA

// more globals

extern UINT     uOmPostWmCommand;
extern UINT	uOleMessage;
extern COleStaticMutexSem g_mxsSingleThreadOle;


// this dummy function is used to avoid a copy of the environment variables.
// NOTE: the moniker and dde code still use the windows heap.

extern "C" void _setenvp(void) {
        VDATEHEAP();
 }


#ifdef _CHICAGO_
// Private Chicago Defines
//
//  The Chicago Shell will dynamically load the OLE32.DLL to improve
//  bootup start time.  When an application calls CoInitialize, post
//  a message to the shell to inform it to load OLE32.DLL if it hasn't
//  already.     The Shell will never unload OLE32.DLL.
//
//  We are using an undocumented Shell interface.
//
BOOL    gfShellInitialized = FALSE;

#define WM_SHELLNOTIFY           0x0034
#define SHELLNOTIFY_OLELOADED    0x0002

extern "C" HWND WINAPI GetShellWindow(void);
#endif  // _CHICAGO_

//+---------------------------------------------------------------------------
//
//  Function:   OleInitializeWOW
//  Synopsis:   Entry point to initialize the 16-bit WOW thunk layer.
//
//  Effects:    This routine is called when OLE32 is loaded by a VDM.
//              It serves two functions: It lets OLE know that it is
//              running in a VDM, and it passes in the address to a set
//              of functions that are called by the thunk layer. This
//              allows normal 32-bit processes to avoid loading the WOW
//              DLL since the thunk layer references it.
//
//  Arguments:  [vlpmalloc] -- 16:16 pointer to the 16 bit allocator.
//              [lpthk] -- Flat pointer to the OleThunkWOW virtual
//                         interface. This is NOT an OLE/IUnknown style
//                         interface.
//  Requires:
//
//  Returns:
//
//  Signals:
//
//  Modifies:
//
//  Algorithm:
//
//  History:    3-15-94   kevinro   Created
//
//  Notes:
//
//----------------------------------------------------------------------------
STDAPI OleInitializeWOW( LPMALLOC vlpmalloc, LPOLETHUNKWOW lpthk )
{
    OLETRACEIN((API_OleInitializeWOW, PARAMFMT("vlpmalloc= %x, lpthk= %p"),
                                                                                vlpmalloc, lpthk));

    SetOleThunkWowPtr(lpthk);

    HRESULT hr;

    hr = OleInitializeEx( NULL, COINIT_APARTMENTTHREADED );

    OLETRACEOUT((API_OleInitializeWOW, hr));

    return hr;
}


//+-------------------------------------------------------------------------
//
//  Function:   OleInitialize
//
//  Synopsis:   Initializes OLE in single threaded mode
//
//  Effects:
//
//  Arguments:  [pMalloc]       -- the memory allocator to use
//
//  Requires:
//
//  Returns:    HRESULT
//
//  Signals:
//
//  Modifies:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              06-Dec-93 alexgo    32bit port
//
//  Notes:
//
//--------------------------------------------------------------------------

STDAPI OleInitialize(void * pMalloc)
{
    OLETRACEIN((API_OleInitialize, PARAMFMT("pMalloc= %p"), pMalloc));

    VDATEHEAP();

    HRESULT hr;

    hr = OleInitializeEx( pMalloc, COINIT_APARTMENTTHREADED );

    OLETRACEOUT((API_OleInitialize, hr));

    return hr;
}

//+-------------------------------------------------------------------------
//
//  Function:   OleInitializeEx
//
//  Synopsis:   Initializes ole
//
//  Effects:
//
//  Arguments:  [pMalloc]       -- the task memory allocator to use
//              [flags]         -- single or multi-threaded
//
//  Requires:
//
//  Returns:    HRESULT
//
//  Signals:
//
//  Modifies:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              06-Dec-93 alexgo    32bit port
//              24-May-94 AlexT     Propagate CoInitializeEx's return code
//              21-Jul-94 AlexT     Allow nested OleInit/Uninit calls
//              24-Aug-94 AlexT     Return S_OK for first success and S_FALSE
//                                  thereafter (unless an allocator was
//                                  passed in)
//
//  Notes:      This routine may be called multiple times per apartment
//
//--------------------------------------------------------------------------
#pragma SEG(OleInitialize)
STDAPI OleInitializeEx(LPVOID pMalloc, ULONG ulFlags)
{
    OLETRACEIN((API_OleInitialize, PARAMFMT("pMalloc= %p, ulFlags= %x"), pMalloc, ulFlags));
    VDATEHEAP();

    HRESULT hr;
#if DBG==1
    HRESULT hrCoInit = S_OK;
#endif
    DWORD cThreadOleInits;

    StartPerfCounter(CoInitialize);
    hr = CoInitializeEx(pMalloc, ulFlags);
    EndPerfCounter(CoInitialize);

    if (SUCCEEDED(hr))
    {
	Assert (g_hmodOLE2);
#if DBG==1
	hrCoInit = hr;
#endif

	COleTls tls;
	cThreadOleInits = ++ tls->cOleInits;

	do
	{
	    // We only want to do the below initialization once per apartment
	    if (cThreadOleInits > 1)
	    {
		// We've already been this way before, just return
		Assert(SUCCEEDED(hr) && "Bad OleInitializeEx logic");
		break;
	    }

	    // single thread registration of DDE and clipboard formats.
	    // Only do this once per process.

	    COleStaticLock lck(g_mxsSingleThreadOle);

	    if (++g_cOleProcessInits != 1)
	    {
		// already done the per-process initialization
		break;
	    }

	    if (FALSE==DDELibMain (g_hmodOLE2, (WORD)0, (WORD)0, NULL))
	    {
		Assert (!"DDELibMain failed()");

		hr = E_OUTOFMEMORY;
		break;
	    }

	    // Only need to do the initialization once so check the global
	    // that gets assigned last.

	    if( !g_aDropTarget )
	    {
#ifndef _CHICAGO_
	    // on NT3.51, clipboard formats are pre-registered for us by user32.
	    // We know they are going to be sequential.  This gives us a
	    // good performance improvement (since the clipboard formats never
	    // change.

	    // BUGBUG(alexgo); Chicago needs to get this behaviour too

	    g_cfObjectLink = RegisterClipboardFormat(OLESTR("ObjectLink"));

            g_cfOwnerLink = g_cfObjectLink + 1;
	    Assert(g_cfOwnerLink == RegisterClipboardFormat(OLESTR("OwnerLink")));

            g_cfNative = g_cfObjectLink + 2;
            Assert(g_cfNative == RegisterClipboardFormat(OLESTR("Native")));

            g_cfBinary = g_cfObjectLink + 3;
            Assert(g_cfBinary == RegisterClipboardFormat(OLESTR("Binary")));

            g_cfFileName = g_cfObjectLink + 4;
	    Assert(g_cfFileName == RegisterClipboardFormat(OLESTR("FileName")));

            g_cfFileNameW = g_cfObjectLink + 5;
            Assert(g_cfFileNameW ==
                    RegisterClipboardFormat(OLESTR("FileNameW")));

            g_cfNetworkName = g_cfObjectLink + 6;
            Assert(g_cfNetworkName  ==
                    RegisterClipboardFormat(OLESTR("NetworkName")));

            g_cfDataObject = g_cfObjectLink + 7;
            Assert(g_cfDataObject ==
                    RegisterClipboardFormat(OLESTR("DataObject")));

            g_cfEmbeddedObject = g_cfObjectLink + 8;
            Assert(g_cfEmbeddedObject ==
                    RegisterClipboardFormat(OLESTR("Embedded Object")));

            g_cfEmbedSource = g_cfObjectLink + 9;
            Assert(g_cfEmbedSource ==
                    RegisterClipboardFormat(OLESTR("Embed Source")));

            g_cfCustomLinkSource = g_cfObjectLink + 10;
            Assert(g_cfCustomLinkSource  ==
                    RegisterClipboardFormat(OLESTR("Custom Link Source")));

            g_cfLinkSource = g_cfObjectLink + 11;
            Assert(g_cfLinkSource ==
                    RegisterClipboardFormat(OLESTR("Link Source")));

            g_cfObjectDescriptor = g_cfObjectLink + 12;
            Assert(g_cfObjectDescriptor ==
                    RegisterClipboardFormat(OLESTR("Object Descriptor")));

            g_cfLinkSrcDescriptor = g_cfObjectLink + 13;
            Assert(g_cfLinkSrcDescriptor ==
                    RegisterClipboardFormat(OLESTR("Link Source Descriptor")));

            g_cfOleDraw = g_cfObjectLink + 14;
            Assert(g_cfOleDraw == RegisterClipboardFormat(OLESTR("OleDraw")));

            g_cfPBrush = g_cfObjectLink + 15;
            Assert(g_cfPBrush == RegisterClipboardFormat(OLESTR("PBrush")));

            g_cfMSDraw = g_cfObjectLink + 16;
            Assert(g_cfMSDraw == RegisterClipboardFormat(OLESTR("MSDraw")));

            g_cfOlePrivateData = g_cfObjectLink + 17;
            Assert(g_cfOlePrivateData ==
                    RegisterClipboardFormat(OLESTR("Ole Private Data")));

            g_cfScreenPicture = g_cfObjectLink + 18;
            Assert(g_cfScreenPicture  ==
                RegisterClipboardFormat(OLESTR("Screen Picture")));

            g_aDropTarget = GlobalAddAtom(OLE_DROP_TARGET_PROP);
            AssertSz(g_aDropTarget, "Couldn't add drop target atom\n");
	    }

	    // Used in Inplace editing
	    uOmPostWmCommand = RegisterWindowMessage(OLESTR("OM_POST_WM_COMMAND"));
	    uOleMessage	     = RegisterWindowMessage(OLESTR("OLE_MESSAHE"));

#else  //  !_CHICAGO_

	    g_cfObjectLink	  = SSRegisterClipboardFormatA("ObjectLink");
            g_cfOwnerLink         = SSRegisterClipboardFormatA("OwnerLink");
            g_cfNative            = SSRegisterClipboardFormatA("Native");
            g_cfBinary            = SSRegisterClipboardFormatA("Binary");
            g_cfFileName          = SSRegisterClipboardFormatA("FileName");
            g_cfFileNameW         = SSRegisterClipboardFormatA("FileNameW");
            g_cfNetworkName       = SSRegisterClipboardFormatA("NetworkName");
            g_cfDataObject        = SSRegisterClipboardFormatA("DataObject");
            g_cfEmbeddedObject    = SSRegisterClipboardFormatA("Embedded Object");
            g_cfEmbedSource       = SSRegisterClipboardFormatA("Embed Source");
            g_cfCustomLinkSource  = SSRegisterClipboardFormatA("Custom Link Source");
            g_cfLinkSource        = SSRegisterClipboardFormatA("Link Source");
            g_cfObjectDescriptor  = SSRegisterClipboardFormatA("Object Descriptor");
            g_cfLinkSrcDescriptor = SSRegisterClipboardFormatA("Link Source Descriptor");
            g_cfOleDraw           = SSRegisterClipboardFormatA("OleDraw");
            g_cfPBrush            = SSRegisterClipboardFormatA("PBrush");
            g_cfMSDraw            = SSRegisterClipboardFormatA("MSDraw");
            g_cfOlePrivateData    = SSRegisterClipboardFormatA("Ole Private Data");
            g_cfScreenPicture     = SSRegisterClipboardFormatA("Screen Picture");
            g_aDropTarget         = GlobalAddAtomA(OLE_DROP_TARGET_PROPA);
            AssertSz(g_aDropTarget, "Couldn't add drop target atom\n");
	    }

	    // Used in Inplace editing
	    uOmPostWmCommand = RegisterWindowMessageA("OM_POST_WM_COMMAND");
	    uOleMessage	     = RegisterWindowMessageA("OLE_MESSAHE");

#endif // !_CHICAGO_

	} while (FALSE); // end of do


	if (FAILED(hr))
	{
	    // clean up and break out
	    DDEWEP (WEP_FREE_DLL);

	    tls->cOleInits--;
	    CoUninitialize();
	}
	else
	{
#if defined(_CHICAGO_)
	    if (!gfShellInitialized && CoGetCurrentProcess() == 1)
	    {
		//  The Chicago Shell will dynamically load the OLE32.DLL to improve
		//  bootup start time.	    When an application calls CoInitialize, post
		//  a message to the shell to inform it to load OLE32.DLL if it hasn't
		//  already.   The Shell will never unload OLE32.DLL.
		//
		//  We are using an undocumented Shell interface.
		//
		//  We do this last so that we dont take a task switch while in
		//  CoInitialize.
#if DBG==1
		if (RegQueryValueEx(HKEY_CURRENT_USER,
                            L"Software\\Microsoft\\OLE2\\NoShellNotify",
                            NULL,  // reserved
                            NULL,  // lpdwType
                            NULL,  // lpbData
                            NULL) != ERROR_SUCCESS) // lpcbData
#endif
		{
		    HWND hwndShell = GetShellWindow();
		    if (hwndShell)
		    {
			PostMessage(hwndShell,WM_SHELLNOTIFY,
                                 SHELLNOTIFY_OLELOADED,0L);
		    }
		}

	    }

	    gfShellInitialized = TRUE;
#endif  // _CHICAGO_

	    Assert(SUCCEEDED(hr) && "Bad OleInitializeEx logic");

	    //	If we're overriding the allocator, we return whatever
	    //	CoInitializeEx returned

	    if (NULL != pMalloc)
	    {
		Assert(hr == hrCoInit && "Bad OleInit logic");
	    }
	    else if (1 == cThreadOleInits)
	    {
		//  First successful call to OleInitializeEx - S_OK
		hr = S_OK;
	    }
	    else
	    {
		//  Second or greater succesful call to OleInitializeEx - S_FALSE
		hr = S_FALSE;
	    }
	}
    }

    OLETRACEOUT((API_OleInitialize, hr));
    return hr;
}


//+-------------------------------------------------------------------------
//
//  Function:   OleUnitialize
//
//  Synopsis:   Unitializes OLE, releasing any grabbed resources
//
//  Effects:
//
//  Arguments:  void
//
//  Requires:
//
//  Returns:    void
//
//  Signals:
//
//  Modifies:
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              06-Dec-93 alexgo    32bit port
//              21-Jul-94 AlexT     Allow nested OleInit/Uninit calls
//
//  Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(OleUninitialize)
STDAPI_(void) OleUninitialize(void)
{
    OLETRACEIN((API_OleUninitialize, NOPARAM));

    VDATEHEAP();

    COleTls tls(TRUE);

    if (tls.IsNULL() || 0 == tls->cOleInits)
    {
        LEDebugOut((DEB_ERROR,
                    "(0 == thread inits) Unbalanced call to OleUninitialize\n"));
        goto errRtn;
    }

    if (0 == -- tls->cOleInits)
    {
	// This thread has called OleUninitialize for the last time. Check if
	// we need to do per process uninit now.

	ClipboardUninitialize(); // Must be first thing
	DestroyCommonDdeWindow();

	COleStaticLock lck(g_mxsSingleThreadOle);

	if (--g_cOleProcessInits == 0)
	{

	    DragDropProcessUninitialize();

	    // after this point, the uninit should not fail (because we don't
	    // have code to redo the init).
	    DDEWEP (WEP_FREE_DLL);

#if DBG==1
	    // check for unreleased globals
	    UtGlobalFlushTracking();
#endif
	}
    }

    //  We call CoInitialize each time we call OleInitialize, so here we
    //  balance that call
    CoUninitialize();

errRtn:
    OLETRACEOUTEX((API_OleUninitialize, NORETURN));

    return;
}