able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/ole32/olethunk/ole16/compobj/comlocal.cxx

1262 lines
33 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1993.
//
// File: COMLOCAL.CXX (16 bit target)
//
// Contents: CompObj APIs
//
// Functions:
//
// History: 16-Dec-93 JohannP Created
//
//--------------------------------------------------------------------------
#include <headers.cxx>
#pragma hdrstop
#include <ole2ver.h>
#include <ole2sp.h>
#include <olecoll.h>
#include <map_kv.h>
#include "comlocal.hxx"
#include "map_htsk.h"
#include "etask.hxx"
#include "call32.hxx"
#include "apilist.hxx"
UINT v_pidHighWord = 1; // incremented each time used
IMalloc FAR* v_pMallocShared = NULL; // is not addrefed
// Note: bug 3698
// MsPub is not calling CoInitialize befor calling OpenStorage to
// preview templates. This pointer has an addref!
// When this pointer is not NULL CoGetMalloc was called prior to CoInitialize
// The pointer is transfered as soon as CoInitialize is called by any task.
IMalloc FAR* v_pMallocPreShared = NULL;
BOOL SetupSharedAllocator(Etask FAR& etask);
//+---------------------------------------------------------------------------
//
// Function: TaskAlloc, private
//
// Synopsis: Allocates task memory
//
// Arguments: [cb] - Number of bytes to allocate
//
// Returns: Pointer to memory or NULL
//
// History: 03-Mar-94 DrewB Created
//
//----------------------------------------------------------------------------
LPVOID __loadds FAR PASCAL TaskAlloc(ULONG cb)
{
HRESULT hr;
LPMALLOC lpMalloc = NULL;
LPVOID lpv;
hr = CoGetMalloc(MEMCTX_TASK, &lpMalloc);
if (FAILED(GetScode(hr)) )
{
lpv = NULL;
}
else
{
thkAssert(lpMalloc != NULL && "CoGetMalloc pMalloce is NULL\n");
lpv = lpMalloc->Alloc(cb);
lpMalloc->Release();
}
return lpv;
}
//+---------------------------------------------------------------------------
//
// Function: TaskFree, private
//
// Synopsis: Free task memory
//
// Arguments: [pv] - Memory
//
// History: 03-Mar-94 DrewB Created
//
//----------------------------------------------------------------------------
void __loadds FAR PASCAL TaskFree(LPVOID pv)
{
HRESULT hr;
LPMALLOC lpMalloc;
hr = CoGetMalloc(MEMCTX_TASK, &lpMalloc);
if (SUCCEEDED(GetScode(hr)))
{
lpMalloc->Free(pv);
lpMalloc->Release();
}
}
#if defined(_CHICAGO_)
//+---------------------------------------------------------------------------
//
// Function: IsProcessIn32Context, private
//
// Synopsis: Returns true if current process is 32-bits.
//
// Arguments: None.
//
// History: 03-Jan-95 KentCe Created
//
// Remarks: This function takes advantage of internal Chicago data
// structures. No other method available.
//
//----------------------------------------------------------------------------
BOOL IsProcessIn32Context(void)
{
LPBYTE pTaskFlag;
//
// Create a pointer to the 0x16 byte of the task structure.
//
pTaskFlag = (LPBYTE)MAKELONG(0x16, GetCurrentTask());
//
// Bit 4 (0x10) is only true when we are a 32-bit process.
//
if (*pTaskFlag & 0x10)
return TRUE;
return FALSE;
}
#endif
//+---------------------------------------------------------------------------
//
// Method: SetupSharedAllocator
//
// Synopsis: Allocats the shared allocator and
// initializes the etask shared allocator
//
// Arguments: [etask] --
//
// Returns:
//
// History: 2-03-95 JohannP (Johann Posch) Created
//
// Notes: call by CoInitialize and DllEntryPoint
//
//----------------------------------------------------------------------------
BOOL SetupSharedAllocator(Etask FAR& etask)
{
// we must ensure we have a shared allocator now since that is where the
// etask map wiil be stored; if another process already created it, use it;
// this is so we always use the same shared pool of memory for all
// processes (so the DidAlloc method returns 1 for the same call from
// different process); the pointer refers to shared memory within
// the blocks managed by the IMalloc implementation and the
// vtable is always valid on Windows; the global pointer carries
// no ref count on its own; changes might be requires on
// other platforms.
if (v_pMallocPreShared != NULL)
{
// Note: fix for bug 3698;l MsPub not calling CoInitialize
// transfer addref from preshared to task entry
etask.m_pMallocShared = v_pMallocPreShared;
v_pMallocShared = v_pMallocPreShared;
v_pMallocPreShared = NULL;
}
else if (v_pMallocShared != NULL)
{
(etask.m_pMallocShared = v_pMallocShared)->AddRef();
}
else
{
// sets pMalloc to NULL on error
CoCreateStandardMalloc(MEMCTX_SHARED, &etask.m_pMallocShared);
v_pMallocShared = etask.m_pMallocShared;
thkAssert(v_pMallocShared != NULL && "SetupSharedAllocator failed!");
}
return (v_pMallocShared != NULL) ? TRUE : FALSE;
}
//+---------------------------------------------------------------------------
//
// Function: CoInitialize, Split
//
// Synopsis:
//
// Effects:
//
// Arguments: [pMalloc] --
//
// Requires:
//
// Returns:
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: 2-28-94 kevinro Created
// 3-08-94 BobDay Added code from \\ole\slm\...\compobj.cpp
//
// Notes:
//
//----------------------------------------------------------------------------
// initialize compobj; errors: S_FALSE, E_OUTOFMEMORY
STDAPI CoInitialize(IMalloc FAR* pMalloc)
{
LPMALLOC pmlNull = NULL;
HRESULT hresult;
HTASK htask;
Etask etask;
thkDebugOut((DEB_ITRACE, "CoInitialize\n"));
thkDebugOut((DEB_APIS16, "CoInitilaize called on Process (%X) \n", GetCurrentProcess()));
#if defined(_CHICAGO_)
//
// Prevent 32-bit MPLAYER from loading a 16-bit DLL's which in turns
// uses 16-bit OLE2. We can't handle the condition of a 32-bit process
// thunking up thru the 16:32 OLE2 interop layer. So return an error
// and not fault out.
//
if (IsProcessIn32Context())
return ResultFromScode(E_OUTOFMEMORY);
etask.m_Dllinits = 0;
#endif
// if already init, bump count and return S_FALSE
if ( IsEtaskInit(htask, etask)
&& IsValidInterface((etask.m_pMalloc)) )
{
if ( etask.m_inits != ETASK_FAKE_INIT )
{
etask.m_inits++;
thkVerify(SetEtask(htask, etask));
return ResultFromScode(S_FALSE);
}
//
// CoInitialize has been called after we've done a fake call for them
// we can just take over their allocator and get rid of our fake one.
//
if ( pMalloc != NULL )
{
etask.m_pMalloc->Release(); // Get rid of the old task allocator
etask.m_pMalloc = pMalloc;
etask.m_pMalloc->AddRef();
}
else
{
//
// It would be nice if we could assert that the fake task
// allocator was a default task allocator. i.e. no operation
// were really needed!
//
}
//
// "We need to have a way to clean up any fake calls to
// CoInitialize. Should the application go away after using one of
// the apis that caused us to do a fake CoInitialize in the first
// place, and should the application exit without really making a
// call to CoInitialize eventually, then we wouldn't know enough to
// clean up... I think this is ok for now. Most apps do call
// CoInitialize eventually."
//
etask.m_inits = 1;
thkAssert(etask.m_pMalloc != NULL); // now have task allocator in all cases
thkVerify(SetEtask(htask, etask));
return ResultFromScode(S_OK);
}
#ifdef _CHICAGO_
else if (etask.m_Dllinits == 0)
{
// Note: we might end up here since some app call
// CoInitialize in LibMain. The call to our DllEntryPoint
// will follow.
if (!Call32Initialize())
{
return ResultFromScode(E_OUTOFMEMORY);
}
etask.m_htask = GetCurrentProcess();
}
#endif
// set/create task malloc
if (pMalloc != NULL)
{
VDATEIFACE( pMalloc );
(etask.m_pMalloc = pMalloc)->AddRef();
}
else
{
if ((hresult = CoCreateStandardMalloc(MEMCTX_TASK,
&etask.m_pMalloc)) != NOERROR)
return hresult;
}
thkAssert(etask.m_pMalloc != NULL); // now have task allocator in all cases
// set up the shared allocator
if ( etask.m_pMallocShared == NULL
&& SetupSharedAllocator(etask) == FALSE)
{
etask.m_pMalloc->Release(); // was created or AddRef'd above
return ResultFromScode(E_OUTOFMEMORY);
}
// now have shared allocator in all cases
thkAssert(etask.m_pMallocShared != NULL);
// init remaining entries and add entry to table for this app/task pair;
// leave maps null for now (they are allocated on demand)
etask.m_pMallocSBlock = NULL;
etask.m_pMallocPrivate = NULL;
etask.m_pid = MAKELONG(GetCurrentProcess(),v_pidHighWord++);
etask.m_inits = 1;
etask.m_oleinits = 0;
etask.m_reserved = 0;
etask.m_pDlls = NULL;
etask.m_pMapToServerCO = NULL;
etask.m_pMapToHandlerCO = NULL;
etask.m_pArraySH = NULL;
etask.m_pCThrd = NULL;
etask.m_hwndClip = NULL;
etask.m_hwndDde = NULL;
etask.m_punkState = NULL;
if (!SetEtask(htask, etask))
{
ReleaseEtask(NULL, etask);
thkAssert(0 && "CompObj: CoInitialize SetEtask failed.");
return ResultFromScode(E_OUTOFMEMORY);
}
// Initialize the thunk manager for this apartment.
if (SUCCEEDED(hresult = CallThkMgrInitialize()))
{
//
// Now transition into 32-bit world to give it a chance for
// initialization at this time.
//
// Never pass the 16-bit allocator on to 32-bits
pMalloc = NULL;
hresult = (HRESULT)CallObjectInWOW(THK_API_METHOD(THK_API_CoInitialize),
PASCAL_STACK_PTR(pMalloc) );
}
if (FAILED(GetScode(hresult)))
{
ReleaseEtask(htask, etask);
}
return hresult;
}
//+---------------------------------------------------------------------------
//
// Function: CoUninitialize, Split
//
// Synopsis:
//
// Effects:
//
// Arguments: [void] --
//
// Requires:
//
// Returns:
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: 2-28-94 kevinro Created
// 10-Mar-94 BobDay Copied & Merged with compobj.cpp 16-bit
//
// Notes:
//
//----------------------------------------------------------------------------
STDAPI_(void) CoUninitialize(void)
{
HTASK htask;
Etask etask;
thkDebugOut((DEB_ITRACE, "CoUninitialize\n"));
thkDebugOut((DEB_APIS16, "CoUninitilaize called on Process (%X) \n", GetCurrentProcess()));
if (!IsEtaskInit(htask, etask))
return;
// if not last uninit, just decrement count and return.
if (etask.m_inits != 1)
{
//
// If a fake init, then just ignore as if we haven't ever init'd
//
if ( etask.m_inits == ETASK_FAKE_INIT )
{
//
// Some slimy app doesn't call CoInitialize but does eventually
// call CoUninitialize. Lets find them if they do!
//
thkAssert(FALSE &&
"CoUninitialize called after fake CoInitialize\n");
}
else
{
etask.m_inits--;
thkVerify(SetEtask(htask, etask));
}
return ;
}
// Some applications pass on module handle of loaded dlls.
// As a result LibMain and WEP is not called in the same process.
// To prevent premature unloading of OleThk32.dll call
// SetReleaseDLL(FALSE)
SetReleaseDLL(FALSE);
//
// Now transition into 32-bit world to give it a chance for
// initialization at this time.
//
CallObjectInWOW(THK_API_METHOD(THK_API_CoUninitialize), NULL );
// Reset dll unloading - see above
SetReleaseDLL(TRUE);
CoFreeAllLibraries();
//
// We do not uninitialize the thunk manager at this point. The app may attempt
// to call additional API's after CoUninitialize. For example, Lotus 1-2-3
// is known to do this, as is Publisher. The thunk manager will clean up
// as part of its thread detach.
//
// the last thing is to remove the allocator and delete the etask for us;
// must lookup again in case contents changed.
if (LookupEtask(htask, etask))
ReleaseEtask(htask, etask);
thkDebugOut((DEB_APIS16, "CoUninitilaize on Process (%X) done.\n", GetCurrentProcess()));
thkDebugOut((DEB_ITRACE, "CoUninitialize exit\n"));
// Note: some apps check the return value if the void function CoUninitialize
// and they fail if it is not NULL like WinOffice Setup 4.3
// Please don't take it out.
_asm mov ax,0;
_asm mov dx,0;
}
//+---------------------------------------------------------------------------
//
// Function: CoGetMalloc, Local
//
// Synopsis:
//
// Effects:
//
// Arguments: [dwMemContext] --
// [ppMalloc] --
//
// Requires:
//
// Returns:
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: 2-28-94 kevinro Created
// 10-Mar-94 BobDay Copied & Merged with compobj.cpp 16-bit
//
// Notes:
//
//----------------------------------------------------------------------------
// return pMalloc for the current task; errors: E_INVALIDARG,
// CO_E_NOTINITIALIZED, E_OUTOFMEMORY (not for task or shared allocators)
STDAPI CoGetMalloc(DWORD dwContext, IMalloc FAR* FAR* ppMalloc)
{
Etask etask;
HTASK htask;
thkDebugOut((DEB_ITRACE, " CoGetMalloc\n"));
VDATEPTROUT( ppMalloc, IMalloc FAR* );
// NOTE: we set *ppMalloc to NULL only in the error cases below
// MOre work here!
// need this for the bootstrap case
if (dwContext == MEMCTX_SHARED)
{
if (v_pMallocShared != NULL)
{
*ppMalloc = v_pMallocShared;
goto Exit;
}
// pMallocShared is NULL -- CoInitialize was not called yet.
if (v_pMallocPreShared == NULL)
{
CoCreateStandardMalloc(MEMCTX_SHARED, &v_pMallocPreShared);
if (v_pMallocPreShared != NULL)
{
*ppMalloc = v_pMallocPreShared;
goto Exit;
}
else
{
*ppMalloc = NULL;
return ResultFromScode(CO_E_NOTINITIALIZED);
}
}
else
{
*ppMalloc = v_pMallocPreShared;
goto Exit;
}
}
//
// Clip Art Gallery will call pStream->Stat before calling CoInitialize.
// This causes the thunk logic to allocation 16bit memory which will
// fail at this point. The below code to auto-initialize should this
// happen. (Really just a hack for Clip Art Gallery).
//
if ( !IsEtaskInit(htask, etask)
|| !IsValidInterface((etask.m_pMalloc)) )
{
if (FAILED(CoInitialize(NULL)))
{
*ppMalloc = NULL;
return ResultFromScode(CO_E_NOTINITIALIZED);
}
thkVerify(LookupEtask( htask, etask ));
etask.m_inits = ETASK_FAKE_INIT;
thkVerify(SetEtask(htask, etask));
}
// shared always available if initialized; no need to handle here
thkAssert(dwContext != MEMCTX_SHARED);
if (dwContext == MEMCTX_TASK)
{
thkAssert(etask.m_pMalloc != NULL);
*ppMalloc = etask.m_pMalloc;
}
else
{
#ifdef NOTYET
// contexts which are delay-created
IMalloc FAR* FAR* ppMallocStore;
if (dwContext == MEMCTX_SHAREDBLOCK)
ppMallocStore = &etask.m_pMallocSBlock;
else if (dwContext == MEMCTX_COPRIVATE)
ppMallocStore = &etask.m_pMallocPrivate;
else
{
// invalid context
*ppMalloc = NULL;
return ResultFromScode(E_INVALIDARG);
}
if (*ppMallocStore == NULL)
{
// sets pMalloc to NULL on error
if (CoCreateStandardMalloc(dwContext, ppMallocStore) != NOERROR)
{
*ppMalloc = NULL;
return ResultFromScode(E_OUTOFMEMORY);
}
thkVerify(SetEtask(htask, etask));
}
*ppMalloc = *ppMallocStore;
#else
// invalid context
thkAssert(!"Unknown memctx in CoGetMalloc");
*ppMalloc = NULL;
return ResultFromScode(E_INVALIDARG);
#endif // NOTYET
}
Exit: // have non-null *ppMalloc
thkAssert(*ppMalloc != NULL);
(*ppMalloc)->AddRef();
return NOERROR;
}
//+---------------------------------------------------------------------------
//
// Function: CoGetState, Local
//
// Synopsis: Retrieves task-specific state
//
// Arguments: [ppunk] - IUnknown pointer to fill in
//
// Returns: Appropriate status code
//
// History: 26-Jul-94 DrewB Created
//
// Notes: Private API for OLE automation
//
//----------------------------------------------------------------------------
STDAPI CoGetState(IUnknown FAR * FAR *ppunk)
{
Etask etask;
HTASK htask;
thkDebugOut((DEB_APIS16, "CoGetState called\n"));
if (IsBadWritePtr(ppunk, sizeof(IUnknown *)))
{
thkDebugOut((DEB_APIS16, "CoGetState failed\n"));
return ResultFromScode(E_INVALIDARG);
}
if (!LookupEtask(htask, etask) || etask.m_punkState == NULL )
{
*ppunk = NULL;
thkDebugOut((DEB_APIS16, "CoGetState failed\n"));
return ResultFromScode(S_FALSE);
}
if ( !IsValidInterface((etask.m_punkState)) )
{
*ppunk = NULL;
etask.m_punkState = NULL;
thkDebugOut((DEB_APIS16, "CoGetState failed (invalid interface)\n"));
return ResultFromScode(S_FALSE);
}
*ppunk = etask.m_punkState;
etask.m_punkState->AddRef();
thkDebugOut((DEB_APIS16, "CoGetState done %p\n", *ppunk));
return NOERROR;
}
//+---------------------------------------------------------------------------
//
// Function: CoSetState, Local
//
// Synopsis: Sets task-specific state
//
// Arguments: [punk] - State to set
//
// Returns: Appropriate status code
//
// History: 26-Jul-94 DrewB Created
//
// Notes: Private API for OLE automation
//
//----------------------------------------------------------------------------
STDAPI CoSetState(IUnknown FAR *punk)
{
Etask etask;
HTASK htask;
IUnknown FAR *punkStateOld;
thkDebugOut((DEB_APIS16, "CoSetState called %p\n", punk));
if (punk != NULL && !IsValidInterface(punk))
{
thkDebugOut((DEB_APIS16, "CoSetState called %p failed\n", punk));
return ResultFromScode(E_INVALIDARG);
}
if (!IsEtaskInit(htask, etask))
{
thkDebugOut((DEB_APIS16, "CoSetState called %p failed\n", punk));
return ResultFromScode(S_FALSE);
}
if (punk != NULL)
{
punk->AddRef();
}
punkStateOld = etask.m_punkState;
etask.m_punkState = punk;
thkVerify(SetEtask(htask, etask));
if (punkStateOld != NULL && IsValidInterface(punkStateOld))
{
punkStateOld->Release();
}
thkDebugOut((DEB_APIS16, "CoSetState called %p done\n", punk));
return NOERROR;
}
//+---------------------------------------------------------------------------
//
// Function: CoGetCurrentProcess, Local
//
//----------------------------------------------------------------------------
// returns a unique value for the current task; this routine is
// necessary because htask values from Window get reused periodically.
STDAPI_(DWORD) CoGetCurrentProcess(void)
{
HTASK htask;
Etask etask;
thkDebugOut((DEB_ITRACE, " CoGetCurrentProcess\n"));
if (!IsEtaskInit(htask, etask))
return 0;
return etask.m_pid;
}
//+---------------------------------------------------------------------------
//
// Function: CoBuildVersion, Local
//
//----------------------------------------------------------------------------
STDAPI_(DWORD) CoBuildVersion(VOID)
{
thkDebugOut((DEB_ITRACE, " CoBuildVersion\n"));
// We must return 23 as our major version number to remain
// compatible with shipped OLE 2.01
// OLE 2.01 shipped with minor version 640
// We return a number slightly higher to differentiate
// our product while indicating compatibility
return MAKELONG(700, 23);
}
//+---------------------------------------------------------------------------
//
// Function: CoMarshalHresult, Local
//
// History: Taken straight from OLE2 sources
//
//----------------------------------------------------------------------------
STDAPI CoMarshalHresult(LPSTREAM pstm, HRESULT hresult)
{
HRESULT hr;
thkDebugOut((DEB_ITRACE, "CoMarshalHresult\n"));
if (!IsValidInterface(pstm))
{
hr = ResultFromScode(E_INVALIDARG);
}
else
{
SCODE sc;
ULONG cb;
sc = GetScode(hresult);
hr = pstm->Write(&sc, sizeof(sc), &cb);
if (SUCCEEDED(GetScode(hr)) && cb != sizeof(sc))
{
hr = ResultFromScode(STG_E_WRITEFAULT);
}
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: CoUnmarshalHresult, Local
//
// History: Taken straight from OLE2 sources
//
//----------------------------------------------------------------------------
STDAPI CoUnmarshalHresult(LPSTREAM pstm, HRESULT FAR * phresult)
{
HRESULT hr;
thkDebugOut((DEB_ITRACE, "CoUnmarshalHresult\n"));
if (!IsValidPtrOut(phresult, sizeof(HRESULT)))
{
hr = ResultFromScode(E_INVALIDARG);
}
else
{
*phresult = 0;
if (!IsValidInterface(pstm))
{
hr = ResultFromScode(E_INVALIDARG);
}
else
{
SCODE sc;
ULONG cb;
hr = pstm->Read(&sc, sizeof(sc), &cb);
if (SUCCEEDED(GetScode(hr)))
{
if (cb != sizeof(sc))
{
hr = ResultFromScode(STG_E_READFAULT);
}
else
{
*phresult = ResultFromScode(sc);
}
}
}
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: IsEqualGUID, Local
//
// History: Taken straight from OLE2 sources
//
//----------------------------------------------------------------------------
#pragma intrinsic(_fmemcmp)
STDAPI_(BOOL) IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
{
//thkDebugOut((DEB_ITRACE, "IsEqualGUID\n"));
return !_fmemcmp(&rguid1, &rguid2, sizeof(GUID));
}
#pragma function(_fmemcmp)
#define GUIDSTR_MAX (1+ 8 + 1 + 4 + 1 + 4 + 1 + 4 + 1 + 12 + 1 + 1)
//+---------------------------------------------------------------------------
//
// Function: HexStringToDword, private
//
// History: Straight from OLE2 sources
//
//----------------------------------------------------------------------------
static BOOL HexStringToDword(LPCSTR FAR& lpsz, DWORD FAR& Value, int cDigits,
char chDelim)
{
int Count;
Value = 0;
for (Count = 0; Count < cDigits; Count++, lpsz++)
{
if (*lpsz >= '0' && *lpsz <= '9')
{
Value = (Value << 4) + *lpsz - '0';
}
else if (*lpsz >= 'A' && *lpsz <= 'F')
{
Value = (Value << 4) + *lpsz - 'A' + 10;
}
else if (*lpsz >= 'a' && *lpsz <= 'f')
{
Value = (Value << 4) + *lpsz - 'a' + 10;
}
else
{
return(FALSE);
}
}
if (chDelim != 0)
{
return *lpsz++ == chDelim;
}
else
{
return TRUE;
}
}
//+---------------------------------------------------------------------------
//
// Function: GUIDFromString, private
//
// History: Straight from OLE2 sources
//
//----------------------------------------------------------------------------
STDAPI_(BOOL) GUIDFromString(LPCSTR lpsz, LPGUID pguid)
{
DWORD dw;
if (*lpsz++ != '{')
return FALSE;
if (!HexStringToDword(lpsz, pguid->Data1, sizeof(DWORD)*2, '-'))
return FALSE;
if (!HexStringToDword(lpsz, dw, sizeof(WORD)*2, '-'))
return FALSE;
pguid->Data2 = (WORD)dw;
if (!HexStringToDword(lpsz, dw, sizeof(WORD)*2, '-'))
return FALSE;
pguid->Data3 = (WORD)dw;
if (!HexStringToDword(lpsz, dw, sizeof(BYTE)*2, 0))
return FALSE;
pguid->Data4[0] = (BYTE)dw;
if (!HexStringToDword(lpsz, dw, sizeof(BYTE)*2, '-'))
return FALSE;
pguid->Data4[1] = (BYTE)dw;
if (!HexStringToDword(lpsz, dw, sizeof(BYTE)*2, 0))
return FALSE;
pguid->Data4[2] = (BYTE)dw;
if (!HexStringToDword(lpsz, dw, sizeof(BYTE)*2, 0))
return FALSE;
pguid->Data4[3] = (BYTE)dw;
if (!HexStringToDword(lpsz, dw, sizeof(BYTE)*2, 0))
return FALSE;
pguid->Data4[4] = (BYTE)dw;
if (!HexStringToDword(lpsz, dw, sizeof(BYTE)*2, 0))
return FALSE;
pguid->Data4[5] = (BYTE)dw;
if (!HexStringToDword(lpsz, dw, sizeof(BYTE)*2, 0))
return FALSE;
pguid->Data4[6] = (BYTE)dw;
if (!HexStringToDword(lpsz, dw, sizeof(BYTE)*2, '}'))
return FALSE;
pguid->Data4[7] = (BYTE)dw;
return TRUE;
}
//+---------------------------------------------------------------------------
//
// Function: StringFromCLSID, Local
//
// History: Straight from OLE2 sources
//
//----------------------------------------------------------------------------
#define CLSIDSTR_MAX (GUIDSTR_MAX)
STDAPI StringFromCLSID(REFCLSID rclsid, LPSTR FAR* lplpsz)
{
SCODE sc;
char *psz;
thkDebugOut((DEB_ITRACE, "StringFromCLSID\n"));
psz = NULL;
do
{
if (!IsValidPtrOut(lplpsz, sizeof(LPSTR)))
{
sc = E_INVALIDARG;
break;
}
*lplpsz = NULL;
if (!IsValidPtrIn(&rclsid, sizeof(CLSID)))
{
sc = E_INVALIDARG;
break;
}
psz = (char *)TaskAlloc(CLSIDSTR_MAX);
if (psz == NULL)
{
sc = E_OUTOFMEMORY;
break;
}
if (StringFromGUID2(rclsid, psz, CLSIDSTR_MAX) == 0)
{
sc = E_INVALIDARG;
TaskFree(psz);
break;
}
*lplpsz = psz;
sc = S_OK;
} while (FALSE);
return ResultFromScode(sc);
}
//+---------------------------------------------------------------------------
//
// Function: StringFromIID, Local
//
// History: Straight from OLE2 sources
//
//----------------------------------------------------------------------------
STDAPI StringFromIID(REFIID rclsid, LPSTR FAR* lplpsz)
{
SCODE sc;
char *psz;
thkDebugOut((DEB_ITRACE, "StringFromIID\n"));
do
{
if (!IsValidPtrOut(lplpsz, sizeof(LPSTR)))
{
sc = E_INVALIDARG;
break;
}
*lplpsz = NULL;
if (!IsValidPtrIn(&rclsid, sizeof(IID)))
{
sc = E_INVALIDARG;
break;
}
psz = (char *)TaskAlloc(GUIDSTR_MAX);
if (psz == NULL)
{
sc = E_OUTOFMEMORY;
break;
}
if (StringFromGUID2(rclsid, psz, GUIDSTR_MAX) == 0)
{
sc = E_INVALIDARG;
TaskFree(psz);
break;
}
*lplpsz = psz;
sc = S_OK;
} while (FALSE);
return ResultFromScode(sc);
}
//+---------------------------------------------------------------------------
//
// Function: IIDFromString, Local
//
// History: Straight from OLE2 sources
//
//----------------------------------------------------------------------------
STDAPI IIDFromString(LPSTR lpsz, LPIID lpiid)
{
SCODE sc;
thkDebugOut((DEB_ITRACE, "IIDFromString\n"));
sc = S_OK;
if (!IsValidPtrOut(lpiid, sizeof(IID)))
{
sc = E_INVALIDARG;
}
else if (lpsz == NULL)
{
*lpiid = IID_NULL;
}
else if (!IsValidPtrIn(lpsz, sizeof(LPSTR)))
{
sc = E_INVALIDARG;
}
else if (!GUIDFromString(lpsz, lpiid))
{
sc = CO_E_IIDSTRING;
}
return ResultFromScode(sc);
}
//+---------------------------------------------------------------------------
//
// Function: StringFromGUID2, Local
//
// History: Straight from OLE2 sources
//
//----------------------------------------------------------------------------
STDAPI_(int) StringFromGUID2(REFGUID rguid, LPSTR lpsz, int cbMax)
{
thkDebugOut((DEB_ITRACE, "StringFromGUID2\n"));
if (cbMax < GUIDSTR_MAX)
{
return 0;
}
wsprintf(lpsz, "{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
rguid.Data1, rguid.Data2, rguid.Data3,
rguid.Data4[0], rguid.Data4[1],
rguid.Data4[2], rguid.Data4[3],
rguid.Data4[4], rguid.Data4[5],
rguid.Data4[6], rguid.Data4[7]);
return GUIDSTR_MAX;
}
// The following two APIs are now macros but must still be exported
// so use PASCAL-form names to avoid problems with the macros
//+---------------------------------------------------------------------------
//
// Function: GETSCODE, Local
//
// History: Straight from OLE2 sources
//
//----------------------------------------------------------------------------
STDAPI_(SCODE) GETSCODE(HRESULT hr)
{
return GetScode(hr);
}
//+---------------------------------------------------------------------------
//
// Function: RESULTFROMSCODE, Local
//
// History: Straight from OLE2 sources
//
//----------------------------------------------------------------------------
STDAPI RESULTFROMSCODE(SCODE sc)
{
return ResultFromScode(sc);
}
//+---------------------------------------------------------------------------
//
// Function: PropagateResult, Local
//
// History: Straight from OLE2 sources
//
//----------------------------------------------------------------------------
STDAPI PropagateResult(HRESULT hrPrev, SCODE scNew)
{
thkDebugOut((DEB_ITRACE, "PropagateResult\n"));
return (HRESULT)((scNew & 0x800FFFFF) | ((DWORD)hrPrev & 0x7FF00000)
+ 0x100000);
}
//+---------------------------------------------------------------------------
//
// Function: FnAssert, Local
//
// History: Straight from OLE2 sources
//
//----------------------------------------------------------------------------
#if DBG == 1
static char lpBuffer[512];
static char lpLocBuffer[256];
#endif
STDAPI FnAssert( LPSTR lpstrExpr,
LPSTR lpstrMsg,
LPSTR lpstrFileName,
UINT iLine )
{
#if DBG == 1
int iResult;
wsprintf(lpBuffer, "Assertion \"%s\" failed! %s", lpstrExpr, lpstrMsg);
wsprintf(lpLocBuffer, "File %s, line %d; (A=exit; R=break; I=continue)",
lpstrFileName, iLine);
iResult = MessageBox(NULL, lpLocBuffer, lpBuffer,
MB_ABORTRETRYIGNORE | MB_SYSTEMMODAL);
if (iResult == IDRETRY)
{
DebugBreak();
}
else if (iResult == IDABORT)
{
CoFreeAllLibraries();
FatalAppExit(0, "Assertion failure");
}
#endif
return NOERROR;
}
//
// NOTE- These APIs are exported by the .DEF file, but are not documented,
// nor is there any code in the 16-bit world to deal with them. Each of these
// needs to be investigated to determine what we need to do to implement them.
//
// LRPCDISPATCH
// REMCONNECTTOOBJECT
// REMCREATEREMOTEHANDLER
// REMALLOCOID
// LRPCFREEMONITORDATA
// TIMERCALLBACKPROC
// COSETACKSTATE
// COGETCLASSEXT
// LRPCCALL
// LRPCREGISTERMONITOR
// CLSIDFROMOLE1CLASS
// COOPENCLASSKEY
// LRPCGETTHREADWINDOW
// LRPCREVOKEMONITOR
// COHANDLEINCOMINGCALL
// REMGETINFOFORCID
//
// The below stubs probably don't clean up the stack properly either!!!
#define UNDEFINED_DEF_ENTRY(x) STDAPI x ( void ) \
{ return ResultFromScode(E_NOTIMPL); }
UNDEFINED_DEF_ENTRY( LRPCDISPATCH )
UNDEFINED_DEF_ENTRY( REMCONNECTTOOBJECT )
UNDEFINED_DEF_ENTRY( REMCREATEREMOTEHANDLER )
UNDEFINED_DEF_ENTRY( REMALLOCOID )
UNDEFINED_DEF_ENTRY( LRPCFREEMONITORDATA )
UNDEFINED_DEF_ENTRY( TIMERCALLBACKPROC )
UNDEFINED_DEF_ENTRY( COSETACKSTATE )
UNDEFINED_DEF_ENTRY( COGETCLASSEXT )
UNDEFINED_DEF_ENTRY( LRPCCALL )
UNDEFINED_DEF_ENTRY( LRPCREGISTERMONITOR )
UNDEFINED_DEF_ENTRY( CLSIDFROMOLE1CLASS )
UNDEFINED_DEF_ENTRY( COOPENCLASSKEY )
UNDEFINED_DEF_ENTRY( LRPCGETTHREADWINDOW )
UNDEFINED_DEF_ENTRY( LRPCREVOKEMONITOR )
UNDEFINED_DEF_ENTRY( COHANDLEINCOMINGCALL )
UNDEFINED_DEF_ENTRY( REMGETINFOFORCID )
UNDEFINED_DEF_ENTRY( OLE1CLASSFROMCLSID2 )
UNDEFINED_DEF_ENTRY( REMLOOKUPSHUNK )
UNDEFINED_DEF_ENTRY( REMFREEOID )
Reference in a new issue Copy permalink