Microsoft/WindowsXP-SP1
Microsoft/WindowsXP-SP1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
WindowsXP-SP1/com/ole32/olethunk/olethk32/apinot.cxx
Microsoft f7ca35dddd First commit
2020-09-30 16:53:49 +02:00

1035 lines
29 KiB
C++
Raw Permalink Blame History

//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1994.
//
// File: apinot.cxx
//
// Contents: Implementation of non-API thunks
//
// History: 11-Mar-94 BobDay Created
//
//----------------------------------------------------------------------------
#include "headers.cxx"
#pragma hdrstop
#include <thunkapi.hxx>
#include <wownt32.h>
#include "olethk32.hxx"
#include "apinot.hxx"
#include "tlsthk.hxx"
//
// The following is a global static used by OLE32 to call back into
// this DLL. There is no static data associated with the static, so
// it merely defines a virtual interface that OLE32 can use.
//
OleThunkWOW g_thkOleThunkWOW;
//
// The following API is exported from WOW32.DLL. There is no global include
// file that it exists in yet.
//
#if defined(_CHICAGO_)
/* Not supported under Chicago yet. */
/* But it's probably not important anymore. */
#define WOWFreeMetafile(x) (0)
#else
extern "C" BOOL WINAPI WOWFreeMetafile( HANDLE h32 );
#endif
//+---------------------------------------------------------------------------
//
// Function: CoInitializeNot, public
//
// Synopsis: Thunks for the 16-bit applications call to CoInitialize
//
// Arguments: [lpmalloc] - Parameter from the 16-bit world
//
// Returns: Appropriate status code
//
// History: 11-Mar-94 BobDay Created
//
//----------------------------------------------------------------------------
STDAPI_(DWORD) CoInitializeNot( LPMALLOC lpMalloc )
{
HRESULT hresult;
hresult = CoInitializeWOW( lpMalloc, &g_thkOleThunkWOW );
return (DWORD)hresult;
}
//+---------------------------------------------------------------------------
//
// Function: OleInitializeNot, public
//
// Synopsis: Thunks for the 16-bit applications call to OleInitialize
//
// Arguments: [lpmalloc] - Parameter from the 16-bit world
//
// Returns: Appropriate status code
//
// History: 11-Mar-94 BobDay Created
//
//----------------------------------------------------------------------------
STDAPI_(DWORD) OleInitializeNot( LPMALLOC lpMalloc )
{
HRESULT hresult;
hresult = OleInitializeWOW( lpMalloc, &g_thkOleThunkWOW );
return (DWORD)hresult;
}
//+---------------------------------------------------------------------------
//
// Function: RegisterDelayedClassFactories
//
// Synopsis: This function is called to actually do the registration of
// the delayed class factories.
//
// Effects: When the application specific 'trigger' is hit
// (ie OleRegGetUserType for WordPerfect), this routine is
// called to actually do all of the delayed class factory
// registrations.
//
// Arguments: (none)
//
// Requires:
//
// Returns: nothing
//
// History: 4-18-95 kevinro Created
//
//----------------------------------------------------------------------------
void RegisterDelayedClassFactories()
{
thkDebugOut((DEB_ITRACE,
"_IN RegisterDelayedClassFactories()\n"));
PThreadData pdata;
IUnknown *punk;
HRESULT hr;
DelayedRegistrationTable *pTable = NULL;
DelayRegistration *pdelayed;
DWORD dwReg;
int i;
//
// Get the thread specific data and table to determine if there are
// any delayed registrations. If not, just call the real routine.
//
pdata = TlsThkGetData();
if (pdata == NULL)
{
goto exitRtn;
}
if ((pTable = pdata->pDelayedRegs) == NULL)
{
goto exitRtn;
}
//
//
//
for (i = 0 ; i < MAX_DELAYED_REGISTRATIONS ; i++)
{
pdelayed = &(pTable->_Entries[i]);
if((pdelayed->_punk != NULL) && (pdelayed->_dwRealKey == 0))
{
hr = CoRegisterClassObject(pdelayed->_clsid,
pdelayed->_punk,
pdelayed->_dwClsContext,
pdelayed->_flags,
&(pdelayed->_dwRealKey));
if (FAILED(hr))
{
thkDebugOut((DEB_ERROR,
"RegisterDelayedClassFactory gets %x\n",hr));
}
}
}
exitRtn:
thkDebugOut((DEB_ITRACE,
"OUT RegisterDelayedClassFactories()\n"));
}
//+---------------------------------------------------------------------------
//
// Function: CoRevokeClassObjectNot
//
// Synopsis: Unregisters a class object that might have been delayed
//
// Effects: The 16-bit API CoRevokeClassObject has been directed to this
// routine. This routine will check the list of interfaces that
// have been registered, and will try to determine if the key
// needs to be translated.
//
// Arguments: [dwKey] -- Key to revoke
//
// History: 4-18-95 kevinro Created
//
// Notes:
//
//----------------------------------------------------------------------------
HRESULT CoRevokeClassObjectNot( DWORD dwKey)
{
thkDebugOut((DEB_ITRACE,
"_IN CoRevokeClassObjectNot(dwKey = %x)\n",
dwKey));
PThreadData pdata;
IUnknown *punk;
HRESULT hr;
DelayedRegistrationTable *pTable = NULL;
DWORD dwReg = ~dwKey;
//
// Get the thread specific data and table to determine if there are
// any delayed registrations. If not, just call the real routine.
//
pdata = TlsThkGetData();
if (pdata == NULL)
{
goto exitRtn;
}
if ((pTable = pdata->pDelayedRegs) == NULL)
{
goto exitRtn;
}
//
// the 'fake' key is really the bitwise not of the index
//
if ( dwReg >= MAX_DELAYED_REGISTRATIONS)
{
goto exitRtn;
}
if(pTable->_Entries[dwReg]._punk != NULL)
{
punk = pTable->_Entries[dwReg]._punk;
pTable->_Entries[dwReg]._punk = NULL;
dwKey = pTable->_Entries[dwReg]._dwRealKey;
pTable->_Entries[dwReg]._dwRealKey = 0;
//
// The class object table normally does an addref on the class factory.
// We are also holding an addref on the punk. Release it.
//
if (punk != NULL)
{
punk->Release();
//
// If the real key is zero, then we never did actually finish
// the registration. In this case, we return S_OK, because we
// are faking the app out anyway. This might happen if the app
// decides to shutdown for some reason without triggering the
// operation that causes us to register its class objects
//
if (dwKey == 0)
{
hr = S_OK;
goto exitNow;
}
}
}
exitRtn:
hr = CoRevokeClassObject(dwKey);
exitNow:
thkDebugOut((DEB_ITRACE,"OUT CoRevokeClassObjectNot():%x\n",hr));
return(hr);
}
//+---------------------------------------------------------------------------
//
// Function: CoRegisterClassObjectDelayed
//
// Synopsis: Delay the registration of class objects. Some applications,
// such as Word Perfect 6.1, register their class objects then
// do peek message operations BEFORE they are fully initialized.
// This causes problems because we can call in and do
// CreateInstance calls before they are ready for them. This
// wonderful hack will delay the registration of class objects
// until someone calls RegisterClassObjectsNow(), which is
// called when we know it is safe.
//
// Novell knows about this hack, and promised not to change
// the 16-bit code on us.
//
// Effects: Store all of the registration information in an array, and
// return a special key value.
//
//
// Arguments: ( Same as CoRegisterClassObject)
//
// Requires: The associated routine CoUnregisterClassObjectDelayed needs
// to be called in the CoRevokeClassObject path to check to see
// if the key being passed in is a special key. That way we
// can translate the key before calling the real routine.
//
// The special key value is not of the key
//
// Returns: S_OK or E_UNEXPECTED
//
// History: 4-14-95 kevinro Created
//
// Notes:
//
//----------------------------------------------------------------------------
HRESULT CoRegisterClassObjectDelayed( REFCLSID refclsid, LPUNKNOWN punk,
DWORD dwClsContext, DWORD flags, DWORD *pdwReg)
{
thkDebugOut((DEB_ITRACE,"_IN CoRegisterClassObjectDelayed\n"));
PThreadData pdata;
int i;
DelayedRegistrationTable *pTable = NULL;
//
// Assume this is going to fail
//
HRESULT hr = E_UNEXPECTED;
*pdwReg = 0;
pdata = TlsThkGetData();
if (pdata == NULL)
{
goto exitRtn;
}
if ((pTable = pdata->pDelayedRegs) == NULL)
{
pTable = pdata->pDelayedRegs = new DelayedRegistrationTable();
}
if (pTable != NULL)
{
for (i = 0 ; i < MAX_DELAYED_REGISTRATIONS ; i++)
{
if(pTable->_Entries[i]._punk == NULL)
{
pTable->_Entries[i]._punk = punk;
pTable->_Entries[i]._clsid = refclsid;
pTable->_Entries[i]._dwClsContext = dwClsContext;
pTable->_Entries[i]._flags = flags;
//
// The class object table normally does an
// addref on the class factory. We will hang on to this
// to keep the class factory and the 3216 proxy alive
//
punk->AddRef();
*pdwReg = ~i;
hr = S_OK;
break;
}
}
}
exitRtn:
thkDebugOut((DEB_ITRACE,"OUT CoRegisterClassObjectDelayed() : %x\n",hr));
return(hr);
}
//+---------------------------------------------------------------------------
//
// Function: CoRegisterClassObjectNot, public
//
// Synopsis: Thunks for the 16-bit applications call CoRegisterClassObject
// Here we check for the registered class objects to set the
// thread's compatability bits.
//
// Arguments: [refclsid] - CLSID for the class to register
// [punk] - ClassFactory interface
// [dwClsContext] - Class context
// [flags] - flags
// [lpdwreg] - register
//
// Returns: Appropriate status code
//
// History: 18-Jul-94 BobDay Created
//
//----------------------------------------------------------------------------
EXTERN_C const CLSID CDECL CLSID_EXCEL5_WORKSHEET =
{ 0x020810, 0, 0, {0xC0, 0, 0, 0, 0, 0, 0, 0x46}};
EXTERN_C const CLSID CDECL CLSID_WORD6_DOCUMENT =
{ 0x020900, 0, 0, {0xC0, 0, 0, 0, 0, 0, 0, 0x46}};
EXTERN_C const CLSID CDECL CLSID_WPWIN61 =
{ 0x89FE3FE3, 0x9FF6, 0x101B, {0xB6, 0x78, 0x04, 0x02, 0x1C, 0x00, 0x70, 0x02}};
EXTERN_C const CLSID CDECL CLSID_WPWIN61_FILE =
{ 0x1395F281, 0x4326, 0x101b, {0x8B, 0x9A, 0xCE, 0x29, 0x3E, 0xF3, 0x84, 0x49}};
EXTERN_C const CLSID CDECL CLSID_IKITARO_130 =
{ 0x02B501, 0, 0, {0xC0, 0, 0, 0, 0, 0, 0, 0x46}};
DEFINE_OLEGUID(CLSID_EXCEL5_WORKSHEET, 0x20810, 0, 0);
STDAPI_(DWORD) CoRegisterClassObjectNot( REFCLSID refclsid, LPUNKNOWN punk,
DWORD dwClsContext, DWORD flags,
LPDWORD lpdwreg )
{
//
// Excel didn't AddRef the IOleObjectClientSite returned from
// the IOleObject::GetClientSite method.
//
if ( IsEqualCLSID(refclsid,CLSID_EXCEL5_WORKSHEET) )
{
DWORD dw;
dw = TlsThkGetAppCompatFlags();
TlsThkSetAppCompatFlags(dw | OACF_CLIENTSITE_REF);
thkDebugOut((DEB_WARN,"AppCompatFlag: OACF_CLIENTSITE_REF enabled\n"));
}
//
// WinWord didn't call OleSetMenuDescriptor(NULL) during
// IOleInPlaceFrame::RemoveMenus. We do it for them.
//
// Also WinWord thinks GDI objects like palettes and bitmaps can be
// transferred on HGLOBALs during GetData calls. In order to thunk
// them properly, we need to patch up the STGMEDIUMS given to use
// by word. This is controlled by OACF_USEGDI.
//
// YAWC: Word chokes and dies because it fails to disconnect some of its
// objects. During shutdown of a link, for example, cleaning up the stdid
// table causes WORD to fault.
//
else if ( IsEqualCLSID(refclsid,CLSID_WORD6_DOCUMENT) )
{
DWORD dw;
dw = TlsThkGetAppCompatFlags();
TlsThkSetAppCompatFlags(dw | OACF_RESETMENU | OACF_USEGDI | OACF_NO_UNINIT_CLEANUP);
thkDebugOut((DEB_WARN,"AppCompatFlag: OACF_RESETMENU enabled\n"));
thkDebugOut((DEB_WARN,"AppCompatFlag: OACF_USEGDI enabled\n"));
thkDebugOut((DEB_WARN,"AppCompatFlag: OACF_NO_UNINIT_CLEANUP enabled\n"));
}
else if ( IsEqualCLSID(refclsid,CLSID_WPWIN61) )
{
thkDebugOut((DEB_WARN,"WordPerfect hack triggered\n"));
thkDebugOut((DEB_WARN,"Intercepting CoRegisterClassObject(WPWIN61)\n"));
return CoRegisterClassObjectDelayed( refclsid,punk,dwClsContext,flags,lpdwreg);
}
else if ( IsEqualCLSID(refclsid,CLSID_WPWIN61_FILE) )
{
thkDebugOut((DEB_WARN,"WordPerfect hack triggered\n"));
thkDebugOut((DEB_WARN,"Intercepting CoRegisterClassObject(WPWIN61_FILE)\n"));
return CoRegisterClassObjectDelayed( refclsid,punk,dwClsContext,flags,lpdwreg);
}
else if ( IsEqualCLSID(refclsid,CLSID_IKITARO_130) )
{
// Note: Ikitaro queries for IViewObject and uses it as IViewObject2
DWORD dw = TlsThkGetAppCompatFlags();
thkDebugOut((DEB_WARN,"Ikitaro hack triggered\n"));
TlsThkSetAppCompatFlags(dw | OACF_IVIEWOBJECT2);
}
return (DWORD)CoRegisterClassObject( refclsid, punk, dwClsContext,
flags, lpdwreg );
}
//+---------------------------------------------------------------------------
//
// Function: OleRegGetUserTypeNot
//
// Synopsis: Adds a hook for a WordPerfect hack. Check out the functions
// CoRegisterClassObjectDelayed and
// RegisterDelayedClassFactories for details. In essence, when
// this function is called for the WPWIN61 classID, we know
// that it is safe to register all of the delayed class objects.
// This determination was done by debugging Wordperfect. When
// they call this API, then are actually done initializing the
// internals of their app.
//
// Effects:
//
// History: 4-18-95 kevinro Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDAPI_(DWORD)
OleRegGetUserTypeNot(REFCLSID clsid,DWORD dwFormOfType,LPOLESTR *pszUserType)
{
//
// Wordperfect has a bug. When they call OleRegGetUserType for their
// classid, we know that it is safe to register their class objects for
// real.
//
// See CoRegisterClassObjectDelayed for details
//
if ( IsEqualCLSID(clsid,CLSID_WPWIN61) )
{
thkDebugOut((DEB_WARN,"Registering WordPerfects class objects\n"));
RegisterDelayedClassFactories();
}
return OleRegGetUserType(clsid,dwFormOfType,pszUserType);
}
//+---------------------------------------------------------------------------
//
// Member: OleThunkWOW::LoadProcDll, public
//
// Synopsis: Callback function for 32-bit OLE to load a 16-bit DLL
//
// Arguments: [pszDllName] - Name of 16-bit DLL
// [lpvpfnGetClassObject] - returned 16:16 address of
// "DllGetClassObject"
// [lpvpfnCanUnloadNow] - returned 16:16 address of
// "DllCanUnloadNow"
// [lpvhmodule] - returned 16-bit hmodule
//
// Returns: Appropriate status code
//
// History: 11-Mar-94 BobDay Created
//
//----------------------------------------------------------------------------
STDMETHODIMP
OleThunkWOW::LoadProcDll(
LPCTSTR pszDllName,
LPDWORD lpvpfnGetClassObject,
LPDWORD lpvpfnCanUnloadNow,
LPDWORD lpvhmodule
)
{
HRESULT hr;
UINT uiSize;
VPSTR vpstr16;
VPVOID vplpds16;
LOADPROCDLLSTRUCT UNALIGNED *lplpds16;
char string[256];
// Ensure that Interop is enabled
Win4Assert(gfIteropEnabled);
// Ensure that callbacks are allowed on this thread
Win4Assert(TlsThkGetThkMgr()->AreCallbacksAllowed());
uiSize = lstrlen(pszDllName) + 1;
vpstr16 = STACKALLOC16(uiSize*sizeof(TCHAR));
if (vpstr16 == 0)
{
hr = E_OUTOFMEMORY;
goto Exit;
}
#ifndef _CHICAGO_
hr = Convert_LPOLESTR_to_VPSTR(pszDllName, vpstr16,
uiSize, uiSize*sizeof(TCHAR));
#else
hr = Convert_LPSTR_to_VPSTR(pszDllName, vpstr16,
uiSize, uiSize*sizeof(TCHAR));
#endif
if (FAILED(hr))
{
goto EH_vpstr16;
}
vplpds16 = STACKALLOC16(sizeof(LOADPROCDLLSTRUCT));
if (vplpds16 == 0)
{
hr = E_OUTOFMEMORY;
goto EH_vpstr16;
}
lplpds16 = FIXVDMPTR(vplpds16, LOADPROCDLLSTRUCT);
lplpds16->vpDllName = vpstr16;
lplpds16->vpfnGetClassObject = 0;
lplpds16->vpfnCanUnloadNow = 0;
lplpds16->vhmodule = 0;
RELVDMPTR(vplpds16);
hr = CallbackTo16( gdata16Data.fnLoadProcDll, vplpds16 );
if (SUCCEEDED(hr))
{
lplpds16 = FIXVDMPTR(vplpds16, LOADPROCDLLSTRUCT);
*lpvpfnGetClassObject = lplpds16->vpfnGetClassObject;
*lpvpfnCanUnloadNow = lplpds16->vpfnCanUnloadNow;
*lpvhmodule = lplpds16->vhmodule;
RELVDMPTR(vplpds16);
#ifdef _CHICAGO_
thkDebugOut((DEB_WARN, "Loaded COM DLL: %s with HMODULE: 0x%x\n",
pszDllName, *lpvhmodule));
#else
thkDebugOut((DEB_WARN, "Loaded COM DLL: %ws with HMODULE: 0x%x\n",
pszDllName, *lpvhmodule));
#endif
}
else
{
hr = CO_E_DLLNOTFOUND;
}
STACKFREE16(vplpds16, sizeof(LOADPROCDLLSTRUCT));
EH_vpstr16:
STACKFREE16(vpstr16,uiSize*sizeof(TCHAR));
Exit:
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: OleThunkWOW::UnloadProcDll, public
//
// Synopsis: Callback function for 32-bit OLE to unload a 16-bit DLL
//
// Arguments: [vhmodule] - 16-bit hmodule
//
// Returns: Appropriate status code
//
// History: 11-Mar-94 BobDay Created
//
//----------------------------------------------------------------------------
STDMETHODIMP
OleThunkWOW::UnloadProcDll(
HMODULE vhmodule
)
{
HRESULT hr = S_OK;
// Ensure that Interop is enabled and callbacks are
// not allowed on this thread
if(gfIteropEnabled && TlsThkGetThkMgr()->AreCallbacksAllowed())
hr = CallbackTo16(gdata16Data.fnUnloadProcDll, HandleToUlong(vhmodule));
return(hr);
}
//+---------------------------------------------------------------------------
//
// Member: OleThunkWOW::CallGetClassObject, public
//
// Synopsis: Callback function for 32-bit OLE to call 16-bit
// DllGetClassObject
//
// Arguments: [vpfnGetClassObject] - 16:16 address of DllGetClassObject
// [rclsid] - CLSID of object
// [riid] - IID of interface on object
// [ppv] - returned object interface
//
// Returns: Appropriate status code
//
// History: 11-Mar-94 BobDay Created
//
//----------------------------------------------------------------------------
STDMETHODIMP
OleThunkWOW::CallGetClassObject(
DWORD vpfnGetClassObject,
REFCLSID rclsid,
REFIID riid,
LPVOID FAR *ppv
)
{
DWORD dwResult;
VPVOID vpcgcos16;
CALLGETCLASSOBJECTSTRUCT UNALIGNED *lpcgcos16;
VPVOID iface16;
IIDIDX iidx;
IUnknown *punkThis32;
CThkMgr *pThkMgr;
ThreadData *ptd;
// Ensure that Interop is enabled
Win4Assert(gfIteropEnabled);
// Ensure that callbacks are allowed on this thread
Win4Assert(TlsThkGetThkMgr()->AreCallbacksAllowed());
ptd = TlsThkGetData();
if (ptd == NULL)
{
thkDebugOut((DEB_WARN, "WARNING: CallGetClassObject refused\n"));
dwResult = (DWORD)E_FAIL;
goto Exit;
}
pThkMgr = ptd->pCThkMgr;
vpcgcos16 = STACKALLOC16(sizeof(CALLGETCLASSOBJECTSTRUCT));
if (vpcgcos16 == 0)
{
dwResult = (DWORD)E_OUTOFMEMORY;
goto Exit;
}
lpcgcos16 = FIXVDMPTR(vpcgcos16, CALLGETCLASSOBJECTSTRUCT);
lpcgcos16->vpfnGetClassObject = vpfnGetClassObject;
lpcgcos16->clsid = rclsid;
lpcgcos16->iid = riid;
lpcgcos16->iface = 0;
RELVDMPTR(vpcgcos16);
dwResult = CallbackTo16( gdata16Data.fnCallGetClassObject, vpcgcos16 );
if ( SUCCEEDED(dwResult) )
{
lpcgcos16 = FIXVDMPTR(vpcgcos16, CALLGETCLASSOBJECTSTRUCT);
iface16 = lpcgcos16->iface;
iidx = IidToIidIdx(riid);
// We're on the way out creating a proxy so set the state
// appropriately
pThkMgr->SetThkState(THKSTATE_INVOKETHKOUT32);
// Get a 32-bit proxy object for the 16-bit object
punkThis32 = pThkMgr->FindProxy3216(NULL, iface16, NULL, iidx, FALSE, NULL);
pThkMgr->SetThkState(THKSTATE_NOCALL);
// Set the out param
*(IUnknown **)ppv = punkThis32;
// As this is an OUT parameter, release the actual 16-bit interface
// This could be the last release on the 16-bit interface, if the
// proxy was not successfully created
ReleaseOnObj16(iface16);
if(punkThis32 == NULL) {
dwResult = (DWORD)E_OUTOFMEMORY;
}
RELVDMPTR(vpcgcos16);
}
else { // need to map dwResult only for failure cases (see hmMappings)
dwResult = TransformHRESULT_1632( dwResult );
}
STACKFREE16(vpcgcos16, sizeof(CALLGETCLASSOBJECTSTRUCT));
Exit:
return dwResult;
}
//+---------------------------------------------------------------------------
//
// Member: OleThunkWOW::CallCanUnloadNow, public
//
// Synopsis: Callback function for 32-bit OLE to call 16-bit
// CanUnloadNow
//
// Arguments: [vpfnCanUnloadNow] - 16:16 address of DllCanUnloadNow
//
// Returns: Appropriate status code
//
// History: 11-Mar-94 BobDay Created
//
//----------------------------------------------------------------------------
STDMETHODIMP OleThunkWOW::CallCanUnloadNow(
DWORD vpfnCanUnloadNow)
{
HRESULT hr = S_OK;
// Ensure that Interop is enabled and callbacks are
// not allowed on this thread
if(gfIteropEnabled && TlsThkGetThkMgr()->AreCallbacksAllowed())
hr = CallbackTo16(gdata16Data.fnCallCanUnloadNow, vpfnCanUnloadNow);
return(hr);
}
//+---------------------------------------------------------------------------
//
// Member: OleThunkWOW::GetThunkManager, public
//
// Synopsis: Callback function for 32-bit OLE to retrieve the thunkmanager
//
// Arguments: [ppThkMgr] - Thunk manager return
//
// Returns: Appropriate status code
//
// History: 11-May-94 JohannP Created
//
//----------------------------------------------------------------------------
STDMETHODIMP OleThunkWOW::GetThunkManager(IThunkManager **ppThkMgr)
{
thkDebugOut((DEB_THUNKMGR, "%sIn OleThunkWOW::GetThunkManager\n",
NestingLevelString()));
thkAssert(ppThkMgr != NULL);
IUnknown *pUnk = TlsThkGetThkMgr();
thkAssert(pUnk && "Invalid Thunkmanager");
*ppThkMgr = (IThunkManager *)pUnk;
pUnk->AddRef();
thkDebugOut((DEB_THUNKMGR, "%sOut OleThunkWOW::GetThunkManager: (%p)\n",
NestingLevelString(), pUnk));
return NOERROR;
}
//+---------------------------------------------------------------------------
//
// Member: OleThunkWOW::WinExec16, public
//
// Synopsis: Callback function for 32-bit OLE to run an application
//
// Arguments: [pszCommandLine] - command line for WinExec
// [usShow] - fShow for WinExec
//
// Returns: Appropriate status code
//
// History: 27-Jul-94 AlexT Created
//
//----------------------------------------------------------------------------
STDMETHODIMP OleThunkWOW::WinExec16(
LPCOLESTR pszCommandLine,
USHORT usShow
)
{
HRESULT hr;
UINT uiSize;
VPSTR vpstr16;
VPVOID vplpds16;
WINEXEC16STRUCT UNALIGNED *lpwes16;
ULONG ulRet;
// Ensure that Interop is enabled
Win4Assert(gfIteropEnabled);
// Ensure that callbacks are allowed on this thread
Win4Assert(TlsThkGetThkMgr()->AreCallbacksAllowed());
uiSize = lstrlenW(pszCommandLine) + 1;
vpstr16 = STACKALLOC16(uiSize*2);
if (vpstr16 == 0)
{
hr = E_OUTOFMEMORY;
goto Exit;
}
hr = Convert_LPOLESTR_to_VPSTR(pszCommandLine, vpstr16,
uiSize, uiSize*2);
if (FAILED(hr))
{
goto EH_vpstr16;
}
vplpds16 = STACKALLOC16(sizeof(WINEXEC16STRUCT));
if (vplpds16 == 0)
{
hr = E_OUTOFMEMORY;
goto EH_vpstr16;
}
lpwes16 = FIXVDMPTR(vplpds16, WINEXEC16STRUCT);
lpwes16->vpCommandLine = vpstr16;
lpwes16->vusShow = usShow;
RELVDMPTR(vplpds16);
ulRet = CallbackTo16( gdata16Data.fnWinExec16, vplpds16 );
thkDebugOut((DEB_ITRACE,
"CallbackTo16(WinExec16) returned %ld\n", ulRet));
// According to the Windows spec, return values greater than 31 indicate
// success.
if (ulRet > 31)
{
hr = S_OK;
}
else if (0 == ulRet)
{
// 0 indicates lack of some kind of resource
hr = E_OUTOFMEMORY;
}
else
{
hr = HRESULT_FROM_WIN32(ulRet);
}
STACKFREE16(vplpds16, sizeof(WINEXEC16STRUCT));
EH_vpstr16:
STACKFREE16(vpstr16, uiSize*2);
Exit:
return hr;
}
//+---------------------------------------------------------------------------
//
// Method: OleThunkWOW::ConvertHwndToFullHwnd
//
// Synopsis: Converts a 16 bit HWND into a 32-bit HWND
//
// Effects: Since OLE32 doesn't directly link to WOW, this function allows
// the DDE layer to access the routine that maps 16 bit HWND to
// full 32-bit HWND's.
//
// Arguments: [hwnd] -- HWND to convert
//
// History: 8-03-94 kevinro Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP_(HWND) OleThunkWOW::ConvertHwndToFullHwnd(HWND hwnd)
{
return(FULLHWND_32((USHORT)hwnd));
}
//+---------------------------------------------------------------------------
//
// Method: OleThunkWOW::FreeMetaFile
//
// Synopsis: Calls wow to delete a metafile that has memory reserved in
// the 16 bit address space
//
// Effects: Since OLE32 doesn't directly link to WOW, this function allows
// the DDE layer to access the routine in WOW
//
// Arguments: [hmf] -- HANDLE to delete
//
// History: 8-03-94 kevinro Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP_(BOOL) OleThunkWOW::FreeMetaFile(HANDLE hmf)
{
return(WOWFreeMetafile(hmf));
}
//+---------------------------------------------------------------------------
//
// Member: OleThunkWOW::YieldTask16, public
//
// Synopsis: Callback function for 32-bit OLE to yield
//
// History: 08-Aug-94 Ricksa Created
//
//----------------------------------------------------------------------------
STDMETHODIMP OleThunkWOW::YieldTask16(void)
{
WOWYield16();
return S_OK;
}
//+---------------------------------------------------------------------------
//
// Member: OleThunkWOW::DirectedYield, public
//
// Synopsis: Does a directed yield in the VDM.
//
// History: 08-Aug-94 Rickhi Created
//
//----------------------------------------------------------------------------
STDMETHODIMP OleThunkWOW::DirectedYield(DWORD dwCalleeTID)
{
WORD hTask16 = WOWHandle16((void *)dwCalleeTID, WOW_TYPE_HTASK);
thkDebugOut((DEB_ITRACE, "WOWDirectedYield16(%x)\n", hTask16));
WOWDirectedYield16(hTask16);
thkDebugOut((DEB_ITRACE, "WOWDirectedYield16() returned\n"));
return S_OK;
}
//+---------------------------------------------------------------------------
//
// Method: OleThunkWOW::PrepareForCleanup
//
// Synopsis: Prepares OLETHK32 for OLE32.DLL's cleanup.
//
// Effects: It does this by taking all of the remaining 3216 proxies
// and marking them such that no callbacks into the 16-bit
// world are possible.
//
// Arguments: -none-
//
// History: 24-Aug-94 bobday Created
//
// Notes:
//
//----------------------------------------------------------------------------
STDMETHODIMP_(void) OleThunkWOW::PrepareForCleanup(void)
{
CThkMgr *pcthkmgr;
if ( TlsThkGetData() != NULL )
{
pcthkmgr = (CThkMgr*)TlsThkGetThkMgr();
//
// Tell the thkmgr to prepare for cleaning itself up
//
pcthkmgr->PrepareForCleanup();
}
}
//+---------------------------------------------------------------------------
//
// Method: OleThunkWOW::GetAppCompatibilityFlags
//
// Synopsis: Used to return the current THK app compatibility flags to
// OLE32.DLL
// Arguments: [void] --
//
// Requires:
//
// Returns: Flags defined in ih\thunkapi.hxx
//
// History: 1-11-96 kevinro Created
//
//----------------------------------------------------------------------------
STDMETHODIMP_(DWORD) OleThunkWOW::GetAppCompatibilityFlags(void)
{
return(TlsThkGetAppCompatFlags());
}
Reference in New Issue View Git Blame Copy Permalink