ndr_marshall.c File Reference

#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "ndr_misc.h"
#include "rpcndr.h"
#include "ndrtypes.h"
#include "wine/debug.h"
#include "pshpack1.h"
#include "poppack.h"

Include dependency graph for ndr_marshall.c:

Go to the source code of this file.

Classes
struct	_NDR_MEMORY_LIST
struct	NDR_RANGE
struct	_NDR_CSTRUCT_FORMAT
struct	NDR_SMFARRAY_FORMAT
struct	NDR_LGFARRAY_FORMAT

Macros
#define	NONAMELESSUNION
#define	LITTLE_ENDIAN_UINT32_WRITE(pchar, uint32)
#define	LITTLE_ENDIAN_UINT32_READ(pchar)
#define	BIG_ENDIAN_UINT32_WRITE(pchar, uint32)
#define	BIG_ENDIAN_UINT32_READ(pchar)
#define	NDR_LOCAL_UINT32_WRITE(pchar, uint32)    LITTLE_ENDIAN_UINT32_WRITE(pchar, uint32)
#define	NDR_LOCAL_UINT32_READ(pchar)    LITTLE_ENDIAN_UINT32_READ(pchar)
#define	STD_OVERFLOW_CHECK(_Msg)
#define	NDR_POINTER_ID_BASE   0x20000
#define	NDR_POINTER_ID(pStubMsg)   (NDR_POINTER_ID_BASE + ((pStubMsg)->UniquePtrCount++) * 4)
#define	NDR_TABLE_SIZE   128
#define	NDR_TABLE_MASK   127
#define	MEML_MAGIC   ('M' << 24 | 'E' << 16 | 'M' << 8 | 'L')
#define	BASE_TYPE_UNMARSHALL(type)
#define	USER_MARSHAL_PTR_PREFIX
#define	RANGE_UNMARSHALL(mem_type, wire_type, format_spec)
#define	BASE_TYPE_UNMARSHALL(type)

Typedefs
typedef struct _NDR_MEMORY_LIST	NDR_MEMORY_LIST
typedef struct _NDR_CSTRUCT_FORMAT	NDR_CSTRUCT_FORMAT
typedef struct _NDR_CSTRUCT_FORMAT	NDR_CVSTRUCT_FORMAT

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
static void	align_length (ULONG *len, unsigned int align)
static void	align_pointer (unsigned char **ptr, unsigned int align)
static void	align_pointer_clear (unsigned char **ptr, unsigned int align)
static void	align_pointer_offset (unsigned char **ptr, unsigned char *base, unsigned int align)
static void	align_pointer_offset_clear (unsigned char **ptr, unsigned char *base, unsigned int align)
static unsigned char *WINAPI	NdrBaseTypeMarshall (PMIDL_STUB_MESSAGE, unsigned char *, PFORMAT_STRING)
static unsigned char *WINAPI	NdrBaseTypeUnmarshall (PMIDL_STUB_MESSAGE, unsigned char **, PFORMAT_STRING, unsigned char)
static void WINAPI	NdrBaseTypeBufferSize (PMIDL_STUB_MESSAGE, unsigned char *, PFORMAT_STRING)
static void WINAPI	NdrBaseTypeFree (PMIDL_STUB_MESSAGE, unsigned char *, PFORMAT_STRING)
static ULONG WINAPI	NdrBaseTypeMemorySize (PMIDL_STUB_MESSAGE, PFORMAT_STRING)
static unsigned char *WINAPI	NdrContextHandleMarshall (PMIDL_STUB_MESSAGE, unsigned char *, PFORMAT_STRING)
static void WINAPI	NdrContextHandleBufferSize (PMIDL_STUB_MESSAGE, unsigned char *, PFORMAT_STRING)
static unsigned char *WINAPI	NdrContextHandleUnmarshall (PMIDL_STUB_MESSAGE, unsigned char **, PFORMAT_STRING, unsigned char)
static unsigned char *WINAPI	NdrRangeMarshall (PMIDL_STUB_MESSAGE, unsigned char *, PFORMAT_STRING)
static void WINAPI	NdrRangeBufferSize (PMIDL_STUB_MESSAGE, unsigned char *, PFORMAT_STRING)
static ULONG WINAPI	NdrRangeMemorySize (PMIDL_STUB_MESSAGE, PFORMAT_STRING)
static void WINAPI	NdrRangeFree (PMIDL_STUB_MESSAGE, unsigned char *, PFORMAT_STRING)
static ULONG WINAPI	NdrByteCountPointerMemorySize (PMIDL_STUB_MESSAGE, PFORMAT_STRING)
static unsigned char *	ComplexBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat, PFORMAT_STRING pPointer)
static unsigned char *	ComplexMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat, PFORMAT_STRING pPointer)
static unsigned char *	ComplexUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat, PFORMAT_STRING pPointer, unsigned char fMustAlloc)
static ULONG	ComplexStructMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, PFORMAT_STRING pPointer)
static unsigned char *	ComplexFree (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat, PFORMAT_STRING pPointer)
void *WINAPI	NdrAllocate (MIDL_STUB_MESSAGE *pStubMsg, SIZE_T len)
static void *	NdrAllocateZero (MIDL_STUB_MESSAGE *stubmsg, SIZE_T len)
static void	NdrFree (MIDL_STUB_MESSAGE *pStubMsg, unsigned char *Pointer)
static BOOL	IsConformanceOrVariancePresent (PFORMAT_STRING pFormat)
static PFORMAT_STRING	SkipConformance (const PMIDL_STUB_MESSAGE pStubMsg, const PFORMAT_STRING pFormat)
static PFORMAT_STRING	ReadConformance (MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat)
static PFORMAT_STRING	ReadVariance (MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat, ULONG MaxValue)
static void	WriteConformance (MIDL_STUB_MESSAGE *pStubMsg)
static void	WriteVariance (MIDL_STUB_MESSAGE *pStubMsg)
static void	SizeConformance (MIDL_STUB_MESSAGE *pStubMsg)
static void	SizeVariance (MIDL_STUB_MESSAGE *pStubMsg)
PFORMAT_STRING	ComputeConformanceOrVariance (MIDL_STUB_MESSAGE *pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat, ULONG_PTR def, ULONG_PTR *pCount)
static PFORMAT_STRING	SkipVariance (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
static ULONG	safe_multiply (ULONG a, ULONG b)
static void	safe_buffer_increment (MIDL_STUB_MESSAGE *pStubMsg, ULONG size)
static void	safe_buffer_length_increment (MIDL_STUB_MESSAGE *pStubMsg, ULONG size)
static void	safe_copy_from_buffer (MIDL_STUB_MESSAGE *pStubMsg, void *p, ULONG size)
static void	safe_copy_to_buffer (MIDL_STUB_MESSAGE *pStubMsg, const void *p, ULONG size)
static void	validate_string_data (MIDL_STUB_MESSAGE *pStubMsg, ULONG bufsize, ULONG esize)
static void	dump_pointer_attr (unsigned char attr)
static void	PointerMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *Buffer, unsigned char *Pointer, PFORMAT_STRING pFormat)
static void	PointerUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *Buffer, unsigned char **pPointer, unsigned char *pSrcPointer, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
static void	PointerBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *Pointer, PFORMAT_STRING pFormat)
static ULONG	PointerMemorySize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *Buffer, PFORMAT_STRING pFormat)
static void	PointerFree (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *Pointer, PFORMAT_STRING pFormat)
static unsigned char *	EmbeddedPointerMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
static unsigned char *	EmbeddedPointerUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pDstBuffer, unsigned char *pSrcMemoryPtrs, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
static void	EmbeddedPointerBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
static ULONG	EmbeddedPointerMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
static void	EmbeddedPointerFree (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrPointerMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrPointerUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
void WINAPI	NdrPointerBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
ULONG WINAPI	NdrPointerMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
void WINAPI	NdrPointerFree (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
void WINAPI	NdrSimpleTypeMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, unsigned char FormatChar)
void WINAPI	NdrSimpleTypeUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, unsigned char FormatChar)
unsigned char *WINAPI	NdrSimpleStructMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrSimpleStructUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
void WINAPI	NdrSimpleStructBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
ULONG WINAPI	NdrSimpleStructMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
void WINAPI	NdrSimpleStructFree (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
static void	array_compute_and_size_conformance (unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
static void	array_buffer_size (unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat, unsigned char fHasPointers)
static void	array_compute_and_write_conformance (unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
static void	array_write_variance_and_marshall (unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat, unsigned char fHasPointers)
static ULONG	array_read_conformance (unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
static ULONG	array_read_variance_and_unmarshall (unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc, unsigned char fUseBufferMemoryServer, unsigned char fUnmarshall)
static void	array_memory_size (unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, unsigned char fHasPointers)
static void	array_free (unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat, unsigned char fHasPointers)
unsigned char *WINAPI	NdrConformantStringMarshall (MIDL_STUB_MESSAGE *pStubMsg, unsigned char *pszMessage, PFORMAT_STRING pFormat)
void WINAPI	NdrConformantStringBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
ULONG WINAPI	NdrConformantStringMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrConformantStringUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
unsigned char *WINAPI	NdrNonConformantStringMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrNonConformantStringUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
void WINAPI	NdrNonConformantStringBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
ULONG WINAPI	NdrNonConformantStringMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
static ULONG	EmbeddedComplexSize (MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat)
static ULONG	EmbeddedComplexMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
ULONG	ComplexStructSize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrComplexStructMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrComplexStructUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
void WINAPI	NdrComplexStructBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
ULONG WINAPI	NdrComplexStructMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
void WINAPI	NdrComplexStructFree (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrConformantArrayMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrConformantArrayUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
void WINAPI	NdrConformantArrayBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
ULONG WINAPI	NdrConformantArrayMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
void WINAPI	NdrConformantArrayFree (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrConformantVaryingArrayMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrConformantVaryingArrayUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
void WINAPI	NdrConformantVaryingArrayFree (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
void WINAPI	NdrConformantVaryingArrayBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
ULONG WINAPI	NdrConformantVaryingArrayMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrComplexArrayMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrComplexArrayUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
void WINAPI	NdrComplexArrayBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
ULONG WINAPI	NdrComplexArrayMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
void WINAPI	NdrComplexArrayFree (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
static void	UserMarshalCB (PMIDL_STUB_MESSAGE pStubMsg, USER_MARSHAL_CB_TYPE cbtype, PFORMAT_STRING pFormat, USER_MARSHAL_CB *umcb)
unsigned char *WINAPI	NdrUserMarshalMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrUserMarshalUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
void WINAPI	NdrUserMarshalBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
ULONG WINAPI	NdrUserMarshalMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
void WINAPI	NdrUserMarshalFree (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
RPC_STATUS RPC_ENTRY	NdrGetUserMarshalInfo (ULONG *flags, ULONG level, NDR_USER_MARSHAL_INFO *umi)
void WINAPI	NdrClearOutParameters (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, void *ArgAddr)
void WINAPI	NdrConvert (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
void WINAPI	NdrConvert2 (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, LONG NumberParams)
unsigned char *WINAPI	NdrConformantStructMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrConformantStructUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
void WINAPI	NdrConformantStructBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
ULONG WINAPI	NdrConformantStructMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
void WINAPI	NdrConformantStructFree (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrConformantVaryingStructMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrConformantVaryingStructUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
void WINAPI	NdrConformantVaryingStructBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
ULONG WINAPI	NdrConformantVaryingStructMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
void WINAPI	NdrConformantVaryingStructFree (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrFixedArrayMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrFixedArrayUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
void WINAPI	NdrFixedArrayBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
ULONG WINAPI	NdrFixedArrayMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
void WINAPI	NdrFixedArrayFree (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrVaryingArrayMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrVaryingArrayUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
void WINAPI	NdrVaryingArrayBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
ULONG WINAPI	NdrVaryingArrayMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
void WINAPI	NdrVaryingArrayFree (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
static ULONG	get_discriminant (unsigned char fc, const unsigned char *pMemory)
static PFORMAT_STRING	get_arm_offset_from_union_arm_selector (PMIDL_STUB_MESSAGE pStubMsg, ULONG discriminant, PFORMAT_STRING pFormat)
static unsigned char *	union_arm_marshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, ULONG discriminant, PFORMAT_STRING pFormat)
static unsigned char *	union_arm_unmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, ULONG discriminant, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
static void	union_arm_buffer_size (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, ULONG discriminant, PFORMAT_STRING pFormat)
static ULONG	union_arm_memory_size (PMIDL_STUB_MESSAGE pStubMsg, ULONG discriminant, PFORMAT_STRING pFormat)
static void	union_arm_free (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, ULONG discriminant, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrEncapsulatedUnionMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrEncapsulatedUnionUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
void WINAPI	NdrEncapsulatedUnionBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
ULONG WINAPI	NdrEncapsulatedUnionMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
void WINAPI	NdrEncapsulatedUnionFree (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrNonEncapsulatedUnionMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
static LONG	unmarshall_discriminant (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING *ppFormat)
unsigned char *WINAPI	NdrNonEncapsulatedUnionUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
void WINAPI	NdrNonEncapsulatedUnionBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
ULONG WINAPI	NdrNonEncapsulatedUnionMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
void WINAPI	NdrNonEncapsulatedUnionFree (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrByteCountPointerMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrByteCountPointerUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
void WINAPI	NdrByteCountPointerBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
void WINAPI	NdrByteCountPointerFree (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrXmitOrRepAsMarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrXmitOrRepAsUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
void WINAPI	NdrXmitOrRepAsBufferSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
ULONG WINAPI	NdrXmitOrRepAsMemorySize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
void WINAPI	NdrXmitOrRepAsFree (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
unsigned char *WINAPI	NdrRangeUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, unsigned char **ppMemory, PFORMAT_STRING pFormat, unsigned char fMustAlloc)
void WINAPI	NdrClientContextMarshall (PMIDL_STUB_MESSAGE pStubMsg, NDR_CCONTEXT ContextHandle, int fCheck)
void WINAPI	NdrClientContextUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, NDR_CCONTEXT *pContextHandle, RPC_BINDING_HANDLE BindHandle)
void WINAPI	NdrServerContextMarshall (PMIDL_STUB_MESSAGE pStubMsg, NDR_SCONTEXT ContextHandle, NDR_RUNDOWN RundownRoutine)
NDR_SCONTEXT WINAPI	NdrServerContextUnmarshall (PMIDL_STUB_MESSAGE pStubMsg)
void WINAPI	NdrContextHandleSize (PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory, PFORMAT_STRING pFormat)
NDR_SCONTEXT WINAPI	NdrContextHandleInitialize (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
void WINAPI	NdrServerContextNewMarshall (PMIDL_STUB_MESSAGE pStubMsg, NDR_SCONTEXT ContextHandle, NDR_RUNDOWN RundownRoutine, PFORMAT_STRING pFormat)
NDR_SCONTEXT WINAPI	NdrServerContextNewUnmarshall (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
void WINAPI	NdrCorrelationInitialize (PMIDL_STUB_MESSAGE pStubMsg, void *pMemory, ULONG CacheSize, ULONG Flags)
void WINAPI	NdrCorrelationPass (PMIDL_STUB_MESSAGE pStubMsg)
void WINAPI	NdrCorrelationFree (PMIDL_STUB_MESSAGE pStubMsg)

Variables
const NDR_MARSHALL	NdrMarshaller [NDR_TABLE_SIZE]
const NDR_UNMARSHALL	NdrUnmarshaller [NDR_TABLE_SIZE]
const NDR_BUFFERSIZE	NdrBufferSizer [NDR_TABLE_SIZE]
const NDR_MEMORYSIZE	NdrMemorySizer [NDR_TABLE_SIZE]
const NDR_FREE	NdrFreer [NDR_TABLE_SIZE]

Macro Definition Documentation

BASE_TYPE_UNMARSHALL [1/2]

#define BASE_TYPE_UNMARSHALL

(

type

)

Value:

        align_pointer(&pStubMsg->Buffer, sizeof(type)); \
    TRACE("pMemory: %p\n", pMemory); \
    *(type *)pMemory = *(type *)pStubMsg->Buffer; \
        pStubMsg->Buffer += sizeof(type);

BASE_TYPE_UNMARSHALL [2/2]

#define BASE_TYPE_UNMARSHALL

(

type

)

Value:

        do { \
        align_pointer(&pStubMsg->Buffer, sizeof(type)); \
        if (!fMustAlloc && !pStubMsg->IsClient && !*ppMemory) \
        { \
            *ppMemory = pStubMsg->Buffer; \
            TRACE("*ppMemory: %p\n", *ppMemory); \
            safe_buffer_increment(pStubMsg, sizeof(type)); \
        } \
        else \
        {  \
            if (fMustAlloc) \
                *ppMemory = NdrAllocate(pStubMsg, sizeof(type)); \
            TRACE("*ppMemory: %p\n", *ppMemory); \
            safe_copy_from_buffer(pStubMsg, *ppMemory, sizeof(type)); \
        } \
    } while (0)

BIG_ENDIAN_UINT32_READ

#define BIG_ENDIAN_UINT32_READ

(

pchar

)

Value:

  (MAKELONG( \
    MAKEWORD(*((pchar)+3), *((pchar)+2)), \
    MAKEWORD(*((pchar)+1), *(pchar))))

Definition at line 75 of file ndr_marshall.c.

BIG_ENDIAN_UINT32_WRITE

#define BIG_ENDIAN_UINT32_WRITE	(		pchar,
			uint32
	)

Value:

  (*((pchar)+3) = LOBYTE(LOWORD(uint32)), \
   *((pchar)+2) = HIBYTE(LOWORD(uint32)), \
   *((pchar)+1) = LOBYTE(HIWORD(uint32)), \
   *(pchar)     = HIBYTE(HIWORD(uint32)))

Definition at line 69 of file ndr_marshall.c.

LITTLE_ENDIAN_UINT32_READ

#define LITTLE_ENDIAN_UINT32_READ

(

pchar

)

Value:

    (MAKELONG( \
      MAKEWORD(*(pchar), *((pchar)+1)), \
      MAKEWORD(*((pchar)+2), *((pchar)+3))))

Definition at line 63 of file ndr_marshall.c.

LITTLE_ENDIAN_UINT32_WRITE

#define LITTLE_ENDIAN_UINT32_WRITE	(		pchar,
			uint32
	)

Value:

    (*(pchar)     = LOBYTE(LOWORD(uint32)), \
     *((pchar)+1) = HIBYTE(LOWORD(uint32)), \
     *((pchar)+2) = LOBYTE(HIWORD(uint32)), \
     *((pchar)+3) = HIBYTE(HIWORD(uint32)))

Definition at line 57 of file ndr_marshall.c.

MEML_MAGIC

#define MEML_MAGIC   ('M' << 24 | 'E' << 16 | 'M' << 8 | 'L')

Definition at line 400 of file ndr_marshall.c.

NDR_LOCAL_UINT32_READ

#define NDR_LOCAL_UINT32_READ

(

pchar

)

LITTLE_ENDIAN_UINT32_READ(pchar)

Definition at line 88 of file ndr_marshall.c.

NDR_LOCAL_UINT32_WRITE

#define NDR_LOCAL_UINT32_WRITE	(		pchar,
			uint32
	)		LITTLE_ENDIAN_UINT32_WRITE(pchar, uint32)

Definition at line 86 of file ndr_marshall.c.

NDR_POINTER_ID

#define NDR_POINTER_ID

(

pStubMsg

)

(NDR_POINTER_ID_BASE + ((pStubMsg)->UniquePtrCount++) * 4)

Definition at line 130 of file ndr_marshall.c.

NDR_POINTER_ID_BASE

#define NDR_POINTER_ID_BASE   0x20000

Definition at line 129 of file ndr_marshall.c.

NDR_TABLE_MASK

#define NDR_TABLE_MASK   127

Definition at line 132 of file ndr_marshall.c.

NDR_TABLE_SIZE

#define NDR_TABLE_SIZE   128

Definition at line 131 of file ndr_marshall.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 36 of file ndr_marshall.c.

RANGE_UNMARSHALL

#define RANGE_UNMARSHALL	(		mem_type,
			wire_type,
			format_spec
	)

Value:

    do \
    { \
        align_pointer(&pStubMsg->Buffer, sizeof(wire_type)); \
        if (!fMustAlloc && !*ppMemory) \
            fMustAlloc = TRUE; \
        if (fMustAlloc) \
            *ppMemory = NdrAllocate(pStubMsg, sizeof(mem_type)); \
        if (pStubMsg->Buffer + sizeof(wire_type) > pStubMsg->BufferEnd) \
        { \
            ERR("buffer overflow - Buffer = %p, BufferEnd = %p\n", \
                pStubMsg->Buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength); \
            RpcRaiseException(RPC_X_BAD_STUB_DATA); \
        } \
        if ((*(wire_type *)pStubMsg->Buffer < (mem_type)pRange->low_value) || \
            (*(wire_type *)pStubMsg->Buffer > (mem_type)pRange->high_value)) \
        { \
            ERR("value exceeded bounds: " format_spec ", low: " format_spec ", high: " format_spec "\n", \
                *(wire_type *)pStubMsg->Buffer, (mem_type)pRange->low_value, \
                (mem_type)pRange->high_value); \
            RpcRaiseException(RPC_S_INVALID_BOUND); \
            return NULL; \
        } \
        TRACE("*ppMemory: %p\n", *ppMemory); \
        **(mem_type **)ppMemory = *(wire_type *)pStubMsg->Buffer; \
        pStubMsg->Buffer += sizeof(wire_type); \
    } while (0)

STD_OVERFLOW_CHECK

#define STD_OVERFLOW_CHECK

(

_Msg

)

Value:

    do { \
    TRACE("buffer=%d/%d\n", (ULONG)(_Msg->Buffer - (unsigned char *)_Msg->RpcMsg->Buffer), _Msg->BufferLength); \
    if (_Msg->Buffer > (unsigned char *)_Msg->RpcMsg->Buffer + _Msg->BufferLength) \
        ERR("buffer overflow %d bytes\n", (ULONG)(_Msg->Buffer - ((unsigned char *)_Msg->RpcMsg->Buffer + _Msg->BufferLength))); \
  } while (0)

Definition at line 123 of file ndr_marshall.c.

USER_MARSHAL_PTR_PREFIX

#define USER_MARSHAL_PTR_PREFIX

Value:

        ( (DWORD)'U'         | ( (DWORD)'s' << 8 ) | \
        ( (DWORD)'e' << 16 ) | ( (DWORD)'r' << 24 ) )

Definition at line 4389 of file ndr_marshall.c.

Typedef Documentation

NDR_CSTRUCT_FORMAT

typedef struct _NDR_CSTRUCT_FORMAT NDR_CSTRUCT_FORMAT

NDR_CVSTRUCT_FORMAT

typedef struct _NDR_CSTRUCT_FORMAT NDR_CVSTRUCT_FORMAT

NDR_MEMORY_LIST

typedef struct _NDR_MEMORY_LIST NDR_MEMORY_LIST

Function Documentation

align_length()

static void align_length ( ULONG *  len, unsigned int  align  )

inlinestatic

Definition at line 92 of file ndr_marshall.c.

{
    *len = (*len + align - 1) & ~(align - 1);
}

Referenced by array_buffer_size(), ComplexBufferSize(), ComplexStructMemorySize(), ComplexStructSize(), NdrBaseTypeBufferSize(), NdrBaseTypeMemorySize(), NdrComplexStructBufferSize(), NdrConformantStructBufferSize(), NdrConformantVaryingStructBufferSize(), NdrContextHandleBufferSize(), NdrEncapsulatedUnionBufferSize(), NdrFixedArrayBufferSize(), NdrPointerBufferSize(), NdrPointerMemorySize(), NdrSimpleStructBufferSize(), NdrUserMarshalBufferSize(), NdrVaryingArrayBufferSize(), PointerMemorySize(), SizeConformance(), SizeVariance(), union_arm_buffer_size(), and union_arm_memory_size().

align_pointer()

static void align_pointer ( unsigned char **  ptr, unsigned int  align  )

inlinestatic

Definition at line 97 of file ndr_marshall.c.

{
    ULONG_PTR mask = align - 1;
    *ptr = (unsigned char *)(((ULONG_PTR)*ptr + mask) & ~mask);
}

Referenced by array_memory_size(), array_read_variance_and_unmarshall(), ComplexStructMemorySize(), ComplexUnmarshall(), NdrBaseTypeMemorySize(), NdrBaseTypeUnmarshall(), NdrClientContextUnmarshall(), NdrComplexStructMemorySize(), NdrComplexStructUnmarshall(), NdrConformantStructUnmarshall(), NdrConformantVaryingStructMemorySize(), NdrConformantVaryingStructUnmarshall(), NdrEncapsulatedUnionMemorySize(), NdrEncapsulatedUnionUnmarshall(), NdrFixedArrayMemorySize(), NdrFixedArrayUnmarshall(), NdrPointerMemorySize(), NdrPointerUnmarshall(), NdrServerContextMarshall(), NdrServerContextNewMarshall(), NdrServerContextNewUnmarshall(), NdrServerContextUnmarshall(), NdrSimpleStructMemorySize(), NdrSimpleStructUnmarshall(), NdrSimpleTypeUnmarshall(), NdrUserMarshalMemorySize(), NdrUserMarshalUnmarshall(), NdrVaryingArrayMemorySize(), NdrVaryingArrayUnmarshall(), ReadConformance(), ReadVariance(), union_arm_memory_size(), union_arm_unmarshall(), and unmarshall_discriminant().

align_pointer_clear()

static void align_pointer_clear ( unsigned char **  ptr, unsigned int  align  )

inlinestatic

Definition at line 103 of file ndr_marshall.c.

{
    ULONG_PTR mask = align - 1;
    memset( *ptr, 0, (align - (ULONG_PTR)*ptr) & mask );
    *ptr = (unsigned char *)(((ULONG_PTR)*ptr + mask) & ~mask);
}

Referenced by array_write_variance_and_marshall(), ComplexMarshall(), NdrBaseTypeMarshall(), NdrClientContextMarshall(), NdrComplexStructMarshall(), NdrConformantStructMarshall(), NdrConformantVaryingStructMarshall(), NdrEncapsulatedUnionMarshall(), NdrFixedArrayMarshall(), NdrPointerMarshall(), NdrSimpleStructMarshall(), NdrUserMarshalMarshall(), NdrVaryingArrayMarshall(), union_arm_marshall(), WriteConformance(), and WriteVariance().

align_pointer_offset()

static void align_pointer_offset ( unsigned char **  ptr, unsigned char *  base, unsigned int  align  )

inlinestatic

Definition at line 110 of file ndr_marshall.c.

{
    ULONG_PTR mask = align - 1;
    *ptr = base + (((ULONG_PTR)(*ptr - base) + mask) & ~mask);
}

Referenced by ComplexBufferSize(), ComplexFree(), and ComplexMarshall().

align_pointer_offset_clear()

static void align_pointer_offset_clear ( unsigned char **  ptr, unsigned char *  base, unsigned int  align  )

inlinestatic

Definition at line 116 of file ndr_marshall.c.

{
    ULONG_PTR mask = align - 1;
    memset( *ptr, 0, (align - (ULONG_PTR)(*ptr - base)) & mask );
    *ptr = base + (((ULONG_PTR)(*ptr - base) + mask) & ~mask);
}

Referenced by ComplexUnmarshall().

array_buffer_size()

static void array_buffer_size ( unsigned char  fc, PMIDL_STUB_MESSAGE  pStubMsg, unsigned char *  pMemory, PFORMAT_STRING  pFormat, unsigned char  fHasPointers  )

inlinestatic

Definition at line 1896 of file ndr_marshall.c.

{
  DWORD i, size;
  DWORD esize;
  unsigned char alignment;
 
  switch (fc)
  {
  case FC_CARRAY:
    esize = *(const WORD*)(pFormat+2);
    alignment = pFormat[1] + 1;
 
    pFormat = SkipConformance(pStubMsg, pFormat + 4);
 
    align_length(&pStubMsg->BufferLength, alignment);
 
    size = safe_multiply(esize, pStubMsg->MaxCount);
    /* conformance value plus array */
    safe_buffer_length_increment(pStubMsg, size);
 
    if (fHasPointers)
      EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
    break;
  case FC_CVARRAY:
    esize = *(const WORD*)(pFormat+2);
    alignment = pFormat[1] + 1;
 
    pFormat = SkipConformance(pStubMsg, pFormat + 4);
    pFormat = SkipVariance(pStubMsg, pFormat);
 
    SizeVariance(pStubMsg);
 
    align_length(&pStubMsg->BufferLength, alignment);
 
    size = safe_multiply(esize, pStubMsg->ActualCount);
    safe_buffer_length_increment(pStubMsg, size);
 
    if (fHasPointers)
      EmbeddedPointerBufferSize(pStubMsg, pMemory, pFormat);
    break;
  case FC_C_CSTRING:
  case FC_C_WSTRING:
    if (fc == FC_C_CSTRING)
      esize = 1;
    else
      esize = 2;
 
    SizeVariance(pStubMsg);
 
    size = safe_multiply(esize, pStubMsg->ActualCount);
    safe_buffer_length_increment(pStubMsg, size);
    break;
  case FC_BOGUS_ARRAY:
    alignment = pFormat[1] + 1;
    pFormat = SkipConformance(pStubMsg, pFormat + 4);
    if (IsConformanceOrVariancePresent(pFormat)) SizeVariance(pStubMsg);
    pFormat = SkipVariance(pStubMsg, pFormat);
 
    align_length(&pStubMsg->BufferLength, alignment);
 
    size = pStubMsg->ActualCount;
    for (i = 0; i < size; i++)
      pMemory = ComplexBufferSize(pStubMsg, pMemory, pFormat, NULL);
    break;
  default:
    ERR("unknown array format 0x%x\n", fc);
    RpcRaiseException(RPC_X_BAD_STUB_DATA);
  }
}

Referenced by NdrComplexArrayBufferSize(), NdrComplexStructBufferSize(), NdrConformantArrayBufferSize(), NdrConformantStringBufferSize(), NdrConformantVaryingArrayBufferSize(), and NdrConformantVaryingStructBufferSize().

array_compute_and_size_conformance()

static void array_compute_and_size_conformance ( unsigned char  fc, PMIDL_STUB_MESSAGE  pStubMsg, unsigned char *  pMemory, PFORMAT_STRING  pFormat  )

inlinestatic

Definition at line 1846 of file ndr_marshall.c.

{
  DWORD count;
 
  switch (fc)
  {
  case FC_CARRAY:
    ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
    SizeConformance(pStubMsg);
    break;
  case FC_CVARRAY:
    pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 4, 0);
    pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
    SizeConformance(pStubMsg);
    break;
  case FC_C_CSTRING:
  case FC_C_WSTRING:
    if (fc == FC_C_CSTRING)
    {
      TRACE("string=%s\n", debugstr_a((const char *)pMemory));
      pStubMsg->ActualCount = strlen((const char *)pMemory)+1;
    }
    else
    {
      TRACE("string=%s\n", debugstr_w((LPCWSTR)pMemory));
      pStubMsg->ActualCount = lstrlenW((LPCWSTR)pMemory)+1;
    }
 
    if (pFormat[1] == FC_STRING_SIZED)
      pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 2, 0);
    else
      pStubMsg->MaxCount = pStubMsg->ActualCount;
 
    SizeConformance(pStubMsg);
    break;
  case FC_BOGUS_ARRAY:
    count = *(const WORD *)(pFormat + 2);
    pFormat += 4;
    if (IsConformanceOrVariancePresent(pFormat)) SizeConformance(pStubMsg);
    pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, count);
    pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
    break;
  default:
    ERR("unknown array format 0x%x\n", fc);
    RpcRaiseException(RPC_X_BAD_STUB_DATA);
  }
}

Referenced by NdrComplexArrayBufferSize(), NdrComplexStructBufferSize(), NdrConformantArrayBufferSize(), NdrConformantStringBufferSize(), NdrConformantVaryingArrayBufferSize(), and NdrConformantVaryingStructBufferSize().

array_compute_and_write_conformance()

static void array_compute_and_write_conformance ( unsigned char  fc, PMIDL_STUB_MESSAGE  pStubMsg, unsigned char *  pMemory, PFORMAT_STRING  pFormat  )

inlinestatic

Definition at line 1968 of file ndr_marshall.c.

{
  ULONG def;
  BOOL conformance_present;
 
  switch (fc)
  {
  case FC_CARRAY:
    ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
    WriteConformance(pStubMsg);
    break;
  case FC_CVARRAY:
    pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 4, 0);
    pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
    WriteConformance(pStubMsg);
    break;
  case FC_C_CSTRING:
  case FC_C_WSTRING:
    if (fc == FC_C_CSTRING)
    {
      TRACE("string=%s\n", debugstr_a((const char *)pMemory));
      pStubMsg->ActualCount = strlen((const char *)pMemory)+1;
    }
    else
    {
      TRACE("string=%s\n", debugstr_w((LPCWSTR)pMemory));
      pStubMsg->ActualCount = lstrlenW((LPCWSTR)pMemory)+1;
    }
    if (pFormat[1] == FC_STRING_SIZED)
      pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 2, 0);
    else
      pStubMsg->MaxCount = pStubMsg->ActualCount;
    pStubMsg->Offset = 0;
    WriteConformance(pStubMsg);
    break;
  case FC_BOGUS_ARRAY:
    def = *(const WORD *)(pFormat + 2);
    pFormat += 4;
    conformance_present = IsConformanceOrVariancePresent(pFormat);
    pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, def);
    pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
    if (conformance_present) WriteConformance(pStubMsg);
    break;
  default:
    ERR("unknown array format 0x%x\n", fc);
    RpcRaiseException(RPC_X_BAD_STUB_DATA);
  }
}

Referenced by NdrComplexArrayMarshall(), NdrComplexStructMarshall(), NdrConformantArrayMarshall(), NdrConformantStringMarshall(), NdrConformantVaryingArrayMarshall(), and NdrConformantVaryingStructMarshall().

array_free()

static void array_free ( unsigned char  fc, PMIDL_STUB_MESSAGE  pStubMsg, unsigned char *  pMemory, PFORMAT_STRING  pFormat, unsigned char  fHasPointers  )

inlinestatic

Definition at line 2401 of file ndr_marshall.c.

{
  DWORD i, count;
 
  switch (fc)
  {
  case FC_CARRAY:
    pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
    if (fHasPointers)
      EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
    break;
  case FC_CVARRAY:
    pFormat = ComputeConformance(pStubMsg, pMemory, pFormat+4, 0);
    pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, 0);
    if (fHasPointers)
      EmbeddedPointerFree(pStubMsg, pMemory, pFormat);
    break;
  case FC_C_CSTRING:
  case FC_C_WSTRING:
    /* No embedded pointers so nothing to do */
    break;
  case FC_BOGUS_ARRAY:
      count = *(const WORD *)(pFormat + 2);
      pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 4, count);
      pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
 
      count = pStubMsg->ActualCount;
      for (i = 0; i < count; i++)
          pMemory = ComplexFree(pStubMsg, pMemory, pFormat, NULL);
    break;
  default:
    ERR("unknown array format 0x%x\n", fc);
    RpcRaiseException(RPC_X_BAD_STUB_DATA);
  }
}

Referenced by NdrComplexStructFree(), NdrConformantArrayFree(), NdrConformantVaryingArrayFree(), and NdrConformantVaryingStructFree().

array_memory_size()

static void array_memory_size ( unsigned char  fc, PMIDL_STUB_MESSAGE  pStubMsg, PFORMAT_STRING  pFormat, unsigned char  fHasPointers  )

inlinestatic

Definition at line 2300 of file ndr_marshall.c.

{
  ULONG i, count, SavedMemorySize;
  ULONG bufsize, memsize;
  DWORD esize;
  unsigned char alignment;
 
  switch (fc)
  {
  case FC_CARRAY:
    esize = *(const WORD*)(pFormat+2);
    alignment = pFormat[1] + 1;
 
    pFormat = SkipConformance(pStubMsg, pFormat + 4);
 
    bufsize = memsize = safe_multiply(esize, pStubMsg->MaxCount);
    pStubMsg->MemorySize += memsize;
 
    align_pointer(&pStubMsg->Buffer, alignment);
    if (fHasPointers)
      pStubMsg->BufferMark = pStubMsg->Buffer;
    safe_buffer_increment(pStubMsg, bufsize);
 
    if (fHasPointers)
      EmbeddedPointerMemorySize(pStubMsg, pFormat);
    break;
  case FC_CVARRAY:
    esize = *(const WORD*)(pFormat+2);
    alignment = pFormat[1] + 1;
 
    pFormat = SkipConformance(pStubMsg, pFormat + 4);
 
    pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
 
    bufsize = safe_multiply(esize, pStubMsg->ActualCount);
    memsize = safe_multiply(esize, pStubMsg->MaxCount);
    pStubMsg->MemorySize += memsize;
 
    align_pointer(&pStubMsg->Buffer, alignment);
    if (fHasPointers)
      pStubMsg->BufferMark = pStubMsg->Buffer;
    safe_buffer_increment(pStubMsg, bufsize);
 
    if (fHasPointers)
      EmbeddedPointerMemorySize(pStubMsg, pFormat);
    break;
  case FC_C_CSTRING:
  case FC_C_WSTRING:
    if (fc == FC_C_CSTRING)
      esize = 1;
    else
      esize = 2;
 
    ReadVariance(pStubMsg, NULL, pStubMsg->MaxCount);
 
    if (pFormat[1] != FC_STRING_SIZED && (pStubMsg->MaxCount != pStubMsg->ActualCount))
    {
      ERR("buffer size %d must equal memory size %ld for non-sized conformant strings\n",
          pStubMsg->ActualCount, pStubMsg->MaxCount);
      RpcRaiseException(RPC_S_INVALID_BOUND);
    }
    if (pStubMsg->Offset)
    {
      ERR("conformant strings can't have Offset (%d)\n", pStubMsg->Offset);
      RpcRaiseException(RPC_S_INVALID_BOUND);
    }
 
    memsize = safe_multiply(esize, pStubMsg->MaxCount);
    bufsize = safe_multiply(esize, pStubMsg->ActualCount);
 
    validate_string_data(pStubMsg, bufsize, esize);
 
    safe_buffer_increment(pStubMsg, bufsize);
    pStubMsg->MemorySize += memsize;
    break;
  case FC_BOGUS_ARRAY:
    alignment = pFormat[1] + 1;
    pFormat = SkipConformance(pStubMsg, pFormat + 4);
    pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
 
    align_pointer(&pStubMsg->Buffer, alignment);
 
    SavedMemorySize = pStubMsg->MemorySize;
 
    esize = ComplexStructSize(pStubMsg, pFormat);
    memsize = safe_multiply(pStubMsg->MaxCount, esize);
 
    count = pStubMsg->ActualCount;
    for (i = 0; i < count; i++)
        ComplexStructMemorySize(pStubMsg, pFormat, NULL);
 
    pStubMsg->MemorySize = SavedMemorySize + memsize;
    break;
  default:
    ERR("unknown array format 0x%x\n", fc);
    RpcRaiseException(RPC_X_BAD_STUB_DATA);
  }
}

Referenced by NdrComplexArrayMemorySize(), NdrComplexStructMemorySize(), NdrConformantArrayMemorySize(), NdrConformantStringMemorySize(), NdrConformantVaryingArrayMemorySize(), and NdrConformantVaryingStructMemorySize().

array_read_conformance()

static ULONG array_read_conformance ( unsigned char  fc, PMIDL_STUB_MESSAGE  pStubMsg, PFORMAT_STRING  pFormat  )

inlinestatic

Definition at line 2095 of file ndr_marshall.c.

{
  DWORD def, esize;
 
  switch (fc)
  {
  case FC_CARRAY:
    esize = *(const WORD*)(pFormat+2);
    pFormat = ReadConformance(pStubMsg, pFormat+4);
    return safe_multiply(esize, pStubMsg->MaxCount);
  case FC_CVARRAY:
    esize = *(const WORD*)(pFormat+2);
    pFormat = ReadConformance(pStubMsg, pFormat+4);
    return safe_multiply(esize, pStubMsg->MaxCount);
  case FC_C_CSTRING:
  case FC_C_WSTRING:
    if (fc == FC_C_CSTRING)
      esize = 1;
    else
      esize = 2;
 
    if (pFormat[1] == FC_STRING_SIZED)
      ReadConformance(pStubMsg, pFormat + 2);
    else
      ReadConformance(pStubMsg, NULL);
    return safe_multiply(esize, pStubMsg->MaxCount);
  case FC_BOGUS_ARRAY:
    def = *(const WORD *)(pFormat + 2);
    pFormat += 4;
    if (IsConformanceOrVariancePresent(pFormat)) pFormat = ReadConformance(pStubMsg, pFormat);
    else
    {
        pStubMsg->MaxCount = def;
        pFormat = SkipConformance( pStubMsg, pFormat );
    }
    pFormat = SkipVariance( pStubMsg, pFormat );
 
    esize = ComplexStructSize(pStubMsg, pFormat);
    return safe_multiply(pStubMsg->MaxCount, esize);
  default:
    ERR("unknown array format 0x%x\n", fc);
    RpcRaiseException(RPC_X_BAD_STUB_DATA);
  }
}

Referenced by NdrComplexArrayMemorySize(), NdrComplexArrayUnmarshall(), NdrComplexStructMemorySize(), NdrComplexStructUnmarshall(), NdrConformantArrayMemorySize(), NdrConformantArrayUnmarshall(), NdrConformantStringMemorySize(), NdrConformantStringUnmarshall(), NdrConformantVaryingArrayMemorySize(), NdrConformantVaryingArrayUnmarshall(), NdrConformantVaryingStructMemorySize(), and NdrConformantVaryingStructUnmarshall().

array_read_variance_and_unmarshall()

static ULONG array_read_variance_and_unmarshall ( unsigned char  fc, PMIDL_STUB_MESSAGE  pStubMsg, unsigned char **  ppMemory, PFORMAT_STRING  pFormat, unsigned char  fMustAlloc, unsigned char  fUseBufferMemoryServer, unsigned char  fUnmarshall  )

inlinestatic

Definition at line 2141 of file ndr_marshall.c.

{
  ULONG bufsize, memsize;
  WORD esize;
  unsigned char alignment;
  unsigned char *saved_buffer, *pMemory;
  ULONG i, offset, count;
 
  switch (fc)
  {
  case FC_CARRAY:
    esize = *(const WORD*)(pFormat+2);
    alignment = pFormat[1] + 1;
 
    bufsize = memsize = safe_multiply(esize, pStubMsg->MaxCount);
 
    pFormat = SkipConformance(pStubMsg, pFormat + 4);
 
    align_pointer(&pStubMsg->Buffer, alignment);
 
    if (fUnmarshall)
    {
      if (fMustAlloc)
        *ppMemory = NdrAllocateZero(pStubMsg, memsize);
      else
      {
        if (fUseBufferMemoryServer && !pStubMsg->IsClient && !*ppMemory)
          /* for servers, we just point straight into the RPC buffer */
          *ppMemory = pStubMsg->Buffer;
      }
 
      saved_buffer = pStubMsg->Buffer;
      safe_buffer_increment(pStubMsg, bufsize);
 
      pStubMsg->BufferMark = saved_buffer;
      EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat, fMustAlloc);
 
      TRACE("copying %p to %p\n", saved_buffer, *ppMemory);
      if (*ppMemory != saved_buffer)
        memcpy(*ppMemory, saved_buffer, bufsize);
    }
    return bufsize;
  case FC_CVARRAY:
    esize = *(const WORD*)(pFormat+2);
    alignment = pFormat[1] + 1;
 
    pFormat = SkipConformance(pStubMsg, pFormat + 4);
 
    pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
 
    align_pointer(&pStubMsg->Buffer, alignment);
 
    bufsize = safe_multiply(esize, pStubMsg->ActualCount);
    memsize = safe_multiply(esize, pStubMsg->MaxCount);
 
    if (fUnmarshall)
    {
      offset = pStubMsg->Offset;
 
      if (!fMustAlloc && !*ppMemory)
        fMustAlloc = TRUE;
      if (fMustAlloc)
        *ppMemory = NdrAllocateZero(pStubMsg, memsize);
      saved_buffer = pStubMsg->Buffer;
      safe_buffer_increment(pStubMsg, bufsize);
 
      pStubMsg->BufferMark = saved_buffer;
      EmbeddedPointerUnmarshall(pStubMsg, saved_buffer, *ppMemory, pFormat,
                                fMustAlloc);
 
      memcpy(*ppMemory + offset, saved_buffer, bufsize);
    }
    return bufsize;
  case FC_C_CSTRING:
  case FC_C_WSTRING:
    if (fc == FC_C_CSTRING)
      esize = 1;
    else
      esize = 2;
 
    ReadVariance(pStubMsg, NULL, pStubMsg->MaxCount);
 
    if (pFormat[1] != FC_STRING_SIZED && (pStubMsg->MaxCount != pStubMsg->ActualCount))
    {
      ERR("buffer size %d must equal memory size %ld for non-sized conformant strings\n",
          pStubMsg->ActualCount, pStubMsg->MaxCount);
      RpcRaiseException(RPC_S_INVALID_BOUND);
    }
    if (pStubMsg->Offset)
    {
      ERR("conformant strings can't have Offset (%d)\n", pStubMsg->Offset);
      RpcRaiseException(RPC_S_INVALID_BOUND);
    }
 
    memsize = safe_multiply(esize, pStubMsg->MaxCount);
    bufsize = safe_multiply(esize, pStubMsg->ActualCount);
 
    validate_string_data(pStubMsg, bufsize, esize);
 
    if (fUnmarshall)
    {
      if (fMustAlloc)
        *ppMemory = NdrAllocate(pStubMsg, memsize);
      else
      {
        if (fUseBufferMemoryServer && !pStubMsg->IsClient &&
            !*ppMemory && (pStubMsg->MaxCount == pStubMsg->ActualCount))
          /* if the data in the RPC buffer is big enough, we just point
           * straight into it */
          *ppMemory = pStubMsg->Buffer;
        else if (!*ppMemory)
          *ppMemory = NdrAllocate(pStubMsg, memsize);
      }
 
      if (*ppMemory == pStubMsg->Buffer)
        safe_buffer_increment(pStubMsg, bufsize);
      else
        safe_copy_from_buffer(pStubMsg, *ppMemory, bufsize);
 
      if (*pFormat == FC_C_CSTRING)
        TRACE("string=%s\n", debugstr_a((char*)*ppMemory));
      else
        TRACE("string=%s\n", debugstr_w((LPWSTR)*ppMemory));
    }
    return bufsize;
 
  case FC_BOGUS_ARRAY:
    alignment = pFormat[1] + 1;
    pFormat = SkipConformance(pStubMsg, pFormat + 4);
    pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
 
    esize = ComplexStructSize(pStubMsg, pFormat);
    memsize = safe_multiply(esize, pStubMsg->MaxCount);
 
    assert( fUnmarshall );
 
    if (!fMustAlloc && !*ppMemory)
      fMustAlloc = TRUE;
    if (fMustAlloc)
      *ppMemory = NdrAllocateZero(pStubMsg, memsize);
 
    align_pointer(&pStubMsg->Buffer, alignment);
    saved_buffer = pStubMsg->Buffer;
 
    pMemory = *ppMemory;
    count = pStubMsg->ActualCount;
    for (i = 0; i < count; i++)
        pMemory = ComplexUnmarshall(pStubMsg, pMemory, pFormat, NULL, fMustAlloc);
    return pStubMsg->Buffer - saved_buffer;
 
  default:
    ERR("unknown array format 0x%x\n", fc);
    RpcRaiseException(RPC_X_BAD_STUB_DATA);
  }
}

Referenced by NdrComplexArrayUnmarshall(), NdrComplexStructUnmarshall(), NdrConformantArrayUnmarshall(), NdrConformantStringUnmarshall(), NdrConformantVaryingArrayUnmarshall(), and NdrConformantVaryingStructUnmarshall().

array_write_variance_and_marshall()

static void array_write_variance_and_marshall ( unsigned char  fc, PMIDL_STUB_MESSAGE  pStubMsg, unsigned char *  pMemory, PFORMAT_STRING  pFormat, unsigned char  fHasPointers  )

inlinestatic

Definition at line 2019 of file ndr_marshall.c.

{
  DWORD i, size;
  DWORD esize;
  unsigned char alignment;
 
  switch (fc)
  {
  case FC_CARRAY:
    esize = *(const WORD*)(pFormat+2);
    alignment = pFormat[1] + 1;
 
    pFormat = SkipConformance(pStubMsg, pFormat + 4);
 
    align_pointer_clear(&pStubMsg->Buffer, alignment);
 
    size = safe_multiply(esize, pStubMsg->MaxCount);
    if (fHasPointers)
      pStubMsg->BufferMark = pStubMsg->Buffer;
    safe_copy_to_buffer(pStubMsg, pMemory, size);
 
    if (fHasPointers)
      EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
    break;
  case FC_CVARRAY:
    esize = *(const WORD*)(pFormat+2);
    alignment = pFormat[1] + 1;
 
    pFormat = SkipConformance(pStubMsg, pFormat + 4);
    pFormat = SkipVariance(pStubMsg, pFormat);
 
    WriteVariance(pStubMsg);
 
    align_pointer_clear(&pStubMsg->Buffer, alignment);
 
    size = safe_multiply(esize, pStubMsg->ActualCount);
 
    if (fHasPointers)
      pStubMsg->BufferMark = pStubMsg->Buffer;
    safe_copy_to_buffer(pStubMsg, pMemory + pStubMsg->Offset, size);
 
    if (fHasPointers)
      EmbeddedPointerMarshall(pStubMsg, pMemory, pFormat);
    break;
  case FC_C_CSTRING:
  case FC_C_WSTRING:
    if (fc == FC_C_CSTRING)
      esize = 1;
    else
      esize = 2;
 
    WriteVariance(pStubMsg);
 
    size = safe_multiply(esize, pStubMsg->ActualCount);
    safe_copy_to_buffer(pStubMsg, pMemory, size); /* the string itself */
    break;
  case FC_BOGUS_ARRAY:
    alignment = pFormat[1] + 1;
    pFormat = SkipConformance(pStubMsg, pFormat + 4);
    if (IsConformanceOrVariancePresent(pFormat)) WriteVariance(pStubMsg);
    pFormat = SkipVariance(pStubMsg, pFormat);
 
    align_pointer_clear(&pStubMsg->Buffer, alignment);
 
    size = pStubMsg->ActualCount;
    for (i = 0; i < size; i++)
      pMemory = ComplexMarshall(pStubMsg, pMemory, pFormat, NULL);
    break;
  default:
    ERR("unknown array format 0x%x\n", fc);
    RpcRaiseException(RPC_X_BAD_STUB_DATA);
  }
}

Referenced by NdrComplexArrayMarshall(), NdrComplexStructMarshall(), NdrConformantArrayMarshall(), NdrConformantStringMarshall(), NdrConformantVaryingArrayMarshall(), and NdrConformantVaryingStructMarshall().

ComplexBufferSize()

static unsigned char * ComplexBufferSize ( PMIDL_STUB_MESSAGE  pStubMsg, unsigned char *  pMemory, PFORMAT_STRING  pFormat, PFORMAT_STRING  pPointer  )

static

Definition at line 3178 of file ndr_marshall.c.

{
  unsigned char *mem_base = pMemory;
  PFORMAT_STRING desc;
  NDR_BUFFERSIZE m;
  ULONG size;
 
  while (*pFormat != FC_END) {
    switch (*pFormat) {
    case FC_BYTE:
    case FC_CHAR:
    case FC_SMALL:
    case FC_USMALL:
      safe_buffer_length_increment(pStubMsg, 1);
      pMemory += 1;
      break;
    case FC_WCHAR:
    case FC_SHORT:
    case FC_USHORT:
      safe_buffer_length_increment(pStubMsg, 2);
      pMemory += 2;
      break;
    case FC_ENUM16:
      safe_buffer_length_increment(pStubMsg, 2);
      pMemory += 4;
      break;
    case FC_LONG:
    case FC_ULONG:
    case FC_ENUM32:
    case FC_FLOAT:
      safe_buffer_length_increment(pStubMsg, 4);
      pMemory += 4;
      break;
    case FC_INT3264:
    case FC_UINT3264:
      safe_buffer_length_increment(pStubMsg, 4);
      pMemory += sizeof(INT_PTR);
      break;
    case FC_HYPER:
    case FC_DOUBLE:
      safe_buffer_length_increment(pStubMsg, 8);
      pMemory += 8;
      break;
    case FC_RP:
    case FC_UP:
    case FC_OP:
    case FC_FP:
    case FC_POINTER:
      if (*pFormat != FC_POINTER)
        pPointer = pFormat;
      if (!pStubMsg->IgnoreEmbeddedPointers)
      {
        int saved_buffer_length = pStubMsg->BufferLength;
        pStubMsg->BufferLength = pStubMsg->PointerLength;
        pStubMsg->PointerLength = 0;
        if(!pStubMsg->BufferLength)
          ERR("BufferLength == 0??\n");
        PointerBufferSize(pStubMsg, *(unsigned char**)pMemory, pPointer);
        pStubMsg->PointerLength = pStubMsg->BufferLength;
        pStubMsg->BufferLength = saved_buffer_length;
      }
      if (*pPointer != FC_RP)
      {
        align_length(&pStubMsg->BufferLength, 4);
        safe_buffer_length_increment(pStubMsg, 4);
      }
      if (*pFormat == FC_POINTER)
        pPointer += 4;
      else
        pFormat += 4;
      pMemory += sizeof(void*);
      break;
    case FC_ALIGNM2:
      align_pointer_offset(&pMemory, mem_base, 2);
      break;
    case FC_ALIGNM4:
      align_pointer_offset(&pMemory, mem_base, 4);
      break;
    case FC_ALIGNM8:
      align_pointer_offset(&pMemory, mem_base, 8);
      break;
    case FC_STRUCTPAD1:
    case FC_STRUCTPAD2:
    case FC_STRUCTPAD3:
    case FC_STRUCTPAD4:
    case FC_STRUCTPAD5:
    case FC_STRUCTPAD6:
    case FC_STRUCTPAD7:
      pMemory += *pFormat - FC_STRUCTPAD1 + 1;
      break;
    case FC_EMBEDDED_COMPLEX:
      pMemory += pFormat[1];
      pFormat += 2;
      desc = pFormat + *(const SHORT*)pFormat;
      size = EmbeddedComplexSize(pStubMsg, desc);
      m = NdrBufferSizer[*desc & NDR_TABLE_MASK];
      if (m)
      {
        /* for some reason interface pointers aren't generated as
         * FC_POINTER, but instead as FC_EMBEDDED_COMPLEX, yet
         * they still need the dereferencing treatment that pointers are
         * given */
        if (*desc == FC_IP)
          m(pStubMsg, *(unsigned char **)pMemory, desc);
        else
          m(pStubMsg, pMemory, desc);
      }
      else FIXME("no buffersizer for embedded type %02x\n", *desc);
      pMemory += size;
      pFormat += 2;
      continue;
    case FC_PAD:
      break;
    default:
      FIXME("unhandled format 0x%02x\n", *pFormat);
    }
    pFormat++;
  }
 
  return pMemory;
}

Referenced by array_buffer_size(), and NdrComplexStructBufferSize().

ComplexFree()

static unsigned char * ComplexFree ( PMIDL_STUB_MESSAGE  pStubMsg, unsigned char *  pMemory, PFORMAT_STRING  pFormat, PFORMAT_STRING  pPointer  )

static

Definition at line 3303 of file ndr_marshall.c.

{
  unsigned char *mem_base = pMemory;
  PFORMAT_STRING desc;
  NDR_FREE m;
  ULONG size;
 
  while (*pFormat != FC_END) {
    switch (*pFormat) {
    case FC_BYTE:
    case FC_CHAR:
    case FC_SMALL:
    case FC_USMALL:
      pMemory += 1;
      break;
    case FC_WCHAR:
    case FC_SHORT:
    case FC_USHORT:
      pMemory += 2;
      break;
    case FC_LONG:
    case FC_ULONG:
    case FC_ENUM16:
    case FC_ENUM32:
    case FC_FLOAT:
      pMemory += 4;
      break;
    case FC_INT3264:
    case FC_UINT3264:
      pMemory += sizeof(INT_PTR);
      break;
    case FC_HYPER:
    case FC_DOUBLE:
      pMemory += 8;
      break;
    case FC_RP:
    case FC_UP:
    case FC_OP:
    case FC_FP:
    case FC_POINTER:
      if (*pFormat != FC_POINTER)
        pPointer = pFormat;
      NdrPointerFree(pStubMsg, *(unsigned char**)pMemory, pPointer);
      if (*pFormat == FC_POINTER)
        pPointer += 4;
      else
        pFormat += 4;
      pMemory += sizeof(void *);
      break;
    case FC_ALIGNM2:
      align_pointer_offset(&pMemory, mem_base, 2);
      break;
    case FC_ALIGNM4:
      align_pointer_offset(&pMemory, mem_base, 4);
      break;
    case FC_ALIGNM8:
      align_pointer_offset(&pMemory, mem_base, 8);
      break;
    case FC_STRUCTPAD1:
    case FC_STRUCTPAD2:
    case FC_STRUCTPAD3:
    case FC_STRUCTPAD4:
    case FC_STRUCTPAD5:
    case FC_STRUCTPAD6:
    case FC_STRUCTPAD7:
      pMemory += *pFormat - FC_STRUCTPAD1 + 1;
      break;
    case FC_EMBEDDED_COMPLEX:
      pMemory += pFormat[1];
      pFormat += 2;
      desc = pFormat + *(const SHORT*)pFormat;
      size = EmbeddedComplexSize(pStubMsg, desc);
      m = NdrFreer[*desc & NDR_TABLE_MASK];
      if (m)
      {
        /* for some reason interface pointers aren't generated as
         * FC_POINTER, but instead as FC_EMBEDDED_COMPLEX, yet
         * they still need the dereferencing treatment that pointers are
         * given */
        if (*desc == FC_IP)
          m(pStubMsg, *(unsigned char **)pMemory, desc);
        else
          m(pStubMsg, pMemory, desc);
      }
      pMemory += size;
      pFormat += 2;
      continue;
    case FC_PAD:
      break;
    default:
      FIXME("unhandled format 0x%02x\n", *pFormat);
    }
    pFormat++;
  }
 
  return pMemory;
}

Referenced by array_free(), NdrComplexArrayFree(), and NdrComplexStructFree().

ComplexMarshall()

static unsigned char * ComplexMarshall ( PMIDL_STUB_MESSAGE  pStubMsg, unsigned char *  pMemory, PFORMAT_STRING  pFormat, PFORMAT_STRING  pPointer  )

static

Definition at line 2842 of file ndr_marshall.c.

{
  unsigned char *mem_base = pMemory;
  PFORMAT_STRING desc;
  NDR_MARSHALL m;
  ULONG size;
 
  while (*pFormat != FC_END) {
    switch (*pFormat) {
    case FC_BYTE:
    case FC_CHAR:
    case FC_SMALL:
    case FC_USMALL:
      TRACE("byte=%d <= %p\n", *(WORD*)pMemory, pMemory);
      safe_copy_to_buffer(pStubMsg, pMemory, 1);
      pMemory += 1;
      break;
    case FC_WCHAR:
    case FC_SHORT:
    case FC_USHORT:
      TRACE("short=%d <= %p\n", *(WORD*)pMemory, pMemory);
      safe_copy_to_buffer(pStubMsg, pMemory, 2);
      pMemory += 2;
      break;
    case FC_ENUM16:
    {
      USHORT val = *(DWORD *)pMemory;
      TRACE("enum16=%d <= %p\n", *(DWORD*)pMemory, pMemory);
      if (32767 < *(DWORD*)pMemory)
        RpcRaiseException(RPC_X_ENUM_VALUE_OUT_OF_RANGE);
      safe_copy_to_buffer(pStubMsg, &val, 2);
      pMemory += 4;
      break;
    }
    case FC_LONG:
    case FC_ULONG:
    case FC_ENUM32:
      TRACE("long=%d <= %p\n", *(DWORD*)pMemory, pMemory);
      safe_copy_to_buffer(pStubMsg, pMemory, 4);
      pMemory += 4;
      break;
    case FC_INT3264:
    case FC_UINT3264:
    {
      UINT val = *(UINT_PTR *)pMemory;
      TRACE("int3264=%ld <= %p\n", *(UINT_PTR *)pMemory, pMemory);
      safe_copy_to_buffer(pStubMsg, &val, sizeof(UINT));
      pMemory += sizeof(UINT_PTR);
      break;
    }
    case FC_FLOAT:
      TRACE("float=%f <= %p\n", *(float*)pMemory, pMemory);
      safe_copy_to_buffer(pStubMsg, pMemory, sizeof(float));
      pMemory += sizeof(float);
      break;
    case FC_HYPER:
      TRACE("longlong=%s <= %p\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory), pMemory);
      safe_copy_to_buffer(pStubMsg, pMemory, 8);
      pMemory += 8;
      break;
    case FC_DOUBLE:
      TRACE("double=%f <= %p\n", *(double*)pMemory, pMemory);
      safe_copy_to_buffer(pStubMsg, pMemory, sizeof(double));
      pMemory += sizeof(double);
      break;
    case FC_RP:
    case FC_UP:
    case FC_OP:
    case FC_FP:
    case FC_POINTER:
    {
      unsigned char *saved_buffer;
      BOOL pointer_buffer_mark_set = FALSE;
      TRACE("pointer=%p <= %p\n", *(unsigned char**)pMemory, pMemory);
      TRACE("pStubMsg->Buffer before %p\n", pStubMsg->Buffer);
      if (*pFormat != FC_POINTER)
        pPointer = pFormat;
      if (*pPointer != FC_RP)
        align_pointer_clear(&pStubMsg->Buffer, 4);
      saved_buffer = pStubMsg->Buffer;
      if (pStubMsg->PointerBufferMark)
      {
        pStubMsg->Buffer = pStubMsg->PointerBufferMark;
        pStubMsg->PointerBufferMark = NULL;
        pointer_buffer_mark_set = TRUE;
      }
      else if (*pPointer != FC_RP)
        safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
      PointerMarshall(pStubMsg, saved_buffer, *(unsigned char**)pMemory, pPointer);
      if (pointer_buffer_mark_set)
      {
        STD_OVERFLOW_CHECK(pStubMsg);
        pStubMsg->PointerBufferMark = pStubMsg->Buffer;
        pStubMsg->Buffer = saved_buffer;
        if (*pPointer != FC_RP)
          safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
      }
      TRACE("pStubMsg->Buffer after %p\n", pStubMsg->Buffer);
      if (*pFormat == FC_POINTER)
        pPointer += 4;
      else
        pFormat += 4;
      pMemory += sizeof(void *);
      break;
    }
    case FC_ALIGNM2:
      align_pointer_offset(&pMemory, mem_base, 2);
      break;
    case FC_ALIGNM4:
      align_pointer_offset(&pMemory, mem_base, 4);
      break;
    case FC_ALIGNM8:
      align_pointer_offset(&pMemory, mem_base, 8);
      break;
    case FC_STRUCTPAD1:
    case FC_STRUCTPAD2:
    case FC_STRUCTPAD3:
    case FC_STRUCTPAD4:
    case FC_STRUCTPAD5:
    case FC_STRUCTPAD6:
    case FC_STRUCTPAD7:
      pMemory += *pFormat - FC_STRUCTPAD1 + 1;
      break;
    case FC_EMBEDDED_COMPLEX:
      pMemory += pFormat[1];
      pFormat += 2;
      desc = pFormat + *(const SHORT*)pFormat;
      size = EmbeddedComplexSize(pStubMsg, desc);
      TRACE("embedded complex (size=%d) <= %p\n", size, pMemory);
      m = NdrMarshaller[*desc & NDR_TABLE_MASK];
      if (m)
      {
        /* for some reason interface pointers aren't generated as
         * FC_POINTER, but instead as FC_EMBEDDED_COMPLEX, yet
         * they still need the dereferencing treatment that pointers are
         * given */
        if (*desc == FC_IP)
          m(pStubMsg, *(unsigned char **)pMemory, desc);
        else
          m(pStubMsg, pMemory, desc);
      }
      else FIXME("no marshaller for embedded type %02x\n", *desc);
      pMemory += size;
      pFormat += 2;
      continue;
    case FC_PAD:
      break;
    default:
      FIXME("unhandled format 0x%02x\n", *pFormat);
    }
    pFormat++;
  }
 
  return pMemory;
}

Referenced by array_write_variance_and_marshall(), and NdrComplexStructMarshall().

ComplexStructMemorySize()

static ULONG ComplexStructMemorySize ( PMIDL_STUB_MESSAGE  pStubMsg, PFORMAT_STRING  pFormat, PFORMAT_STRING  pPointer  )

static

Definition at line 3404 of file ndr_marshall.c.

{
  PFORMAT_STRING desc;
  ULONG size = 0;
 
  while (*pFormat != FC_END) {
    switch (*pFormat) {
    case FC_BYTE:
    case FC_CHAR:
    case FC_SMALL:
    case FC_USMALL:
      size += 1;
      safe_buffer_increment(pStubMsg, 1);
      break;
    case FC_WCHAR:
    case FC_SHORT:
    case FC_USHORT:
      size += 2;
      safe_buffer_increment(pStubMsg, 2);
      break;
    case FC_ENUM16:
      size += 4;
      safe_buffer_increment(pStubMsg, 2);
      break;
    case FC_LONG:
    case FC_ULONG:
    case FC_ENUM32:
    case FC_FLOAT:
      size += 4;
      safe_buffer_increment(pStubMsg, 4);
      break;
    case FC_INT3264:
    case FC_UINT3264:
      size += sizeof(INT_PTR);
      safe_buffer_increment(pStubMsg, 4);
      break;
    case FC_HYPER:
    case FC_DOUBLE:
      size += 8;
      safe_buffer_increment(pStubMsg, 8);
      break;
    case FC_RP:
    case FC_UP:
    case FC_OP:
    case FC_FP:
    case FC_POINTER:
    {
      unsigned char *saved_buffer;
      BOOL pointer_buffer_mark_set = FALSE;
      if (*pFormat != FC_POINTER)
        pPointer = pFormat;
      if (*pPointer != FC_RP)
        align_pointer(&pStubMsg->Buffer, 4);
      saved_buffer = pStubMsg->Buffer;
      if (pStubMsg->PointerBufferMark)
      {
        pStubMsg->Buffer = pStubMsg->PointerBufferMark;
        pStubMsg->PointerBufferMark = NULL;
        pointer_buffer_mark_set = TRUE;
      }
      else if (*pPointer != FC_RP)
        safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
 
      if (!pStubMsg->IgnoreEmbeddedPointers)
        PointerMemorySize(pStubMsg, saved_buffer, pPointer);
      if (pointer_buffer_mark_set)
      {
        STD_OVERFLOW_CHECK(pStubMsg);
        pStubMsg->PointerBufferMark = pStubMsg->Buffer;
        pStubMsg->Buffer = saved_buffer;
        if (*pPointer != FC_RP)
          safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
      }
      if (*pFormat == FC_POINTER)
        pPointer += 4;
      else
        pFormat += 4;
      size += sizeof(void *);
      break;
    }
    case FC_ALIGNM2:
      align_length(&size, 2);
      break;
    case FC_ALIGNM4:
      align_length(&size, 4);
      break;
    case FC_ALIGNM8:
      align_length(&size, 8);
      break;
    case FC_STRUCTPAD1:
    case FC_STRUCTPAD2:
    case FC_STRUCTPAD3:
    case FC_STRUCTPAD4:
    case FC_STRUCTPAD5:
    case FC_STRUCTPAD6:
    case FC_STRUCTPAD7:
      size += *pFormat - FC_STRUCTPAD1 + 1;
      break;
    case FC_EMBEDDED_COMPLEX:
      size += pFormat[1];
      pFormat += 2;
      desc = pFormat + *(const SHORT*)pFormat;
      size += EmbeddedComplexMemorySize(pStubMsg, desc);
      pFormat += 2;
      continue;
    case FC_PAD:
      break;
    default:
      FIXME("unhandled format 0x%02x\n", *pFormat);
    }
    pFormat++;
  }
 
  return size;
}

Referenced by array_memory_size(), and NdrComplexStructMemorySize().

ComplexStructSize()

ULONG ComplexStructSize	(	PMIDL_STUB_MESSAGE	pStubMsg,
		PFORMAT_STRING	pFormat
	)

Definition at line 3522 of file ndr_marshall.c.

{
  PFORMAT_STRING desc;
  ULONG size = 0;
 
  while (*pFormat != FC_END) {
    switch (*pFormat) {
    case FC_BYTE:
    case FC_CHAR:
    case FC_SMALL:
    case FC_USMALL:
      size += 1;
      break;
    case FC_WCHAR:
    case FC_SHORT:
    case FC_USHORT:
      size += 2;
      break;
    case FC_LONG:
    case FC_ULONG:
    case FC_ENUM16:
    case FC_ENUM32:
    case FC_FLOAT:
      size += 4;
      break;
    case FC_INT3264:
    case FC_UINT3264:
      size += sizeof(INT_PTR);
      break;
    case FC_HYPER:
    case FC_DOUBLE:
      size += 8;
      break;
    case FC_RP:
    case FC_UP:
    case FC_OP:
    case FC_FP:
    case FC_POINTER:
      size += sizeof(void *);
      if (*pFormat != FC_POINTER)
        pFormat += 4;
      break;
    case FC_ALIGNM2:
      align_length(&size, 2);
      break;
    case FC_ALIGNM4:
      align_length(&size, 4);
      break;
    case FC_ALIGNM8:
      align_length(&size, 8);
      break;
    case FC_STRUCTPAD1:
    case FC_STRUCTPAD2:
    case FC_STRUCTPAD3:
    case FC_STRUCTPAD4:
    case FC_STRUCTPAD5:
    case FC_STRUCTPAD6:
    case FC_STRUCTPAD7:
      size += *pFormat - FC_STRUCTPAD1 + 1;
      break;
    case FC_EMBEDDED_COMPLEX:
      size += pFormat[1];
      pFormat += 2;
      desc = pFormat + *(const SHORT*)pFormat;
      size += EmbeddedComplexSize(pStubMsg, desc);
      pFormat += 2;
      continue;
    case FC_PAD:
      break;
    default:
      FIXME("unhandled format 0x%02x\n", *pFormat);
    }
    pFormat++;
  }
 
  return size;
}

Referenced by array_memory_size(), array_read_conformance(), array_read_variance_and_unmarshall(), calc_arg_size(), NdrComplexStructBufferSize(), and NdrComplexStructMarshall().

ComplexUnmarshall()

static unsigned char * ComplexUnmarshall ( PMIDL_STUB_MESSAGE  pStubMsg, unsigned char *  pMemory, PFORMAT_STRING  pFormat, PFORMAT_STRING  pPointer, unsigned char  fMustAlloc  )

static

Definition at line 3001 of file ndr_marshall.c.

{
  unsigned char *mem_base = pMemory;
  PFORMAT_STRING desc;
  NDR_UNMARSHALL m;
  ULONG size;
 
  while (*pFormat != FC_END) {
    switch (*pFormat) {
    case FC_BYTE:
    case FC_CHAR:
    case FC_SMALL:
    case FC_USMALL:
      safe_copy_from_buffer(pStubMsg, pMemory, 1);
      TRACE("byte=%d => %p\n", *(WORD*)pMemory, pMemory);
      pMemory += 1;
      break;
    case FC_WCHAR:
    case FC_SHORT:
    case FC_USHORT:
      safe_copy_from_buffer(pStubMsg, pMemory, 2);
      TRACE("short=%d => %p\n", *(WORD*)pMemory, pMemory);
      pMemory += 2;
      break;
    case FC_ENUM16:
    {
      WORD val;
      safe_copy_from_buffer(pStubMsg, &val, 2);
      *(DWORD*)pMemory = val;
      TRACE("enum16=%d => %p\n", *(DWORD*)pMemory, pMemory);
      if (32767 < *(DWORD*)pMemory)
        RpcRaiseException(RPC_X_ENUM_VALUE_OUT_OF_RANGE);
      pMemory += 4;
      break;
    }
    case FC_LONG:
    case FC_ULONG:
    case FC_ENUM32:
      safe_copy_from_buffer(pStubMsg, pMemory, 4);
      TRACE("long=%d => %p\n", *(DWORD*)pMemory, pMemory);
      pMemory += 4;
      break;
    case FC_INT3264:
    {
      INT val;
      safe_copy_from_buffer(pStubMsg, &val, 4);
      *(INT_PTR *)pMemory = val;
      TRACE("int3264=%ld => %p\n", *(INT_PTR*)pMemory, pMemory);
      pMemory += sizeof(INT_PTR);
      break;
    }
    case FC_UINT3264:
    {
      UINT val;
      safe_copy_from_buffer(pStubMsg, &val, 4);
      *(UINT_PTR *)pMemory = val;
      TRACE("uint3264=%ld => %p\n", *(UINT_PTR*)pMemory, pMemory);
      pMemory += sizeof(UINT_PTR);
      break;
    }
    case FC_FLOAT:
      safe_copy_from_buffer(pStubMsg, pMemory, sizeof(float));
      TRACE("float=%f => %p\n", *(float*)pMemory, pMemory);
      pMemory += sizeof(float);
      break;
    case FC_HYPER:
      safe_copy_from_buffer(pStubMsg, pMemory, 8);
      TRACE("longlong=%s => %p\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory), pMemory);
      pMemory += 8;
      break;
    case FC_DOUBLE:
      safe_copy_from_buffer(pStubMsg, pMemory, sizeof(double));
      TRACE("double=%f => %p\n", *(double*)pMemory, pMemory);
      pMemory += sizeof(double);
      break;
    case FC_RP:
    case FC_UP:
    case FC_OP:
    case FC_FP:
    case FC_POINTER:
    {
      unsigned char *saved_buffer;
      BOOL pointer_buffer_mark_set = FALSE;
      TRACE("pointer => %p\n", pMemory);
      if (*pFormat != FC_POINTER)
        pPointer = pFormat;
      if (*pPointer != FC_RP)
        align_pointer(&pStubMsg->Buffer, 4);
      saved_buffer = pStubMsg->Buffer;
      if (pStubMsg->PointerBufferMark)
      {
        pStubMsg->Buffer = pStubMsg->PointerBufferMark;
        pStubMsg->PointerBufferMark = NULL;
        pointer_buffer_mark_set = TRUE;
      }
      else if (*pPointer != FC_RP)
        safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
 
      PointerUnmarshall(pStubMsg, saved_buffer, (unsigned char**)pMemory, *(unsigned char**)pMemory, pPointer, fMustAlloc);
      if (pointer_buffer_mark_set)
      {
        STD_OVERFLOW_CHECK(pStubMsg);
        pStubMsg->PointerBufferMark = pStubMsg->Buffer;
        pStubMsg->Buffer = saved_buffer;
        if (*pPointer != FC_RP)
          safe_buffer_increment(pStubMsg, 4); /* for pointer ID */
      }
      if (*pFormat == FC_POINTER)
        pPointer += 4;
      else
        pFormat += 4;
      pMemory += sizeof(void *);
      break;
    }
    case FC_ALIGNM2:
      align_pointer_offset_clear(&pMemory, mem_base, 2);
      break;
    case FC_ALIGNM4:
      align_pointer_offset_clear(&pMemory, mem_base, 4);
      break;
    case FC_ALIGNM8:
      align_pointer_offset_clear(&pMemory, mem_base, 8);
      break;
    case FC_STRUCTPAD1:
    case FC_STRUCTPAD2:
    case FC_STRUCTPAD3:
    case FC_STRUCTPAD4:
    case FC_STRUCTPAD5:
    case FC_STRUCTPAD6:
    case FC_STRUCTPAD7:
      memset(pMemory, 0, *pFormat - FC_STRUCTPAD1 + 1);
      pMemory += *pFormat - FC_STRUCTPAD1 + 1;
      break;
    case FC_EMBEDDED_COMPLEX:
      pMemory += pFormat[1];
      pFormat += 2;
      desc = pFormat + *(const SHORT*)pFormat;
      size = EmbeddedComplexSize(pStubMsg, desc);
      TRACE("embedded complex (size=%d) => %p\n", size, pMemory);
      if (fMustAlloc)
        /* we can't pass fMustAlloc=TRUE into the marshaller for this type
         * since the type is part of the memory block that is encompassed by
         * the whole complex type. Memory is forced to allocate when pointers
         * are set to NULL, so we emulate that part of fMustAlloc=TRUE by
         * clearing the memory we pass in to the unmarshaller */
        memset(pMemory, 0, size);
      m = NdrUnmarshaller[*desc & NDR_TABLE_MASK];
      if (m)
      {
        /* for some reason interface pointers aren't generated as
         * FC_POINTER, but instead as FC_EMBEDDED_COMPLEX, yet
         * they still need the dereferencing treatment that pointers are
         * given */
        if (*desc == FC_IP)
          m(pStubMsg, (unsigned char **)pMemory, desc, FALSE);
        else
          m(pStubMsg, &pMemory, desc, FALSE);
      }
      else FIXME("no unmarshaller for embedded type %02x\n", *desc);
      pMemory += size;
      pFormat += 2;
      continue;
    case FC_PAD:
      break;
    default:
      FIXME("unhandled format %d\n", *pFormat);
    }
    pFormat++;
  }
 
  return pMemory;
}

Referenced by array_read_variance_and_unmarshall(), and NdrComplexStructUnmarshall().

ComputeConformanceOrVariance()

PFORMAT_STRING ComputeConformanceOrVariance	(	MIDL_STUB_MESSAGE *	pStubMsg,
		unsigned char *	pMemory,
		PFORMAT_STRING	pFormat,
		ULONG_PTR	def,
		ULONG_PTR *	pCount
	)

Definition at line 556 of file ndr_marshall.c.

{
  BYTE dtype = pFormat[0] & 0xf;
  short ofs = *(const short *)&pFormat[2];
  LPVOID ptr = NULL;
  ULONG_PTR data = 0;
 
  if (!IsConformanceOrVariancePresent(pFormat)) {
    /* null descriptor */
    *pCount = def;
    goto finish_conf;
  }
 
  switch (pFormat[0] & 0xf0) {
  case FC_NORMAL_CONFORMANCE:
    TRACE("normal conformance, ofs=%d\n", ofs);
    ptr = pMemory;
    break;
  case FC_POINTER_CONFORMANCE:
    TRACE("pointer conformance, ofs=%d\n", ofs);
    ptr = pStubMsg->Memory;
    break;
  case FC_TOP_LEVEL_CONFORMANCE:
    TRACE("toplevel conformance, ofs=%d\n", ofs);
    if (pStubMsg->StackTop) {
      ptr = pStubMsg->StackTop;
    }
    else {
      /* -Os mode, *pCount is already set */
      goto finish_conf;
    }
    break;
  case FC_CONSTANT_CONFORMANCE:
    data = ofs | ((DWORD)pFormat[1] << 16);
    TRACE("constant conformance, val=%ld\n", data);
    *pCount = data;
    goto finish_conf;
  case FC_TOP_LEVEL_MULTID_CONFORMANCE:
    FIXME("toplevel multidimensional conformance, ofs=%d\n", ofs);
    if (pStubMsg->StackTop) {
      ptr = pStubMsg->StackTop;
    }
    else {
      /* ? */
      goto done_conf_grab;
    }
    break;
  default:
    FIXME("unknown conformance type %x, expect crash.\n", pFormat[0] & 0xf0);
    goto finish_conf;
  }
 
  switch (pFormat[1]) {
  case FC_DEREFERENCE:
    ptr = *(LPVOID*)((char *)ptr + ofs);
    break;
  case FC_CALLBACK:
  {
    unsigned char *old_stack_top = pStubMsg->StackTop;
    ULONG_PTR max_count, old_max_count = pStubMsg->MaxCount;
 
    pStubMsg->StackTop = ptr;
 
    /* ofs is index into StubDesc->apfnExprEval */
    TRACE("callback conformance into apfnExprEval[%d]\n", ofs);
    pStubMsg->StubDesc->apfnExprEval[ofs](pStubMsg);
 
    pStubMsg->StackTop = old_stack_top;
 
    /* the callback function always stores the computed value in MaxCount */
    max_count = pStubMsg->MaxCount;
    pStubMsg->MaxCount = old_max_count;
    *pCount = max_count;
    goto finish_conf;
  }
  default:
    ptr = (char *)ptr + ofs;
    break;
  }
 
  switch (dtype) {
  case FC_LONG:
  case FC_ULONG:
    data = *(DWORD*)ptr;
    break;
  case FC_SHORT:
    data = *(SHORT*)ptr;
    break;
  case FC_USHORT:
    data = *(USHORT*)ptr;
    break;
  case FC_CHAR:
  case FC_SMALL:
    data = *(CHAR*)ptr;
    break;
  case FC_BYTE:
  case FC_USMALL:
    data = *(UCHAR*)ptr;
    break;
  case FC_HYPER:
    data = *(ULONGLONG *)ptr;
    break;
  default:
    FIXME("unknown conformance data type %x\n", dtype);
    goto done_conf_grab;
  }
  TRACE("dereferenced data type %x at %p, got %ld\n", dtype, ptr, data);
 
done_conf_grab:
  switch (pFormat[1]) {
  case FC_DEREFERENCE: /* already handled */
  case 0: /* no op */
    *pCount = data;
    break;
  case FC_ADD_1:
    *pCount = data + 1;
    break;
  case FC_SUB_1:
    *pCount = data - 1;
    break;
  case FC_MULT_2:
    *pCount = data * 2;
    break;
  case FC_DIV_2:
    *pCount = data / 2;
    break;
  default:
    FIXME("unknown conformance op %d\n", pFormat[1]);
    goto finish_conf;
  }
 
finish_conf:
  TRACE("resulting conformance is %ld\n", *pCount);
 
  return SkipConformance(pStubMsg, pFormat);
}

Referenced by ComputeConformance(), and ComputeVariance().

dump_pointer_attr()

static void dump_pointer_attr ( unsigned char  attr )

inlinestatic

Definition at line 795 of file ndr_marshall.c.

{
    if (attr & FC_ALLOCATE_ALL_NODES)
        TRACE(" FC_ALLOCATE_ALL_NODES");
    if (attr & FC_DONT_FREE)
        TRACE(" FC_DONT_FREE");
    if (attr & FC_ALLOCED_ON_STACK)
        TRACE(" FC_ALLOCED_ON_STACK");
    if (attr & FC_SIMPLE_POINTER)
        TRACE(" FC_SIMPLE_POINTER");
    if (attr & FC_POINTER_DEREF)
        TRACE(" FC_POINTER_DEREF");
    TRACE("\n");
}

Referenced by PointerBufferSize(), PointerFree(), PointerMarshall(), PointerMemorySize(), and PointerUnmarshall().

EmbeddedComplexMemorySize()

static ULONG EmbeddedComplexMemorySize ( PMIDL_STUB_MESSAGE  pStubMsg, PFORMAT_STRING  pFormat  )

static

Definition at line 2827 of file ndr_marshall.c.

{
  NDR_MEMORYSIZE m = NdrMemorySizer[*pFormat & NDR_TABLE_MASK];
 
  if (!m)
  {
    FIXME("no memorysizer for data type=%02x\n", *pFormat);
    return 0;
  }
 
  return m(pStubMsg, pFormat);
}

Referenced by ComplexStructMemorySize().

EmbeddedComplexSize()

static ULONG EmbeddedComplexSize ( MIDL_STUB_MESSAGE *  pStubMsg, PFORMAT_STRING  pFormat  )

static

Definition at line 2766 of file ndr_marshall.c.

{
  switch (*pFormat) {
  case FC_STRUCT:
  case FC_PSTRUCT:
  case FC_CSTRUCT:
  case FC_BOGUS_STRUCT:
  case FC_SMFARRAY:
  case FC_SMVARRAY:
  case FC_CSTRING:
    return *(const WORD*)&pFormat[2];
  case FC_LGFARRAY:
  case FC_LGVARRAY:
    return *(const ULONG*)&pFormat[2];
  case FC_USER_MARSHAL:
    return *(const WORD*)&pFormat[4];
  case FC_RANGE: {
    switch (((const NDR_RANGE *)pFormat)->flags_type & 0xf) {
    case FC_BYTE:
    case FC_CHAR:
    case FC_SMALL:
    case FC_USMALL:
        return sizeof(UCHAR);
    case FC_WCHAR:
    case FC_SHORT:
    case FC_USHORT:
        return sizeof(USHORT);
    case FC_LONG:
    case FC_ULONG:
    case FC_ENUM32:
        return sizeof(ULONG);
    case FC_FLOAT:
        return sizeof(float);
    case FC_DOUBLE:
        return sizeof(double);
    case FC_HYPER:
        return sizeof(ULONGLONG);
    case FC_ENUM16:
        return sizeof(UINT);
    default:
        ERR("unknown type 0x%x\n", ((const NDR_RANGE *)pFormat)->flags_type & 0xf);
        RpcRaiseException(RPC_X_BAD_STUB_DATA);
    }
  }
  case FC_NON_ENCAPSULATED_UNION:
    pFormat += 2;
    pFormat = SkipConformance(pStubMsg, pFormat);
    pFormat += *(const SHORT*)pFormat;
    return *(const SHORT*)pFormat;
  case FC_IP:
    return sizeof(void *);
  case FC_WSTRING:
    return *(const WORD*)&pFormat[2] * 2;
  default:
    FIXME("unhandled embedded type %02x\n", *pFormat);
  }
  return 0;
}

Referenced by ComplexBufferSize(), ComplexFree(), ComplexMarshall(), ComplexStructSize(), and ComplexUnmarshall().

EmbeddedPointerBufferSize()

static void EmbeddedPointerBufferSize ( PMIDL_STUB_MESSAGE  pStubMsg, unsigned char *  pMemory, PFORMAT_STRING  pFormat  )

static

Definition at line 1337 of file ndr_marshall.c.

{
  unsigned rep, count, stride;
  unsigned i;
  ULONG saved_buffer_length = 0;
 
  TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
 
  if (pStubMsg->IgnoreEmbeddedPointers) return;
 
  if (*pFormat != FC_PP) return;
  pFormat += 2;
 
  if (pStubMsg->PointerLength)
  {
    saved_buffer_length = pStubMsg->BufferLength;
    pStubMsg->BufferLength = pStubMsg->PointerLength;
    pStubMsg->PointerLength = 0;
  }
 
  while (pFormat[0] != FC_END) {
    switch (pFormat[0]) {
    default:
      FIXME("unknown repeat type %d; assuming no repeat\n", pFormat[0]);
      /* fallthrough */
    case FC_NO_REPEAT:
      rep = 1;
      stride = 0;
      count = 1;
      pFormat += 2;
      break;
    case FC_FIXED_REPEAT:
      rep = *(const WORD*)&pFormat[2];
      stride = *(const WORD*)&pFormat[4];
      count = *(const WORD*)&pFormat[8];
      pFormat += 10;
      break;
    case FC_VARIABLE_REPEAT:
      rep = (pFormat[1] == FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
      stride = *(const WORD*)&pFormat[2];
      count = *(const WORD*)&pFormat[6];
      pFormat += 8;
      break;
    }
    for (i = 0; i < rep; i++) {
      PFORMAT_STRING info = pFormat;
      unsigned char *membase = pMemory + (i * stride);
      unsigned u;
 
      for (u=0; u<count; u++,info+=8) {
        unsigned char *memptr = membase + *(const SHORT*)&info[0];
        unsigned char *saved_memory = pStubMsg->Memory;
 
        pStubMsg->Memory = membase;
        PointerBufferSize(pStubMsg, *(unsigned char**)memptr, info+4);
        pStubMsg->Memory = saved_memory;
      }
    }
    pFormat += 8 * count;
  }
 
  if (saved_buffer_length)
  {
    pStubMsg->PointerLength = pStubMsg->BufferLength;
    pStubMsg->BufferLength = saved_buffer_length;
  }
}

Referenced by array_buffer_size(), NdrConformantStructBufferSize(), NdrConformantVaryingStructBufferSize(), NdrFixedArrayBufferSize(), NdrSimpleStructBufferSize(), and NdrVaryingArrayBufferSize().

EmbeddedPointerFree()

static void EmbeddedPointerFree ( PMIDL_STUB_MESSAGE  pStubMsg, unsigned char *  pMemory, PFORMAT_STRING  pFormat  )

static

Definition at line 1480 of file ndr_marshall.c.

{
  unsigned rep, count, stride;
  unsigned i;
 
  TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
  if (*pFormat != FC_PP) return;
  pFormat += 2;
 
  while (pFormat[0] != FC_END) {
    switch (pFormat[0]) {
    default:
      FIXME("unknown repeat type %d; assuming no repeat\n", pFormat[0]);
      /* fallthrough */
    case FC_NO_REPEAT:
      rep = 1;
      stride = 0;
      count = 1;
      pFormat += 2;
      break;
    case FC_FIXED_REPEAT:
      rep = *(const WORD*)&pFormat[2];
      stride = *(const WORD*)&pFormat[4];
      count = *(const WORD*)&pFormat[8];
      pFormat += 10;
      break;
    case FC_VARIABLE_REPEAT:
      rep = (pFormat[1] == FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
      stride = *(const WORD*)&pFormat[2];
      count = *(const WORD*)&pFormat[6];
      pFormat += 8;
      break;
    }
    for (i = 0; i < rep; i++) {
      PFORMAT_STRING info = pFormat;
      unsigned char *membase = pMemory + (i * stride);
      unsigned u;
 
      for (u=0; u<count; u++,info+=8) {
        unsigned char *memptr = membase + *(const SHORT*)&info[0];
        unsigned char *saved_memory = pStubMsg->Memory;
 
        pStubMsg->Memory = membase;
        PointerFree(pStubMsg, *(unsigned char**)memptr, info+4);
        pStubMsg->Memory = saved_memory;
      }
    }
    pFormat += 8 * count;
  }
}

Referenced by array_free(), NdrConformantStructFree(), NdrConformantVaryingStructFree(), NdrFixedArrayFree(), NdrSimpleStructFree(), and NdrVaryingArrayFree().

EmbeddedPointerMarshall()

static unsigned char * EmbeddedPointerMarshall ( PMIDL_STUB_MESSAGE  pStubMsg, unsigned char *  pMemory, PFORMAT_STRING  pFormat  )

static

Definition at line 1177 of file ndr_marshall.c.

{
  unsigned char *Mark = pStubMsg->BufferMark;
  unsigned rep, count, stride;
  unsigned i;
  unsigned char *saved_buffer = NULL;
 
  TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
 
  if (*pFormat != FC_PP) return NULL;
  pFormat += 2;
 
  if (pStubMsg->PointerBufferMark)
  {
    saved_buffer = pStubMsg->Buffer;
    pStubMsg->Buffer = pStubMsg->PointerBufferMark;
    pStubMsg->PointerBufferMark = NULL;
  }
 
  while (pFormat[0] != FC_END) {
    switch (pFormat[0]) {
    default:
      FIXME("unknown repeat type %d; assuming no repeat\n", pFormat[0]);
      /* fallthrough */
    case FC_NO_REPEAT:
      rep = 1;
      stride = 0;
      count = 1;
      pFormat += 2;
      break;
    case FC_FIXED_REPEAT:
      rep = *(const WORD*)&pFormat[2];
      stride = *(const WORD*)&pFormat[4];
      count = *(const WORD*)&pFormat[8];
      pFormat += 10;
      break;
    case FC_VARIABLE_REPEAT:
      rep = (pFormat[1] == FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
      stride = *(const WORD*)&pFormat[2];
      count = *(const WORD*)&pFormat[6];
      pFormat += 8;
      break;
    }
    for (i = 0; i < rep; i++) {
      PFORMAT_STRING info = pFormat;
      unsigned char *membase = pMemory + (i * stride);
      unsigned char *bufbase = Mark + (i * stride);
      unsigned u;
 
      for (u=0; u<count; u++,info+=8) {
        unsigned char *memptr = membase + *(const SHORT*)&info[0];
        unsigned char *bufptr = bufbase + *(const SHORT*)&info[2];
        unsigned char *saved_memory = pStubMsg->Memory;
 
        pStubMsg->Memory = membase;
        PointerMarshall(pStubMsg, bufptr, *(unsigned char**)memptr, info+4);
        pStubMsg->Memory = saved_memory;
      }
    }
    pFormat += 8 * count;
  }
 
  if (saved_buffer)
  {
    pStubMsg->PointerBufferMark = pStubMsg->Buffer;
    pStubMsg->Buffer = saved_buffer;
  }
 
  STD_OVERFLOW_CHECK(pStubMsg);
 
  return NULL;
}

Referenced by array_write_variance_and_marshall(), NdrConformantStructMarshall(), NdrConformantVaryingStructMarshall(), NdrFixedArrayMarshall(), NdrSimpleStructMarshall(), and NdrVaryingArrayMarshall().

EmbeddedPointerMemorySize()

static ULONG EmbeddedPointerMemorySize ( PMIDL_STUB_MESSAGE  pStubMsg, PFORMAT_STRING  pFormat  )

static

Definition at line 1410 of file ndr_marshall.c.

{
  unsigned char *Mark = pStubMsg->BufferMark;
  unsigned rep, count, stride;
  unsigned i;
  unsigned char *saved_buffer = NULL;
 
  TRACE("(%p,%p)\n", pStubMsg, pFormat);
 
  if (pStubMsg->IgnoreEmbeddedPointers) return 0;
 
  if (pStubMsg->PointerBufferMark)
  {
    saved_buffer = pStubMsg->Buffer;
    pStubMsg->Buffer = pStubMsg->PointerBufferMark;
    pStubMsg->PointerBufferMark = NULL;
  }
 
  if (*pFormat != FC_PP) return 0;
  pFormat += 2;
 
  while (pFormat[0] != FC_END) {
    switch (pFormat[0]) {
    default:
      FIXME("unknown repeat type %d; assuming no repeat\n", pFormat[0]);
      /* fallthrough */
    case FC_NO_REPEAT:
      rep = 1;
      stride = 0;
      count = 1;
      pFormat += 2;
      break;
    case FC_FIXED_REPEAT:
      rep = *(const WORD*)&pFormat[2];
      stride = *(const WORD*)&pFormat[4];
      count = *(const WORD*)&pFormat[8];
      pFormat += 10;
      break;
    case FC_VARIABLE_REPEAT:
      rep = (pFormat[1] == FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
      stride = *(const WORD*)&pFormat[2];
      count = *(const WORD*)&pFormat[6];
      pFormat += 8;
      break;
    }
    for (i = 0; i < rep; i++) {
      PFORMAT_STRING info = pFormat;
      unsigned char *bufbase = Mark + (i * stride);
      unsigned u;
      for (u=0; u<count; u++,info+=8) {
        unsigned char *bufptr = bufbase + *(const SHORT*)&info[2];
        PointerMemorySize(pStubMsg, bufptr, info+4);
      }
    }
    pFormat += 8 * count;
  }
 
  if (saved_buffer)
  {
    pStubMsg->PointerBufferMark = pStubMsg->Buffer;
    pStubMsg->Buffer = saved_buffer;
  }
 
  return 0;
}

Referenced by array_memory_size(), NdrConformantVaryingStructMemorySize(), NdrFixedArrayMemorySize(), NdrSimpleStructMemorySize(), and NdrVaryingArrayMemorySize().

EmbeddedPointerUnmarshall()

static unsigned char * EmbeddedPointerUnmarshall ( PMIDL_STUB_MESSAGE  pStubMsg, unsigned char *  pDstBuffer, unsigned char *  pSrcMemoryPtrs, PFORMAT_STRING  pFormat, unsigned char  fMustAlloc  )

static

Definition at line 1260 of file ndr_marshall.c.

{
  unsigned char *Mark = pStubMsg->BufferMark;
  unsigned rep, count, stride;
  unsigned i;
  unsigned char *saved_buffer = NULL;
 
  TRACE("(%p,%p,%p,%p,%d)\n", pStubMsg, pDstBuffer, pSrcMemoryPtrs, pFormat, fMustAlloc);
 
  if (*pFormat != FC_PP) return NULL;
  pFormat += 2;
 
  if (pStubMsg->PointerBufferMark)
  {
    saved_buffer = pStubMsg->Buffer;
    pStubMsg->Buffer = pStubMsg->PointerBufferMark;
    pStubMsg->PointerBufferMark = NULL;
  }
 
  while (pFormat[0] != FC_END) {
    TRACE("pFormat[0] = 0x%x\n", pFormat[0]);
    switch (pFormat[0]) {
    default:
      FIXME("unknown repeat type %d; assuming no repeat\n", pFormat[0]);
      /* fallthrough */
    case FC_NO_REPEAT:
      rep = 1;
      stride = 0;
      count = 1;
      pFormat += 2;
      break;
    case FC_FIXED_REPEAT:
      rep = *(const WORD*)&pFormat[2];
      stride = *(const WORD*)&pFormat[4];
      count = *(const WORD*)&pFormat[8];
      pFormat += 10;
      break;
    case FC_VARIABLE_REPEAT:
      rep = (pFormat[1] == FC_VARIABLE_OFFSET) ? pStubMsg->ActualCount : pStubMsg->MaxCount;
      stride = *(const WORD*)&pFormat[2];
      count = *(const WORD*)&pFormat[6];
      pFormat += 8;
      break;
    }
    for (i = 0; i < rep; i++) {
      PFORMAT_STRING info = pFormat;
      unsigned char *bufdstbase = pDstBuffer + (i * stride);
      unsigned char *memsrcbase = pSrcMemoryPtrs + (i * stride);
      unsigned char *bufbase = Mark + (i * stride);
      unsigned u;
 
      for (u=0; u<count; u++,info+=8) {
        unsigned char **bufdstptr = (unsigned char **)(bufdstbase + *(const SHORT*)&info[2]);
        unsigned char **memsrcptr = (unsigned char **)(memsrcbase + *(const SHORT*)&info[0]);
        unsigned char *bufptr = bufbase + *(const SHORT*)&info[2];
        PointerUnmarshall(pStubMsg, bufptr, bufdstptr, *memsrcptr, info+4, fMustAlloc);
      }
    }
    pFormat += 8 * count;
  }
 
  if (saved_buffer)
  {
    pStubMsg->PointerBufferMark = pStubMsg->Buffer;
    pStubMsg->Buffer = saved_buffer;
  }
 
  return NULL;
}

Referenced by array_read_variance_and_unmarshall(), NdrConformantStructUnmarshall(), NdrConformantVaryingStructUnmarshall(), NdrFixedArrayUnmarshall(), NdrSimpleStructUnmarshall(), and NdrVaryingArrayUnmarshall().

get_arm_offset_from_union_arm_selector()

static PFORMAT_STRING get_arm_offset_from_union_arm_selector ( PMIDL_STUB_MESSAGE  pStubMsg, ULONG  discriminant, PFORMAT_STRING  pFormat  )

static

Definition at line 5685 of file ndr_marshall.c.

{
    unsigned short num_arms, arm, type;
 
    num_arms = *(const SHORT*)pFormat & 0x0fff;
    pFormat += 2;
    for(arm = 0; arm < num_arms; arm++)
    {
        if(discriminant == *(const ULONG*)pFormat)
        {
            pFormat += 4;
            break;
        }
        pFormat += 6;
    }
 
    type = *(const unsigned short*)pFormat;
    TRACE("type %04x\n", type);
    if(arm == num_arms) /* default arm extras */
    {
        if(type == 0xffff)
        {
            ERR("no arm for 0x%x and no default case\n", discriminant);
            RpcRaiseException(RPC_S_INVALID_TAG);
            return NULL;
        }
        if(type == 0)
        {
            TRACE("falling back to empty default case for 0x%x\n", discriminant);
            return NULL;
        }
    }
    return pFormat;
}

Referenced by union_arm_buffer_size(), union_arm_free(), union_arm_marshall(), union_arm_memory_size(), and union_arm_unmarshall().

get_discriminant()

static ULONG get_discriminant ( unsigned char  fc, const unsigned char *  pMemory  )

static

Definition at line 5661 of file ndr_marshall.c.

{
    switch (fc)
    {
    case FC_BYTE:
    case FC_CHAR:
    case FC_SMALL:
    case FC_USMALL:
        return *pMemory;
    case FC_WCHAR:
    case FC_SHORT:
    case FC_USHORT:
    case FC_ENUM16:
        return *(const USHORT *)pMemory;
    case FC_LONG:
    case FC_ULONG:
    case FC_ENUM32:
        return *(const ULONG *)pMemory;
    default:
        FIXME("Unhandled base type: 0x%02x\n", fc);
        return 0;
    }
}

Referenced by NdrEncapsulatedUnionBufferSize(), NdrEncapsulatedUnionFree(), NdrEncapsulatedUnionMarshall(), NdrEncapsulatedUnionMemorySize(), and NdrEncapsulatedUnionUnmarshall().

IsConformanceOrVariancePresent()

static BOOL IsConformanceOrVariancePresent ( PFORMAT_STRING  pFormat )

inlinestatic

Definition at line 463 of file ndr_marshall.c.

{
    return (*(const ULONG *)pFormat != -1);
}

Referenced by array_buffer_size(), array_compute_and_size_conformance(), array_compute_and_write_conformance(), array_read_conformance(), array_write_variance_and_marshall(), ComputeConformanceOrVariance(), and ReadVariance().

NdrAllocate()

void *WINAPI NdrAllocate	(	MIDL_STUB_MESSAGE *	pStubMsg,
		SIZE_T	len
	)

Definition at line 419 of file ndr_marshall.c.

{
    SIZE_T aligned_len;
    SIZE_T adjusted_len;
    void *p;
    NDR_MEMORY_LIST *mem_list;
 
    aligned_len = (len + 7) & ~7;
    adjusted_len = aligned_len + sizeof(NDR_MEMORY_LIST);
    /* check for overflow */
    if (adjusted_len < len)
    {
        ERR("overflow of adjusted_len %ld, len %ld\n", adjusted_len, len);
        RpcRaiseException(RPC_X_BAD_STUB_DATA);
    }
 
    p = pStubMsg->pfnAllocate(adjusted_len);
    if (!p) RpcRaiseException(RPC_X_NO_MEMORY);
 
    mem_list = (NDR_MEMORY_LIST *)((char *)p + aligned_len);
    mem_list->magic = MEML_MAGIC;
    mem_list->size = aligned_len;
    mem_list->reserved = 0;
    mem_list->next = pStubMsg->pMemoryList;
    pStubMsg->pMemoryList = mem_list;
 
    TRACE("-- %p\n", p);
    return p;
}

Referenced by array_read_variance_and_unmarshall(), NdrAllocateZero(), NdrBaseTypeUnmarshall(), NdrEncapsulatedUnionUnmarshall(), NdrNonConformantStringUnmarshall(), NdrNonEncapsulatedUnionUnmarshall(), NdrUserMarshalUnmarshall(), stub_do_args(), and test_ndr_allocate().

NdrAllocateZero()

static void * NdrAllocateZero ( MIDL_STUB_MESSAGE *  stubmsg, SIZE_T  len  )

static

Definition at line 449 of file ndr_marshall.c.

{
    void *mem = NdrAllocate(stubmsg, len);
    memset(mem, 0, len);
    return mem;
}

Referenced by array_read_variance_and_unmarshall(), NdrComplexStructUnmarshall(), NdrConformantStructUnmarshall(), NdrConformantVaryingStructUnmarshall(), NdrFixedArrayUnmarshall(), NdrSimpleStructUnmarshall(), NdrVaryingArrayUnmarshall(), and PointerUnmarshall().

NdrBaseTypeBufferSize()

static void WINAPI NdrBaseTypeBufferSize ( PMIDL_STUB_MESSAGE  pStubMsg, unsigned char *  pMemory, PFORMAT_STRING  pFormat  )

static

Definition at line 6811 of file ndr_marshall.c.

{
    TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
 
    switch(*pFormat)
    {
    case FC_BYTE:
    case FC_CHAR:
    case FC_SMALL:
    case FC_USMALL:
        safe_buffer_length_increment(pStubMsg, sizeof(UCHAR));
        break;
    case FC_WCHAR:
    case FC_SHORT:
    case FC_USHORT:
    case FC_ENUM16:
        align_length(&pStubMsg->BufferLength, sizeof(USHORT));
        safe_buffer_length_increment(pStubMsg, sizeof(USHORT));
        break;
    case FC_LONG:
    case FC_ULONG:
    case FC_ENUM32:
    case FC_INT3264:
    case FC_UINT3264:
        align_length(&pStubMsg->BufferLength, sizeof(ULONG));
        safe_buffer_length_increment(pStubMsg, sizeof(ULONG));
        break;
    case FC_FLOAT:
        align_length(&pStubMsg->BufferLength, sizeof(float));
        safe_buffer_length_increment(pStubMsg, sizeof(float));
        break;
    case FC_DOUBLE:
        align_length(&pStubMsg->BufferLength, sizeof(double));
        safe_buffer_length_increment(pStubMsg, sizeof(double));
        break;
    case FC_HYPER:
        align_length(&pStubMsg->BufferLength, sizeof(ULONGLONG));
        safe_buffer_length_increment(pStubMsg, sizeof(ULONGLONG));
        break;
    case FC_ERROR_STATUS_T:
        align_length(&pStubMsg->BufferLength, sizeof(error_status_t));
        safe_buffer_length_increment(pStubMsg, sizeof(error_status_t));
        break;
    case FC_IGNORE:
        break;
    default:
        FIXME("Unhandled base type: 0x%02x\n", *pFormat);
    }
}

Referenced by NdrEncapsulatedUnionBufferSize(), NdrNonEncapsulatedUnionBufferSize(), NdrRangeBufferSize(), and union_arm_buffer_size().

NdrBaseTypeFree()

static void WINAPI NdrBaseTypeFree ( PMIDL_STUB_MESSAGE  pStubMsg, unsigned char *  pMemory, PFORMAT_STRING  pFormat  )

static

Definition at line 6948 of file ndr_marshall.c.

{
   TRACE("pStubMsg %p pMemory %p type 0x%02x\n", pStubMsg, pMemory, *pFormat);
 
   /* nothing to do */
}

NdrBaseTypeMarshall()

static unsigned char *WINAPI NdrBaseTypeMarshall ( PMIDL_STUB_MESSAGE  pStubMsg, unsigned char *  pMemory, PFORMAT_STRING  pFormat  )

static

Definition at line 6617 of file ndr_marshall.c.

{
    TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
 
    switch(*pFormat)
    {
    case FC_BYTE:
    case FC_CHAR:
    case FC_SMALL:
    case FC_USMALL:
        safe_copy_to_buffer(pStubMsg, pMemory, sizeof(UCHAR));
        TRACE("value: 0x%02x\n", *pMemory);
        break;
    case FC_WCHAR:
    case FC_SHORT:
    case FC_USHORT:
        align_pointer_clear(&pStubMsg->Buffer, sizeof(USHORT));
        safe_copy_to_buffer(pStubMsg, pMemory, sizeof(USHORT));
        TRACE("value: 0x%04x\n", *(USHORT *)pMemory);
        break;
    case FC_LONG:
    case FC_ULONG:
    case FC_ERROR_STATUS_T:
    case FC_ENUM32:
        align_pointer_clear(&pStubMsg->Buffer, sizeof(ULONG));
        safe_copy_to_buffer(pStubMsg, pMemory, sizeof(ULONG));
        TRACE("value: 0x%08x\n", *(ULONG *)pMemory);
        break;
    case FC_FLOAT:
        align_pointer_clear(&pStubMsg->Buffer, sizeof(float));
        safe_copy_to_buffer(pStubMsg, pMemory, sizeof(float));
        break;
    case FC_DOUBLE:
        align_pointer_clear(&pStubMsg->Buffer, sizeof(double));
        safe_copy_to_buffer(pStubMsg, pMemory, sizeof(double));
        break;
    case FC_HYPER:
        align_pointer_clear(&pStubMsg->Buffer, sizeof(ULONGLONG));
        safe_copy_to_buffer(pStubMsg, pMemory, sizeof(ULONGLONG));
        TRACE("value: %s\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory));
        break;
    case FC_ENUM16:
    {
        USHORT val = *(UINT *)pMemory;
        /* only 16-bits on the wire, so do a sanity check */
        if (*(UINT *)pMemory > SHRT_MAX)
            RpcRaiseException(RPC_X_ENUM_VALUE_OUT_OF_RANGE);
        align_pointer_clear(&pStubMsg->Buffer, sizeof(USHORT));
        safe_copy_to_buffer(pStubMsg, &val, sizeof(val));
        TRACE("value: 0x%04x\n", *(UINT *)pMemory);
        break;
    }
    case FC_INT3264:
    case FC_UINT3264:
    {
        UINT val = *(UINT_PTR *)pMemory;
        align_pointer_clear(&pStubMsg->Buffer, sizeof(UINT));
        safe_copy_to_buffer(pStubMsg, &val, sizeof(val));
        break;
    }
    case FC_IGNORE:
        break;
    default:
        FIXME("Unhandled base type: 0x%02x\n", *pFormat);
    }
 
    /* FIXME: what is the correct return value? */
    return NULL;
}

Referenced by NdrEncapsulatedUnionMarshall(), NdrNonEncapsulatedUnionMarshall(), NdrRangeMarshall(), NdrSimpleTypeMarshall(), and union_arm_marshall().

NdrBaseTypeMemorySize()

static ULONG WINAPI NdrBaseTypeMemorySize ( PMIDL_STUB_MESSAGE  pStubMsg, PFORMAT_STRING  pFormat  )

static

Definition at line 6867 of file ndr_marshall.c.

{
    TRACE("pStubMsg %p, type 0x%02x\n", pStubMsg, *pFormat);
 
    switch(*pFormat)
    {
    case FC_BYTE:
    case FC_CHAR:
    case FC_SMALL:
    case FC_USMALL:
        safe_buffer_increment(pStubMsg, sizeof(UCHAR));
        pStubMsg->MemorySize += sizeof(UCHAR);
        return sizeof(UCHAR);
    case FC_WCHAR:
    case FC_SHORT:
    case FC_USHORT:
        align_pointer(&pStubMsg->Buffer, sizeof(USHORT));
        safe_buffer_increment(pStubMsg, sizeof(USHORT));
        align_length(&pStubMsg->MemorySize, sizeof(USHORT));
        pStubMsg->MemorySize += sizeof(USHORT);
        return sizeof(USHORT);
    case FC_LONG:
    case FC_ULONG:
    case FC_ENUM32:
        align_pointer(&pStubMsg->Buffer, sizeof(ULONG));
        safe_buffer_increment(pStubMsg, sizeof(ULONG));
        align_length(&pStubMsg->MemorySize, sizeof(ULONG));
        pStubMsg->MemorySize += sizeof(ULONG);
        return sizeof(ULONG);
    case FC_FLOAT:
        align_pointer(&pStubMsg->Buffer, sizeof(float));
        safe_buffer_increment(pStubMsg, sizeof(float));
        align_length(&pStubMsg->MemorySize, sizeof(float));
        pStubMsg->MemorySize += sizeof(float);
        return sizeof(float);
    case FC_DOUBLE:
        align_pointer(&pStubMsg->Buffer, sizeof(double));
        safe_buffer_increment(pStubMsg, sizeof(double));
        align_length(&pStubMsg->MemorySize, sizeof(double));
        pStubMsg->MemorySize += sizeof(double);
        return sizeof(double);
    case FC_HYPER:
        align_pointer(&pStubMsg->Buffer, sizeof(ULONGLONG));
        safe_buffer_increment(pStubMsg, sizeof(ULONGLONG));
        align_length(&pStubMsg->MemorySize, sizeof(ULONGLONG));
        pStubMsg->MemorySize += sizeof(ULONGLONG);
        return sizeof(ULONGLONG);
    case FC_ERROR_STATUS_T:
        align_pointer(&pStubMsg->Buffer, sizeof(error_status_t));
        safe_buffer_increment(pStubMsg, sizeof(error_status_t));
        align_length(&pStubMsg->MemorySize, sizeof(error_status_t));
        pStubMsg->MemorySize += sizeof(error_status_t);
        return sizeof(error_status_t);
    case FC_ENUM16:
        align_pointer(&pStubMsg->Buffer, sizeof(USHORT));
        safe_buffer_increment(pStubMsg, sizeof(USHORT));
        align_length(&pStubMsg->MemorySize, sizeof(UINT));
        pStubMsg->MemorySize += sizeof(UINT);
        return sizeof(UINT);
    case FC_INT3264:
    case FC_UINT3264:
        align_pointer(&pStubMsg->Buffer, sizeof(UINT));
        safe_buffer_increment(pStubMsg, sizeof(UINT));
        align_length(&pStubMsg->MemorySize, sizeof(UINT_PTR));
        pStubMsg->MemorySize += sizeof(UINT_PTR);
        return sizeof(UINT_PTR);
    case FC_IGNORE:
        align_length(&pStubMsg->MemorySize, sizeof(void *));
        pStubMsg->MemorySize += sizeof(void *);
        return sizeof(void *);
    default:
        FIXME("Unhandled base type: 0x%02x\n", *pFormat);
       return 0;
    }
}

Referenced by NdrRangeMemorySize(), and union_arm_memory_size().

NdrBaseTypeUnmarshall()

static unsigned char *WINAPI NdrBaseTypeUnmarshall ( PMIDL_STUB_MESSAGE  pStubMsg, unsigned char **  ppMemory, PFORMAT_STRING  pFormat, unsigned char  fMustAlloc  )

static

Definition at line 6693 of file ndr_marshall.c.

{
    TRACE("pStubMsg: %p, ppMemory: %p, type: 0x%02x, fMustAlloc: %s\n", pStubMsg, ppMemory, *pFormat, fMustAlloc ? "true" : "false");
 
#define BASE_TYPE_UNMARSHALL(type) do { \
        align_pointer(&pStubMsg->Buffer, sizeof(type)); \
        if (!fMustAlloc && !pStubMsg->IsClient && !*ppMemory) \
        { \
            *ppMemory = pStubMsg->Buffer; \
            TRACE("*ppMemory: %p\n", *ppMemory); \
            safe_buffer_increment(pStubMsg, sizeof(type)); \
        } \
        else \
        {  \
            if (fMustAlloc) \
                *ppMemory = NdrAllocate(pStubMsg, sizeof(type)); \
            TRACE("*ppMemory: %p\n", *ppMemory); \
            safe_copy_from_buffer(pStubMsg, *ppMemory, sizeof(type)); \
        } \
    } while (0)
 
    switch(*pFormat)
    {
    case FC_BYTE:
    case FC_CHAR:
    case FC_SMALL:
    case FC_USMALL:
        BASE_TYPE_UNMARSHALL(UCHAR);
        TRACE("value: 0x%02x\n", **ppMemory);
        break;
    case FC_WCHAR:
    case FC_SHORT:
    case FC_USHORT:
        BASE_TYPE_UNMARSHALL(USHORT);
        TRACE("value: 0x%04x\n", **(USHORT **)ppMemory);
        break;
    case FC_LONG:
    case FC_ULONG:
    case FC_ERROR_STATUS_T:
    case FC_ENUM32:
        BASE_TYPE_UNMARSHALL(ULONG);
        TRACE("value: 0x%08x\n", **(ULONG **)ppMemory);
        break;
   case FC_FLOAT:
        BASE_TYPE_UNMARSHALL(float);
        TRACE("value: %f\n", **(float **)ppMemory);
        break;
    case FC_DOUBLE:
        BASE_TYPE_UNMARSHALL(double);
        TRACE("value: %f\n", **(double **)ppMemory);
        break;
    case FC_HYPER:
        BASE_TYPE_UNMARSHALL(ULONGLONG);
        TRACE("value: %s\n", wine_dbgstr_longlong(**(ULONGLONG **)ppMemory));
        break;
    case FC_ENUM16:
    {
        USHORT val;
        align_pointer(&pStubMsg->Buffer, sizeof(USHORT));
        if (!fMustAlloc && !*ppMemory)
            fMustAlloc = TRUE;
        if (fMustAlloc)
            *ppMemory = NdrAllocate(pStubMsg, sizeof(UINT));
        safe_copy_from_buffer(pStubMsg, &val, sizeof(USHORT));
        /* 16-bits on the wire, but int in memory */
        **(UINT **)ppMemory = val;
        TRACE("value: 0x%08x\n", **(UINT **)ppMemory);
        break;
    }
    case FC_INT3264:
        if (sizeof(INT_PTR) == sizeof(INT)) BASE_TYPE_UNMARSHALL(INT);
        else
        {
            INT val;
            align_pointer(&pStubMsg->Buffer, sizeof(INT));
            if (!fMustAlloc && !*ppMemory)
                fMustAlloc = TRUE;
            if (fMustAlloc)
                *ppMemory = NdrAllocate(pStubMsg, sizeof(INT_PTR));
            safe_copy_from_buffer(pStubMsg, &val, sizeof(INT));
            **(INT_PTR **)ppMemory = val;
            TRACE("value: 0x%08lx\n", **(INT_PTR **)ppMemory);
        }
        break;
    case FC_UINT3264:
        if (sizeof(UINT_PTR) == sizeof(UINT)) BASE_TYPE_UNMARSHALL(UINT);
        else
        {
            UINT val;
            align_pointer(&pStubMsg->Buffer, sizeof(UINT));
            if (!fMustAlloc && !*ppMemory)
                fMustAlloc = TRUE;
            if (fMustAlloc)
                *ppMemory = NdrAllocate(pStubMsg, sizeof(UINT_PTR));
            safe_copy_from_buffer(pStubMsg, &val, sizeof(UINT));
            **(UINT_PTR **)ppMemory = val;
            TRACE("value: 0x%08lx\n", **(UINT_PTR **)ppMemory);
        }
        break;
    case FC_IGNORE:
        break;
    default:
        FIXME("Unhandled base type: 0x%02x\n", *pFormat);
    }
#undef BASE_TYPE_UNMARSHALL
 
    /* FIXME: what is the correct return value? */
 
    return NULL;
}

Referenced by NdrEncapsulatedUnionUnmarshall(), and union_arm_unmarshall().

NdrByteCountPointerBufferSize()

void WINAPI NdrByteCountPointerBufferSize	(	PMIDL_STUB_MESSAGE	pStubMsg,
		unsigned char *	pMemory,
		PFORMAT_STRING	pFormat
	)

Definition at line 6355 of file ndr_marshall.c.

{
    FIXME("stub\n");
}

NdrByteCountPointerFree()

void WINAPI NdrByteCountPointerFree	(	PMIDL_STUB_MESSAGE	pStubMsg,
		unsigned char *	pMemory,
		PFORMAT_STRING	pFormat
	)

Definition at line 6375 of file ndr_marshall.c.

{
    FIXME("stub\n");
}

NdrByteCountPointerMarshall()

unsigned char *WINAPI NdrByteCountPointerMarshall	(	PMIDL_STUB_MESSAGE	pStubMsg,
		unsigned char *	pMemory,
		PFORMAT_STRING	pFormat
	)

Definition at line 6332 of file ndr_marshall.c.

{
    FIXME("stub\n");
    return NULL;
}

NdrByteCountPointerMemorySize()

static ULONG WINAPI NdrByteCountPointerMemorySize ( PMIDL_STUB_MESSAGE  pStubMsg, PFORMAT_STRING  pFormat  )

static

Definition at line 6365 of file ndr_marshall.c.

{
    FIXME("stub\n");
    return 0;
}

NdrByteCountPointerUnmarshall()

unsigned char *WINAPI NdrByteCountPointerUnmarshall	(	PMIDL_STUB_MESSAGE	pStubMsg,
		unsigned char **	ppMemory,
		PFORMAT_STRING	pFormat,
		unsigned char	fMustAlloc
	)

Definition at line 6343 of file ndr_marshall.c.

{
    FIXME("stub\n");
    return NULL;
}

NdrClearOutParameters()

void WINAPI NdrClearOutParameters	(	PMIDL_STUB_MESSAGE	pStubMsg,
		PFORMAT_STRING	pFormat,
		void *	ArgAddr
	)

Definition at line 4661 of file ndr_marshall.c.

{
  FIXME("(%p,%p,%p): stub\n", pStubMsg, pFormat, ArgAddr);
}

Referenced by client_do_args().

NdrClientContextMarshall()

void WINAPI NdrClientContextMarshall	(	PMIDL_STUB_MESSAGE	pStubMsg,
		NDR_CCONTEXT	ContextHandle,
		int	fCheck
	)

Definition at line 7057 of file ndr_marshall.c.

{
    TRACE("(%p, %p, %d)\n", pStubMsg, ContextHandle, fCheck);
 
    align_pointer_clear(&pStubMsg->Buffer, 4);
 
    if (pStubMsg->Buffer + cbNDRContext > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
    {
        ERR("buffer overflow - Buffer = %p, BufferEnd = %p\n",
            pStubMsg->Buffer, (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength);
        RpcRaiseException(RPC_X_BAD_STUB_DATA);
    }
 
    /* FIXME: what does fCheck do? */
    NDRCContextMarshall(ContextHandle,
                        pStubMsg->Buffer);
 
    pStubMsg->Buffer += cbNDRContext;
}

Referenced by CtxClose(), CtxHello(), m_CtxClose(), m_CtxHello(), m_CtxOpen2(), and NdrContextHandleMarshall().

NdrClientContextUnmarshall()

void WINAPI NdrClientContextUnmarshall	(	PMIDL_STUB_MESSAGE	pStubMsg,
		NDR_CCONTEXT *	pContextHandle,
		RPC_BINDING_HANDLE	BindHandle
	)

Definition at line 7082 of file ndr_marshall.c.

{
    TRACE("(%p, %p, %p)\n", pStubMsg, pContextHandle, BindHandle);
 
    align_pointer(&pStubMsg->Buffer, 4);
 
    if (pStubMsg->Buffer + cbNDRContext > pStubMsg->BufferEnd)
        RpcRaiseException(RPC_X_BAD_STUB_DATA);
 
    NDRCContextUnmarshall(pContextHandle,
                          BindHandle,
                          pStubMsg->Buffer,
                          pStubMsg->RpcMsg->DataRepresentation);
 
    pStubMsg->Buffer += cbNDRContext;
}

Referenced by CtxClose(), CtxOpen(), m_CtxClose(), m_CtxOpen(), m_CtxOpen2(), and NdrContextHandleUnmarshall().

NdrComplexArrayBufferSize()

void WINAPI NdrComplexArrayBufferSize	(	PMIDL_STUB_MESSAGE	pStubMsg,
		unsigned char *	pMemory,
		PFORMAT_STRING	pFormat
	)

Definition at line 4271 of file ndr_marshall.c.

{
  int pointer_length_set = 0;
 
  TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
 
  if (pFormat[0] != FC_BOGUS_ARRAY)
  {
      ERR("invalid format type %x\n", pFormat[0]);
      RpcRaiseException(RPC_S_INTERNAL_ERROR);
      return;
  }
 
  if (!pStubMsg->IgnoreEmbeddedPointers && !pStubMsg->PointerLength)
  {
    /* save buffer fields that may be changed by buffer sizer functions
     * and that may be needed later on */
    int saved_ignore_embedded = pStubMsg->IgnoreEmbeddedPointers;
    ULONG saved_buffer_length = pStubMsg->BufferLength;
    ULONG_PTR saved_max_count = pStubMsg->MaxCount;
    ULONG saved_offset = pStubMsg->Offset;
    ULONG saved_actual_count = pStubMsg->ActualCount;
 
    /* get the buffer pointer after complex array data, but before
     * pointer data */
    pStubMsg->IgnoreEmbeddedPointers = 1;
    NdrComplexArrayBufferSize(pStubMsg, pMemory, pFormat);
    pStubMsg->IgnoreEmbeddedPointers = saved_ignore_embedded;
 
    /* save it for use by embedded pointer code later */
    pStubMsg->PointerLength = pStubMsg->BufferLength;
    pointer_length_set = 1;
 
    /* restore fields */
    pStubMsg->ActualCount = saved_actual_count;
    pStubMsg->Offset = saved_offset;
    pStubMsg->MaxCount = saved_max_count;
    pStubMsg->BufferLength = saved_buffer_length;
  }
 
  array_compute_and_size_conformance(FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat);
  array_buffer_size(FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat, TRUE /* fHasPointers */);
 
  if(pointer_length_set)
  {
    pStubMsg->BufferLength = pStubMsg->PointerLength;
    pStubMsg->PointerLength = 0;
  }
}

Referenced by NdrComplexArrayBufferSize(), and NdrComplexArrayMarshall().

NdrComplexArrayFree()

void WINAPI NdrComplexArrayFree	(	PMIDL_STUB_MESSAGE	pStubMsg,
		unsigned char *	pMemory,
		PFORMAT_STRING	pFormat
	)

Definition at line 4346 of file ndr_marshall.c.

{
  ULONG i, count, def;
 
  TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
 
  if (pFormat[0] != FC_BOGUS_ARRAY)
  {
      ERR("invalid format type %x\n", pFormat[0]);
      RpcRaiseException(RPC_S_INTERNAL_ERROR);
      return;
  }
 
  def = *(const WORD*)&pFormat[2];
  pFormat += 4;
 
  pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, def);
  TRACE("conformance = %ld\n", pStubMsg->MaxCount);
 
  pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
  TRACE("variance = %d\n", pStubMsg->ActualCount);
 
  count = pStubMsg->ActualCount;
  for (i = 0; i < count; i++)
    pMemory = ComplexFree(pStubMsg, pMemory, pFormat, NULL);
}

NdrComplexArrayMarshall()

unsigned char *WINAPI NdrComplexArrayMarshall	(	PMIDL_STUB_MESSAGE	pStubMsg,
		unsigned char *	pMemory,
		PFORMAT_STRING	pFormat
	)

Definition at line 4155 of file ndr_marshall.c.

{
  BOOL pointer_buffer_mark_set = FALSE;
 
  TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
 
  if (pFormat[0] != FC_BOGUS_ARRAY)
  {
      ERR("invalid format type %x\n", pFormat[0]);
      RpcRaiseException(RPC_S_INTERNAL_ERROR);
      return NULL;
  }
 
  if (!pStubMsg->PointerBufferMark)
  {
    /* save buffer fields that may be changed by buffer sizer functions
     * and that may be needed later on */
    int saved_ignore_embedded = pStubMsg->IgnoreEmbeddedPointers;
    ULONG saved_buffer_length = pStubMsg->BufferLength;
    ULONG_PTR saved_max_count = pStubMsg->MaxCount;
    ULONG saved_offset = pStubMsg->Offset;
    ULONG saved_actual_count = pStubMsg->ActualCount;
 
    /* get the buffer pointer after complex array data, but before
     * pointer data */
    pStubMsg->BufferLength = pStubMsg->Buffer - (unsigned char *)pStubMsg->RpcMsg->Buffer;
    pStubMsg->IgnoreEmbeddedPointers = 1;
    NdrComplexArrayBufferSize(pStubMsg, pMemory, pFormat);
    pStubMsg->IgnoreEmbeddedPointers = saved_ignore_embedded;
 
    /* save it for use by embedded pointer code later */
    pStubMsg->PointerBufferMark = (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength;
    TRACE("difference = 0x%x\n", (ULONG)(pStubMsg->Buffer - (unsigned char *)pStubMsg->RpcMsg->Buffer));
    pointer_buffer_mark_set = TRUE;
 
    /* restore fields */
    pStubMsg->ActualCount = saved_actual_count;
    pStubMsg->Offset = saved_offset;
    pStubMsg->MaxCount = saved_max_count;
    pStubMsg->BufferLength = saved_buffer_length;
  }
 
  array_compute_and_write_conformance(FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat);
  array_write_variance_and_marshall(FC_BOGUS_ARRAY, pStubMsg,
                                    pMemory, pFormat, TRUE /* fHasPointers */);
 
  STD_OVERFLOW_CHECK(pStubMsg);
 
  if (pointer_buffer_mark_set)
  {
    pStubMsg->Buffer = pStubMsg->PointerBufferMark;
    pStubMsg->PointerBufferMark = NULL;
  }
 
  return NULL;
}

NdrComplexArrayMemorySize()

ULONG WINAPI NdrComplexArrayMemorySize	(	PMIDL_STUB_MESSAGE	pStubMsg,
		PFORMAT_STRING	pFormat
	)

Definition at line 4326 of file ndr_marshall.c.

{
  TRACE("(%p,%p)\n", pStubMsg, pFormat);
 
  if (pFormat[0] != FC_BOGUS_ARRAY)
  {
      ERR("invalid format type %x\n", pFormat[0]);
      RpcRaiseException(RPC_S_INTERNAL_ERROR);
      return 0;
  }
 
  array_read_conformance(FC_BOGUS_ARRAY, pStubMsg, pFormat);
  array_memory_size(FC_BOGUS_ARRAY, pStubMsg, pFormat, TRUE /* fHasPointers */);
  return pStubMsg->MemorySize;
}

Referenced by NdrComplexArrayUnmarshall().

NdrComplexArrayUnmarshall()

unsigned char *WINAPI NdrComplexArrayUnmarshall	(	PMIDL_STUB_MESSAGE	pStubMsg,
		unsigned char **	ppMemory,
		PFORMAT_STRING	pFormat,