//+---------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1993 - 1994.
//
// File: d:\nt\private\cairole\com\remote\channelb.cxx
//
// Contents: This module contains thunking classes that allow proxies
// and stubs to use a buffer interface on top of RPC for Cairo
//
// Classes: CRpcChannelBuffer
//
// Functions:
// ChannelThreadInitialize
// ChannelProcessInitialize
// ChannelRegisterProtseq
// ChannelThreadUninitialize
// ChannelProcessUninitialize
// CRpcChannelBuffer::AddRef
// CRpcChannelBuffer::AppInvoke
// CRpcChannelBuffer::CRpcChannelBuffer
// CRpcChannelBuffer::FreeBuffer
// CRpcChannelBuffer::GetBuffer
// CRpcChannelBuffer::QueryInterface
// CRpcChannelBuffer::Release
// CRpcChannelBuffer::SendReceive
// DebugCoSetRpcFault
// DllDebugObjectRPCHook
// ThreadInvoke
// ThreadSendReceive
//
// History: 22 Jun 93 AlexMi Created
// 31 Dec 93 ErikGav Chicago port
// 15 Mar 94 JohannP Added call category support.
// 09 Jun 94 BruceMa Get call category from RPC message
// 19 Jul 94 CraigWi Added support for ASYNC calls
// 01-Aug-94 BruceMa Memory sift fix
//
//----------------------------------------------------------------------
#include <ole2int.h>
#include <channelb.hxx>
#include <hash.hxx> // CUUIDHashTable
#include <riftbl.hxx> // gRIFTbl
#include <callctrl.hxx> // CAptRpcChnl, AptInvoke
#include <threads.hxx> // CRpcThreadCache
#include <service.hxx> // StopListen
#include <resolver.hxx> // CRpcResolver
extern "C"
{
#include "orpc_dbg.h"
}
#include <rpcdcep.h>
#include <rpcndr.h>
#include <obase.h>
#include <ipidtbl.hxx>
#include <security.hxx>
#include <chock.hxx>
// This is needed for the debug hooks. See orpc_dbg.h
#pragma code_seg(".orpc")
/***************************************************************************/
/* Defines. */
#define MAKE_WIN32( status ) \
MAKE_SCODE( SEVERITY_ERROR, FACILITY_WIN32, (status) )
// This should just return a status to runtime, but runtime does not
// support both comm and fault status yet.
#ifdef _CHICAGO_
#define RETURN_COMM_STATUS( status ) return (status)
#else
#define RETURN_COMM_STATUS( status ) RpcRaiseException( status )
#endif
// Flags for local rpc header.
// These are only valid on a request (in a ORPCTHIS header).
const int ORPCF_INPUT_SYNC = ORPCF_RESERVED1;
const int ORPCF_ASYNC = ORPCF_RESERVED2;
// These are only valid on a reply (in a ORPCTHAT header).
const int ORPCF_REJECTED = ORPCF_RESERVED1;
const int ORPCF_RETRY_LATER = ORPCF_RESERVED2;
// Default size of hash table.
const int INITIAL_NUM_BUCKETS = 20;
/***************************************************************************/
/* Typedefs. */
// This structure contains a copy of all the information needed to make a
// call. It is copied so it can be canceled without stray pointer references.
const DWORD CALLCACHE_SIZE = 8;
struct working_call : public CChannelCallInfo
{
working_call( CALLCATEGORY callcat,
RPCOLEMESSAGE *message,
DWORD flags,
REFIPID ipidServer,
DWORD destctx,
CRpcChannelBuffer *channel,
DWORD authn_level );
void *operator new ( size_t );
void operator delete( void * );
static void Cleanup ( void );
static void Initialize ( void );
RPCOLEMESSAGE message;
private:
static void *list[CALLCACHE_SIZE];
static DWORD next;
};
void *working_call::list[CALLCACHE_SIZE] =
{ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
DWORD working_call::next = 0;
/***************************************************************************/
/* Macros. */
// Compute the size needed for the implicit this pointer including the
// various optional headers.
inline DWORD SIZENEEDED_ORPCTHIS( BOOL local, DWORD debug_size )
{
if (debug_size == 0)
return sizeof(WireThisPart1) + ((local) ? sizeof(LocalThis) : 0);
else
return sizeof(WireThisPart2) + ((local) ? sizeof(LocalThis) : 0) +
debug_size;
}
inline DWORD SIZENEEDED_ORPCTHAT( DWORD debug_size )
{
if (debug_size == 0)
return sizeof(WireThatPart1);
else
return sizeof(WireThatPart2) + debug_size;
}
inline CALLCATEGORY GetCallCat( void *header )
{
WireThis *inb = (WireThis *) header;
if (inb->c.flags & ORPCF_ASYNC)
return CALLCAT_ASYNC;
else if (inb->c.flags & ORPCF_INPUT_SYNC)
return CALLCAT_INPUTSYNC;
else
return CALLCAT_SYNCHRONOUS;
}
/***************************************************************************/
/* Globals. */
// Should the debugger hooks be called?
BOOL DoDebuggerHooks = FALSE;
LPORPC_INIT_ARGS DebuggerArg = NULL;
// The extension identifier for debug data.
const uuid_t DEBUG_EXTENSION =
{ 0xf1f19680, 0x4d2a, 0x11ce, {0xa6, 0x6a, 0x00, 0x20, 0xaf, 0x6e, 0x72, 0xf4}};
#if DBG == 1
// strings that prefix the call
WCHAR *wszDebugORPCCallPrefixString[4] = { L"--> [BEG]", // Invoke
L" --> [end]",
L"<-- [BEG]", // SendReceive
L" <-- [end]" };
LONG ulDebugORPCCallNestingLevel[4] = {1, -1, 1, -1};
#endif
SHashChain OIDBuckets[23] = { {&OIDBuckets[0], &OIDBuckets[0]},
{&OIDBuckets[1], &OIDBuckets[1]},
{&OIDBuckets[2], &OIDBuckets[2]},
{&OIDBuckets[3], &OIDBuckets[3]},
{&OIDBuckets[4], &OIDBuckets[4]},
{&OIDBuckets[5], &OIDBuckets[5]},
{&OIDBuckets[6], &OIDBuckets[6]},
{&OIDBuckets[7], &OIDBuckets[7]},
{&OIDBuckets[8], &OIDBuckets[8]},
{&OIDBuckets[9], &OIDBuckets[9]},
{&OIDBuckets[10], &OIDBuckets[10]},
{&OIDBuckets[11], &OIDBuckets[11]},
{&OIDBuckets[12], &OIDBuckets[12]},
{&OIDBuckets[13], &OIDBuckets[13]},
{&OIDBuckets[14], &OIDBuckets[14]},
{&OIDBuckets[15], &OIDBuckets[15]},
{&OIDBuckets[16], &OIDBuckets[16]},
{&OIDBuckets[17], &OIDBuckets[17]},
{&OIDBuckets[18], &OIDBuckets[18]},
{&OIDBuckets[19], &OIDBuckets[19]},
{&OIDBuckets[20], &OIDBuckets[20]},
{&OIDBuckets[21], &OIDBuckets[21]},
{&OIDBuckets[22], &OIDBuckets[22]}
};
CUUIDHashTable gClientRegisteredOIDs;
// flag whether or not the channel has been initialized for current process
BOOL gfChannelProcessInitialized = 0;
BOOL gfMTAChannelInitialized = 0;
// count of multi-threaded apartment inits (see CoInitializeEx)
extern DWORD g_cMTAInits;
// Channel debug hook object.
CDebugChannelHook gDebugHook;
// Channel error hook object.
CErrorChannelHook gErrorHook;
#if DBG==1
//-------------------------------------------------------------------------
//
// Function: GetInterfaceName
//
// synopsis: Gets the human readable name of an Interface given it's IID.
//
// History: 12-Jun-95 Rickhi Created
//
//-------------------------------------------------------------------------
LONG GetInterfaceName(REFIID riid, WCHAR *pwszName)
{
// convert the iid to a string
CDbgGuidStr dbgsIID(riid);
// Read the registry entry for the interface to get the interface name
LONG ulcb=256;
WCHAR szKey[80];
szKey[0] = L'\0';
lstrcatW(szKey, L"Interface\\");
lstrcatW(szKey, dbgsIID._wszGuid);
LONG result = RegQueryValue(
HKEY_CLASSES_ROOT,
szKey,
pwszName,
&ulcb);
Win4Assert( result == 0 );
return result;
}
//---------------------------------------------------------------------------
//
// Function: DebugPrintORPCCall
//
// synopsis: Prints the interface name and method number to the debugger
// to allow simple ORPC call tracing.
//
// History: 12-Jun-95 Rickhi Created
//
//---------------------------------------------------------------------------
void DebugPrintORPCCall(DWORD dwFlag, REFIID riid, DWORD iMethod, DWORD Callcat)
{
if (CairoleInfoLevel & DEB_USER15)
{
Win4Assert (dwFlag < 4);
// adjust the nesting level for this thread.
COleTls tls;
tls->cORPCNestingLevel += ulDebugORPCCallNestingLevel[dwFlag];
// set the indentation string according to the nesting level
CHAR szNesting[100];
memset(szNesting, 0x20, 100);
if (tls->cORPCNestingLevel > 99) // watch for overflow
szNesting[99] = '\0';
else
szNesting[tls->cORPCNestingLevel] = '\0';
// construct the debug strings
WCHAR *pwszDirection = wszDebugORPCCallPrefixString[dwFlag];
WCHAR wszName[100];
GetInterfaceName(riid, wszName);
ComDebOut((DEB_USER15, "%s%ws [%x] %ws:: %x\n",
szNesting, pwszDirection, Callcat, wszName, iMethod));
}
}
#endif
/***************************************************************************/
void ByteSwapThis( DWORD drep, WireThis *inb )
{
if ((drep & NDR_LOCAL_DATA_REPRESENTATION) != NDR_LITTLE_ENDIAN)
{
// Extensions are swapped later. If we ever use the reserved field,
// swap it.
ByteSwapShort( inb->c.version.MajorVersion );
ByteSwapShort( inb->c.version.MinorVersion );
ByteSwapLong( inb->c.flags );
// ByteSwapLong( inb->c.reserved1 );
ByteSwapLong( inb->c.cid.Data1 );
ByteSwapShort( inb->c.cid.Data2 );
ByteSwapShort( inb->c.cid.Data3 );
}
}
/***************************************************************************/
void ByteSwapThat( DWORD drep, WireThat *outb )
{
if ((drep & NDR_LOCAL_DATA_REPRESENTATION) != NDR_LITTLE_ENDIAN)
{
// Extensions are swapped later.
ByteSwapLong( outb->c.flags );
}
}
//+-------------------------------------------------------------------
//
// Function: ChannelProcessInitialize, public
//
// Synopsis: Initializes the channel subsystem per process data.
//
// History: 23-Nov-93 AlexMit Created
//
//--------------------------------------------------------------------
STDAPI ChannelProcessInitialize()
{
TRACECALL(TRACE_RPC, "ChannelProcessInitialize");
ComDebOut((DEB_COMPOBJ, "ChannelProcessInitialize [IN]\n"));
Win4Assert( (sizeof(WireThisPart1) & 7) == 0 );
Win4Assert( (sizeof(WireThisPart2) & 7) == 0 );
Win4Assert( (sizeof(LocalThis) & 7) == 0 );
Win4Assert( (sizeof(WireThatPart1) & 7) == 0 );
Win4Assert( (sizeof(WireThatPart2) & 7) == 0 );
// we want to take the gComLock since that prevents other Rpc
// threads from accessing anything we are about to create, in
// particular, the event cache and working_call cache are accessed
// by Rpc worker threads of cancelled calls.
ASSERT_LOCK_RELEASED
LOCK
HRESULT hr = S_OK;
if (!gfChannelProcessInitialized)
{
// Initialize the interface hash tables, the OID hash table, and
// the MID hash table. We dont need to cleanup these on errors.
gMIDTbl.Initialize();
gOXIDTbl.Initialize();
gRIFTbl.Initialize();
gIPIDTbl.Initialize();
gSRFTbl.Initialize();
gClientRegisteredOIDs.Initialize(OIDBuckets);
// Register the debug channel hook.
hr = CoRegisterChannelHook( DEBUG_EXTENSION, &gDebugHook );
// Register the error channel hook.
if(SUCCEEDED(hr))
{
hr = CoRegisterChannelHook( ERROR_EXTENSION, &gErrorHook );
}
// Initialize security.
if (SUCCEEDED(hr))
{
hr = InitializeSecurity();
}
// always set to TRUE if we initialized ANYTHING, regardless of
// whether there were any errors. That way, ChannelProcessUninit
// will cleanup anything we have initialized.
gfChannelProcessInitialized = TRUE;
}
UNLOCK
ASSERT_LOCK_RELEASED
if (FAILED(hr))
{
// cleanup anything we have created thus far.
ChannelProcessUninitialize();
}
ComDebOut((DEB_COMPOBJ, "ChannelProcessInitialize [OUT] hr:%x\n", hr));
return hr;
}
//+-------------------------------------------------------------------
//
// Function: CleanupRegOIDs, public
//
// Synopsis: called to delete each node of the registered OID list.
//
//+-------------------------------------------------------------------
void CleanupRegOIDs(SHashChain *pNode)
{
delete pNode;
}
//+-------------------------------------------------------------------
//
// Function: ChannelProcessUninitialize, public
//
// Synopsis: Uninitializes the channel subsystem global data.
//
// History: 23-Nov-93 Rickhi Created
//
// Notes: This is called at process uninitialize, not thread
// uninitialize.
//
//--------------------------------------------------------------------
STDAPI_(void) ChannelProcessUninitialize(void)
{
TRACECALL(TRACE_RPC, "ChannelProcessUninitialize");
ComDebOut((DEB_COMPOBJ, "ChannelProcessUninitialize [IN]\n"));
if (gfChannelProcessInitialized)
{
// Stop accepting calls from the object resolver and flag that service
// is no longer initialized. This can result in calls being
// dispatched. Do not hold the lock around this call.
UnregisterDcomInterfaces();
}
gResolver.ReleaseSCMProxy();
// we want to take the gComLock since that prevents other Rpc
// threads from accessing anything we are about to cleanup, in
// particular, the event cache and working_call are accessed by
// Rpc worker threaded for cancelled calls.
ASSERT_LOCK_RELEASED
LOCK
if (gfChannelProcessInitialized)
{
// Release the interface tables. This causes RPC to stop dispatching
// DCOM calls. This can result in calls being dispatched.
// UnRegisterServerInterface releases and reaquires the lock each
// time it is called.
gRIFTbl.Cleanup();
if (gpLocalMIDEntry)
{
// release the local MIDEntry
DecMIDRefCnt(gpLocalMIDEntry);
gpLocalMIDEntry = NULL;
}
// release the MTA apartment's OXIDEntry if there is one. Do this
// after the RIFTble cleanup so we are not processing any calls
// while it happens.
gOXIDTbl.ReleaseLocalMTAEntry();
if (gpsaCurrentProcess)
{
// delete the string bindings for the current process
PrivMemFree(gpsaCurrentProcess);
gpsaCurrentProcess = NULL;
}
// cleanup the IPID, OXID, and MID tables
gOXIDTbl.FreeExpiredEntries(GetTickCount()+1);
gIPIDTbl.Cleanup();
gOXIDTbl.Cleanup();
gMIDTbl.Cleanup();
gSRFTbl.Cleanup();
// Cleanup the OID registration table.
gClientRegisteredOIDs.Cleanup(CleanupRegOIDs);
// Cleanup the call cache.
working_call::Cleanup();
// Release all cached threads.
gRpcThreadCache.ClearFreeList();
// cleanup the event cache
gEventCache.Cleanup();
// Cleanup the channel hooks.
CleanupChannelHooks();
}
// Always cleanup the RPC OXID resolver since security may initialize it.
gResolver.Cleanup();
// Cleanup security.
UninitializeSecurity();
// mark the channel as no longer intialized for this process
gfChannelProcessInitialized = FALSE;
gfMTAChannelInitialized = FALSE;
UNLOCK
ASSERT_LOCK_RELEASED
// release the static unmarshaler
if (gpStdMarshal)
{
((CStdIdentity *)gpStdMarshal)->UnlockAndRelease();
gpStdMarshal = NULL;
}
ComDebOut((DEB_COMPOBJ, "ChannelProcessUninitialize [OUT]\n"));
return;
}
//+-------------------------------------------------------------------
//
// Function: STAChannelInitialize, public
//
// Synopsis: Initializes the channel subsystem per thread data
// for single-threaded apartments.
//
// History: 23-Nov-93 Rickhi Created
//
// Notes: This is called at thread initialize, not process
// initialize. Cleanup is done in ChannelThreadUninitialize.
//
//--------------------------------------------------------------------
STDAPI STAChannelInitialize(void)
{
ComDebOut((DEB_COMPOBJ, "STAChannelInitialize [IN]\n"));
Win4Assert(IsSTAThread());
HRESULT hr = S_OK;
if (!gfChannelProcessInitialized)
{
// process initialization has not been done, do that now.
if (FAILED(hr = ChannelProcessInitialize()))
return hr;
}
// create the callctrl before calling ThreadStart, since the latter
// tries to register with the call controller. We might already have
// a callctrl if some DDE stuff has already run.
COleTls tls;
if (tls->pCallCtrl == NULL)
{
// assume OOM and try to create callctrl. ctor sets tls.
hr = E_OUTOFMEMORY;
CAptCallCtrl *pCallCtrl = new CAptCallCtrl();
}
if (tls->pCallCtrl)
{
// mark the channel as initialized now to prevent re-entracy in
// GetLocalEntry.
tls->dwFlags |= OLETLS_CHANNELTHREADINITIALZED;
// Precreate the thread window. The window is normally only used
// for requests (and thus created during marshalling). But in WOW
// it is used for responses (and thus created during initialization).
// We do it for normal cases here too in order to avoid recursion
// when marshaling the first interface.
ASSERT_LOCK_RELEASED
LOCK
OXIDEntry *pOxid;
hr = gOXIDTbl.GetLocalEntry( &pOxid );
UNLOCK
ASSERT_LOCK_RELEASED
if (SUCCEEDED(hr))
{
hr = ThreadStart();
}
// Clear the channel initialized flag if initialization fails.
// Everything gets cleaned up in uninitialize regardless of the
// channel flag.
if (FAILED(hr))
tls->dwFlags &= ~OLETLS_CHANNELTHREADINITIALZED;
}
ComDebOut((DEB_COMPOBJ, "STAChannelInitialize [OUT] hr:%x\n", hr));
return hr;
}
//+-------------------------------------------------------------------
//
// Function: MTAChannelInitialize, public
//
// Synopsis: Initializes the channel subsystem per thread data
// for multi-threaded apartments.
//
// History: 19-Mar-96 Rickhi Created
//
// Notes: This is called at thread initialize, not process
// initialize. Cleanup is done in ChannelThreadUninitialize.
//
//--------------------------------------------------------------------
STDAPI MTAChannelInitialize(void)
{
ComDebOut((DEB_COMPOBJ, "MTAChannelInitialize [IN]\n"));
Win4Assert(IsMTAThread());
HRESULT hr = S_OK;
if (!gfChannelProcessInitialized)
{
// process initialization has not been done, do that now.
if (FAILED(hr = ChannelProcessInitialize()))
return hr;
}
ASSERT_LOCK_RELEASED
LOCK
if (!gfMTAChannelInitialized)
{
// Create the OXID entry for this apartment. Do it now to avoid
// any races with two threads creating it simultaneously.
OXIDEntry *pOxid;
hr = gOXIDTbl.GetLocalEntry( &pOxid );
if (SUCCEEDED(hr))
{
pOxid->dwFlags &= ~ OXIDF_STOPPED;
gfMTAChannelInitialized = TRUE;
}
}
UNLOCK
ASSERT_LOCK_RELEASED
ComDebOut((DEB_COMPOBJ, "MTAChannelInitialize [OUT] hr:%x\n", hr));
return hr;
}
//+-------------------------------------------------------------------
//
// Function: ChannelThreadUninitialize, private
//
// Synopsis: Uninitializes the channel subsystem per thread data.
//
// History: 23-Nov-93 Rickhi Created
//
// Notes: This is called at thread uninitialize, not process
// uninitialize.
//
//--------------------------------------------------------------------
STDAPI_(void) ChannelThreadUninitialize(void)
{
TRACECALL(TRACE_RPC, "ChannelThreadUninitialize");
ComDebOut((DEB_COMPOBJ, "ChannelThreadUninitialize [IN]\n"));
COleTls tls;
if (tls->dwFlags & OLETLS_APARTMENTTHREADED)
{
// Cleanup the window for this thread.
ThreadCleanup();
// Free the apartment call control.
delete tls->pCallCtrl;
tls->pCallCtrl = NULL;
// Free any registered MessageFilter that has not been picked
// up by the call ctrl.
if (tls->pMsgFilter)
{
tls->pMsgFilter->Release();
tls->pMsgFilter = NULL;
}
// release the OXIDEntry for this thread.
ASSERT_LOCK_RELEASED
LOCK
gOXIDTbl.ReleaseLocalSTAEntry();
UNLOCK
ASSERT_LOCK_RELEASED
// mark the thread as no longer intialized for the channel
tls->dwFlags &= ~OLETLS_CHANNELTHREADINITIALZED;
}
else
{
// the MTA channel is no longer initialized.
gfMTAChannelInitialized = FALSE;
}
ComDebOut((DEB_COMPOBJ, "ChannelThreadUninitialize [OUT]\n"));
}
// count of multi-threaded inits
//+-------------------------------------------------------------------
//
// Function: InitChannelIfNecessary, private
//
// Synopsis: Checks if the ORPC channel has been initialized for
// the current apartment and initializes if not. This is
// required by the delayed initialization logic.
//
// History: 26-Oct-95 Rickhi Created
//
//--------------------------------------------------------------------
INTERNAL InitChannelIfNecessary()
{
HRESULT hr;
COleTls tls(hr);
if (FAILED(hr))
return hr;
if (!(tls->dwFlags & OLETLS_APARTMENTTHREADED))
{
if (!gfMTAChannelInitialized)
{
if (g_cMTAInits > 0)
{
// initialize the MTAChannel
return MTAChannelInitialize();
}
// CoInitializeEx(MULTITHREADED) has not been called
return CO_E_NOTINITIALIZED;
}
}
else if (!(tls->dwFlags & OLETLS_CHANNELTHREADINITIALZED))
{
if (tls->cComInits > 0 &&
!(tls->dwFlags & OLETLS_THREADUNINITIALIZING))
return STAChannelInitialize();
// CoInitializeEx(APARTMENTTHREADED) has not been called,
// or the thread is Uninitializing
return CO_E_NOTINITIALIZED;
}
return S_OK;
}
/***************************************************************************/
/*
Make a copy of a message for an asyncronous call. Also make a fake
reply for the call.
*/
CChannelCallInfo *MakeAsyncCopy( CChannelCallInfo *original )
{
void *pBuffer = NULL;
WireThat *outb;
BOOL success;
ASSERT_LOCK_HELD
working_call *copy = new working_call( original->category,
original->pmessage,
original->iFlags,
original->ipid,
original->iDestCtx,
original->pChannel,
original->lAuthnLevel );
if (copy != NULL)
{
original->hResult = S_OK;
if (original->pmessage->rpcFlags & RPCFLG_LOCAL_CALL)
{
// no need to duplicate the buffer, just use it as is.
copy->message.Buffer = original->pmessage->Buffer;
}
else
{
pBuffer = PrivMemAlloc8(original->pmessage->cbBuffer);
Win4Assert(((ULONG)pBuffer & 0x7) == 0 && "Buffer not aligned properly");
if (pBuffer != NULL)
{
copy->message.Buffer = pBuffer;
memcpy(pBuffer, original->pmessage->Buffer,
original->pmessage->cbBuffer);
}
else
{
original->hResult = RPC_E_OUT_OF_RESOURCES;
}
}
if (SUCCEEDED(original->hResult))
{
// pretend local so we don't touch rpc for more buffers, etc.
copy->message.rpcFlags |= RPCFLG_LOCAL_CALL;
// Create a fake reply containing a result even though the
// client will never see it.
original->pmessage->cbBuffer = SIZENEEDED_ORPCTHAT(0) + 4;
if (original->pmessage->rpcFlags & RPCFLG_LOCAL_CALL)
{
original->pmessage->Buffer = PrivMemAlloc8(original->pmessage->cbBuffer);
success = original->pmessage->Buffer != NULL;
}
else
{
success = I_RpcGetBuffer((RPC_MESSAGE *) original->pmessage) == RPC_S_OK;
}
// simulate success in method call
if (success)
{
outb = (WireThat *) original->pmessage->Buffer;
outb->c.flags = ORPCF_NULL;
outb->c.unique = 0;
*(SCODE *)((WireThatPart1 *)outb + 1) = S_OK;
return copy;
}
}
PrivMemFree(pBuffer);
delete copy;
}
return NULL;
}
/***************************************************************************/
STDMETHODIMP_(ULONG) CRpcChannelBuffer::AddRef( THIS )
{
// can't call AssertValid(FALSE) since it is used in asserts
InterlockedIncrement( (long *) &ref_count );
return ref_count;
}
/***************************************************************************/
HRESULT CRpcChannelBuffer::AppInvoke( CChannelCallInfo *call,
IRpcStubBuffer *stub,
void *pv,
void *orig_stub_buffer,
LocalThis *localb )
{
ASSERT_LOCK_RELEASED
RPC_MESSAGE *message = (RPC_MESSAGE *) call->pmessage;
void *orig_buffer = message->Buffer;
WireThat *outb = NULL;
HRESULT result;
// Save a pointer to the inbound header.
call->pHeader = message->Buffer;
// Adjust the buffer.
message->BufferLength -= (char *) orig_stub_buffer - (char *) message->Buffer;
message->Buffer = orig_stub_buffer;
message->ProcNum &= ~RPC_FLAGS_VALID_BIT;
// if the incoming call is from a non-NDR client, then set a bit in
// the message flags field so the stub can figure out how to dispatch
// the call. This allows a 32bit server to simultaneously service a
// 32bit client using NDR and a 16bit client using non-NDR, in particular,
// to support OLE Automation.
if (localb != NULL && localb->flags & LOCALF_NONNDR)
message->RpcFlags |= RPCFLG_NON_NDR;
if (IsMTAThread())
{
// do multi-threaded apartment invoke
result = MTAInvoke((RPCOLEMESSAGE *)message, GetCallCat( call->pHeader ),
stub, this, &call->server_fault);
}
else
{
// do single-threaded apartment invoke
result = STAInvoke((RPCOLEMESSAGE *)message, GetCallCat( call->pHeader ),
stub, this, pv, &call->server_fault);
}
// For local calls, just free the in buffer. For non-local calls,
// the RPC runtime does this for us.
if (message->RpcFlags & RPCFLG_LOCAL_CALL)
PrivMemFree( orig_buffer );
// If an exception occurred before a new buffer was allocated,
// set the Buffer field to point to the original buffer.
if (message->Buffer == orig_stub_buffer)
{
// The buffer pointer in the message must be correct so RPC can free it.
if (message->RpcFlags & RPCFLG_LOCAL_CALL)
message->Buffer = NULL;
else
message->Buffer = orig_buffer;
}
else if (message->Buffer != NULL)
{
// An out buffer exists, get the pointer to the channel header.
Win4Assert( call->pHeader != orig_buffer );
message->BufferLength += (char *) message->Buffer - (char *) call->pHeader;
message->Buffer = call->pHeader;
outb = (WireThat *) message->Buffer;
}
// If successful, adjust the buffer.
if (result == S_OK)
{
if (call->iDestCtx == MSHCTX_DIFFERENTMACHINE)
outb->c.flags = 0;
else
outb->c.flags = ORPCF_LOCAL;
// For asynchronous calls, MSWMSG will delete the out buffer. If MSWMSG
// is not the transport, delete it here. Non-Mswmsg async calls have
// been converted to local calls.
if (message->RpcFlags & RPCFLG_LOCAL_CALL &&
call->category == CALLCAT_ASYNC)
{
PrivMemFree( message->Buffer );
message->Buffer = NULL;
}
}
else if (result == RPC_E_CALL_REJECTED)
{
// Call was rejected. If the caller is on another machine, just fail the
// call.
if (call->iDestCtx != MSHCTX_DIFFERENTMACHINE && outb != NULL)
{
// Otherwise return S_OK so the buffer gets back, but set the flag
// to indicate it was rejected.
outb->c.flags = ORPCF_LOCAL | ORPCF_REJECTED;
result = S_OK;
}
}
else if (result == RPC_E_SERVERCALL_RETRYLATER)
{
// Call was rejected. If the caller is on another machine, just fail the
// call.
if (call->iDestCtx != MSHCTX_DIFFERENTMACHINE && outb != NULL)
{
// Otherwise return S_OK so the buffer gets back, but set the flag
// to indicate it was rejected with retry later.
outb->c.flags = ORPCF_LOCAL | ORPCF_RETRY_LATER;
result = S_OK;
}
}
else if (message->RpcFlags & RPCFLG_LOCAL_CALL)
{
// call failed and the call is local, free the out buffer. For
// non-local calls the RPC runtime does this for us.
PrivMemFree( message->Buffer );
message->Buffer = NULL;
}
ASSERT_LOCK_RELEASED
return result;
}
//+---------------------------------------------------------------------------
//
// Function: AppInvokeExceptionFilter
//
// Synopsis: Determine if the application as thrown an exception we want
// to report. If it has, then print out enough information for
// the 'user' to debug the problem
//
// Arguments: [lpep] -- Exception context records
//
// History: 6-20-95 kevinro Created
//
// Notes:
//
// At the moment, I was unable to get this to work for Win95, so I have
// commented out the code.
//
//----------------------------------------------------------------------------
#ifdef _CHICAGO_
//
// Win95 doesn't appear to support this functionality by default.
//
inline LONG
AppInvokeExceptionFilter(
LPEXCEPTION_POINTERS lpep
)
{
return(EXCEPTION_EXECUTE_HANDLER);
}
#else
#include <imagehlp.h>
#define SYM_HANDLE GetCurrentProcess()
#if defined(_M_IX86)
#define MACHINE_TYPE IMAGE_FILE_MACHINE_I386
#elif defined(_M_MRX000)
#define MACHINE_TYPE IMAGE_FILE_MACHINE_R4000
#elif defined(_M_ALPHA)
#define MACHINE_TYPE IMAGE_FILE_MACHINE_ALPHA
#elif defined(_M_PPC)
#define MACHINE_TYPE IMAGE_FILE_MACHINE_POWERPC
#else
#error( "unknown target machine" );
#endif
LONG
AppInvokeExceptionFilter(
LPEXCEPTION_POINTERS lpep
)
{
#if DBG == 1
BOOL rVal;
STACKFRAME StackFrame;
CONTEXT Context;
SymSetOptions( SYMOPT_UNDNAME );
SymInitialize( SYM_HANDLE, NULL, TRUE );
ZeroMemory( &StackFrame, sizeof(StackFrame) );
Context = *lpep->ContextRecord;
#if defined(_M_IX86)
StackFrame.AddrPC.Offset = Context.Eip;
StackFrame.AddrPC.Mode = AddrModeFlat;
StackFrame.AddrFrame.Offset = Context.Ebp;
StackFrame.AddrFrame.Mode = AddrModeFlat;
StackFrame.AddrStack.Offset = Context.Esp;
StackFrame.AddrStack.Mode = AddrModeFlat;
#endif
ComDebOut((DEB_FORCE,"An Exception occurred while calling into app\n"));
ComDebOut((DEB_FORCE,
"Exception address = 0x%x Exception number 0x%x\n",
lpep->ExceptionRecord->ExceptionAddress,
lpep->ExceptionRecord->ExceptionCode ));
ComDebOut((DEB_FORCE,"The following stack trace is where the exception occured\n"));
ComDebOut((DEB_FORCE,"Frame RetAddr mod!symbol\n"));
do
{
rVal = StackWalk(MACHINE_TYPE,SYM_HANDLE,0,&StackFrame,&Context,ReadProcessMemory,
SymFunctionTableAccess,SymGetModuleBase,NULL);
if (rVal)
{
DWORD dump[200];
ULONG Displacement;
PIMAGEHLP_SYMBOL sym = (PIMAGEHLP_SYMBOL) &dump;
IMAGEHLP_MODULE ModuleInfo;
LPSTR pModuleName = "???";
BOOL fSuccess;
sym->SizeOfStruct = sizeof(dump);
fSuccess = SymGetSymFromAddr(SYM_HANDLE,StackFrame.AddrPC.Offset,
&Displacement,sym);
//
// If there is module name information available, then grab it.
//
if(SymGetModuleInfo(SYM_HANDLE,StackFrame.AddrPC.Offset,&ModuleInfo))
{
pModuleName = ModuleInfo.ModuleName;
}
if (fSuccess)
{
ComDebOut((DEB_FORCE,
"%08x %08x %s!%s + %x\n",
StackFrame.AddrFrame.Offset,
StackFrame.AddrReturn.Offset,
pModuleName,
sym->Name,
Displacement));
}
else
{
ComDebOut((DEB_FORCE,
"%08x %08x %s!%08x\n",
StackFrame.AddrFrame.Offset,
StackFrame.AddrReturn.Offset,
pModuleName,
StackFrame.AddrPC.Offset));
}
}
} while( rVal );
SymCleanup( SYM_HANDLE );
#endif
return EXCEPTION_EXECUTE_HANDLER;
}
#endif // _CHICAGO_
/***************************************************************************/
#if DBG == 1
DWORD AppInvoke_break = 0;
DWORD AppInvoke_count = 0;
#endif
HRESULT StubInvoke(RPCOLEMESSAGE *pMsg, IRpcStubBuffer *pStub,
IRpcChannelBuffer *pChnl, DWORD *pdwFault)
{
ComDebOut((DEB_CHANNEL, "StubInvoke pMsg:%x pStub:%x pChnl:%x pdwFault:%x\n",
pMsg, pStub, pChnl, pdwFault));
ASSERT_LOCK_RELEASED
HRESULT hr;
#if DBG==1
DWORD dwMethod = pMsg->iMethod;
IID iidBeingCalled = ((RPC_SERVER_INTERFACE *) pMsg->reserved2[1])->InterfaceId.SyntaxGUID;
#endif
_try
{
TRACECALL(TRACE_RPC, "StubInvoke");
#if DBG == 1
//
// On a debug build, we are able to break on a call by serial number.
// This isn't really 100% thread safe, but is still extremely useful
// when debugging a problem.
//
DWORD dwBreakCount = ++AppInvoke_count;
ComDebOut((DEB_CHANNEL, "AppInvoke(0x%x) calling method 0x%x iid %I\n",
dwBreakCount,dwMethod, &iidBeingCalled));
if(AppInvoke_break == dwBreakCount)
{
DebugBreak();
}
#endif
#ifdef WX86OLE
if (! gcwx86.IsN2XProxy(pStub))
{
IUnknown *pActual;
hr = pStub->DebugServerQueryInterface((void **)&pActual);
if (SUCCEEDED(hr))
{
if (gcwx86.IsN2XProxy(pActual))
{
// If we are going to invoke a native stub that is
// connected to an object on the x86 side then
// set a flag in the Wx86 thread environment to
// let the thunk layer know that the call is a
// stub invoked call and allow any in or out
// custom interface pointers to be thunked as
// IUnknown rather than failing the interface thunking
gcwx86.SetStubInvokeFlag((BOOL)1);
}
pStub->DebugServerRelease(pActual);
}
}
#endif
hr = pStub->Invoke(pMsg, pChnl);
}
_except(AppInvokeExceptionFilter( GetExceptionInformation()))
{
hr = RPC_E_SERVERFAULT;
*pdwFault = GetExceptionCode();
#if DBG == 1
//
// OLE catches exceptions when the server generates them. This is so we can
// cleanup properly, and allow the client to continue.
//
if (*pdwFault == STATUS_ACCESS_VIOLATION ||
*pdwFault == STATUS_POSSIBLE_DEADLOCK ||
*pdwFault == STATUS_INSTRUCTION_MISALIGNMENT ||
*pdwFault == STATUS_DATATYPE_MISALIGNMENT )
{
WCHAR iidName[256];
iidName[0] = 0;
char achProgname[256];
achProgname[0] = 0;
GetModuleFileNameA(NULL,achProgname,sizeof(achProgname));
GetInterfaceName(iidBeingCalled,iidName);
ComDebOut((DEB_FORCE,
"OLE has caught a fault 0x%08x on behalf of the server %s\n",
*pdwFault,
achProgname));
ComDebOut((DEB_FORCE,
"The fault occured when OLE called the interface %I (%ws) method 0x%x\n",
&iidBeingCalled,iidName,dwMethod));
Win4Assert(!"The server application has faulted processing an inbound RPC request. Check the kernel debugger for useful output. OLE can continue but you probably want to stop and debug the application.");
}
#endif
}
ASSERT_LOCK_RELEASED
ComDebOut((DEB_CHANNEL, "StubInvoke hr:%x dwFault:%x\n", hr, *pdwFault));
return hr;
}
/***************************************************************************/
#if DBG==1
LONG ComInvokeExceptionFilter( DWORD lCode,
LPEXCEPTION_POINTERS lpep )
{
ComDebOut((DEB_ERROR, "Exception 0x%x in ComInvoke at address 0x%x\n",
lCode, lpep->ExceptionRecord->ExceptionAddress));
DebugBreak();
return EXCEPTION_EXECUTE_HANDLER;
}
#endif
/***************************************************************************/
HRESULT ComInvoke( CChannelCallInfo *call )
{
TRACECALL(TRACE_RPC, "ComInvoke");
ASSERT_LOCK_RELEASED
RPC_MESSAGE *message = (RPC_MESSAGE *) call->pmessage;
LocalThis *localb;
void *saved_buffer;
RPC_STATUS status;
HRESULT result;
IPIDEntry *ipid_entry = NULL;
CRpcChannelBuffer *server_channel = NULL;
DWORD TIDCallerSaved;
BOOL fLocalSaved;
UUID saved_threadid;
IUnknown *save_context;
DWORD saved_authn_level;
char *stub_data;
WireThis *inb = (WireThis *) message->Buffer;
OXIDEntry *oxid;
HANDLE hWakeup = NULL;
ComDebOut((DEB_CHANNEL, "ComInvoke callinfo:%x header:%x\n",
call, message->Buffer));
COleTls tls(result);
if (FAILED(result))
return result;
// Catch exceptions that might keep the lock.
#if DBG == 1
_try
{
#endif
// Find the IPID entry. Fail if the IPID or the OXID are not ready.
LOCK
ipid_entry = gIPIDTbl.LookupIPID( call->ipid );
Win4Assert( ipid_entry == NULL || ipid_entry->pOXIDEntry != NULL );
if (ipid_entry == NULL || (ipid_entry->dwFlags & IPIDF_DISCONNECTED) ||
(ipid_entry->pOXIDEntry->dwFlags & OXIDF_STOPPED) ||
ipid_entry->pChnl == NULL)
result = RPC_E_DISCONNECTED;
else if (ipid_entry->pStub == NULL)
result = E_NOINTERFACE;
// Keep the server object and our associated objects alive during the call.
if (SUCCEEDED(result))
{
oxid = ipid_entry->pOXIDEntry;
server_channel = ipid_entry->pChnl;
Win4Assert( server_channel != NULL && server_channel->pStdId != NULL );
server_channel->pStdId->LockServer();
InterlockedIncrement( &oxid->cCalls );
}
UNLOCK
ASSERT_LOCK_RELEASED
if (FAILED(result))
{
return result;
}
// Create a new security call context;
CServerSecurity security( call );
save_context = tls->pCallContext;
tls->pCallContext = &security;
// save the original threadid & copy in the new one.
if (!(tls->dwFlags & OLETLS_UUIDINITIALIZED))
{
UuidCreate(&tls->LogicalThreadId);
tls->dwFlags |= OLETLS_UUIDINITIALIZED;
}
saved_threadid = tls->LogicalThreadId;
tls->LogicalThreadId = inb->c.cid;
ComDebOut((DEB_CALLCONT, "ComInvoke: LogicalThreads Old:%I New:%I\n",
&saved_threadid, &tls->LogicalThreadId));
// Save the call info in TLS.
call->pNext = (CChannelCallInfo *) tls->pCallInfo;
tls->pCallInfo = call;
saved_authn_level = tls->dwAuthnLevel;
tls->dwAuthnLevel = call->lAuthnLevel;
// Call the channel hooks. Set up as much TLS data as possible before
// calling the hooks so they can access it.
result = ServerNotify(
((RPC_SERVER_INTERFACE *) message->RpcInterfaceInformation)->InterfaceId.SyntaxGUID,
(WireThis *) message->Buffer,
message->BufferLength,
(void **) &stub_data,
message->DataRepresentation );
// Find the local header.
if (inb->c.flags & ORPCF_LOCAL)
{
localb = (LocalThis *) stub_data;
stub_data += sizeof(LocalThis);
}
else
localb = NULL;
// Set the caller TID. This is needed by some interop code in order
// to do focus management via tying queues together. We first save the
// current one so we can restore later to deal with nested calls
// correctly.
TIDCallerSaved = tls->dwTIDCaller;
fLocalSaved = tls->dwFlags & OLETLS_LOCALTID;
tls->dwTIDCaller = localb != NULL ? localb->client_thread : 0;
if (call->iFlags & CF_PROCESS_LOCAL)
tls->dwFlags |= OLETLS_LOCALTID; // turn the local bit on
else
tls->dwFlags &= ~OLETLS_LOCALTID; // turn the local bit off
// Continue dispatching the call.
if (result == S_OK)
{
result = server_channel->AppInvoke(
call,
(IRpcStubBuffer *) ipid_entry->pStub,
ipid_entry->pv,
stub_data,
localb );
}
// Restore the original thread id, call info, dest context and thread id.
tls->LogicalThreadId = saved_threadid;
tls->pCallInfo = call->pNext;
tls->dwTIDCaller = TIDCallerSaved;
tls->dwAuthnLevel = saved_authn_level;
if (fLocalSaved)
tls->dwFlags |= OLETLS_LOCALTID;
else
tls->dwFlags &= ~OLETLS_LOCALTID;
// Restore the security context;
tls->pCallContext = save_context;
security.EndCall();
// Decrement the call count. If the MTA is waiting to uninitialize
// and this is the last call, wake up the uninitializing thread, but
// do this *after* calling UnLockServer so the other thread does not
// blow away the server.
if (InterlockedDecrement( &oxid->cCalls ) == 0 &&
(oxid->dwFlags & (OXIDF_MTASERVER | OXIDF_STOPPED)) == (OXIDF_MTASERVER | OXIDF_STOPPED))
hWakeup = oxid->hComplete;
// Release our hold on the object and channel.
server_channel->pStdId->UnLockServer();
if (hWakeup)
SetEvent(hWakeup);
// Catch exceptions that might keep the lock.
#if DBG == 1
}
_except( ComInvokeExceptionFilter(GetExceptionCode(),
GetExceptionInformation()) )
{
}
#endif
ASSERT_LOCK_RELEASED
return result;
}
/***************************************************************************/
CRpcChannelBuffer *CRpcChannelBuffer::Copy(OXIDEntry *pOXIDEntry,
REFIPID ripid, REFIID riid)
{
Win4Assert( !(state & server_cs) );
CRpcChannelBuffer *chan;
if (IsMTAThread())
{
// make client side multi-threaded apartment version of channel
chan = new CMTARpcChnl(pStdId, pOXIDEntry, state);
}
else
{
// make client side single-threaded apartment version of channel
chan = new CAptRpcChnl(pStdId, pOXIDEntry, state);
}
if (chan != NULL)
{
chan->state = proxy_cs | (state & ~client_cs);
chan->lAuthnLevel = lAuthnLevel;
}
return chan;
}
/***************************************************************************/
HRESULT CRpcChannelBuffer::InitClientSideHandle()
{
Win4Assert((state & proxy_cs));
ASSERT_LOCK_HELD
if (state & initialized_cs)
return S_OK;
// Lookup the interface info. This cant fail.
pInterfaceInfo = gRIFTbl.GetClientInterfaceInfo(pIPIDEntry->iid);
RPC_STATUS status;
#ifndef _CHICAGO_
if (state & process_local_cs)
{
handle = NULL;
status = RPC_S_OK;
}
else
#endif
{
status = RpcBindingCopy(pOXIDEntry->hServerSTA, &handle);
if (status == RPC_S_OK)
// If this is a single threaded apartment, give LRPC the blocking
// hook.
if (state & mswmsg_cs)
status = I_RpcBindingSetAsync(handle, OleModalLoopBlockFn);
#ifndef CHICAGO
// If the server is a single threaded apartment, tell LRPC to
// use MSWMSG to dispatch.
else if (pOXIDEntry->dwTid != 0)
status = I_RpcBindingSetAsync(handle, NULL);
#endif
if (status == RPC_S_OK)
status = RpcBindingSetObject(handle, (GUID *)&pIPIDEntry->ipid);
}
if (status == RPC_S_OK)
{
state |= initialized_cs;
return S_OK;
}
return MAKE_WIN32(status);
}
/***************************************************************************/
CRpcChannelBuffer::CRpcChannelBuffer(CStdIdentity *standard_identity,
OXIDEntry *pOXID,
DWORD eState )
{
ComDebOut((DEB_MARSHAL, "CRpcChannelBuffer %s Created this:%x pOXID:%x\n",
(eState & client_cs) ? "CLIENT" : "SERVER", this, pOXID));
// Fill in the easy fields first.
ref_count = 1;
pStdId = standard_identity;
handle = NULL;
pOXIDEntry = pOXID;
pIPIDEntry = NULL;
pInterfaceInfo = NULL;
hToken = NULL;
lAuthnLevel = gAuthnLevel;
state = eState;
state |= pOXID->dwPid == GetCurrentProcessId() ? process_local_cs : 0;
SetImpLevel( gImpLevel );
if ((pOXID->dwFlags & OXIDF_MSWMSG) && IsSTAThread())
{
// use MSWMSG protocol with the blocking hook
state |= mswmsg_cs;
}
if (state & (client_cs | proxy_cs))
{
// Determine the destination context.
if (pOXID->dwFlags & OXIDF_MACHINE_LOCAL)
if (!IsWOWThread() && (state & process_local_cs))
iDestCtx = MSHCTX_INPROC;
else
iDestCtx = MSHCTX_LOCAL;
else
iDestCtx = MSHCTX_DIFFERENTMACHINE;
}
else
{
// On the server side, the destination context isn't known
// untill a call arrives.
iDestCtx = 0;
}
}
/***************************************************************************/
CRpcChannelBuffer::~CRpcChannelBuffer()
{
ComDebOut((DEB_MARSHAL, "CRpcChannelBuffer %s Deleted this:%x\n",
(state & server_cs) ? "SERVER" : "CLIENT", this));
if (handle != NULL)
RpcBindingFree( &handle );
if (hToken != NULL)
CloseHandle( hToken );
}
/***************************************************************************/
STDMETHODIMP CRpcChannelBuffer::FreeBuffer( RPCOLEMESSAGE *pMessage )
{
TRACECALL(TRACE_RPC, "CRpcChannelBuffer::FreeBuffer");
ASSERT_LOCK_RELEASED
AssertValid(FALSE, TRUE);
if (pMessage->Buffer == NULL)
return S_OK;
// Pop the call stack.
COleTls tls;
Win4Assert( tls->pCallInfo != NULL );
working_call *pCall = (working_call *) tls->pCallInfo;
tls->pCallInfo = pCall->pNext;
tls->dwAuthnLevel = pCall->lSavedAuthnLevel;
pMessage->Buffer = pCall->pHeader;;
DeallocateBuffer(pCall->pmessage);
// Resume any outstanding impersonation.
ResumeImpersonate( tls->pCallContext, pCall->iFlags & CF_WAS_IMPERSONATING );
// Release the AddRef we did earlier. Note that we cant do this until
// after DeallocateBuffer since it may release a binding handle that
// I_RpcFreeBuffer needs.
if (pCall->Locked())
pStdId->UnLockClient();
pMessage->Buffer = NULL;
delete pCall;
ASSERT_LOCK_RELEASED
return S_OK;
}
//-------------------------------------------------------------------------
//
// Member: CRpcChannelBuffer::GetBuffer
//
// Synopsis: Calls ClientGetBuffer or ServerGetBuffer
//
//-------------------------------------------------------------------------
STDMETHODIMP CRpcChannelBuffer::GetBuffer( RPCOLEMESSAGE *pMessage,
REFIID riid )
{
gOXIDTbl.ValidateOXID();
if (state & proxy_cs)
return ClientGetBuffer( pMessage, riid );
else
return ServerGetBuffer( pMessage, riid );
}
//-------------------------------------------------------------------------
//
// Member: CRpcChannelBuffer::ClientGetBuffer
//
// Synopsis: Gets a buffer and sets up client side stuff
//
//-------------------------------------------------------------------------
HRESULT CRpcChannelBuffer::ClientGetBuffer( RPCOLEMESSAGE *pMessage,
REFIID riid )
{
TRACECALL(TRACE_RPC, "CRpcChannelBuffer::ClientGetBuffer");
ASSERT_LOCK_RELEASED
RPC_STATUS status;
CALLCATEGORY callcat = CALLCAT_SYNCHRONOUS;
ULONG debug_size;
ULONG num_extent;
WireThis *inb;
LocalThis *localb;
IID *logical_thread;
working_call *call;
DWORD flags;
BOOL resume;
DWORD orig_size = pMessage->cbBuffer;
COleTls tls;
Win4Assert(state & proxy_cs);
AssertValid(FALSE, TRUE);
// Don't allow remote calls if DCOM is disabled.
if (gDisableDCOM && iDestCtx == MSHCTX_DIFFERENTMACHINE)
return RPC_E_REMOTE_DISABLED;
// Fetch the call category from the RPC message structure
if (pMessage->rpcFlags & RPCFLG_ASYNCHRONOUS)
{
// only allow async for these two interfaces for now
if (riid != IID_IAdviseSink && riid != IID_IAdviseSink2)
return E_UNEXPECTED;
callcat = CALLCAT_ASYNC;
}
else
{
logical_thread = TLSGetLogicalThread();
if (logical_thread == NULL)
{
return RPC_E_OUT_OF_RESOURCES;
}
if (pMessage->rpcFlags & RPCFLG_INPUT_SYNCHRONOUS)
{
callcat = CALLCAT_INPUTSYNC;
}
}
// Set the buffer complete flag for local calls.
pMessage->rpcFlags |= RPC_BUFFER_COMPLETE;
// Note - RPC requires that the 16th bit of the proc num be set because
// we use the rpcFlags field of the RPC_MESSAGE struct.
pMessage->iMethod |= RPC_FLAGS_VALID_BIT;
// if service object of destination is in same process, definitely local
// calls; async calls are also forced to be local.
if (state & process_local_cs)
{
pMessage->rpcFlags |= RPCFLG_LOCAL_CALL;
flags = CF_PROCESS_LOCAL;
}
else
flags = 0;
// Find out if we need hook data.
debug_size = ClientGetSize( riid, &num_extent );
LOCK
// Complete the channel initialization if needed.
status = InitClientSideHandle();
if (status != RPC_S_OK)
{
UNLOCK;
ASSERT_LOCK_RELEASED;
return status;
}
// Fill in the binding handle. Adjust the size. Clear the transfer
// syntax. Set the interface identifier.
if ((pMessage->rpcFlags & RPCFLG_LOCAL_CALL) == 0)
pMessage->reserved1 = handle;
pMessage->cbBuffer += SIZENEEDED_ORPCTHIS( pOXIDEntry->dwFlags & OXIDF_MACHINE_LOCAL,
debug_size );
pMessage->reserved2[0] = 0;
pMessage->reserved2[1] = pInterfaceInfo;
Win4Assert( pMessage->reserved2[1] != NULL );
// Allocate a call record.
call = new working_call( callcat, pMessage, flags, pIPIDEntry->ipid,
iDestCtx, this, lAuthnLevel );
pMessage->cbBuffer = orig_size;
UNLOCK
ASSERT_LOCK_RELEASED
if (call == NULL)
return E_OUTOFMEMORY;
// Suspend any outstanding impersonation and ignore failures.
SuspendImpersonate( tls->pCallContext, &resume );
// Get a buffer.
if (call->pmessage->rpcFlags & RPCFLG_LOCAL_CALL)
{
// NDR_DREP_ASCII | NDR_DREP_LITTLE_ENDIAN | NDR_DREP_IEEE
call->pmessage->dataRepresentation = 0x00 | 0x10 | 0x0000;
call->pmessage->Buffer = PrivMemAlloc8( call->pmessage->cbBuffer );
if (call->pmessage->Buffer == NULL)
status = RPC_S_OUT_OF_MEMORY;
else
status = RPC_S_OK;
}
else
{
TRACECALL(TRACE_RPC, "I_RpcGetBuffer");
status = I_RpcGetBuffer( (RPC_MESSAGE *) call->pmessage );
}
if (status != RPC_S_OK)
{
// Resume any outstanding impersonation.
ResumeImpersonate( tls->pCallContext, resume );
// Cleanup.
pMessage->cbBuffer = 0;
tls->fault = MAKE_WIN32( status );
delete call;
return MAKE_WIN32( status );
}
// Save the impersonation flag.
if (resume)
call->iFlags |= CF_WAS_IMPERSONATING;
// Chain the call info in TLS.
call->pNext = (CChannelCallInfo *)tls->pCallInfo;
tls->pCallInfo = call;
call->pHeader = call->message.Buffer;
// Adjust the authentication level in TLS.
call->lSavedAuthnLevel = tls->dwAuthnLevel;
tls->dwAuthnLevel = lAuthnLevel;
// Fill in the COM header.
pMessage->Buffer = call->message.Buffer;
inb = (WireThis *) pMessage->Buffer;
inb->c.version.MajorVersion = COM_MAJOR_VERSION;
inb->c.version.MinorVersion = COM_MINOR_VERSION;
inb->c.reserved1 = 0;
// Generate a new logical thread for async calls.
if (callcat == CALLCAT_ASYNC)
UuidCreate( &inb->c.cid );
// Find the logical thread id.
else
inb->c.cid = *logical_thread;
if (pOXIDEntry->dwFlags & OXIDF_MACHINE_LOCAL)
inb->c.flags = ORPCF_LOCAL;
else
inb->c.flags = ORPCF_NULL;
// Fill in any hook data and adjust the buffer pointer.
if (debug_size != 0)
{
pMessage->Buffer = FillBuffer( riid, &inb->d.ea, debug_size, num_extent,
TRUE );
inb->c.unique = 0x77646853; // Any non-zero value.
}
else
{
pMessage->Buffer = (void *) &inb->d.ea;
inb->c.unique = FALSE;
}
// Fill in the local header.
if (pOXIDEntry->dwFlags & OXIDF_MACHINE_LOCAL)
{
localb = (LocalThis *) pMessage->Buffer;
localb->client_thread = GetCurrentApartmentId();
localb->flags = 0;
pMessage->Buffer = localb + 1;
if (callcat == CALLCAT_ASYNC)
inb->c.flags |= ORPCF_ASYNC;
else if (callcat == CALLCAT_INPUTSYNC)
inb->c.flags |= ORPCF_INPUT_SYNC;
// if the caller is using a non-NDR proxy, set a bit in the local
// header flags so that server side stub knows which way to unmarshal
// the parameters. This lets a 32bit server simultaneously service calls
// from 16bit non-NDR clients and 32bit NDR clients, in particular, to
// support OLE Automation.
if (pIPIDEntry->dwFlags & (IPIDF_NONNDRPROXY | IPIDF_NONNDRSTUB))
localb->flags |= LOCALF_NONNDR;
}
ComDebOut((DEB_CALLCONT, "ClientGetBuffer: LogicalThreadId:%I\n",
&(tls->LogicalThreadId)));
ASSERT_LOCK_RELEASED
return S_OK;
}
//-------------------------------------------------------------------------
//
// Member: CRpcChannelBuffer::ServerGetBuffer
//
// Synopsis: Gets a buffer and sets up server side stuff
//
//-------------------------------------------------------------------------
HRESULT CRpcChannelBuffer::ServerGetBuffer( RPCOLEMESSAGE *pMessage,
REFIID riid )
{
TRACECALL(TRACE_RPC, "CRpcChannelBuffer::ServerGetBuffer");
ASSERT_LOCK_RELEASED
RPC_STATUS status;
ULONG debug_size;
ULONG num_extent;
HRESULT result = S_OK;
WireThis *inb;
WireThat *outb;
CChannelCallInfo *call;
void *stub_data;
DWORD orig_size = pMessage->cbBuffer;
Win4Assert( state & server_cs );
AssertValid(FALSE, TRUE);
// Get the call info from TLS.
COleTls tls;
call = (CChannelCallInfo *) tls->pCallInfo;
Win4Assert( call != NULL );
// Find out if we need debug data.
pMessage->Buffer = call->pHeader;
debug_size = ServerGetSize( riid, &num_extent );
// Adjust the buffer size.
pMessage->cbBuffer += SIZENEEDED_ORPCTHAT( debug_size );
// Get a buffer.
if (pMessage->rpcFlags & RPCFLG_LOCAL_CALL)
{
// NDR_DREP_ASCII | NDR_DREP_LITTLE_ENDIAN | NDR_DREP_IEEE
pMessage->dataRepresentation = 0x00 | 0x10 | 0x0000;
pMessage->Buffer = PrivMemAlloc8( pMessage->cbBuffer );
if (pMessage->Buffer == NULL)
status = RPC_S_OUT_OF_MEMORY;
else
status = RPC_S_OK;
}
else
{
TRACECALL(TRACE_RPC, "I_RpcGetBuffer");
status = I_RpcGetBuffer( (RPC_MESSAGE *) pMessage );
Win4Assert( call->pHeader != pMessage->Buffer || status != RPC_S_OK );
}
if (status != RPC_S_OK)
{
pMessage->cbBuffer = 0;
pMessage->Buffer = NULL;
tls->fault = MAKE_WIN32( status );
return MAKE_WIN32( status );
}
// Fill in the outbound COM header.
call->pHeader = pMessage->Buffer;
outb = (WireThat *) pMessage->Buffer;
outb->c.flags = ORPCF_NULL;
pMessage->cbBuffer = orig_size;
if (debug_size != 0)
{
stub_data = FillBuffer( riid, &outb->d.ea, debug_size, num_extent, FALSE );
outb->c.unique = 0x77646853; // Any non-zero value.
pMessage->Buffer = stub_data;
}
else
{
outb->c.unique = 0;
pMessage->Buffer = &outb->d.ea;
}
ComDebOut((DEB_CALLCONT, "ServerGetBuffer: LogicalThreadId:%I\n",
&(tls->LogicalThreadId)));
ASSERT_LOCK_RELEASED
return S_OK;
}
/***************************************************************************/
STDMETHODIMP CRpcChannelBuffer::GetDestCtx( DWORD FAR* lpdwDestCtx,
LPVOID FAR* lplpvDestCtx )
{
TRACECALL(TRACE_RPC, "CRpcChannelBuffer::GetDestCtx");
AssertValid(FALSE, FALSE);
// On the client side, get the destination context from the channel.
if (state & (client_cs | proxy_cs))
{
*lpdwDestCtx = iDestCtx;
}
// On the server side, get the destination context from TLS.
else
{
COleTls tls;
Win4Assert( tls->pCallInfo != NULL );
*lpdwDestCtx = ((CChannelCallInfo *) tls->pCallInfo)->iDestCtx;
}
if (lplpvDestCtx != NULL)
*lplpvDestCtx = NULL;
return S_OK;
}
/***************************************************************************/
STDMETHODIMP CRpcChannelBuffer::IsConnected( THIS )
{
// must be on right thread because it is only called by proxies and stubs.
AssertValid(FALSE, TRUE);
// Server channels never know if they are connected. The only time the
// client side knows it is disconnected is after the standard identity
// has disconnected the proxy from the channel. In that case it doesn't
// matter.
return S_OK;
}
/***************************************************************************/
STDMETHODIMP CRpcChannelBuffer::QueryInterface( THIS_ REFIID riid, LPVOID FAR* ppvObj)
{
AssertValid(FALSE, FALSE);
// IMarshal is queried more frequently than any other interface, so
// check for that first.
if (IsEqualIID(riid, IID_IMarshal))
{
*ppvObj = (IMarshal *) this;
}
else if (IsEqualIID(riid, IID_IUnknown) ||
IsEqualIID(riid, IID_IRpcChannelBuffer))
{
*ppvObj = (IRpcChannelBuffer *) this;
}
else if (IsEqualIID(riid, IID_INonNDRStub) &&
(state & proxy_cs) && pIPIDEntry &&
(pIPIDEntry->dwFlags & IPIDF_NONNDRSTUB))
{
// this interface is used to tell proxies whether the server side speaks
// NDR or not. Returns S_OK if NOT NDR.
*ppvObj = (IUnknown *) this;
}
else
{
*ppvObj = NULL;
return E_NOINTERFACE;
}
AddRef();
return S_OK;
}
/***************************************************************************/
STDMETHODIMP_(ULONG) CRpcChannelBuffer::Release( THIS )
{
// can't call AssertValid(FALSE) since it is used in asserts
ULONG lRef = ref_count - 1;
if (InterlockedDecrement( (long*) &ref_count ) == 0)
{
delete this;
return 0;
}
else
{
return lRef;
}
}
/***************************************************************************/
STDMETHODIMP CRpcChannelBuffer::SendReceive( THIS_ RPCOLEMESSAGE *pMessage,
ULONG *status )
{
return CRpcChannelBuffer::SendReceive2(pMessage, status);
}
/***************************************************************************/
STDMETHODIMP CRpcChannelBuffer::SendReceive2( THIS_ RPCOLEMESSAGE *pMessage,
ULONG *status )
{
TRACECALL(TRACE_RPC, "CRpcChannelBuffer::SendReceive");
ComDebOut((DEB_CHANNEL, "CRpcChannelBuffer::SendReceive pChnl:%x pMsg:%x\n",
this, pMessage));
AssertValid(FALSE, TRUE);
Win4Assert( state & proxy_cs );
gOXIDTbl.ValidateOXID();
ASSERT_LOCK_RELEASED
HRESULT result;
working_call *call;
working_call *next_call;
IID iid;
WireThis *inb;
WireThat *outb;
DWORD saved_authn_level;
BOOL resume;
char *stub_data;
// Get the information about the call stored in TLS
COleTls tls;
call = (working_call *) tls->pCallInfo;
Win4Assert( call != NULL );
next_call = (working_call *) call->pNext;
saved_authn_level = call->lSavedAuthnLevel;
resume = call->iFlags & CF_WAS_IMPERSONATING;
// Set up the header pointers.
inb = (WireThis *) call->pHeader;
iid =
((RPC_CLIENT_INTERFACE *) ((RPC_MESSAGE *) call->pmessage)->RpcInterfaceInformation)->InterfaceId.SyntaxGUID;
// we must ensure that we dont go away during this call. we will Release
// ourselves in the FreeBuffer call, or in the error handling at the
// end of this function.
pStdId->LockClient();
#if DBG==1
DWORD CallCat = GetCallCat( inb );
DebugPrintORPCCall(ORPC_SENDRECEIVE_BEGIN, iid, call->message.iMethod, CallCat);
RpcSpy((CALLOUT_BEGIN, inb, iid, call->message.iMethod, 0));
#endif
// Send the request.
if ((state & mswmsg_cs) || (IsMTAThread() && !call->Local()))
{
// For MSWMSG or non-local MTA, call ThreadSendReceive directly.
result = ThreadSendReceive( call );
}
else
{
if (call->Local())
call->message.reserved2[3] = NULL;
if (IsMTAThread())
{
LOCK
result = GetToSTA( pOXIDEntry, call);
UNLOCK
}
else
{
result = SwitchSTA( pOXIDEntry, (CChannelCallInfo **) &call );
}
}
#if DBG==1
DebugPrintORPCCall(ORPC_SENDRECEIVE_END, iid, pMessage->iMethod, CallCat);
RpcSpy((CALLOUT_END, inb, iid, pMessage->iMethod, result));
#endif
// We can't look at the call structure if the call was canceled.
if (result != RPC_E_CALL_CANCELED)
{
// Get the reply header if there is a reply buffer.
if ((state & mswmsg_cs) && (pMessage->rpcFlags & RPCFLG_ASYNCHRONOUS))
outb = NULL;
else
outb = (WireThat *) call->message.Buffer;
// Local calls reuse pNext on the server side.
call->pNext = next_call;
// Save the real buffer pointer for FreeBuffer.
call->pHeader = call->message.Buffer;
}
else
outb = NULL;
// Figure out when to retry.
// FreeThreaded - treat retry as a failure.
// Apartment - return the buffer and let call control decide.
if (result == S_OK)
{
// No buffer was returned for async calls on MSWMSG.
if (outb == NULL)
*status = S_OK;
else if (IsMTAThread())
{
if (outb->c.flags & ORPCF_REJECTED)
result = RPC_E_CALL_REJECTED;
else if (outb->c.flags & ORPCF_RETRY_LATER)
result = RPC_E_SERVERCALL_RETRYLATER;
else
*status = S_OK;
}
else if (outb->c.flags & ORPCF_REJECTED)
*status = (ULONG) RPC_E_CALL_REJECTED;
else if (outb->c.flags & ORPCF_RETRY_LATER)
*status = (ULONG) RPC_E_SERVERCALL_RETRYLATER;
else
*status = S_OK;
}
// Check the packet extensions.
if (result != RPC_E_CALL_CANCELED)
{
stub_data = (char *) call->message.Buffer;
result = ClientNotify( iid, outb, call->message.cbBuffer,
(void **) &stub_data,
call->message.dataRepresentation,
result );
}
else
result = ClientNotify( iid, outb, 0, (void **) &stub_data, 0, result );
// Call succeeded.
if (result == S_OK && outb != NULL)
{
// The locked flag lets FreeBuffer know that it has to call
// RH->UnlockClient.
call->iFlags |= CF_LOCKED;
pMessage->Buffer = stub_data;
pMessage->cbBuffer = call->message.cbBuffer -
(stub_data - (char *) call->message.Buffer);
pMessage->dataRepresentation = call->message.dataRepresentation;
result = *status;
// Copy a portion of the message structure that RPC updated on SendReceive.
// This is needed to free the buffer. Note that we still have to free
// the buffer in certain failure cases (reject).
pMessage->reserved2[2] = call->message.reserved2[2];
}
else
{
// Resume any outstanding impersonation.
ResumeImpersonate( tls->pCallContext, resume );
// Clean up the call.
pStdId->UnLockClient();
tls->pCallInfo = next_call;
tls->dwAuthnLevel = saved_authn_level;
delete call;
// Make sure FreeBuffer doesn't try to free the in buffer.
pMessage->Buffer = NULL;
// If the result is server fault, get the exception code from the CChannelCallInfo.
if (result == RPC_E_SERVERFAULT)
{
*status = call->server_fault;
}
// Everything else is a comm fault.
else if (result != S_OK)
{
*status = result;
result = RPC_E_FAULT;
}
tls->fault = *status;
// Since result is almost always mapped to RPC_E_FAULT, display the
// real error here to assist debugging.
if (*status != S_OK)
ComDebOut((DEB_CHANNEL, "ORPC call failed. status = %x\n", *status));
}
ASSERT_LOCK_RELEASED
gOXIDTbl.ValidateOXID();
ComDebOut((DEB_CHANNEL, "CRpcChannelBuffer::SendReceive hr:%x\n", result));
return result;
}
/***************************************************************************/
HANDLE CRpcChannelBuffer::SwapSecurityToken( HANDLE hNew )
{
HANDLE hOld = hToken;
hToken = hNew;
return hOld;
}
#if DBG == 1
//+-------------------------------------------------------------------
//
// Member: CRpcChannelBuffer::AssertValid
//
// Synopsis: Validates that the state of the object is consistent.
//
// History: 25-Jan-94 CraigWi Created.
//
// DCOMWORK - Put in some asserts.
//
//--------------------------------------------------------------------
void CRpcChannelBuffer::AssertValid(BOOL fKnownDisconnected,
BOOL fMustBeOnCOMThread)
{
Win4Assert(state & (proxy_cs | client_cs | server_cs ));
if (state & (client_cs | proxy_cs))
{
;
}
else if (state & server_cs)
{
Win4Assert( !(state & freethreaded_cs) );
if (fMustBeOnCOMThread && IsSTAThread())
Win4Assert(IsMTAThread() || pOXIDEntry->dwTid == GetCurrentThreadId());
// ref count can be 0 in various stages of connection and disconnection
Win4Assert(ref_count < 0x7fff && "Channel ref count unreasonably high");
// the pStdId pointer can not be NULL
// Win4Assert(IsValidInterface(pStdId));
}
}
#endif // DBG == 1
/***************************************************************************/
STDAPI_(ULONG) DebugCoGetRpcFault()
{
HRESULT hr;
COleTls tls(hr);
if (SUCCEEDED(hr))
return tls->fault;
return 0;
}
/***************************************************************************/
STDAPI_(void) DebugCoSetRpcFault( ULONG fault )
{
HRESULT hr;
COleTls tls(hr);
if (SUCCEEDED(hr))
tls->fault = fault;
}
/***************************************************************************/
extern "C"
BOOL _stdcall DllDebugObjectRPCHook( BOOL trace, LPORPC_INIT_ARGS pass_through )
{
if (!IsWOWThread())
{
DoDebuggerHooks = trace;
DebuggerArg = pass_through;
return TRUE;
}
else
return FALSE;
}
/***************************************************************************/
BOOL LocalCall()
{
CChannelCallInfo *call;
// Get the call info from TLS.
COleTls tls;
call = (CChannelCallInfo *) tls->pCallInfo;
Win4Assert( call != NULL );
return call->iFlags & CF_PROCESS_LOCAL;
}
/***************************************************************************/
LONG ThreadInvokeExceptionFilter( DWORD lCode,
LPEXCEPTION_POINTERS lpep )
{
ComDebOut((DEB_ERROR, "Exception 0x%x in ThreadInvoke at address 0x%x\n",
lCode, lpep->ExceptionRecord->ExceptionAddress));
DebugBreak();
return EXCEPTION_EXECUTE_HANDLER;
}
/***************************************************************************/
/* This routine returns both comm status and server faults to the runtime
by raising exceptions. If FreeThreading is true, ComInvoke will throw
exceptions to indicate server faults. These will not be caught and will
propogate directly to the runtime. If FreeThreading is false, ComInvoke
will return the result and fault in the CChannelCallInfo record.
NOTE:
This function switches to the 32 bit stack under WIN95.
An exception has to be caught while switched to the 32 bit stack.
The exceptions has to be pass as a value and rethrown again on the
16 bit stack (see SSInvoke in stkswtch.cxx)
*/
#ifdef _CHICAGO_
DWORD
#else
void
#endif
SSAPI(ThreadInvoke)(RPC_MESSAGE *message )
{
HRESULT result = S_OK;
TRACECALL(TRACE_RPC, "ThreadInvoke");
ComDebOut((DEB_CHANNEL,"ThreadInvoke pMsg:%x\n", message));
gOXIDTbl.ValidateOXID();
ASSERT_LOCK_RELEASED
BOOL success;
WireThis *inb = (WireThis *) message->Buffer;
IPID ipid;
RPC_STATUS status;
OXIDEntry *pOxid;
unsigned int transport_type;
DWORD authn_level;
// Byte swap the header.
ByteSwapThis( message->DataRepresentation, inb );
// Validate several things:
// The packet size is larger then the first header size.
// No extra flags are set.
// The procedure number is greater then 2 (not QI, AddRef, Release).
if (sizeof(WireThisPart1) > message->BufferLength ||
(inb->c.flags & ~(ORPCF_LOCAL | ORPCF_RESERVED1 |
ORPCF_RESERVED2 | ORPCF_RESERVED3 | ORPCF_RESERVED4)) != 0 ||
message->ProcNum < 3)
RETURN_COMM_STATUS( RPC_E_INVALID_HEADER );
// Validate the version.
if (inb->c.version.MajorVersion != COM_MAJOR_VERSION ||
inb->c.version.MinorVersion > COM_MINOR_VERSION)
RETURN_COMM_STATUS( RPC_E_VERSION_MISMATCH );
// Get the transport the call arrived on.
status = I_RpcServerInqTransportType( &transport_type );
if (status != RPC_S_OK)
RETURN_COMM_STATUS( RPC_E_SYS_CALL_FAILED );
// Don't accept the local header on remote calls.
if (inb->c.flags & ORPCF_LOCAL)
{
if (transport_type != TRANSPORT_TYPE_LPC &&
transport_type != TRANSPORT_TYPE_WMSG)
RETURN_COMM_STATUS( RPC_E_INVALID_HEADER );
// For local calls the authentication level will always be encrypt.
authn_level = RPC_C_AUTHN_LEVEL_PKT_PRIVACY;
}
// Don't accept remote calls if DCOM is diabled.
else if (gDisableDCOM &&
(transport_type == TRANSPORT_TYPE_CN || transport_type == TRANSPORT_TYPE_DG))
RETURN_COMM_STATUS( RPC_E_CALL_REJECTED );
// Lookup the authentication level.
else
{
result = RpcBindingInqAuthClient( message->Handle, NULL,
NULL, &authn_level, NULL, NULL );
if (result == RPC_S_BINDING_HAS_NO_AUTH)
authn_level = RPC_C_AUTHN_LEVEL_NONE;
else if (result != RPC_S_OK)
{
Win4Assert( result == RPC_S_OUT_OF_RESOURCES );
RETURN_COMM_STATUS( MAKE_WIN32( result ) );
}
// Verify the authentication level.
if (gAuthnLevel > RPC_C_AUTHN_LEVEL_NONE ||
gImpLevel > 0)
{
if (authn_level < gAuthnLevel)
RETURN_COMM_STATUS( RPC_E_ACCESS_DENIED );
}
}
#if DBG==1
_try
{
#endif
// Find the ipid entry from the ipid.
status = RpcBindingInqObject( message->Handle, &ipid );
if (status == RPC_S_OK)
{
// The CChannelCallInfo is created in a nested scope so that it
// is destroyed before the calls to throw an exception at the
// end of this function.
CChannelCallInfo call(
GetCallCat( inb ),
(RPCOLEMESSAGE *) message,
0,
ipid,
(inb->c.flags & ORPCF_LOCAL) ? MSHCTX_LOCAL : MSHCTX_DIFFERENTMACHINE,
NULL,
authn_level );
// Find the OXIDEntry of the server apartment.
ASSERT_LOCK_RELEASED
LOCK
IPIDEntry *ipid_entry = gIPIDTbl.LookupIPID( ipid );
if (ipid_entry == NULL || (ipid_entry->dwFlags & IPIDF_DISCONNECTED)
|| ipid_entry->pChnl == NULL )
{
UNLOCK
ASSERT_LOCK_RELEASED
result = RPC_E_DISCONNECTED;
}
else
{
pOxid = ipid_entry->pOXIDEntry;
// NCALRPC always gets the thread right (except on Chicago).
// For MTAs, any thread will do.
if (transport_type == TRANSPORT_TYPE_WMSG ||
#ifndef _CHICAGO_
transport_type == TRANSPORT_TYPE_LPC ||
#endif
(pOxid->dwFlags & OXIDF_MTASERVER))
{
UNLOCK
ASSERT_LOCK_RELEASED
result = ComInvoke( &call );
}
else
{
// Pass the message to the app thread.
IncOXIDRefCnt( pOxid );
result = GetToSTA( pOxid, &call );
DecOXIDRefCnt( pOxid );
UNLOCK
ASSERT_LOCK_RELEASED
}
}
}
else
{
result = MAKE_WIN32( status );
}
#if DBG==1
}
_except( ThreadInvokeExceptionFilter(GetExceptionCode(),
GetExceptionInformation()) )
{
}
#endif
// For comm and server faults, generate an exception. Otherwise the buffer
// is set up correctly.
gOXIDTbl.ValidateOXID();
if (result == RPC_E_SERVERFAULT)
{
ASSERT_LOCK_RELEASED
RETURN_COMM_STATUS( RPC_E_SERVERFAULT );
}
else if (result != S_OK)
{
ASSERT_LOCK_RELEASED
RETURN_COMM_STATUS( result );
}
#ifdef _CHICAGO_
return 0;
#endif //_CHICAGO_
}
/***************************************************************************/
HRESULT ThreadSendReceive( CChannelCallInfo *call )
{
TRACECALL(TRACE_RPC, "ThreadSendReceive");
ComDebOut((DEB_CHANNEL, "ThreadSendReceive pCall:%x\n", call));
ASSERT_LOCK_RELEASED
HRESULT result;
RPCOLEMESSAGE *message = call->pmessage;
WireThat *outb;
// Call the runtime. In the future, detect server faults and
// change the value of result to RPC_E_SERVERFAULT.
if (call->pChannel->state & mswmsg_cs)
{
CAptCallCtrl *pACC = GetAptCallCtrl();
CCliModalLoop *pCML = (pACC) ? pACC->GetTopCML() : NULL;
OXIDEntry *pOxidClient;
HWND hwnd = NULL;
if (IsWOWThread())
{
LOCK
result = gOXIDTbl.GetLocalEntry( &pOxidClient );
UNLOCK
Win4Assert( result == S_OK );
hwnd = (HWND) pOxidClient->hServerSTA;
}
TRACECALL(TRACE_RPC, "I_RpcAsyncSendReceive");
result = I_RpcAsyncSendReceive( (RPC_MESSAGE *) message, pCML, hwnd );
// If the call was canceled, the rest of the code path assumes that
// the call was deleted (by SwitchComThread). So delete it.
if (result == RPC_S_CALL_CANCELLED)
{
// Convert the win32 error to a hresult.
result = RPC_E_CALL_CANCELED;
delete call;
}
}
else
{
TRACECALL(TRACE_RPC, "I_RpcSendReceive");
result = I_RpcSendReceive( (RPC_MESSAGE *) message );
}
// If the result is small, it is probably a Win32 code.
if (result != 0)
{
message->Buffer = NULL;
if ((ULONG) result > 0xfffffff7 || (ULONG) result < 0x2000)
result = MAKE_WIN32( result );
}
else
{
// No buffer is returned for asynchronous calls on MSWMSG.
if ((call->pChannel->state & mswmsg_cs) == 0 ||
(message->rpcFlags & RPCFLG_ASYNCHRONOUS) == 0)
{
// Byte swap the reply header. Fail the call if the buffer is too
// small.
outb = (WireThat *) message->Buffer;
if (message->cbBuffer >= sizeof(WireThatPart1))
ByteSwapThat( message->dataRepresentation, outb);
else
result = RPC_E_INVALID_HEADER;
}
}
ComDebOut((DEB_CHANNEL, "ThreadSendReceive pCall:%x hr:%x\n", call, result));
return result;
}
/***************************************************************************/
/* static */
void working_call::Cleanup()
{
ASSERT_LOCK_HELD
DWORD i;
// Release everything.
if (next <= CALLCACHE_SIZE)
{
for (i = 0; i < next; i++)
if (list[i] != NULL)
{
PrivMemFree( list[i] );
list[i] = NULL;
}
next = 0;
}
}
/***************************************************************************/
/* static */
void working_call::Initialize()
{
ASSERT_LOCK_HELD
next = 0;
}
//---------------------------------------------------------------------------
//
// Method: working_call:: operator delete
//
// Synopsis: Cache or actually free a working call.
//
// Notes: gComLock need not be held before calling this function.
//
//---------------------------------------------------------------------------
void working_call::operator delete( void *call )
{
// Add the structure to the list if the list is not full and
// if the process is still initialized (since latent threads may try
// to return stuff).
LOCK
if (next < CALLCACHE_SIZE && gfChannelProcessInitialized)
{
list[next] = call;
next += 1;
}
// Otherwise just free it.
else
{
PrivMemFree( call );
}
UNLOCK
}
//---------------------------------------------------------------------------
//
// Method: working_call:: operator new
//
// Synopsis: Keep a cache of working_calls. Since the destructor is
// virtual, the correct delete will be called if any base
// class is deleted.
//
// Notes: gComLock must be held before calling this function.
//
//---------------------------------------------------------------------------
void *working_call::operator new( size_t size )
{
ASSERT_LOCK_HELD
void *call;
// Get the last entry from the cache.
Win4Assert( size == sizeof( working_call ) );
if (next > 0 && next < CALLCACHE_SIZE+1)
{
next -= 1;
call = list[next];
list[next] = NULL;
}
// If there are none, allocate a new one.
else
call = PrivMemAlloc(size);
return call;
}
/**********************************************************************/
working_call::working_call( CALLCATEGORY callcat,
RPCOLEMESSAGE *original_msg,
DWORD flags,
REFIPID ipidServer,
DWORD destctx,
CRpcChannelBuffer *channel,
DWORD authn_level ) :
CChannelCallInfo( callcat, &message, flags, ipidServer, destctx, channel,
authn_level )
{
message = *original_msg;
}
rpc消息调用具体实现
猜你喜欢
转载自blog.csdn.net/oShuangYue12/article/details/81035014
今日推荐
周排行