You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
347 lines
10 KiB
347 lines
10 KiB
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
Copyright (c) 1993 - 2000 Microsoft Corporation
|
|
|
|
Module Name :
|
|
|
|
cltcall.c
|
|
|
|
Abstract :
|
|
|
|
This file contains the single call Ndr64 routine for the client side.
|
|
|
|
Author :
|
|
|
|
David Kays dkays October 1993.
|
|
|
|
Revision History :
|
|
|
|
brucemc 11/15/93 Added struct by value support, corrected
|
|
varargs use.
|
|
brucemc 12/20/93 Binding handle support
|
|
ryszardk 3/12/94 handle optimization and fixes
|
|
|
|
---------------------------------------------------------------------*/
|
|
#include "precomp.hxx"
|
|
|
|
#define CINTERFACE
|
|
#define USE_STUBLESS_PROXY
|
|
|
|
#include <stdarg.h>
|
|
#include "hndl.h"
|
|
#include "interp2.h"
|
|
#include "pipendr.h"
|
|
|
|
#include "ndrole.h"
|
|
#include "rpcproxy.h"
|
|
|
|
#pragma code_seg(".ndr64")
|
|
|
|
#define NDR_MAX_RESEND_COUNT 5
|
|
|
|
#define WIN32RPC
|
|
#include "rpcerrp.h"
|
|
|
|
|
|
void
|
|
Ndr64ClearOutParameters(
|
|
PMIDL_STUB_MESSAGE pStubMsg,
|
|
PNDR64_FORMAT pFormat,
|
|
uchar * pArg
|
|
)
|
|
/*++
|
|
|
|
Routine Description :
|
|
|
|
Free and clear an [out] parameter in case of exceptions for object
|
|
interfaces.
|
|
|
|
Arguments :
|
|
|
|
pStubMsg - pointer to stub message structure
|
|
pFormat - The format string offset
|
|
pArg - The [out] pointer to clear.
|
|
|
|
Return :
|
|
|
|
NA
|
|
|
|
Notes:
|
|
|
|
--*/
|
|
{
|
|
const NDR64_POINTER_FORMAT *pPointerFormat =
|
|
(const NDR64_POINTER_FORMAT*)pFormat;
|
|
PFORMAT_STRING pPointee = (PFORMAT_STRING)pPointerFormat->Pointee;
|
|
|
|
if( pStubMsg->dwStubPhase != PROXY_UNMARSHAL)
|
|
return;
|
|
|
|
// Let's not die on a null ref pointer.
|
|
|
|
if ( !pArg )
|
|
return;
|
|
|
|
NDR64_UINT32 Size = 0;
|
|
uchar *pArgSaved = pArg;
|
|
|
|
//
|
|
// Look for a non-Interface pointer.
|
|
//
|
|
if ( NDR64_IS_BASIC_POINTER(*(PFORMAT_STRING)pFormat) )
|
|
{
|
|
// Pointer to a basetype.
|
|
if ( NDR64_SIMPLE_POINTER(pPointerFormat->Flags) )
|
|
{
|
|
//
|
|
// It seems wierd to zero an [out] pointer to a basetypes, but this
|
|
// is what we did in NT 3.5x and I wouldn't be surprised if
|
|
// something broke if we changed this behavior.
|
|
//
|
|
Size = NDR64_SIMPLE_TYPE_MEMSIZE( *pPointee );
|
|
goto DoZero;
|
|
}
|
|
|
|
// Pointer to a pointer.
|
|
if ( NDR64_POINTER_DEREF( pPointerFormat->Flags ) )
|
|
{
|
|
Size = PTR_MEM_SIZE;
|
|
pArg = *((uchar **)pArg);
|
|
}
|
|
|
|
// context handle is not allowed in DCOM interface so I don't think
|
|
// we need the check here (for both DCE & NDR64). we can get
|
|
// rid of this code in Longhorn. yongqu
|
|
if ( *(PFORMAT_STRING)pFormat == FC64_BIND_CONTEXT )
|
|
{
|
|
*((NDR_CCONTEXT *)pArg) = (NDR_CCONTEXT) 0;
|
|
return;
|
|
}
|
|
|
|
pFormat = pPointee;
|
|
}
|
|
|
|
// We have a pointer to complex type.
|
|
Ndr64ToplevelTypeFree( pStubMsg,
|
|
pArg,
|
|
pFormat );
|
|
|
|
if ( ! Size )
|
|
{
|
|
Size = Ndr64pMemorySize( pStubMsg,
|
|
pFormat,
|
|
FALSE );
|
|
}
|
|
|
|
DoZero:
|
|
|
|
MIDL_memset( pArgSaved, 0, (size_t)Size );
|
|
}
|
|
|
|
|
|
__forceinline void
|
|
Ndr64pGetBuffer( void * pThis,
|
|
MIDL_STUB_MESSAGE * pStubMsg,
|
|
NDR_PROC_CONTEXT * pContext )
|
|
{
|
|
if ( pThis )
|
|
NdrProxyGetBuffer( pThis,
|
|
pStubMsg );
|
|
else
|
|
{
|
|
if ( pContext->HandleType != FC64_AUTO_HANDLE )
|
|
{
|
|
Ndr64GetBuffer( pStubMsg,
|
|
pStubMsg->BufferLength );
|
|
}
|
|
else
|
|
Ndr64NsGetBuffer( pStubMsg,
|
|
pStubMsg->BufferLength );
|
|
|
|
// We only need to save the stubmsg in sync interfaces.
|
|
// In the client side, runtime tls would be available AFTER call
|
|
// to runtime, it might be after I_RpcNegotiateTransferSyntax or
|
|
// GetBuffer, and we are sure the slot is available now.
|
|
}
|
|
|
|
NdrRpcSetNDRSlot( pStubMsg );
|
|
}
|
|
|
|
__forceinline void
|
|
Ndr64pSendReceive( void * pThis,
|
|
MIDL_STUB_MESSAGE * pStubMsg,
|
|
NDR_PROC_CONTEXT * pContext )
|
|
{
|
|
if ( pContext->HasPipe )
|
|
NdrPipeSendReceive( pStubMsg, pContext->pPipeDesc );
|
|
else
|
|
{
|
|
if ( pThis )
|
|
NdrProxySendReceive( pThis, pStubMsg );
|
|
else
|
|
if ( pContext->HandleType != FC64_AUTO_HANDLE )
|
|
NdrSendReceive( pStubMsg, pStubMsg->Buffer );
|
|
else
|
|
NdrNsSendReceive( pStubMsg,
|
|
pStubMsg->Buffer,
|
|
(RPC_BINDING_HANDLE*) pStubMsg->StubDesc
|
|
->IMPLICIT_HANDLE_INFO.pAutoHandle );
|
|
}
|
|
}
|
|
|
|
|
|
CLIENT_CALL_RETURN RPC_VAR_ENTRY
|
|
NdrClientCall3(
|
|
MIDL_STUBLESS_PROXY_INFO *pProxyInfo,
|
|
ulong nProcNum,
|
|
void *pReturnValue,
|
|
...
|
|
)
|
|
/*
|
|
This routine is called from the object stubless proxy dispatcher.
|
|
*/
|
|
{
|
|
va_list ArgList;
|
|
RPC_STATUS res = RPC_S_OK;
|
|
NDR_PROC_CONTEXT ProcContext;
|
|
|
|
INIT_ARG( ArgList, pReturnValue );
|
|
GET_FIRST_IN_ARG(ArgList);
|
|
uchar * StartofStack = (uchar *)GET_STACK_START(ArgList);
|
|
|
|
Ndr64ClientInitializeContext( NdrpGetSyntaxType( pProxyInfo->pTransferSyntax),
|
|
pProxyInfo,
|
|
nProcNum,
|
|
&ProcContext,
|
|
StartofStack );
|
|
|
|
|
|
// call_as routines in ORPC interface come through here also.
|
|
return NdrpClientCall3( ProcContext.IsObject ? *(void **)StartofStack : NULL,
|
|
pProxyInfo,
|
|
nProcNum,
|
|
pReturnValue,
|
|
&ProcContext,
|
|
StartofStack );
|
|
}
|
|
|
|
CLIENT_CALL_RETURN RPC_ENTRY
|
|
NdrpClientCall3(
|
|
void * pThis,
|
|
MIDL_STUBLESS_PROXY_INFO *pProxyInfo,
|
|
ulong nProcNum,
|
|
void *pReturnValue,
|
|
NDR_PROC_CONTEXT * pContext,
|
|
uchar * StartofStack
|
|
)
|
|
{
|
|
|
|
RPC_MESSAGE RpcMsg;
|
|
MIDL_STUB_MESSAGE StubMsg;
|
|
PMIDL_STUB_MESSAGE pStubMsg = &StubMsg;
|
|
CLIENT_CALL_RETURN ReturnValue;
|
|
|
|
ReturnValue.Pointer = 0;
|
|
|
|
if ( NULL == pReturnValue )
|
|
pReturnValue = &ReturnValue;
|
|
|
|
//
|
|
// Wrap everything in a try-finally pair. The finally clause does the
|
|
// required freeing of resources (RpcBuffer and Full ptr package).
|
|
//
|
|
RpcTryFinally
|
|
{
|
|
//
|
|
// Use a nested try-except pair to support OLE. In OLE case, test the
|
|
// exception and map it if required, then set the return value. In
|
|
// nonOLE case, just reraise the exception.
|
|
//
|
|
RpcTryExcept
|
|
{
|
|
|
|
// client initialization and syntax negotiation.
|
|
Ndr64pClientSetupTransferSyntax(pThis,
|
|
&RpcMsg,
|
|
pStubMsg,
|
|
pProxyInfo,
|
|
pContext,
|
|
nProcNum );
|
|
|
|
( * pContext->pfnInit) ( pStubMsg,
|
|
pReturnValue );
|
|
|
|
( * pContext->pfnSizing) ( pStubMsg,
|
|
TRUE ); // isclient
|
|
|
|
//
|
|
// Do the GetBuffer.
|
|
//
|
|
|
|
Ndr64pGetBuffer( pThis, &StubMsg, pContext );
|
|
|
|
|
|
NDR_ASSERT( StubMsg.fBufferValid, "Invalid buffer" );
|
|
|
|
(* pContext->pfnMarshal) (&StubMsg,
|
|
( pThis != NULL ) ); // isobject
|
|
|
|
|
|
//
|
|
// Make the RPC call.
|
|
//
|
|
|
|
|
|
Ndr64pSendReceive( pThis, &StubMsg, pContext ) ;
|
|
|
|
( * pContext->pfnUnMarshal )( &StubMsg,
|
|
pContext->HasComplexReturn
|
|
? &pReturnValue
|
|
: pReturnValue );
|
|
|
|
}
|
|
RpcExcept( EXCEPTION_FLAG )
|
|
{
|
|
|
|
RPC_STATUS ExceptionCode = RpcExceptionCode();
|
|
NDR_ASSERT( pContext->NeedsResend == FALSE, "resend flag should be false here" );
|
|
|
|
// fail after some retries.
|
|
if ( ExceptionCode == RPC_P_TRANSFER_SYNTAX_CHANGED &&
|
|
( pContext->ResendCount < NDR_MAX_RESEND_COUNT ) &&
|
|
( pProxyInfo->nCount > 1 ) )
|
|
{
|
|
// we'll retry only if:
|
|
// . runtime returns changed syntax error code
|
|
// . client support multiple transfer syntax
|
|
// . we retried less than the max retried number
|
|
pContext->ResendCount ++;
|
|
pContext->NeedsResend = TRUE;
|
|
}
|
|
else
|
|
(pContext->pfnExceptionHandling) ( pStubMsg,
|
|
nProcNum,
|
|
ExceptionCode,
|
|
&ReturnValue );
|
|
}
|
|
RpcEndExcept
|
|
}
|
|
RpcFinally
|
|
{
|
|
|
|
(pContext->pfnClientFinally )( pStubMsg,
|
|
pThis );
|
|
|
|
// recurse back if resend is needed. we are very much making a new call again because runtime doesn't
|
|
// know which tranfer syntax the new server supports when the previous negotiated transfer syntax failes.
|
|
if ( pContext->NeedsResend )
|
|
NdrpClientCall3( pThis, pProxyInfo, nProcNum, pReturnValue, pContext, StartofStack );
|
|
}
|
|
RpcEndFinally
|
|
|
|
return ReturnValue;
|
|
}
|
|
|
|
|
|
#pragma code_seg()
|
|
|