able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/rpc/ndr64/pickle64.cxx

1320 lines
41 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Copyright (c) 2000 Microsoft Corporation
Module Name:
pickle64.cxx
Abstract:
This module contains ndr64 related pickling ndr library routines.
Notes:
Author:
Yong Qu Nov, 1993
Revision History:
------------------------------------------------------------------------*/
#include "precomp.hxx"
#include <midles.h>
#include "endianp.h"
#include "picklep.hxx"
extern "C"
{
void RPC_ENTRY
NdrpPicklingClientFinally( PMIDL_STUB_MESSAGE pStubMsg,
void * pThis );
void RPC_ENTRY
Ndr64pPicklingClientFinally( PMIDL_STUB_MESSAGE pStubMsg,
void * pThis );
}
const SYNTAX_DISPATCH_TABLE SyncDcePicklingClient =
{
NdrpClientInit,
NdrpSizing,
NdrpClientMarshal,
NdrpClientUnMarshal,
NdrpClientExceptionHandling,
NdrpPicklingClientFinally
};
const SYNTAX_DISPATCH_TABLE SyncNdr64PicklingClient =
{
Ndr64pClientInit,
Ndr64pSizing,
Ndr64pClientMarshal,
Ndr64pClientUnMarshal,
Ndr64pClientExceptionHandling,
Ndr64pPicklingClientFinally
};
extern const MIDL_FORMAT_STRING __MIDLFormatString;
__inline
void Ndr64pMesTypeInit( PMIDL_STUB_MESSAGE pStubMsg,
NDR_PROC_CONTEXT * pContext,
PMIDL_STUB_DESC pStubDesc )
{
// we need this for correlation cache.
NdrpInitializeProcContext( pContext );
pStubMsg->pContext = pContext;
pStubMsg->fHasExtensions = 1;
pStubMsg->StubDesc = pStubDesc;
pStubMsg->pfnAllocate = pStubDesc->pfnAllocate;
pStubMsg->pfnFree = pStubDesc->pfnFree;
pStubMsg->pCorrInfo = NULL;
}
#define NdrpSetupMesTypeCommon( pfnName, pfnDCE, pfnNDR64 ) \
\
if ( pMesMsg->Operation == MES_ENCODE || pMesMsg->Operation == MES_DECODE ) \
{ \
SyntaxType = XFER_SYNTAX_DCE; \
pfnName = &pfnDCE; \
} \
else \
{ \
SyntaxType = XFER_SYNTAX_NDR64; \
pfnName = &pfnNDR64; \
} \
\
for ( long i = 0; i < (long) pProxyInfo->nCount; i ++ ) \
if ( NdrpGetSyntaxType( &pProxyInfo->pSyntaxInfo[i].TransferSyntax ) == SyntaxType ) \
{ \
pSyntaxInfo = &pProxyInfo->pSyntaxInfo[i]; \
break; \
} \
\
if (NULL == pSyntaxInfo ) \
RpcRaiseException( RPC_S_UNSUPPORTED_TRANS_SYN ); \
\
if ( XFER_SYNTAX_DCE == SyntaxType ) \
{ \
ulong nFormatOffset = ArrTypeOffset[i][nTypeIndex]; \
pTypeFormat = &pSyntaxInfo->TypeString[nFormatOffset]; \
} \
else \
{ \
if ( SyntaxType == XFER_SYNTAX_NDR64 ) \
Ndr64pMesTypeInit( &pMesMsg->StubMsg, &ProcContext, pProxyInfo->pStubDesc ); \
\
pTypeFormat = (PFORMAT_STRING)(((const FormatInfoRef **) ArrTypeOffset)[i][nTypeIndex]); \
} \
\
ProcContext.pSyntaxInfo = pSyntaxInfo;
void
Ndr64pValidateMesHandle(
PMIDL_ES_MESSAGE_EX pMesMsgEx )
{
RpcTryExcept
{
if ( pMesMsgEx == 0 ||
pMesMsgEx->Signature != MIDL_ES_SIGNATURE ||
( pMesMsgEx->MesMsg.MesVersion != MIDL_NDR64_ES_VERSION &&
pMesMsgEx->MesMsg.MesVersion != MIDL_ES_VERSION ) )
RpcRaiseException( RPC_S_INVALID_ARG );
}
RpcExcept( 1 )
{
RpcRaiseException( RPC_S_INVALID_ARG );
}
RpcEndExcept
}
RPC_STATUS
Ndr64pValidateMesHandleReturnStatus(
PMIDL_ES_MESSAGE_EX pMesMsgEx )
{
RPC_STATUS Status = RPC_S_OK;
RpcTryExcept
{
if ( pMesMsgEx == 0 || pMesMsgEx->Signature != MIDL_NDR64_ES_SIGNATURE ||
pMesMsgEx->MesMsg.MesVersion != MIDL_NDR64_ES_VERSION )
Status = RPC_S_INVALID_ARG;
}
RpcExcept( 1 )
{
Status = RPC_S_INVALID_ARG;
}
RpcEndExcept
return Status;
}
void
Ndr64pCommonTypeHeaderSize(
PMIDL_ES_MESSAGE pMesMsg
)
{
// This check is to prevent a decoding handle from being used
// for both encoding and sizing of types.
if ( pMesMsg->Operation != MES_ENCODE_NDR64 )
RpcRaiseException( RPC_X_INVALID_ES_ACTION );
if ( ! GET_COMMON_TYPE_HEADER_SIZED( pMesMsg ) )
{
pMesMsg->StubMsg.BufferLength += MES_NDR64_CTYPE_HEADER_SIZE;
SET_COMMON_TYPE_HEADER_SIZED( pMesMsg );
}
}
size_t RPC_ENTRY
Ndr64MesTypeAlignSize(
handle_t Handle,
const MIDL_TYPE_PICKLING_INFO * pxPicklingInfo,
const MIDL_STUB_DESC * pStubDesc,
PFORMAT_STRING pFormat,
const void __RPC_FAR * pObject
)
{
PMIDL_ES_MESSAGE pMesMsg = ( PMIDL_ES_MESSAGE )Handle;
PMIDL_STUB_MESSAGE pStubMsg = &pMesMsg->StubMsg;
size_t OldLength = pStubMsg->BufferLength;
PMIDL_TYPE_PICKLING_INFOp pPicklingInfo;
Ndr64pValidateMesHandle( (PMIDL_ES_MESSAGE_EX)Handle );
if ( ! pObject )
RpcRaiseException( RPC_X_NULL_REF_POINTER );
if( (long)pStubMsg->BufferLength & 0xf )
RpcRaiseException( RPC_X_INVALID_BUFFER );
pPicklingInfo = (PMIDL_TYPE_PICKLING_INFOp) pxPicklingInfo;
NDR_ASSERT( pPicklingInfo->Flags.Oicf, "Oicf should always be on" );
// See if we need to size the common type header.
Ndr64pCommonTypeHeaderSize( (PMIDL_ES_MESSAGE)Handle );
// Now the individual type object.
pStubMsg->BufferLength += MES_NDR64_HEADER_SIZE;
if ( NDR64_IS_POINTER_TYPE(*pFormat) )
{
// We have to dereference the pointer once.
pObject = *(void __RPC_FAR * __RPC_FAR *)pObject;
}
(Ndr64SizeRoutinesTable[ NDR64_ROUTINE_INDEX(*pFormat) ])
( pStubMsg,
(uchar __RPC_FAR *)pObject,
pFormat );
LENGTH_ALIGN( pStubMsg->BufferLength, 0xf );
Ndr64pPicklingClientFinally( pStubMsg, NULL ); // object
return( pStubMsg->BufferLength - OldLength );
}
// ndr64 entries.
size_t RPC_ENTRY
NdrMesTypeAlignSize3(
handle_t Handle,
const MIDL_TYPE_PICKLING_INFO * pPicklingInfo,
const MIDL_STUBLESS_PROXY_INFO* pProxyInfo,
const unsigned long ** ArrTypeOffset,
unsigned long nTypeIndex,
const void __RPC_FAR * pObject )
{
PMIDL_ES_MESSAGE pMesMsg = (PMIDL_ES_MESSAGE) Handle;
PFORMAT_STRING pTypeFormat;
MIDL_SYNTAX_INFO * pSyntaxInfo = NULL;
PFNMESTYPEALIGNSIZE pfnSize;
PMIDL_STUB_MESSAGE pStubMsg = &pMesMsg->StubMsg;
SYNTAX_TYPE SyntaxType;
NDR_PROC_CONTEXT ProcContext;
if ( (( PMIDL_ES_MESSAGE)Handle )->Operation != MES_ENCODE &&
(( PMIDL_ES_MESSAGE)Handle )->Operation != MES_ENCODE_NDR64 )
RpcRaiseException( RPC_X_INVALID_ES_ACTION );
NdrpSetupMesTypeCommon( pfnSize, NdrMesTypeAlignSize2, Ndr64MesTypeAlignSize );
return
( *pfnSize )( Handle, pPicklingInfo, pProxyInfo->pStubDesc, pTypeFormat, pObject );
}
// common type header for type pickling is longer than before:
// if version is 1, the header size is 8,
// if version is higher than 1, the header size is 24+2*sizeof(RPC_SYNTAX_IDENTIFIER)
// starting 8 bytes is still the same as old one:
// <version:1><endian:1><header_size:2><endian info: 4>
// addtional header:
// <reserved: 16> <transfer_syntax><iid>
//
size_t
Ndr64pCommonTypeHeaderMarshall(
PMIDL_ES_MESSAGE pMesMsg
)
/*++
Returns the space used by the common header.
--*/
{
if ( ! GET_COMMON_TYPE_HEADER_IN( pMesMsg ) )
{
PMIDL_STUB_MESSAGE pStubMsg = &pMesMsg->StubMsg;
if ( (ULONG_PTR)pStubMsg->Buffer & 15 )
RpcRaiseException( RPC_X_INVALID_BUFFER );
MIDL_memset( pStubMsg->Buffer, 0xcc, MES_NDR64_CTYPE_HEADER_SIZE );
*pStubMsg->Buffer++ = MIDL_NDR64_ES_VERSION;
*pStubMsg->Buffer++ = NDR_LOCAL_ENDIAN;
* PSHORT_CAST pStubMsg->Buffer = MES_NDR64_CTYPE_HEADER_SIZE;
pStubMsg->Buffer += MES_CTYPE_HEADER_SIZE + 16 -2 ; // skip over reserved, make header size 64bytes
RpcpMemoryCopy( pStubMsg->Buffer,
& NDR64_TRANSFER_SYNTAX,
sizeof(RPC_SYNTAX_IDENTIFIER) );
pStubMsg->Buffer += sizeof( RPC_SYNTAX_IDENTIFIER );
RpcpMemoryCopy( pStubMsg->Buffer ,
& pMesMsg->InterfaceId,
sizeof(RPC_SYNTAX_IDENTIFIER) + sizeof(long) );
pStubMsg->Buffer += sizeof( RPC_SYNTAX_IDENTIFIER );
SET_COMMON_TYPE_HEADER_IN( pMesMsg );
return( MES_NDR64_CTYPE_HEADER_SIZE );
}
return( 0 );
}
void RPC_ENTRY
Ndr64MesTypeEncode(
handle_t Handle,
const MIDL_TYPE_PICKLING_INFO * pxPicklingInfo,
const MIDL_STUB_DESC * pStubDesc,
PFORMAT_STRING pFormat,
const void __RPC_FAR * pObject
)
{
PMIDL_ES_MESSAGE pMesMsg = (PMIDL_ES_MESSAGE) Handle;
PMIDL_STUB_MESSAGE pStubMsg = &pMesMsg->StubMsg;
PMIDL_TYPE_PICKLING_INFOp pPicklingInfo;
uchar __RPC_FAR * pBufferSaved, *pTypeHeader;
size_t RequiredLen, CommonHeaderSize, LengthSaved;
pPicklingInfo = (PMIDL_TYPE_PICKLING_INFOp) pxPicklingInfo;
NDR_ASSERT( pPicklingInfo->Flags.Oicf, "Oicf should always be on" )
Ndr64pValidateMesHandle( (PMIDL_ES_MESSAGE_EX)Handle );
if ( ! pObject )
RpcRaiseException( RPC_X_NULL_REF_POINTER );
if( (LONG_PTR)pStubMsg->Buffer & 0xf )
RpcRaiseException( RPC_X_INVALID_BUFFER );
pStubMsg->BufferLength = 0xf & PtrToUlong( pStubMsg->Buffer );
RequiredLen = Ndr64MesTypeAlignSize( Handle,
pxPicklingInfo,
pStubDesc,
pFormat,
pObject );
NdrpAllocPicklingBuffer( pMesMsg, RequiredLen );
pBufferSaved = pStubMsg->Buffer;
LengthSaved = RequiredLen;
// See if we need to marshall the common type header
CommonHeaderSize = Ndr64pCommonTypeHeaderMarshall( pMesMsg );
// Marshall the header and the object.
memset( pStubMsg->Buffer, 0, MES_NDR64_HEADER_SIZE );
pStubMsg->Buffer += MES_NDR64_HEADER_SIZE;
if ( NDR64_IS_POINTER_TYPE(*pFormat) )
{
// We have to dereference the pointer once.
pObject = *(void __RPC_FAR * __RPC_FAR *)pObject;
}
RpcTryFinally
{
ALIGN( pStubMsg->Buffer, 0xf );
(Ndr64MarshallRoutinesTable[ NDR64_ROUTINE_INDEX(*pFormat) ])
( pStubMsg,
(uchar __RPC_FAR *)pObject,
pFormat );
// We adjust the buffer to the next align by 16 and
// so, we tell the user that we've written out till next mod 16.
// cleanup possible leaks before raising exception.
}
RpcFinally
{
Ndr64pPicklingClientFinally( pStubMsg, NULL ); // object
}
RpcEndFinally
ALIGN( pStubMsg->Buffer, 0xf );
size_t WriteLength = (size_t)(pStubMsg->Buffer - pBufferSaved);
// We always save the rounded up object length in the type header.
*(unsigned long __RPC_FAR *)(pBufferSaved + CommonHeaderSize) =
WriteLength - CommonHeaderSize - MES_NDR64_HEADER_SIZE;
if ( LengthSaved < WriteLength )
{
NDR_ASSERT( 0, "NdrMesTypeEncode: encode buffer overflow" );
RpcRaiseException( RPC_S_INTERNAL_ERROR );
}
NdrpWritePicklingBuffer( pMesMsg, pBufferSaved, WriteLength );
}
void RPC_ENTRY
NdrMesTypeEncode3(
handle_t Handle,
const MIDL_TYPE_PICKLING_INFO * pPicklingInfo,
const MIDL_STUBLESS_PROXY_INFO* pProxyInfo,
const unsigned long ** ArrTypeOffset,
unsigned long nTypeIndex,
const void __RPC_FAR * pObject )
{
PMIDL_ES_MESSAGE pMesMsg = (PMIDL_ES_MESSAGE) Handle;
PFORMAT_STRING pTypeFormat;
MIDL_SYNTAX_INFO * pSyntaxInfo = NULL;
PFNMESTYPEENCODE pfnEncode;
PMIDL_STUB_MESSAGE pStubMsg = &pMesMsg->StubMsg;
SYNTAX_TYPE SyntaxType;
NDR_PROC_CONTEXT ProcContext;
if ( (( PMIDL_ES_MESSAGE)Handle )->Operation != MES_ENCODE &&
(( PMIDL_ES_MESSAGE)Handle )->Operation != MES_ENCODE_NDR64 )
RpcRaiseException( RPC_X_INVALID_ES_ACTION );
NdrpSetupMesTypeCommon( pfnEncode, NdrMesTypeEncode2, Ndr64MesTypeEncode );
( *pfnEncode )( Handle, pPicklingInfo, pProxyInfo->pStubDesc, pTypeFormat, pObject );
}
// read the type header, and determine if the buffer is marshalled
// using ndr or ndr64
// for future extension, we can allow other transfer syntaxes.
void RPC_ENTRY
Ndr64pCommonTypeHeaderUnmarshall(
PMIDL_ES_MESSAGE pMesMsg
)
{
BOOL IsNewPickling = FALSE;
if ( pMesMsg->Operation != MES_DECODE &&
pMesMsg->Operation != MES_DECODE_NDR64 )
RpcRaiseException( RPC_X_INVALID_ES_ACTION );
if ( ! GET_COMMON_TYPE_HEADER_IN( pMesMsg ) )
{
PMIDL_STUB_MESSAGE pStubMsg = &pMesMsg->StubMsg;
// read the common header first.
NdrpReadPicklingBuffer( pMesMsg, MES_CTYPE_HEADER_SIZE );
// Check the version number, endianness.
if ( *pStubMsg->Buffer == MIDL_ES_VERSION )
{
IsNewPickling = FALSE;
pMesMsg->Operation = MES_DECODE;
}
else
{
IsNewPickling = TRUE;
}
if ( pStubMsg->Buffer[1] == NDR_LOCAL_ENDIAN )
{
// Read the note about endianess at NdrMesTypeDecode.
//
pMesMsg->AlienDataRep = NDR_LOCAL_DATA_REPRESENTATION;
}
else
{
NDR_ASSERT( pMesMsg->Operation != MES_DECODE_NDR64,
"endian convertion is not supported in ndr64" );
unsigned char temp = pStubMsg->Buffer[2];
pStubMsg->Buffer[2] = pStubMsg->Buffer[3];
pStubMsg->Buffer[3] = temp;
pMesMsg->AlienDataRep = ( NDR_ASCII_CHAR | // chars
pStubMsg->Buffer[1] | // endianness
NDR_IEEE_FLOAT ); // float
}
pStubMsg->Buffer += MES_CTYPE_HEADER_SIZE;
if ( IsNewPickling )
{
SYNTAX_TYPE SyntaxType;
// read the remaining header.
NdrpReadPicklingBuffer( pMesMsg, MES_NDR64_CTYPE_HEADER_SIZE - MES_CTYPE_HEADER_SIZE );
pStubMsg->Buffer += 16; // skip over Reserved;
SyntaxType = NdrpGetSyntaxType( (RPC_SYNTAX_IDENTIFIER *)pStubMsg->Buffer );
if ( SyntaxType == XFER_SYNTAX_DCE )
{
pMesMsg->Operation = MES_DECODE;
}
else if ( SyntaxType = XFER_SYNTAX_NDR64 )
{
pMesMsg->Operation = ( MIDL_ES_CODE )MES_DECODE_NDR64;
}
else
{
RpcRaiseException( RPC_S_UNSUPPORTED_TRANS_SYN );
}
// skip over iid: we don't need it for now. might be used for verification.
pStubMsg->Buffer += 2*sizeof( RPC_SYNTAX_IDENTIFIER );
}
SET_COMMON_TYPE_HEADER_IN( pMesMsg );
}
}
void RPC_ENTRY
Ndr64MesTypeDecode(
handle_t Handle,
const MIDL_TYPE_PICKLING_INFO * pxPicklingInfo,
const MIDL_STUB_DESC * pStubDesc,
PFORMAT_STRING pFormat,
void __RPC_FAR * pObject
)
{
PMIDL_ES_MESSAGE pMesMsg = (PMIDL_ES_MESSAGE) Handle;
PMIDL_STUB_MESSAGE pStubMsg = &pMesMsg->StubMsg;
PMIDL_TYPE_PICKLING_INFOp pPicklingInfo;
uchar __RPC_FAR * pBufferSaved, pTypeHeader;
size_t RequiredLen, CommonHeaderSize, LengthSaved;
pPicklingInfo = (PMIDL_TYPE_PICKLING_INFOp) pxPicklingInfo;
NDR_ASSERT( pPicklingInfo->Flags.Oicf, "Oicf should always be on" )
Ndr64pValidateMesHandle( (PMIDL_ES_MESSAGE_EX)Handle );
if( (LONG_PTR)pStubMsg->Buffer & 0xf )
RpcRaiseException( RPC_X_INVALID_BUFFER );
pStubMsg->BufferLength = 0xf & PtrToUlong( pStubMsg->Buffer );
NdrpReadPicklingBuffer( pMesMsg, MES_NDR64_HEADER_SIZE );
RequiredLen = (size_t) *(unsigned long __RPC_FAR *)pStubMsg->Buffer;
pStubMsg->Buffer += MES_NDR64_HEADER_SIZE;
NdrpReadPicklingBuffer( pMesMsg, RequiredLen );
void * pArg = pObject;
if ( NDR64_IS_POINTER_TYPE(*pFormat) )
{
// We have to dereference the pointer once.
//
pArg = *(void **)pArg;
}
RpcTryFinally
{
(Ndr64UnmarshallRoutinesTable[ NDR64_ROUTINE_INDEX( *pFormat )])
( pStubMsg,
(uchar __RPC_FAR * __RPC_FAR *)&pArg,
pFormat,
FALSE );
if ( NDR64_IS_POINTER_TYPE(*pFormat) )
{
// Don't drop the pointee, if it was allocated.
*(void **)pObject = pArg;
}
// Next decoding needs to start at aligned to 8.
ALIGN( pStubMsg->Buffer, 15 );
}
RpcFinally
{
Ndr64pPicklingClientFinally( pStubMsg, NULL ); // object
}
RpcEndFinally
}
void RPC_ENTRY
NdrMesTypeDecode3(
handle_t Handle,
const MIDL_TYPE_PICKLING_INFO * pPicklingInfo,
const MIDL_STUBLESS_PROXY_INFO* pProxyInfo,
const unsigned long ** ArrTypeOffset,
unsigned long nTypeIndex,
void __RPC_FAR * pObject )
{
size_t RequiredLen;
PMIDL_ES_MESSAGE pMesMsg = (PMIDL_ES_MESSAGE) Handle;
PMIDL_STUB_MESSAGE pStubMsg = &pMesMsg->StubMsg;
uchar * BufferSaved;
PFNMESDECODE pfnDecode;
MIDL_SYNTAX_INFO * pSyntaxInfo;
PFORMAT_STRING pTypeFormat;
SYNTAX_TYPE SyntaxType;
NDR_PROC_CONTEXT ProcContext;
if ( ! pObject )
RpcRaiseException( RPC_X_NULL_REF_POINTER );
Ndr64pCommonTypeHeaderUnmarshall( pMesMsg );
NdrpSetupMesTypeCommon( pfnDecode, NdrMesTypeDecode2, Ndr64MesTypeDecode );
(* pfnDecode )( Handle, pPicklingInfo, pProxyInfo->pStubDesc, pTypeFormat, pObject );
}
void RPC_ENTRY
Ndr64MesTypeFree(
handle_t Handle,
const MIDL_TYPE_PICKLING_INFO * pxPicklingInfo,
const MIDL_STUB_DESC * pStubDesc,
PFORMAT_STRING pFormat,
void __RPC_FAR * pObject
)
/*++
Routine description:
Free the object.
Arguments:
Handle - a pickling handle,
pStubDesc - a pointer to the stub descriptor,
pFormat - a pointer to the format code describing the object type
pObject - a pointer to the object being freed.
Returns:
Note:
The pickling header is included in the sizing.
--*/
{
NDR_PROC_CONTEXT ProcContext;
PMIDL_ES_MESSAGE pMesMsg = (PMIDL_ES_MESSAGE) Handle;
PMIDL_STUB_MESSAGE pStubMsg = &pMesMsg->StubMsg;
PMIDL_TYPE_PICKLING_INFOp pPicklingInfo;
Ndr64pValidateMesHandle( (PMIDL_ES_MESSAGE_EX)Handle );
pPicklingInfo = (PMIDL_TYPE_PICKLING_INFOp) pxPicklingInfo;
NDR_ASSERT( pPicklingInfo->Flags.Oicf, "Oicf should always be on" )
if ( ! pObject )
RpcRaiseException( RPC_X_NULL_REF_POINTER );
if( (LONG_PTR)pStubMsg->Buffer & 0xf )
RpcRaiseException( RPC_X_INVALID_BUFFER );
// Now the individual type object.
if ( NDR64_IS_POINTER_TYPE(*pFormat) )
{
// We have to dereference the pointer once.
pObject = *(void __RPC_FAR * __RPC_FAR *)pObject;
}
(Ndr64FreeRoutinesTable[ NDR64_ROUTINE_INDEX(*pFormat) ])
( pStubMsg,
(uchar __RPC_FAR *)pObject,
pFormat );
Ndr64pPicklingClientFinally( pStubMsg, NULL ); // object
}
void RPC_ENTRY
NdrMesTypeFree3(
handle_t Handle,
const MIDL_TYPE_PICKLING_INFO * pxPicklingInfo,
const MIDL_STUBLESS_PROXY_INFO* pProxyInfo,
const unsigned long ** ArrTypeOffset,
unsigned long nTypeIndex,
void __RPC_FAR * pObject )
{
PMIDL_ES_MESSAGE pMesMsg = (PMIDL_ES_MESSAGE) Handle;
PMIDL_STUB_MESSAGE pStubMsg = &pMesMsg->StubMsg;
PMIDL_TYPE_PICKLING_INFOp pPicklingInfo;
PFNMESFREE pfnFree;
MIDL_SYNTAX_INFO * pSyntaxInfo;
PFORMAT_STRING pTypeFormat;
SYNTAX_TYPE SyntaxType;
NDR_PROC_CONTEXT ProcContext;
pPicklingInfo = (PMIDL_TYPE_PICKLING_INFOp) pxPicklingInfo;
NdrpSetupMesTypeCommon( pfnFree, NdrMesTypeFree2, Ndr64MesTypeFree );
(*pfnFree)(Handle, pxPicklingInfo, pProxyInfo->pStubDesc, pTypeFormat, pObject );
}
void
Ndr64pMesProcEncodeInit( PMIDL_ES_MESSAGE pMesMsg,
const MIDL_STUBLESS_PROXY_INFO * pProxyInfo,
unsigned long nProcNum,
MIDL_ES_CODE Operation,
NDR_PROC_CONTEXT * pContext,
uchar * StartofStack)
{
PMIDL_STUB_DESC pStubDesc = pProxyInfo->pStubDesc;
SYNTAX_TYPE syntaxType;
BOOL fUseEncode, fIsSupported = FALSE;
PMIDL_STUB_MESSAGE pStubMsg = &pMesMsg->StubMsg;
RPC_STATUS res;
// TODO: verify stub version.
if ( Operation == MES_ENCODE )
{
syntaxType = XFER_SYNTAX_DCE;
memcpy( &( (PMIDL_ES_MESSAGE_EX)pMesMsg )->TransferSyntax,
&NDR_TRANSFER_SYNTAX ,
sizeof( RPC_SYNTAX_IDENTIFIER ) );
}
else
{
syntaxType = XFER_SYNTAX_NDR64;
memcpy( &( (PMIDL_ES_MESSAGE_EX)pMesMsg )->TransferSyntax,
&NDR64_TRANSFER_SYNTAX ,
sizeof( RPC_SYNTAX_IDENTIFIER ) );
}
Ndr64ClientInitializeContext( syntaxType, pProxyInfo, nProcNum, pContext, StartofStack );
pStubMsg->pContext = pContext;
pStubMsg->StubDesc = pStubDesc;
pStubMsg->pfnAllocate = pStubDesc->pfnAllocate;
pStubMsg->pfnFree = pStubDesc->pfnFree;
// varify proc header
if ( syntaxType == XFER_SYNTAX_DCE )
{
uchar InterpreterFlag = * ((uchar *)&pContext->NdrInfo.InterpreterFlags );
fUseEncode = InterpreterFlag & ENCODE_IS_USED;
memcpy( & (pContext->pfnInit), &SyncDcePicklingClient, sizeof( SYNTAX_DISPATCH_TABLE ) );
}
else
{
fUseEncode = ( ( (NDR64_PROC_FLAGS *) & pContext->Ndr64Header->Flags)->IsEncode );
memcpy( & (pContext->pfnInit), &SyncNdr64PicklingClient, sizeof( SYNTAX_DISPATCH_TABLE ) );
}
if (!fUseEncode )
RpcRaiseException( RPC_X_INVALID_ES_ACTION );
}
CLIENT_CALL_RETURN RPC_VAR_ENTRY
NdrMesProcEncode3(
PMIDL_ES_MESSAGE pMesMsg,
const MIDL_STUBLESS_PROXY_INFO* pProxyInfo,
unsigned long nProcNum,
uchar * StartofStack )
{
PMIDL_STUB_MESSAGE pStubMsg = & pMesMsg->StubMsg;
NDR_PROC_CONTEXT ProcContext;
unsigned long ulAlignment;
unsigned char * BufferSaved;
size_t WriteLength;
CLIENT_CALL_RETURN Ret;
Ret.Simple = NULL;
pMesMsg->ProcNumber = nProcNum;
Ndr64pMesProcEncodeInit( pMesMsg,
pProxyInfo,
nProcNum,
pMesMsg->Operation,
&ProcContext,
StartofStack );
RpcTryFinally
{
ProcContext.pfnInit( pStubMsg,
NULL ); // return value
ProcContext.pfnSizing( pStubMsg,
TRUE );
if ( pMesMsg->Operation == MES_ENCODE )
ulAlignment = 0x7;
else
ulAlignment = 0xf;
// we are not changing the proc header, but we need to overestimate because
// proc header is marshalled first.
LENGTH_ALIGN( pStubMsg->BufferLength, ulAlignment );
pStubMsg->BufferLength += MES_PROC_HEADER_SIZE ;
LENGTH_ALIGN( pStubMsg->BufferLength, ulAlignment );
size_t LengthSaved;
NdrpAllocPicklingBuffer( pMesMsg, pStubMsg->BufferLength );
BufferSaved = pStubMsg->Buffer;
LengthSaved = pStubMsg->BufferLength;
NDR_ASSERT( ( (ULONG_PTR)pStubMsg->Buffer & ulAlignment ) == 0, "pickling buffer is not aligned" );
NdrpProcHeaderMarshallAll( pMesMsg );
ALIGN( pStubMsg->Buffer, ulAlignment );
ProcContext.pfnMarshal( pStubMsg,
FALSE );
ALIGN( pStubMsg->Buffer, ulAlignment );
WriteLength = (size_t)(pStubMsg->Buffer - BufferSaved);
* (unsigned long __RPC_FAR *)
( BufferSaved + MES_PROC_HEADER_SIZE - 4) =
WriteLength - MES_PROC_HEADER_SIZE;
if ( LengthSaved < WriteLength )
{
NDR_ASSERT( 0, "NdrMesProcEncodeDecode: encode buffer overflow" );
RpcRaiseException( RPC_S_INTERNAL_ERROR );
}
NdrpWritePicklingBuffer( pMesMsg, BufferSaved, WriteLength );
}
RpcFinally
{
( *ProcContext.pfnClientFinally)( pStubMsg, NULL ); // not object
}
RpcEndFinally
return Ret;
}
// both encode and decode acts like the client side.
void
Ndr64pMesProcDecodeInit( PMIDL_ES_MESSAGE pMesMsg,
const MIDL_STUBLESS_PROXY_INFO * pProxyInfo,
SYNTAX_TYPE SyntaxType,
unsigned long nProcNum,
NDR_PROC_CONTEXT * pContext,
uchar * StartofStack )
{
RPC_STATUS res;
PMIDL_STUB_MESSAGE pStubMsg = &pMesMsg->StubMsg;
unsigned long nFormatOffset;
PMIDL_STUB_DESC pStubDesc = pProxyInfo->pStubDesc;
BOOL fUseDecode;
// REVIEW: Calling the "Client" init for decode seems weird but it does
// the right thing and NdrServerSetupMultipleTransferSyntax assumes
// ndr64.
Ndr64ClientInitializeContext(
SyntaxType,
pProxyInfo,
nProcNum,
pContext,
StartofStack );
pStubMsg->pContext = pContext;
pStubMsg->StubDesc = pStubDesc;
pStubMsg->pfnAllocate = pStubDesc->pfnAllocate;
pStubMsg->pfnFree = pStubDesc->pfnFree;
NdrpDataBufferInit( pMesMsg, pContext->pProcFormat );
if ( SyntaxType == XFER_SYNTAX_DCE )
{
uchar InterpreterFlag = * ((uchar *)&pContext->NdrInfo.InterpreterFlags );
fUseDecode = InterpreterFlag & DECODE_IS_USED;
memcpy( & (pContext->pfnInit), &SyncDcePicklingClient, sizeof( SYNTAX_DISPATCH_TABLE ) );
}
else
{
fUseDecode = ( ( (NDR64_PROC_FLAGS *) & pContext->Ndr64Header->Flags)->IsDecode );
memcpy( & (pContext->pfnInit), &SyncNdr64PicklingClient, sizeof( SYNTAX_DISPATCH_TABLE ) );
}
if (!fUseDecode )
RpcRaiseException( RPC_X_INVALID_ES_ACTION );
}
CLIENT_CALL_RETURN RPC_VAR_ENTRY
NdrMesProcDecode3(
PMIDL_ES_MESSAGE pMesMsg,
const MIDL_STUBLESS_PROXY_INFO *pProxyInfo,
unsigned long nProcNum,
uchar * StartofStack,
void * pReturnValue )
{
CLIENT_CALL_RETURN RetVal;
NDR_PROC_CONTEXT ProcContext;
SYNTAX_TYPE SyntaxType;
PMIDL_STUB_MESSAGE pStubMsg = & pMesMsg->StubMsg;
NDR64_PROC_FLAGS *ProcFlags;
unsigned long ulAlign;
long HasComplexReturn;
RetVal.Simple = NULL;
if (NULL == pReturnValue )
pReturnValue = &RetVal;
if ( GET_MES_HEADER_PEEKED( pMesMsg ) )
{
// This makes it possible to encode/decode several procs one after
// another with the same pickling handle (using the same buffer).
CLEAR_MES_HEADER_PEEKED( pMesMsg );
}
else
NdrpProcHeaderUnmarshallAll( pMesMsg );
SyntaxType = NdrpGetSyntaxType( &((PMIDL_ES_MESSAGE_EX)pMesMsg)->TransferSyntax );
if ( SyntaxType == XFER_SYNTAX_DCE )
{
pMesMsg->Operation = MES_DECODE;
ulAlign = 0x7;
}
else if ( SyntaxType == XFER_SYNTAX_NDR64 )
{
pMesMsg->Operation = ( MIDL_ES_CODE )MES_DECODE_NDR64;
ulAlign = 0xf;
}
else
RpcRaiseException( RPC_S_UNSUPPORTED_TRANS_SYN );
if ( (LONG_PTR)pStubMsg->BufferStart & ulAlign )
RpcRaiseException( RPC_X_INVALID_BUFFER );
Ndr64pMesProcDecodeInit( pMesMsg,
pProxyInfo,
SyntaxType,
nProcNum,
&ProcContext,
StartofStack );
RpcTryFinally
{
ProcContext.pfnInit( pStubMsg,
NULL ); // return value
ALIGN( pStubMsg->Buffer, ulAlign );
ProcContext.pfnUnMarshal( pStubMsg,
ProcContext.HasComplexReturn
? &pReturnValue
: pReturnValue );
// prepare for new decoding.
ALIGN( pStubMsg->Buffer, ulAlign );
}
RpcFinally
{
( *ProcContext.pfnClientFinally)( pStubMsg, NULL ); // object
}
RpcEndFinally
return *(CLIENT_CALL_RETURN *)pReturnValue;
}
CLIENT_CALL_RETURN RPC_VAR_ENTRY
NdrMesProcEncodeDecode3(
handle_t Handle,
const MIDL_STUBLESS_PROXY_INFO* pProxyInfo,
unsigned long nProcNum,
void *pReturnValue,
... )
{
BOOL fMoreParams;
PFORMAT_STRING pProcFormat;
void __RPC_FAR * pArg;
va_list ArgList;
unsigned char * BufferSaved;
size_t WriteLength;
uchar * StartofStack;
Ndr64pValidateMesHandle( (PMIDL_ES_MESSAGE_EX)Handle );
PMIDL_ES_MESSAGE pMesMsg = (PMIDL_ES_MESSAGE) Handle;
INIT_ARG( ArgList, pReturnValue );
GET_FIRST_IN_ARG(ArgList);
StartofStack = (uchar *)GET_STACK_START(ArgList);
if ( pMesMsg->Operation == MES_ENCODE ||
pMesMsg->Operation == MES_ENCODE_NDR64 )
return NdrMesProcEncode3( (PMIDL_ES_MESSAGE)Handle, pProxyInfo, nProcNum, StartofStack );
else
return NdrMesProcDecode3( (PMIDL_ES_MESSAGE)Handle, pProxyInfo, nProcNum, StartofStack, pReturnValue );
}
void RPC_ENTRY
NdrpPicklingClientFinally( PMIDL_STUB_MESSAGE pStubMsg,
void * pThis )
{
NDR_PROC_CONTEXT * pContext = (NDR_PROC_CONTEXT *) pStubMsg->pContext;
PMIDL_STUB_DESC pStubDesc = pStubMsg->StubDesc;
NdrFullPointerXlatFree(pStubMsg->FullPtrXlatTables);
NdrCorrelationFree( pStubMsg );
NdrpAllocaDestroy( & pContext->AllocateContext );
}
void RPC_ENTRY
Ndr64pPicklingClientFinally( PMIDL_STUB_MESSAGE pStubMsg,
void * pThis )
{
NdrFullPointerXlatFree(pStubMsg->FullPtrXlatTables);
NdrpAllocaDestroy( & ( (NDR_PROC_CONTEXT *)pStubMsg->pContext )->AllocateContext );
}
// =======================================================================
//
// Ready to use AlignSize routines for simple types
//
// =======================================================================
void ValidateMesSimpleTypeAll( const MIDL_STUBLESS_PROXY_INFO * pProxyInfo,
MIDL_ES_CODE Operation )
{
ulong i;
SYNTAX_TYPE SyntaxType;
if ( Operation == MES_ENCODE ||
Operation == MES_DECODE )
SyntaxType = XFER_SYNTAX_DCE;
else
SyntaxType = XFER_SYNTAX_NDR64;
for ( i = 0; i < ( ulong )pProxyInfo->nCount; i++ )
{
if ( NdrpGetSyntaxType( &pProxyInfo->pSyntaxInfo[i].TransferSyntax ) == SyntaxType )
break;
}
// Raise exception if we didn't find the supported syntax in proxyinfo.
if ( i >= pProxyInfo->nCount )
RpcRaiseException( RPC_S_UNSUPPORTED_TRANS_SYN );
}
size_t RPC_ENTRY
NdrMesSimpleTypeAlignSizeAll(
handle_t Handle,
const MIDL_STUBLESS_PROXY_INFO * pProxyInfo
)
/*++
Size is always 8 bytes for data and there is no header here per data.
However, the common header gets included for the first object.
--*/
{
if ( (( PMIDL_ES_MESSAGE)Handle )->Operation != MES_ENCODE &&
(( PMIDL_ES_MESSAGE)Handle )->Operation != MES_ENCODE_NDR64 )
RpcRaiseException( RPC_X_INVALID_ES_ACTION );
Ndr64pValidateMesHandle( (PMIDL_ES_MESSAGE_EX)Handle );
PMIDL_STUB_MESSAGE pStubMsg = &((PMIDL_ES_MESSAGE) Handle)->StubMsg;
ValidateMesSimpleTypeAll( pProxyInfo, ((PMIDL_ES_MESSAGE)Handle)->Operation );
unsigned long OldLength = pStubMsg->BufferLength;
if ( ((PMIDL_ES_MESSAGE)Handle)->Operation == MES_ENCODE )
{
if( (long)( pStubMsg->BufferLength & 0x7 ) )
RpcRaiseException( RPC_X_INVALID_BUFFER );
NdrpCommonTypeHeaderSize( (PMIDL_ES_MESSAGE)Handle );
pStubMsg->BufferLength += 8;
}
else
{
if( (long)( pStubMsg->BufferLength & 0xf ) )
RpcRaiseException( RPC_X_INVALID_BUFFER );
Ndr64pCommonTypeHeaderSize( (PMIDL_ES_MESSAGE)Handle );
LENGTH_ALIGN( pStubMsg->BufferLength, 0xf );
pStubMsg->BufferLength += 16;
}
return( (size_t)(pStubMsg->BufferLength - OldLength) );
}
// =======================================================================
//
// Ready to use Encode routines for simple types
//
// =======================================================================
void RPC_ENTRY
NdrMesSimpleTypeEncodeAll(
handle_t Handle,
const MIDL_STUBLESS_PROXY_INFO * pProxyInfo,
const void __RPC_FAR * pData,
short Size )
/*++
Marshall a simple type entity. There is no header here per data.
However, the common header gets included for the first object.
--*/
{
if ( (( PMIDL_ES_MESSAGE)Handle )->Operation != MES_ENCODE &&
(( PMIDL_ES_MESSAGE)Handle )->Operation != MES_ENCODE_NDR64 )
RpcRaiseException( RPC_X_INVALID_ES_ACTION );
Ndr64pValidateMesHandle( (PMIDL_ES_MESSAGE_EX)Handle );
PMIDL_ES_MESSAGE pMesMsg = (PMIDL_ES_MESSAGE) Handle;
PMIDL_STUB_MESSAGE pStubMsg = &pMesMsg->StubMsg;
PMIDL_STUB_DESC pStubDesc = pProxyInfo->pStubDesc;
pStubMsg->pfnAllocate = pStubDesc->pfnAllocate;
pStubMsg->pfnFree = pStubDesc->pfnFree;
unsigned long ulAlignment;
size_t RequiredLen;
// Size and allocate the buffer.
// The req len includes: (the common header) and the data
// Take the pointer alignment to come up with the right size.
pStubMsg->BufferLength = 0xf & PtrToUlong( pStubMsg->Buffer );
RequiredLen = NdrMesSimpleTypeAlignSizeAll( Handle, pProxyInfo );
NdrpAllocPicklingBuffer( pMesMsg, RequiredLen );
// See if we need to marshall the common type header
uchar __RPC_FAR * pBufferSaved = pStubMsg->Buffer;
if ( pMesMsg->Operation == MES_ENCODE )
{
NdrpCommonTypeHeaderMarshall( pMesMsg );
ulAlignment = 0x7;
}
else if ( pMesMsg->Operation == MES_ENCODE_NDR64 )
{
Ndr64pCommonTypeHeaderMarshall( pMesMsg );
ulAlignment = 0xf;
}
else
RpcRaiseException( RPC_X_INVALID_ES_ACTION );
ALIGN( pStubMsg->Buffer, ulAlignment );
switch ( Size )
{
case 1:
* PCHAR_CAST pStubMsg->Buffer = * PCHAR_CAST pData;
break;
case 2:
* PSHORT_CAST pStubMsg->Buffer = * PSHORT_CAST pData;
break;
case 4:
* PLONG_CAST pStubMsg->Buffer = * PLONG_CAST pData;
break;
case 8:
* PHYPER_CAST pStubMsg->Buffer = * PHYPER_CAST pData;
break;
default:
NDR_ASSERT( 0, " Size generation problem" );
}
pStubMsg->Buffer += ulAlignment+1;
NdrpWritePicklingBuffer( pMesMsg, pBufferSaved, RequiredLen );
}
// =======================================================================
//
// Ready to use Decode routines for simple types
//
// =======================================================================
void RPC_ENTRY
NdrMesSimpleTypeDecodeAll(
handle_t Handle,
const MIDL_STUBLESS_PROXY_INFO * pProxyInfo,
void __RPC_FAR * pData,
short FormatChar )
/*++
Does not include the header for the data.
However, the common header gets included for the first object.
Note. Endianness and other conversions for decode.
This has been deemed as not worthy doing in the Daytona time frame.
However, to be able to add it in future without backward compatibility
problems, we have the last argument to be the format character as
opposed to the size.
This makes it possible to call NdrSimpleTypeConvert, if needed.
Note that the compiler uses the 32bit tokens for this since this routine
is common to both formats.
--*/
{
if ( ( (PMIDL_ES_MESSAGE)Handle )->Operation != MES_DECODE &&
( (PMIDL_ES_MESSAGE)Handle )->Operation != MES_DECODE_NDR64 )
RpcRaiseException( RPC_X_INVALID_ES_ACTION );
Ndr64pValidateMesHandle( (PMIDL_ES_MESSAGE_EX)Handle );
PMIDL_ES_MESSAGE pMesMsg = (PMIDL_ES_MESSAGE) Handle;
PMIDL_STUB_MESSAGE pStubMsg = &((PMIDL_ES_MESSAGE)Handle)->StubMsg;
uchar * BufferSaved;
unsigned long ulAlignment;
// See if we need to unmarshall the common type header.
Ndr64pCommonTypeHeaderUnmarshall( pMesMsg );
// Now the data.
if ( pMesMsg->Operation == MES_DECODE )
{
NdrpReadPicklingBuffer( (PMIDL_ES_MESSAGE) Handle, 8);
ulAlignment = 0x7;
}
else
{
NdrpReadPicklingBuffer( (PMIDL_ES_MESSAGE) Handle, 16);
ulAlignment = 0xf;
}
NDR_ASSERT( ( (ULONG_PTR)pStubMsg->Buffer & ulAlignment ) == 0, "invalid buffer alignment in simple type pickling" );
ValidateMesSimpleTypeAll( pProxyInfo, ((PMIDL_ES_MESSAGE)Handle)->Operation );
if ( pMesMsg->AlienDataRep != NDR_LOCAL_DATA_REPRESENTATION )
{
pStubMsg->RpcMsg->DataRepresentation = pMesMsg->AlienDataRep;
BufferSaved = pStubMsg->Buffer;
NdrSimpleTypeConvert( pStubMsg, (unsigned char)FormatChar );
pStubMsg->Buffer = BufferSaved;
}
switch ( FormatChar )
{
case FC_BYTE:
case FC_CHAR:
case FC_SMALL:
case FC_USMALL:
* PCHAR_CAST pData = * PCHAR_CAST pStubMsg->Buffer;
break;
case FC_WCHAR:
case FC_SHORT:
case FC_USHORT:
* PSHORT_CAST pData = * PSHORT_CAST pStubMsg->Buffer;
break;
case FC_LONG:
case FC_ULONG:
case FC_FLOAT:
case FC_ENUM32:
case FC_ERROR_STATUS_T:
* PLONG_CAST pData = * PLONG_CAST pStubMsg->Buffer;
break;
case FC_HYPER:
case FC_DOUBLE:
* PHYPER_CAST pData = * PHYPER_CAST pStubMsg->Buffer;
break;
#if defined(__RPC_WIN64__)
case FC_INT3264:
if (pMesMsg->Operation == MES_DECODE )
*((INT64 *)pData) = *((long *) pStubMsg->Buffer);
else
*((INT64 *)pData) = *((INT64 *) pStubMsg->Buffer);
break;
case FC_UINT3264:
if (pMesMsg->Operation == MES_DECODE )
*((UINT64 *)pData) = *((ulong *)pStubMsg->Buffer);
else
*((UINT64 *)pData) = *((UINT64 *)pStubMsg->Buffer);
break;
#endif
default:
NDR_ASSERT( 0, " Size generation problem for simple types" );
}
pStubMsg->Buffer += ulAlignment+1;
}
Reference in a new issue Copy permalink