/************************************************************************ Copyright (c) 1993 - 1999 Microsoft Corporation Module Name : mrshl.c Abstract : This file contains the marshalling routines called by MIDL generated stubs and the interpreter. Author : David Kays dkays September 1993. Revision History : ***********************************************************************/ #include "precomp.hxx" #include "..\..\ndr20\ndrole.h" void Ndr64SimpleTypeMarshall( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, uchar FormatChar ) /*++ Routine Description : Marshalls a simple type. Arguments : pStubMsg - Pointer to the stub message. pMemory - Pointer to the data to be marshalled. FormatChar - Simple type format character. Return : None. --*/ { switch ( FormatChar ) { case FC64_CHAR : case FC64_UINT8: case FC64_INT8: *(pStubMsg->Buffer)++ = *pMemory; break; case FC64_WCHAR : case FC64_UINT16: case FC64_INT16: ALIGN(pStubMsg->Buffer,1); *((NDR64_UINT16 *)pStubMsg->Buffer) = *((NDR64_UINT16 *)pMemory); pStubMsg->Buffer += sizeof(NDR64_UINT16); break; case FC64_UINT32: case FC64_INT32: case FC64_ERROR_STATUS_T: case FC64_FLOAT32: ALIGN(pStubMsg->Buffer,3); *((NDR64_UINT32 *)pStubMsg->Buffer) = *((NDR64_UINT32 *)pMemory); pStubMsg->Buffer += sizeof(NDR64_UINT32); break; case FC64_UINT64: case FC64_INT64: case FC64_FLOAT64: ALIGN(pStubMsg->Buffer,7); *((NDR64_UINT64 *)pStubMsg->Buffer) = *((NDR64_UINT64 *)pMemory); pStubMsg->Buffer += sizeof(NDR64_UINT64); break; case FC64_IGNORE: break; default : NDR_ASSERT(0,"Ndr64SimpleTypeMarshall : bad format char"); RpcRaiseException( RPC_S_INTERNAL_ERROR ); return; } } void Ndr64UDTSimpleTypeMarshall1( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT FormatString ) { Ndr64SimpleTypeMarshall(pStubMsg,pMemory,*(PFORMAT_STRING)FormatString); } void Ndr64pRangeMarshall( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) /*++ --*/ { const NDR64_RANGE_FORMAT * pRangeFormat = (const NDR64_RANGE_FORMAT*)pFormat; Ndr64SimpleTypeMarshall( pStubMsg, pMemory, pRangeFormat->RangeType ); } void Ndr64pInterfacePointerMarshall ( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) /*++ Routine Description : Marshalls an interface pointer. Arguments : pStubMsg - Pointer to the stub message. pMemory - Pointer to the interface pointer being marshalled. pFormat - Interface pointer's format string description. Return : None. Notes : There is now one representation of a marshalled interface pointer. // wire representation of a marshalled interface pointer typedef struct tagMInterfacePointer { ULONG ulCntData; // size of data [size_is(ulCntData)] BYTE abData[]; // data (OBJREF) } MInterfacePointer; --*/ { const NDR64_CONSTANT_IID_FORMAT *pConstInterfaceFormat = (NDR64_CONSTANT_IID_FORMAT*)pFormat; const NDR64_IID_FORMAT *pInterfaceFormat = (NDR64_IID_FORMAT*)pFormat; // // Get an IID pointer. // IID *piid; if ( ((NDR64_IID_FLAGS*)&pInterfaceFormat->Flags)->ConstantIID ) { piid = (IID*)&pConstInterfaceFormat->Guid; } else { piid = (IID *) Ndr64EvaluateExpr( pStubMsg, pInterfaceFormat->IIDDescriptor, EXPR_IID ); if(piid == 0) { RpcRaiseException( RPC_S_INVALID_ARG ); return; } } // Leave space in the buffer for the conformant size. ALIGN( pStubMsg->Buffer, NDR64_WIRE_COUNT_ALIGN ); NDR64_WIRE_COUNT_TYPE * pMaxCount = (NDR64_WIRE_COUNT_TYPE *) pStubMsg->Buffer; pStubMsg->Buffer += sizeof(NDR64_WIRE_COUNT_TYPE); ulong *pulCntData = (ulong *) pStubMsg->Buffer; pStubMsg->Buffer += sizeof(ulong); //Calculate the maximum size of the stream. ulong position = (ulong)( pStubMsg->Buffer - (uchar *)pStubMsg->RpcMsg->Buffer); ulong cbMax = pStubMsg->RpcMsg->BufferLength - position; //Create a stream on memory. #if defined(DEBUG_WALKIP) { CHAR AppName[MAX_PATH]; memset(AppName, 0, sizeof(AppName ) ); GetModuleFileNameA( NULL, AppName, sizeof(AppName ) ); DbgPrint("MRSHL64 %s %p\n", AppName, pStubMsg->Buffer ); } #endif IStream *pStream = NdrpCreateStreamOnMemory(pStubMsg->Buffer, cbMax); if(pStream == 0) { RpcRaiseException(RPC_S_OUT_OF_MEMORY); return; } RpcTryFinally { HRESULT hr = (*pfnCoMarshalInterface)(pStream, *piid, (IUnknown *)pMemory, pStubMsg->dwDestContext, pStubMsg->pvDestContext, 0); if(FAILED(hr)) { RpcRaiseException(hr); return; } ULARGE_INTEGER libPosition; LARGE_INTEGER libMove; libMove.QuadPart = 0; pStream->Seek(libMove, STREAM_SEEK_CUR, &libPosition); //Update the array bounds. *pMaxCount = libPosition.QuadPart; //Advance the stub message buffer pointer. pStubMsg->Buffer += (*pulCntData = Ndr64pConvertTo2GB(libPosition.QuadPart)); } RpcFinally { pStream->Release(); } RpcEndFinally } __forceinline void Ndr64pPointerMarshallInternal( PMIDL_STUB_MESSAGE pStubMsg, NDR64_PTR_WIRE_TYPE *pBufferMark, uchar * pMemory, PNDR64_FORMAT pFormat ) /*++ Routine Description : Private routine for marshalling a pointer and its pointee. This is the entry point for pointers embedded in structures, arrays, and unions. Used for FC64_RP, FC64_UP, FC64_FP, FC64_OP. Arguments : pStubMsg - Pointer to the stub message. pBufferMark - Pointer to the pointer in the wire buffer. pMemory - Pointer to the data to be marshalled. pFormat - Pointer format string description. pStubMsg->Buffer - the place for the pointee. Return : None. --*/ { const NDR64_POINTER_FORMAT *pPointerFormat = (NDR64_POINTER_FORMAT*) pFormat; // // Check the pointer type. // switch ( pPointerFormat->FormatCode ) { case FC64_RP : if ( pBufferMark ) { // Put the pointer in the buffer. *((NDR64_PTR_WIRE_TYPE*)pBufferMark) = PTR_WIRE_REP(pMemory); } if ( !pMemory ) { RpcRaiseException( RPC_X_NULL_REF_POINTER ); } break; case FC64_UP : case FC64_OP : // Put the pointer in the buffer. *((NDR64_PTR_WIRE_TYPE*)pBufferMark) = PTR_WIRE_REP(pMemory); if ( ! pMemory ) { return; } break; case FC64_IP : // Put the pointer in the buffer *((NDR64_PTR_WIRE_TYPE*)pBufferMark) = PTR_WIRE_REP(pMemory); if ( ! pMemory ) { return; } Ndr64pInterfacePointerMarshall (pStubMsg, pMemory, pPointerFormat->Pointee ); return; case FC64_FP : // // Marshall the pointer's ref id and see if we've already // marshalled the pointer's data. // { ulong RefId; BOOL Result = Ndr64pFullPointerQueryPointer( pStubMsg, pMemory, FULL_POINTER_MARSHALLED, &RefId ); *(NDR64_PTR_WIRE_TYPE*)pBufferMark = Ndr64pRefIdToWirePtr( RefId ); if ( Result ) return; } break; default : NDR_ASSERT(0,"Ndr64pPointerMarshall : bad pointer type"); RpcRaiseException( RPC_S_INTERNAL_ERROR ); return; } if ( NDR64_SIMPLE_POINTER( pPointerFormat->Flags ) ) { Ndr64SimpleTypeMarshall( pStubMsg, pMemory, *(PFORMAT_STRING)pPointerFormat->Pointee ); return; } if ( NDR64_POINTER_DEREF( pPointerFormat->Flags ) ) pMemory = *((uchar **)pMemory); SAVE_CONTEXT uFlagsSave( pStubMsg->uFlags ); NDR64_RESET_EMBEDDED_FLAGS_TO_STANDALONE(pStubMsg->uFlags); Ndr64TopLevelTypeMarshall( pStubMsg, pMemory, pPointerFormat->Pointee ); } NDR64_MRSHL_POINTER_QUEUE_ELEMENT::NDR64_MRSHL_POINTER_QUEUE_ELEMENT( MIDL_STUB_MESSAGE *pStubMsg, NDR64_PTR_WIRE_TYPE * pBufferMarkNew, uchar * const pMemoryNew, const PFORMAT_STRING pFormatNew) : pBufferMark(pBufferMarkNew), pMemory(pMemoryNew), pFormat(pFormatNew), uFlags(pStubMsg->uFlags), pCorrMemory(pStubMsg->pCorrMemory) { } void NDR64_MRSHL_POINTER_QUEUE_ELEMENT::Dispatch( MIDL_STUB_MESSAGE *pStubMsg) { SAVE_CONTEXT uFlagsSave(pStubMsg->uFlags, uFlags ); CORRELATION_CONTEXT CorrCtxt( pStubMsg, pCorrMemory ); Ndr64pPointerMarshallInternal( pStubMsg, pBufferMark, pMemory, (PNDR64_FORMAT)pFormat ); } #if defined(DBG) void NDR64_MRSHL_POINTER_QUEUE_ELEMENT::Print() { DbgPrint("NDR_MRSHL_POINTER_QUEUE_ELEMENT\n"); DbgPrint("pNext: %p\n", pNext ); DbgPrint("pBufferMark: %p\n", pBufferMark ); DbgPrint("pMemory: %p\n", pMemory ); DbgPrint("pFormat: %p\n", pFormat ); DbgPrint("pCorrMemory: %p\n", pCorrMemory ); DbgPrint("uFlags: %x\n", uFlags ); } #endif void Ndr64pEnquePointerMarshall( PMIDL_STUB_MESSAGE pStubMsg, NDR64_PTR_WIRE_TYPE *pBufferMark, uchar * pMemory, PNDR64_FORMAT pFormat ) { NDR64_POINTER_CONTEXT PointerContext( pStubMsg ); RpcTryFinally { NDR64_MRSHL_POINTER_QUEUE_ELEMENT*pElement = new(PointerContext.GetActiveState()) NDR64_MRSHL_POINTER_QUEUE_ELEMENT(pStubMsg, pBufferMark, pMemory, (PFORMAT_STRING)pFormat); PointerContext.Enque( pElement ); PointerContext.DispatchIfRequired(); } RpcFinally { PointerContext.EndContext(); } RpcEndFinally } void Ndr64pPointerMarshall( PMIDL_STUB_MESSAGE pStubMsg, NDR64_PTR_WIRE_TYPE *pBufferMark, uchar * pMemory, PNDR64_FORMAT pFormat ) { SAVE_CONTEXT uFlagsSave(pStubMsg->uFlags); if ( !NdrIsLowStack(pStubMsg) ) { Ndr64pPointerMarshallInternal( pStubMsg, pBufferMark, pMemory, pFormat ); return; } Ndr64pEnquePointerMarshall( pStubMsg, pBufferMark, pMemory, pFormat ); } __forceinline void Ndr64TopLevelPointerMarshall( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) { NDR64_PTR_WIRE_TYPE *pBufferMark = NULL; // Non embedded ref pointers do not have a wire representation if ( *(PFORMAT_STRING)pFormat != FC64_RP ) { ALIGN( pStubMsg->Buffer, NDR64_PTR_WIRE_ALIGN ); pBufferMark = (NDR64_PTR_WIRE_TYPE*)pStubMsg->Buffer; pStubMsg->Buffer += sizeof(NDR64_PTR_WIRE_TYPE); } Ndr64pPointerMarshall( pStubMsg, pBufferMark, pMemory, pFormat ); } __forceinline void Ndr64EmbeddedPointerMarshall( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) { ALIGN( pStubMsg->Buffer, NDR64_PTR_WIRE_ALIGN ); NDR64_PTR_WIRE_TYPE* pBufferMark = (NDR64_PTR_WIRE_TYPE*)pStubMsg->Buffer; pStubMsg->Buffer += sizeof(NDR64_PTR_WIRE_TYPE); POINTER_BUFFER_SWAP_CONTEXT SwapContext(pStubMsg); Ndr64pPointerMarshall( pStubMsg, pBufferMark, *(uchar**)pMemory, pFormat ); } void Ndr64SimpleStructMarshall( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) /*++ Routine description : Marshalls a simple structure. Used for FC64_STRUCT and FC64_PSTRUCT. Arguments : pStubMsg - Pointer to the stub message. pMemory - Pointer to the structure to be marshalled. pFormat - Structure's format string description. Return : None. --*/ { const NDR64_STRUCTURE_HEADER_FORMAT * const pStructFormat = (NDR64_STRUCTURE_HEADER_FORMAT*) pFormat; const NDR64_UINT32 StructSize = pStructFormat->MemorySize; ALIGN(pStubMsg->Buffer, pStructFormat->Alignment); uchar *pBufferSave = pStubMsg->Buffer; RpcpMemoryCopy( pBufferSave, pMemory, pStructFormat->MemorySize ); pStubMsg->Buffer += pStructFormat->MemorySize; // Marshall embedded pointers. if ( pStructFormat->Flags.HasPointerInfo ) { CORRELATION_CONTEXT CorrCtxt( pStubMsg, pMemory); Ndr64pPointerLayoutMarshall( pStubMsg, pStructFormat + 1, 0, pMemory, pBufferSave ); } } void Ndr64ConformantStructMarshall( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) /*++ Routine description : Marshalls a conformant structure. Arguments : pStubMsg - Pointer to the stub message. pMemory - Pointer to the structure to be marshalled. pFormat - Structure's format string description. Return : None. Note --*/ { const NDR64_CONF_STRUCTURE_HEADER_FORMAT * const pStructFormat = (NDR64_CONF_STRUCTURE_HEADER_FORMAT*) pFormat; const NDR64_CONF_ARRAY_HEADER_FORMAT * const pArrayFormat = (NDR64_CONF_ARRAY_HEADER_FORMAT *) pStructFormat->ArrayDescription; CORRELATION_CONTEXT CorrCtxt( pStubMsg, pMemory ); NDR64_WIRE_COUNT_TYPE MaxCount = Ndr64EvaluateExpr( pStubMsg, pArrayFormat->ConfDescriptor, EXPR_MAXCOUNT ); if ( NDR64_IS_CONF_MARK_VALID( pStubMsg->uFlags ) ) *(NDR64_WIRE_COUNT_TYPE *)pStubMsg->ConformanceMark = MaxCount; else { ALIGN( pStubMsg->Buffer, NDR64_WIRE_COUNT_ALIGN ); *((NDR64_WIRE_COUNT_TYPE *)pStubMsg->Buffer) = MaxCount; pStubMsg->Buffer += sizeof(NDR64_WIRE_COUNT_TYPE); } ALIGN(pStubMsg->Buffer, pStructFormat->Alignment); uchar *pBufferStart = pStubMsg->Buffer; NDR64_UINT32 StructSize = Ndr64pConvertTo2GB( (NDR64_UINT64)pStructFormat->MemorySize + ( MaxCount * (NDR64_UINT64)pArrayFormat->ElementSize ) ); RpcpMemoryCopy( pBufferStart, pMemory, StructSize ); pStubMsg->Buffer += StructSize; if ( pStructFormat->Flags.HasPointerInfo ) { Ndr64pPointerLayoutMarshall( pStubMsg, pStructFormat + 1, (NDR64_UINT32)MaxCount, pMemory, pBufferStart ); } } void Ndr64ComplexStructMarshall( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) /*++ Routine description : Marshalls a complex structure. Used for FC64_BOGUS_STRUCT. Arguments : pStubMsg - Pointer to the stub message. pMemory - Pointer to the structure being marshalled. pFormat - Structure's format string description. Return : None. Notes : --*/ { const NDR64_BOGUS_STRUCTURE_HEADER_FORMAT * pStructFormat = (NDR64_BOGUS_STRUCTURE_HEADER_FORMAT*) pFormat; const NDR64_CONF_BOGUS_STRUCTURE_HEADER_FORMAT * pConfStructFormat = (NDR64_CONF_BOGUS_STRUCTURE_HEADER_FORMAT*) pFormat; uchar * pBufferSave = pStubMsg->Buffer; bool fSetPointerBufferMark = ! pStubMsg->PointerBufferMark; // Compute where the pointees should be unmarshalled to. if ( fSetPointerBufferMark ) { BOOL fOldIgnore = pStubMsg->IgnoreEmbeddedPointers; pStubMsg->IgnoreEmbeddedPointers = TRUE; // // Set BufferLength equal to the current buffer pointer, and then // when we return from NdrComplexStructBufferSize it will pointer to // the location in the buffer where the pointees should be marshalled. // pStubMsg->BufferLength = pBufferSave; // Instead of pointer, we now calculate pointer increment explicitly. // Set the pointer alignment as a base. // We use pBufferSave as the sizing routine accounts for the conf sizes. // ulong BufferLenOffset = 0xf & PtrToUlong( pBufferSave ); ulong BufferLengthSave = pStubMsg->BufferLength; pStubMsg->BufferLength = BufferLenOffset; Ndr64ComplexStructBufferSize( pStubMsg, pMemory, pFormat ); // Pointer increment including alignments. BufferLenOffset = pStubMsg->BufferLength - BufferLenOffset; // Set the location in the buffer where pointees will be marshalled. pStubMsg->PointerBufferMark = pStubMsg->Buffer + BufferLenOffset; pStubMsg->BufferLength = BufferLengthSave; pStubMsg->IgnoreEmbeddedPointers = fOldIgnore; } PFORMAT_STRING pFormatPointers = (PFORMAT_STRING)pStructFormat->PointerLayout; PFORMAT_STRING pFormatArray = NULL; BOOL fIsFullBogus = ( *(PFORMAT_STRING)pFormat == FC64_BOGUS_STRUCT || *(PFORMAT_STRING)pFormat == FC64_CONF_BOGUS_STRUCT ); PFORMAT_STRING pMemberLayout = ( *(PFORMAT_STRING)pFormat == FC64_CONF_BOGUS_STRUCT || *(PFORMAT_STRING)pFormat == FC64_FORCED_CONF_BOGUS_STRUCT ) ? (PFORMAT_STRING)( pConfStructFormat + 1) : (PFORMAT_STRING)( pStructFormat + 1); SAVE_CONTEXT ConformanceMarkSave(pStubMsg->ConformanceMark); SAVE_CONTEXT uFlagsSave( pStubMsg->uFlags ); CORRELATION_CONTEXT CorrCtxt( pStubMsg, pMemory ); // Get conformant array description. if ( pStructFormat->Flags.HasConfArray ) { pFormatArray = (PFORMAT_STRING)pConfStructFormat->ConfArrayDescription; if ( !NDR64_IS_CONF_MARK_VALID( pStubMsg->uFlags ) ) { // Align for conformance marshalling. ALIGN(pStubMsg->Buffer, NDR64_WIRE_COUNT_ALIGN); // Remember where the conformance count(s) will be marshalled. pStubMsg->ConformanceMark = pStubMsg->Buffer; // Increment the buffer pointer for every array dimension. pStubMsg->Buffer += pConfStructFormat->Dimensions * sizeof(NDR64_WIRE_COUNT_TYPE); NDR64_SET_CONF_MARK_VALID( pStubMsg->uFlags ); } } else pFormatArray = 0; // Align buffer on struct's alignment. ALIGN(pStubMsg->Buffer, pStructFormat->Alignment); // // Marshall the structure member by member. // for ( ; ; ) { switch ( *pMemberLayout ) { case FC64_STRUCT: { const NDR64_SIMPLE_REGION_FORMAT *pRegion = (NDR64_SIMPLE_REGION_FORMAT*) pMemberLayout; ALIGN( pStubMsg->Buffer, pRegion->Alignment ); RpcpMemoryCopy( pStubMsg->Buffer, pMemory, pRegion->RegionSize ); pStubMsg->Buffer += pRegion->RegionSize; pMemory += pRegion->RegionSize; pMemberLayout += sizeof( *pRegion ); break; } case FC64_STRUCTPADN : { const NDR64_MEMPAD_FORMAT *pMemPad = (NDR64_MEMPAD_FORMAT*)pMemberLayout; pMemory += pMemPad->MemPad; pMemberLayout += sizeof(*pMemPad); break; } case FC64_POINTER : { NDR_ASSERT(pFormatPointers, "Ndr64ComplexStructMarshall: pointer field but no pointer layout"); Ndr64EmbeddedPointerMarshall( pStubMsg, pMemory, pFormatPointers ); pMemory += PTR_MEM_SIZE; pFormatPointers += sizeof(NDR64_POINTER_FORMAT); pMemberLayout += sizeof(NDR64_SIMPLE_MEMBER_FORMAT); break; } case FC64_EMBEDDED_COMPLEX : { const NDR64_EMBEDDED_COMPLEX_FORMAT * pEmbeddedFormat = (NDR64_EMBEDDED_COMPLEX_FORMAT*) pMemberLayout; Ndr64EmbeddedTypeMarshall( pStubMsg, pMemory, pEmbeddedFormat->Type ); pMemory = Ndr64pMemoryIncrement( pStubMsg, pMemory, pEmbeddedFormat->Type, FALSE ); pMemberLayout += sizeof(*pEmbeddedFormat); break; } case FC64_BUFFER_ALIGN: { const NDR64_BUFFER_ALIGN_FORMAT *pBufAlign = (NDR64_BUFFER_ALIGN_FORMAT*) pMemberLayout; ALIGN(pStubMsg->Buffer, pBufAlign->Alignment); pMemberLayout += sizeof( *pBufAlign ); break; } case FC64_CHAR : case FC64_WCHAR : case FC64_INT8: case FC64_UINT8: case FC64_INT16: case FC64_UINT16: case FC64_INT32: case FC64_UINT32: case FC64_INT64: case FC64_UINT64: case FC64_FLOAT32 : case FC64_FLOAT64 : case FC64_ERROR_STATUS_T: Ndr64SimpleTypeMarshall( pStubMsg, pMemory, *pMemberLayout ); pMemory += NDR64_SIMPLE_TYPE_MEMSIZE(*pMemberLayout); pMemberLayout += sizeof(NDR64_SIMPLE_MEMBER_FORMAT); break; case FC64_IGNORE : ALIGN(pStubMsg->Buffer, NDR64_PTR_WIRE_ALIGN ); pMemory += PTR_MEM_SIZE; *(NDR64_PTR_WIRE_TYPE*)pStubMsg->Buffer = 0; pStubMsg->Buffer += sizeof(NDR64_PTR_WIRE_TYPE); pMemberLayout += sizeof(NDR64_SIMPLE_MEMBER_FORMAT); break; case FC64_END : goto ComplexMarshallEnd; default : NDR_ASSERT(0,"Ndr64ComplexStructMarshall : bad format char"); RpcRaiseException( RPC_S_INTERNAL_ERROR ); return; } // switch } // for ComplexMarshallEnd: // // Marshall conformant array if we have one. if ( pFormatArray ) { Ndr64EmbeddedTypeMarshall( pStubMsg, pMemory, pFormatArray ); } else { // If the structure doesn't have a conformant array, align it again ALIGN( pStubMsg->Buffer, pStructFormat->Alignment ); } if ( fSetPointerBufferMark ) { pStubMsg->Buffer = pStubMsg->PointerBufferMark; pStubMsg->PointerBufferMark = 0; } } void Ndr64NonConformantStringMarshall( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) /*++ Routine description : Marshalls a non conformant string. Arguments : pStubMsg - Pointer to the stub message. pMemory - Pointer to the string to be marshalled. pFormat - String's format string description. Return : None. --*/ { const NDR64_NON_CONFORMANT_STRING_FORMAT * pStringFormat = (NDR64_NON_CONFORMANT_STRING_FORMAT*) pFormat; NDR64_UINT32 CopySize = Ndr64pCommonStringSize( pStubMsg, pMemory, &pStringFormat->Header ); if ( CopySize > pStringFormat->TotalSize ) RpcRaiseException(RPC_X_INVALID_BOUND); ALIGN( pStubMsg->Buffer, NDR64_WIRE_COUNT_ALIGN ); ((NDR64_WIRE_COUNT_TYPE*)pStubMsg->Buffer)[0] = pStubMsg->Offset; ((NDR64_WIRE_COUNT_TYPE*)pStubMsg->Buffer)[1] = pStubMsg->ActualCount; pStubMsg->Buffer += sizeof(NDR64_WIRE_COUNT_TYPE) * 2; // Copy the string. RpcpMemoryCopy( pStubMsg->Buffer, pMemory, CopySize ); pStubMsg->Buffer += CopySize; } void Ndr64ConformantStringMarshall( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) /*++ Routine description : Marshalls a conformant string. Arguments : pStubMsg - Pointer to the stub message. pMemory - Pointer to the string to be marshalled. pFormat - String's format string description. Return : None. --*/ { const NDR64_CONFORMANT_STRING_FORMAT * pStringFormat = (const NDR64_CONFORMANT_STRING_FORMAT*) pFormat; const NDR64_SIZED_CONFORMANT_STRING_FORMAT * pSizedStringFormat = (const NDR64_SIZED_CONFORMANT_STRING_FORMAT*) pFormat; NDR64_WIRE_COUNT_TYPE *pMaxCountMark; if ( !NDR64_IS_CONF_MARK_VALID( pStubMsg->uFlags ) ) { ALIGN( pStubMsg->Buffer, NDR64_WIRE_COUNT_ALIGN ); pMaxCountMark = (NDR64_WIRE_COUNT_TYPE*)pStubMsg->Buffer; pStubMsg->Buffer += sizeof(NDR64_WIRE_COUNT_TYPE); } else { pMaxCountMark = (NDR64_WIRE_COUNT_TYPE*)pStubMsg->ConformanceMark; } NDR64_UINT32 CopySize = Ndr64pCommonStringSize( pStubMsg, pMemory, &pStringFormat->Header ); // // If the string is sized then compute the max count, otherwise the // max count is equal to the actual count. // NDR64_WIRE_COUNT_TYPE MaxCount = pStubMsg->ActualCount; if ( pStringFormat->Header.Flags.IsSized ) { MaxCount = Ndr64EvaluateExpr( pStubMsg, pSizedStringFormat->SizeDescription, EXPR_MAXCOUNT ); if ( pStubMsg->ActualCount > MaxCount ) RpcRaiseException(RPC_X_INVALID_BOUND); } // Marshall the max count. *pMaxCountMark = MaxCount; ALIGN( pStubMsg->Buffer, NDR64_WIRE_COUNT_ALIGN); ((NDR64_WIRE_COUNT_TYPE*)pStubMsg->Buffer)[0] = pStubMsg->Offset; ((NDR64_WIRE_COUNT_TYPE*)pStubMsg->Buffer)[1] = pStubMsg->ActualCount; pStubMsg->Buffer += sizeof(NDR64_WIRE_COUNT_TYPE) * 2; RpcpMemoryCopy( pStubMsg->Buffer, pMemory, CopySize ); // Update the Buffer pointer. pStubMsg->Buffer += CopySize; } void Ndr64FixedArrayMarshall( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) /*++ Routine Description : Marshalls a fixed array of any number of dimensions. Arguments : pStubMsg - Pointer to the stub message. pMemory - Pointer to the array to be marshalled. pFormat - Array's format string description. Return : None. --*/ { const NDR64_FIX_ARRAY_HEADER_FORMAT * pArrayFormat = (NDR64_FIX_ARRAY_HEADER_FORMAT*) pFormat; // Align the buffer. ALIGN( pStubMsg->Buffer, pArrayFormat->Alignment ); uchar *pBufferStart = pStubMsg->Buffer; // Copy the array. RpcpMemoryCopy( pBufferStart, pMemory, pArrayFormat->TotalSize ); // Increment stub message buffer pointer. pStubMsg->Buffer += pArrayFormat->TotalSize; // Marshall embedded pointers. if ( pArrayFormat->Flags.HasPointerInfo ) { Ndr64pPointerLayoutMarshall( pStubMsg, pArrayFormat + 1, 0, pMemory, pBufferStart ); } } void Ndr64ConformantArrayMarshall( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) /*++ Routine Description : Marshalls a top level one dimensional conformant array. Arguments : pStubMsg - Pointer to the stub message. pMemory - Pointer to the array being marshalled. pFormat - Array's format string description. Return : None. --*/ { const NDR64_CONF_ARRAY_HEADER_FORMAT *pArrayFormat = (NDR64_CONF_ARRAY_HEADER_FORMAT*) pFormat; uchar *pConformanceMark; if ( !NDR64_IS_CONF_MARK_VALID( pStubMsg->uFlags ) ) { // Align the buffer for conformance marshalling. ALIGN(pStubMsg->Buffer,NDR64_WIRE_COUNT_ALIGN); pConformanceMark = pStubMsg->Buffer; pStubMsg->Buffer += sizeof(NDR64_WIRE_COUNT_TYPE); } else { pConformanceMark = pStubMsg->ConformanceMark; } NDR64_WIRE_COUNT_TYPE MaxCount = Ndr64EvaluateExpr( pStubMsg, pArrayFormat->ConfDescriptor, EXPR_MAXCOUNT ); *(NDR64_WIRE_COUNT_TYPE*)pConformanceMark = MaxCount; ALIGN( pStubMsg->Buffer, pArrayFormat->Alignment ); // Compute the total array size in bytes. NDR64_UINT32 CopySize = Ndr64pConvertTo2GB(MaxCount * (NDR64_UINT64)pArrayFormat->ElementSize); RpcpMemoryCopy( pStubMsg->Buffer, pMemory, CopySize ); // Update buffer pointer. uchar *pBufferStart = pStubMsg->Buffer; pStubMsg->Buffer += CopySize; // Marshall embedded pointers. if ( pArrayFormat->Flags.HasPointerInfo ) { Ndr64pPointerLayoutMarshall( pStubMsg, pArrayFormat + 1, (NDR64_UINT32)MaxCount, pMemory, pBufferStart ); } } void Ndr64ConformantVaryingArrayMarshall( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) /*++ Routine Description : Marshalls a top level one dimensional conformant varying array. Used for FC64_CVARRAY. Arguments : pStubMsg - Pointer to the stub message. pMemory - Pointer to the array being marshalled. pFormat - Array's format string description. Return : None. --*/ { const NDR64_CONF_VAR_ARRAY_HEADER_FORMAT * pArrayFormat = (NDR64_CONF_VAR_ARRAY_HEADER_FORMAT*) pFormat; uchar *pConformanceMark; if ( ! NDR64_IS_CONF_MARK_VALID( pStubMsg->uFlags ) ) { ALIGN( pStubMsg->Buffer, NDR64_WIRE_COUNT_ALIGN); pConformanceMark = pStubMsg->Buffer; pStubMsg->Buffer += sizeof(NDR64_WIRE_COUNT_TYPE); } else { pConformanceMark = pStubMsg->ConformanceMark; } NDR64_WIRE_COUNT_TYPE MaxCount = Ndr64EvaluateExpr( pStubMsg, pArrayFormat->ConfDescriptor, EXPR_MAXCOUNT ); NDR64_WIRE_COUNT_TYPE ActualCount = Ndr64EvaluateExpr( pStubMsg, pArrayFormat->VarDescriptor, EXPR_ACTUALCOUNT ); if ( ActualCount > MaxCount ) RpcRaiseException( RPC_X_INVALID_BOUND ); *(NDR64_WIRE_COUNT_TYPE*)pConformanceMark = MaxCount; // Align the buffer for variance marshalling. ALIGN(pStubMsg->Buffer, NDR64_WIRE_COUNT_ALIGN); // Marshall variance. ((NDR64_WIRE_COUNT_TYPE *)pStubMsg->Buffer)[0] = 0; ((NDR64_WIRE_COUNT_TYPE *)pStubMsg->Buffer)[1] = ActualCount; pStubMsg->Buffer += sizeof(NDR64_WIRE_COUNT_TYPE) * 2; NDR64_UINT32 CopySize = Ndr64pConvertTo2GB( ActualCount * (NDR64_UINT64)pArrayFormat->ElementSize ); ALIGN( pStubMsg->Buffer, pArrayFormat->Alignment ); RpcpMemoryCopy( pStubMsg->Buffer, pMemory, CopySize ); uchar *pBufferStart = pStubMsg->Buffer; pStubMsg->Buffer += CopySize; // Marshall embedded pointers. if ( pArrayFormat->Flags.HasPointerInfo ) { Ndr64pPointerLayoutMarshall( pStubMsg, pArrayFormat + 1, (NDR64_UINT32)ActualCount, pMemory, pBufferStart ); } } void Ndr64VaryingArrayMarshall( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) /*++ Routine Description : Marshalls a top level or embedded one dimensional varying array. Arguments : pStubMsg - Pointer to the stub message. pMemory - Pointer to the array being marshalled. pFormat - Array's format string description. Return : None. --*/ { const NDR64_VAR_ARRAY_HEADER_FORMAT * pArrayFormat = (NDR64_VAR_ARRAY_HEADER_FORMAT*) pFormat; // Compute the variance offset and count. NDR64_WIRE_COUNT_TYPE ActualCount = Ndr64EvaluateExpr( pStubMsg, pArrayFormat->VarDescriptor, EXPR_ACTUALCOUNT ); NDR64_UINT32 CopySize = Ndr64pConvertTo2GB( ActualCount * (NDR64_UINT64)pArrayFormat->ElementSize ); // Align the buffer for variance marshalling. ALIGN(pStubMsg->Buffer, NDR64_WIRE_COUNT_ALIGN ); // Marshall variance. ((NDR64_WIRE_COUNT_TYPE *)pStubMsg->Buffer)[0] = 0; ((NDR64_WIRE_COUNT_TYPE *)pStubMsg->Buffer)[1] = ActualCount; pStubMsg->Buffer += sizeof(NDR64_WIRE_COUNT_TYPE) * 2; ALIGN(pStubMsg->Buffer, pArrayFormat->Alignment); // Copy the array. RpcpMemoryCopy( pStubMsg->Buffer, pMemory, CopySize ); // Update buffer pointer. uchar *pBufferStart = pStubMsg->Buffer; pStubMsg->Buffer += CopySize; // Marshall embedded pointers. if ( pArrayFormat->Flags.HasPointerInfo ) { Ndr64pPointerLayoutMarshall( pStubMsg, pArrayFormat + 1, (NDR64_UINT32)ActualCount, pMemory, pBufferStart ); } } void Ndr64ComplexArrayMarshall( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) /*++ Routine Description : Marshalls a top level complex array. Arguments : pStubMsg - Pointer to the stub message. pMemory - Pointer to the array being marshalled. pFormat - Array's format string description. Return : None. --*/ { const NDR64_BOGUS_ARRAY_HEADER_FORMAT *pArrayFormat = (NDR64_BOGUS_ARRAY_HEADER_FORMAT *) pFormat; bool fSetPointerBufferMark = ! pStubMsg->PointerBufferMark; if ( fSetPointerBufferMark ) { BOOL fOldIgnore = pStubMsg->IgnoreEmbeddedPointers; pStubMsg->IgnoreEmbeddedPointers = TRUE; ulong BufferLenOffset = 0xf & PtrToUlong( pStubMsg->Buffer ); ulong BufferLengthSave = pStubMsg->BufferLength; pStubMsg->BufferLength = BufferLenOffset; Ndr64ComplexArrayBufferSize( pStubMsg, pMemory, pFormat ); // Pointer increment including alignments. BufferLenOffset = pStubMsg->BufferLength - BufferLenOffset; // // This is the buffer pointer to the position where embedded pointers // will be marshalled. // pStubMsg->PointerBufferMark = pStubMsg->Buffer + BufferLenOffset; pStubMsg->BufferLength = BufferLengthSave; pStubMsg->IgnoreEmbeddedPointers = fOldIgnore; } BOOL IsFixed = ( pArrayFormat->FormatCode == FC64_FIX_BOGUS_ARRAY ) || ( pArrayFormat->FormatCode == FC64_FIX_FORCED_BOGUS_ARRAY ); PFORMAT_STRING pElementFormat = (PFORMAT_STRING)pArrayFormat->Element; NDR64_WIRE_COUNT_TYPE Elements = pArrayFormat->NumberElements; NDR64_WIRE_COUNT_TYPE Count = Elements; NDR64_WIRE_COUNT_TYPE Offset = 0; SAVE_CONTEXT ConformanceMarkSave( pStubMsg->ConformanceMark ); SAVE_CONTEXT VarianceMarkSave( pStubMsg->VarianceMark ); SAVE_CONTEXT uFlagsSave( pStubMsg->uFlags ); if ( !IsFixed ) { const NDR64_CONF_VAR_BOGUS_ARRAY_HEADER_FORMAT* pConfVarFormat= (NDR64_CONF_VAR_BOGUS_ARRAY_HEADER_FORMAT*)pFormat; if ( pConfVarFormat->ConfDescription != 0 ) { if ( ! NDR64_IS_CONF_MARK_VALID( pStubMsg->uFlags ) ) { // // Outer most dimension sets the conformance marker. // // Align the buffer for conformance marshalling. ALIGN(pStubMsg->Buffer, NDR64_WIRE_COUNT_ALIGN); // Mark where the conformance count(s) will be marshalled. pStubMsg->ConformanceMark = pStubMsg->Buffer; // Increment past where the conformance will go. pStubMsg->Buffer += pArrayFormat->NumberDims * sizeof(NDR64_WIRE_COUNT_TYPE); NDR64_SET_CONF_MARK_VALID( pStubMsg->uFlags ); } Elements = Ndr64EvaluateExpr( pStubMsg, pConfVarFormat->ConfDescription, EXPR_MAXCOUNT ); *(NDR64_WIRE_COUNT_TYPE*) pStubMsg->ConformanceMark = Elements; pStubMsg->ConformanceMark += sizeof(NDR64_WIRE_COUNT_TYPE); Offset = 0; Count = Elements; } // // Check for variance description. // if ( pConfVarFormat->VarDescription != 0 ) { if ( ! NDR64_IS_VAR_MARK_VALID( pStubMsg->uFlags ) ) { NDR64_UINT32 Dimensions; // // Set the variance marker. // ALIGN(pStubMsg->Buffer, NDR64_WIRE_COUNT_ALIGN ); Dimensions = ( pArrayFormat->Flags.IsArrayofStrings ) ? ( pArrayFormat->NumberDims - 1) : ( pArrayFormat->NumberDims ); // Increment past where the variance will go. pStubMsg->VarianceMark = pStubMsg->Buffer; pStubMsg->Buffer += Dimensions * sizeof(NDR64_WIRE_COUNT_TYPE) * 2; if ( NDR64_IS_ARRAY_OR_STRING( *pElementFormat ) ) NDR64_SET_VAR_MARK_VALID( pStubMsg->uFlags ); } else if ( !NDR64_IS_ARRAY_OR_STRING( *pElementFormat ) ) NDR64_RESET_VAR_MARK_VALID( pStubMsg->uFlags ); Count = Ndr64EvaluateExpr( pStubMsg, pConfVarFormat->VarDescription, EXPR_ACTUALCOUNT ); Offset = Ndr64EvaluateExpr( pStubMsg, pConfVarFormat->OffsetDescription, EXPR_OFFSET ); if ( Count + Offset > Elements ) RpcRaiseException( RPC_X_INVALID_BOUND ); ((NDR64_WIRE_COUNT_TYPE*)pStubMsg->VarianceMark)[0] = Offset; ((NDR64_WIRE_COUNT_TYPE*)pStubMsg->VarianceMark)[1] = Count; pStubMsg->VarianceMark += sizeof(NDR64_WIRE_COUNT_TYPE) * 2; } } NDR64_UINT32 ElementMemorySize = Ndr64pMemorySize( pStubMsg, pElementFormat, FALSE ); pMemory += Ndr64pConvertTo2GB( Offset * (NDR64_UINT64)ElementMemorySize); Ndr64pConvertTo2GB( Elements * (NDR64_UINT64)ElementMemorySize ); Ndr64pConvertTo2GB( Count * (NDR64_UINT64)ElementMemorySize ); ALIGN(pStubMsg->Buffer, pArrayFormat->Alignment); for ( ; Count--; ) { Ndr64EmbeddedTypeMarshall( pStubMsg, pMemory, pElementFormat ); pMemory += ElementMemorySize; } if ( fSetPointerBufferMark ) { pStubMsg->Buffer = pStubMsg->PointerBufferMark; pStubMsg->PointerBufferMark = 0; } } void Ndr64UnionMarshall ( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) /*++ Routine Description : Marshalls an encapsulated union. Used for FC64_ENCAPSULATED_UNION. Arguments : pStubMsg - Pointer to the stub message. pMemory - Pointer to the union being marshalled. pFormat - Union's format string description. Return : None. --*/ { const NDR64_UNION_ARM_SELECTOR* pArmSelector; EXPR_VALUE SwitchIs; NDR64_FORMAT_CHAR SwitchType; uchar *pArmMemory; switch(*(PFORMAT_STRING)pFormat) { case FC64_NON_ENCAPSULATED_UNION: { const NDR64_NON_ENCAPSULATED_UNION* pNonEncapUnionFormat = (const NDR64_NON_ENCAPSULATED_UNION*) pFormat; ALIGN(pStubMsg->Buffer, pNonEncapUnionFormat->Alignment); SwitchType = pNonEncapUnionFormat->SwitchType; pArmSelector = (NDR64_UNION_ARM_SELECTOR*)(pNonEncapUnionFormat + 1); SwitchIs = Ndr64EvaluateExpr( pStubMsg, pNonEncapUnionFormat->Switch, EXPR_SWITCHIS ); pArmMemory = pMemory; break; } case FC64_ENCAPSULATED_UNION: { const NDR64_ENCAPSULATED_UNION* pEncapUnionFormat = (const NDR64_ENCAPSULATED_UNION*)pFormat; ALIGN(pStubMsg->Buffer, pEncapUnionFormat->Alignment); SwitchType = pEncapUnionFormat->SwitchType; pArmSelector = (NDR64_UNION_ARM_SELECTOR*)(pEncapUnionFormat + 1); SwitchIs = Ndr64pSimpleTypeToExprValue(SwitchType, pMemory); pArmMemory = pMemory + pEncapUnionFormat->MemoryOffset; break; } default: NDR_ASSERT(0, "Bad union format\n"); } Ndr64SimpleTypeMarshall( pStubMsg, (uchar *)&SwitchIs, SwitchType ); ALIGN(pStubMsg->Buffer, pArmSelector->Alignment); PNDR64_FORMAT pArmFormat = Ndr64pFindUnionArm( pStubMsg, pArmSelector, SwitchIs ); if ( !pArmFormat ) return; Ndr64EmbeddedTypeMarshall( pStubMsg, pArmMemory, pArmFormat ); } void Ndr64XmitOrRepAsMarshall ( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat, bool bIsEmbedded ) /*++ Routine Description : Marshalls a transmit as or represent as argument: - translate the presented object into a transmitted object - marshall the transmitted object - free the transmitted object Format string layout: check out ndr64types.h Arguments : pStubMsg - a pointer to the stub message pMemory - presented type translated into transmitted type and than to be marshalled pFormat - format string description --*/ { // Skip the token itself and Oi flag. Fetch the QuintupleIndex. NDR64_TRANSMIT_AS_FORMAT * pTransFormat = ( NDR64_TRANSMIT_AS_FORMAT *) pFormat; NDR_ASSERT( pTransFormat->FormatCode == FC64_TRANSMIT_AS || pTransFormat->FormatCode , "invalid format string for user marshal" ); unsigned short QIndex = pTransFormat->RoutineIndex; // First translate the presented type into the transmitted type. // This includes an allocation of a transmitted type object. pStubMsg->pPresentedType = pMemory; pStubMsg->pTransmitType = NULL; const XMIT_ROUTINE_QUINTUPLE * pQuintuple = pStubMsg->StubDesc->aXmitQuintuple; pQuintuple[ QIndex ].pfnTranslateToXmit( pStubMsg ); unsigned char * pTransmittedType = pStubMsg->pTransmitType; // In NDR64, Xmit/Rep cannot be a pointer or contain a pointer. // So we don't need to worry about the pointer queue here. if ( bIsEmbedded ) { Ndr64EmbeddedTypeMarshall( pStubMsg, pTransmittedType, pTransFormat->TransmittedType ); } else { Ndr64TopLevelTypeMarshall( pStubMsg, pTransmittedType, pTransFormat->TransmittedType ); } pStubMsg->pTransmitType = pTransmittedType; // Free the temporary transmitted object (it was allocated by the user). pQuintuple[ QIndex ].pfnFreeXmit( pStubMsg ); } void Ndr64TopLevelXmitOrRepAsMarshall ( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) { Ndr64XmitOrRepAsMarshall( pStubMsg, pMemory, pFormat, false ); } void Ndr64EmbeddedXmitOrRepAsMarshall ( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) { Ndr64XmitOrRepAsMarshall( pStubMsg, pMemory, pFormat, true ); } void Ndr64UserMarshallMarshallInternal( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat, NDR64_PTR_WIRE_TYPE *pWirePtr ) { NDR64_USER_MARSHAL_FORMAT * pUserFormat = ( NDR64_USER_MARSHAL_FORMAT *) pFormat; unsigned char * pUserBuffer = pStubMsg->Buffer; unsigned char * pUserBufferSaved = pUserBuffer; // We always call user's routine to marshall. USER_MARSHAL_CB UserMarshalCB; Ndr64pInitUserMarshalCB( pStubMsg, pUserFormat, USER_MARSHAL_CB_MARSHALL, & UserMarshalCB ); unsigned short QIndex = pUserFormat->RoutineIndex; const USER_MARSHAL_ROUTINE_QUADRUPLE * pQuadruple = (const USER_MARSHAL_ROUTINE_QUADRUPLE *)( ( NDR_PROC_CONTEXT *)pStubMsg->pContext )->pSyntaxInfo->aUserMarshalQuadruple; if ((pUserBufferSaved < (uchar *) pStubMsg->RpcMsg->Buffer) || ((unsigned long) (pUserBufferSaved - (uchar *) pStubMsg->RpcMsg->Buffer) > pStubMsg->RpcMsg->BufferLength)) { RpcRaiseException( RPC_X_INVALID_BUFFER ); } pUserBuffer = pQuadruple[ QIndex ].pfnMarshall( (ulong*) &UserMarshalCB, pUserBuffer, pMemory ); if ((pUserBufferSaved > pUserBuffer) || ((unsigned long) (pUserBuffer - (uchar *) pStubMsg->RpcMsg->Buffer) > pStubMsg->RpcMsg->BufferLength )) { RpcRaiseException( RPC_X_INVALID_BUFFER ); } if ( pUserBuffer == pUserBufferSaved ) { // This is valid only if the wire type was a unique type. if ( ( pUserFormat->Flags & USER_MARSHAL_UNIQUE) ) { *pWirePtr = 0; return; } else RpcRaiseException( RPC_X_NULL_REF_POINTER ); } pStubMsg->Buffer = pUserBuffer; } void NDR64_USR_MRSHL_MRSHL_POINTER_QUEUE_ELEMENT::Dispatch(MIDL_STUB_MESSAGE *pStubMsg) { Ndr64UserMarshallMarshallInternal( pStubMsg, pMemory, pFormat, pWireMarkerPtr ); } #if defined(DBG) void NDR64_USR_MRSHL_MRSHL_POINTER_QUEUE_ELEMENT::Print() { DbgPrint("NDR_USR_MRSHL_MRSHL_POINTER_QUEUE_ELEMENT\n"); DbgPrint("pMemory: %p\n", pMemory ); DbgPrint("pFormat: %p\n", pFormat ); DbgPrint("pWireMarkerPtr: %p\n", pWireMarkerPtr ); } #endif void Ndr64UserMarshallPointeeMarshall( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat, NDR64_PTR_WIRE_TYPE *pWirePtr ) { if ( !pStubMsg->pPointerQueueState || !pStubMsg->pPointerQueueState->GetActiveQueue() ) { POINTER_BUFFER_SWAP_CONTEXT SwapContext( pStubMsg ); Ndr64UserMarshallMarshallInternal( pStubMsg, pMemory, pFormat, pWirePtr ); return; } NDR64_USR_MRSHL_MRSHL_POINTER_QUEUE_ELEMENT*pElement = new(pStubMsg->pPointerQueueState) NDR64_USR_MRSHL_MRSHL_POINTER_QUEUE_ELEMENT(pMemory, (PFORMAT_STRING)pFormat, pWirePtr); pStubMsg->pPointerQueueState->GetActiveQueue()->Enque( pElement ); } void Ndr64UserMarshalMarshall( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat, bool bIsEmbedded ) /*++ Routine Description : Marshals a usr_marshall object. Arguments : pStubMsg - Pointer to the stub message. pMemory - Pointer to the usr_marshall object to marshall. pFormat - Object's format string description. Return : None. --*/ { NDR64_USER_MARSHAL_FORMAT * pUserFormat = ( NDR64_USER_MARSHAL_FORMAT *) pFormat; NDR_ASSERT( pUserFormat->FormatCode == FC64_USER_MARSHAL, "invalid format string for user marshal" ); ALIGN( pStubMsg->Buffer, pUserFormat->TransmittedTypeWireAlignment ); if ( pUserFormat->Flags & USER_MARSHAL_POINTER ) { NDR64_PTR_WIRE_TYPE *pWireMarkerPtr = NULL; if ( ( pUserFormat->Flags & USER_MARSHAL_UNIQUE ) || (( pUserFormat->Flags & USER_MARSHAL_REF ) && bIsEmbedded) ) { pWireMarkerPtr = (NDR64_PTR_WIRE_TYPE *) pStubMsg->Buffer; *((NDR64_PTR_WIRE_TYPE *)pStubMsg->Buffer) = NDR64_USER_MARSHAL_MARKER; pStubMsg->Buffer += sizeof(NDR64_PTR_WIRE_TYPE); } Ndr64UserMarshallPointeeMarshall( pStubMsg, pMemory, pFormat, pWireMarkerPtr ); return; } Ndr64UserMarshallMarshallInternal( pStubMsg, pMemory, pFormat, NULL ); } void Ndr64TopLevelUserMarshalMarshall( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) { Ndr64UserMarshalMarshall( pStubMsg, pMemory, pFormat, false ); } void Ndr64EmbeddedUserMarshalMarshall( PMIDL_STUB_MESSAGE pStubMsg, uchar * pMemory, PNDR64_FORMAT pFormat ) { Ndr64UserMarshalMarshall( pStubMsg, pMemory, pFormat, true ); } void Ndr64ServerContextNewMarshall( PMIDL_STUB_MESSAGE pStubMsg, NDR_SCONTEXT ContextHandle, NDR_RUNDOWN RundownRoutine, PFORMAT_STRING pFormat ) /* This is a non-optimized NDR engine entry for context handle marshaling. In particular it is able to handle all the new NT5 context handle flavors. The optimized routine follows below. ContextHandle - note, this is not the user's handle but a NDR_SCONTEXT pointer from the stub local stack. User's handle is a field in that object. Note that intepreter calls Ndr64MarshallHandle. However, we can't use it as it assumes a helper array of saved context handles that we don't need. */ { void * pGuard = RPC_CONTEXT_HANDLE_DEFAULT_GUARD; DWORD Flags = RPC_CONTEXT_HANDLE_DEFAULT_FLAGS; NDR64_CONTEXT_HANDLE_FORMAT * pContextFormat; pContextFormat = ( NDR64_CONTEXT_HANDLE_FORMAT * )pFormat; NDR_ASSERT( pContextFormat->FormatCode == FC64_BIND_CONTEXT, "invalid format char " ); // NT5 beta2 features: strict context handle, serialize and noserialize. if ( pContextFormat->ContextFlags & NDR_STRICT_CONTEXT_HANDLE ) { pGuard = pStubMsg->StubDesc->RpcInterfaceInformation; pGuard = & ((PRPC_SERVER_INTERFACE)pGuard)->InterfaceId; } if ( pContextFormat->ContextFlags & NDR_CONTEXT_HANDLE_NOSERIALIZE ) { Flags = RPC_CONTEXT_HANDLE_DONT_SERIALIZE; } else if ( pContextFormat->ContextFlags & NDR_CONTEXT_HANDLE_SERIALIZE ) { Flags = RPC_CONTEXT_HANDLE_SERIALIZE; } ALIGN( pStubMsg->Buffer, 0x3 ); NDRSContextMarshall2( pStubMsg->RpcMsg->Handle, ContextHandle, pStubMsg->Buffer, RundownRoutine, pGuard, Flags ); pStubMsg->Buffer += CONTEXT_HANDLE_WIRE_SIZE; } // define the jump table #define NDR64_BEGIN_TABLE \ PNDR64_MARSHALL_ROUTINE extern const Ndr64MarshallRoutinesTable[] = \ { #define NDR64_TABLE_END \ }; #define NDR64_ZERO_ENTRY NULL #define NDR64_UNUSED_TABLE_ENTRY( number, tokenname ) ,NULL #define NDR64_UNUSED_TABLE_ENTRY_NOSYM( number ) ,NULL #define NDR64_TABLE_ENTRY( number, tokenname, marshall, embeddedmarshall, unmarshall, embeddedunmarshall, buffersize, embeddedbuffersize, memsize, embeddedmemsize, free, embeddedfree, typeflags ) \ ,marshall #define NDR64_SIMPLE_TYPE_TABLE_ENTRY( number, tokenname, typebuffersize, memorysize) \ ,Ndr64UDTSimpleTypeMarshall1 #include "tokntbl.h" C_ASSERT( sizeof(Ndr64MarshallRoutinesTable)/sizeof(PNDR64_MARSHALL_ROUTINE) == 256 ); #undef NDR64_BEGIN_TABLE #undef NDR64_TABLE_ENTRY #define NDR64_TABLE_ENTRY( number, tokenname, marshall, embeddedmarshall, unmarshall, embeddedunmarshall, buffersize, embeddedbuffersize, memsize, embeddedmemsize, free, embeddedfree, typeflags ) \ ,embeddedmarshall #define NDR64_BEGIN_TABLE \ PNDR64_MARSHALL_ROUTINE extern const Ndr64EmbeddedMarshallRoutinesTable[] = \ { #include "tokntbl.h" C_ASSERT( sizeof(Ndr64EmbeddedMarshallRoutinesTable) / sizeof(PNDR64_MARSHALL_ROUTINE) == 256 );