midles.h File Reference

#include <rpcndr.h>

Include dependency graph for midles.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_MIDL_ES_MESSAGE
struct	_MIDL_TYPE_PICKLING_INFO

Typedefs
typedef void(__RPC_USER *	MIDL_ES_ALLOC) (void *, char **, unsigned int *)
typedef void(__RPC_USER *	MIDL_ES_WRITE) (void *, char *, unsigned int)
typedef void(__RPC_USER *	MIDL_ES_READ) (void *, char **, unsigned int *)
typedef struct _MIDL_ES_MESSAGE	MIDL_ES_MESSAGE
typedef struct _MIDL_ES_MESSAGE *	PMIDL_ES_MESSAGE
typedef PMIDL_ES_MESSAGE	MIDL_ES_HANDLE
typedef struct _MIDL_TYPE_PICKLING_INFO	MIDL_TYPE_PICKLING_INFO
typedef struct _MIDL_TYPE_PICKLING_INFO *	PMIDL_TYPE_PICKLING_INFO

Enumerations
enum	MIDL_ES_CODE { MES_ENCODE , MES_DECODE , MES_ENCODE_NDR64 }
enum	MIDL_ES_HANDLE_STYLE { MES_INCREMENTAL_HANDLE , MES_FIXED_BUFFER_HANDLE , MES_DYNAMIC_BUFFER_HANDLE }

Functions
RPC_STATUS RPC_ENTRY	MesEncodeIncrementalHandleCreate (void *, MIDL_ES_ALLOC, MIDL_ES_WRITE, handle_t *)
RPC_STATUS RPC_ENTRY	MesDecodeIncrementalHandleCreate (void *, MIDL_ES_READ, handle_t *)
RPC_STATUS RPC_ENTRY	MesIncrementalHandleReset (handle_t, void *, MIDL_ES_ALLOC, MIDL_ES_WRITE, MIDL_ES_READ, MIDL_ES_CODE)
RPC_STATUS RPC_ENTRY	MesEncodeFixedBufferHandleCreate (char *, ULONG, ULONG *, handle_t *)
RPC_STATUS RPC_ENTRY	MesEncodeDynBufferHandleCreate (char **, ULONG *, handle_t *)
RPC_STATUS RPC_ENTRY	MesDecodeBufferHandleCreate (char *, ULONG, handle_t *)
RPC_STATUS RPC_ENTRY	MesBufferHandleReset (handle_t, ULONG, MIDL_ES_CODE, char **, ULONG, ULONG *)
RPC_STATUS RPC_ENTRY	MesHandleFree (handle_t)
RPC_STATUS RPC_ENTRY	MesInqProcEncodingId (handle_t, PRPC_SYNTAX_IDENTIFIER, ULONG *)
SIZE_T RPC_ENTRY	NdrMesSimpleTypeAlignSize (handle_t)
void RPC_ENTRY	NdrMesSimpleTypeDecode (handle_t, void *, short)
void RPC_ENTRY	NdrMesSimpleTypeEncode (handle_t, const MIDL_STUB_DESC *, const void *, short)
SIZE_T RPC_ENTRY	NdrMesTypeAlignSize (handle_t, const MIDL_STUB_DESC *, PFORMAT_STRING, const void *)
void RPC_ENTRY	NdrMesTypeEncode (handle_t, const MIDL_STUB_DESC *, PFORMAT_STRING, const void *)
void RPC_ENTRY	NdrMesTypeDecode (handle_t, const MIDL_STUB_DESC *, PFORMAT_STRING, void *)
SIZE_T RPC_ENTRY	NdrMesTypeAlignSize2 (handle_t, const MIDL_TYPE_PICKLING_INFO *, const MIDL_STUB_DESC *, PFORMAT_STRING, const void *)
void RPC_ENTRY	NdrMesTypeEncode2 (handle_t, const MIDL_TYPE_PICKLING_INFO *, const MIDL_STUB_DESC *, PFORMAT_STRING, const void *)
void RPC_ENTRY	NdrMesTypeDecode2 (handle_t, const MIDL_TYPE_PICKLING_INFO *, const MIDL_STUB_DESC *, PFORMAT_STRING, void *)
void RPC_ENTRY	NdrMesTypeFree2 (handle_t, const MIDL_TYPE_PICKLING_INFO *, const MIDL_STUB_DESC *, PFORMAT_STRING, void *)
void RPC_VAR_ENTRY	NdrMesProcEncodeDecode (handle_t, const MIDL_STUB_DESC *, PFORMAT_STRING,...)
CLIENT_CALL_RETURN RPC_VAR_ENTRY	NdrMesProcEncodeDeocde2 (handle_t, const MIDL_STUB_DESC *, PFORMAT_STRING,...)

Typedef Documentation

MIDL_ES_ALLOC

typedef void(__RPC_USER * MIDL_ES_ALLOC) (void *, char **, unsigned int *)

Definition at line 44 of file midles.h.

MIDL_ES_HANDLE

typedef PMIDL_ES_MESSAGE MIDL_ES_HANDLE

Definition at line 71 of file midles.h.

MIDL_ES_MESSAGE

typedef struct _MIDL_ES_MESSAGE MIDL_ES_MESSAGE

MIDL_ES_READ

typedef void(__RPC_USER * MIDL_ES_READ) (void *, char **, unsigned int *)

Definition at line 46 of file midles.h.

MIDL_ES_WRITE

typedef void(__RPC_USER * MIDL_ES_WRITE) (void *, char *, unsigned int)

Definition at line 45 of file midles.h.

MIDL_TYPE_PICKLING_INFO

typedef struct _MIDL_TYPE_PICKLING_INFO MIDL_TYPE_PICKLING_INFO

PMIDL_ES_MESSAGE

typedef struct _MIDL_ES_MESSAGE * PMIDL_ES_MESSAGE

PMIDL_TYPE_PICKLING_INFO

typedef struct _MIDL_TYPE_PICKLING_INFO * PMIDL_TYPE_PICKLING_INFO

Enumeration Type Documentation

MIDL_ES_CODE

enum MIDL_ES_CODE

Enumerator
MES_ENCODE
MES_DECODE
MES_ENCODE_NDR64

Definition at line 30 of file midles.h.

{
    MES_ENCODE,
    MES_DECODE,
    MES_ENCODE_NDR64
} MIDL_ES_CODE;

MIDL_ES_HANDLE_STYLE

enum MIDL_ES_HANDLE_STYLE

Enumerator
MES_INCREMENTAL_HANDLE
MES_FIXED_BUFFER_HANDLE
MES_DYNAMIC_BUFFER_HANDLE

Definition at line 37 of file midles.h.

{
    MES_INCREMENTAL_HANDLE,
    MES_FIXED_BUFFER_HANDLE,
    MES_DYNAMIC_BUFFER_HANDLE
} MIDL_ES_HANDLE_STYLE;

Function Documentation

MesBufferHandleReset()

RPC_STATUS RPC_ENTRY MesBufferHandleReset	(	handle_t	Handle,
		ULONG	HandleStyle,
		MIDL_ES_CODE	Operation,
		char **	Buffer,
		ULONG	BufferSize,
		ULONG *	EncodedSize
	)

Definition at line 129 of file ndr_es.c.

{
    MIDL_ES_MESSAGE *pEsMsg = (MIDL_ES_MESSAGE *)Handle;
 
    TRACE("(%p, %lu, %d, %p, %lu, %p)\n", Handle, HandleStyle, Operation, Buffer,
        BufferSize, EncodedSize);
 
    if (!Handle || !Buffer || !EncodedSize)
        return RPC_S_INVALID_ARG;
 
    if (Operation != MES_ENCODE && Operation != MES_DECODE && Operation != MES_ENCODE_NDR64)
        return RPC_S_INVALID_ARG;
 
    if (HandleStyle != MES_FIXED_BUFFER_HANDLE && HandleStyle != MES_DYNAMIC_BUFFER_HANDLE)
        return RPC_S_INVALID_ARG;
 
    init_MIDL_ES_MESSAGE(pEsMsg);
 
    pEsMsg->Operation = Operation;
    pEsMsg->HandleStyle = HandleStyle;
    if (HandleStyle == MES_FIXED_BUFFER_HANDLE)
        pEsMsg->Buffer = (unsigned char*)*Buffer;
    else
        pEsMsg->pDynBuffer = (unsigned char**)Buffer;
    pEsMsg->BufferSize = BufferSize;
    pEsMsg->pEncodedSize = EncodedSize;
 
    return RPC_S_OK;
}

Referenced by test_MesEncodeFixedBufferHandleCreate().

MesDecodeBufferHandleCreate()

RPC_STATUS RPC_ENTRY MesDecodeBufferHandleCreate	(	char *	Buffer,
		ULONG	BufferSize,
		handle_t *	pHandle
	)

Definition at line 249 of file ndr_es.c.

{
    MIDL_ES_MESSAGE *pEsMsg;
    RPC_STATUS status;
 
    TRACE("(%p, %ld, %p)\n", Buffer, BufferSize, pHandle);
 
    if ((status = validate_mes_buffer_pointer(Buffer)))
        return status;
 
    pEsMsg = malloc(sizeof(*pEsMsg));
    if (!pEsMsg)
        return RPC_S_OUT_OF_MEMORY;
 
    init_MIDL_ES_MESSAGE(pEsMsg);
 
    pEsMsg->Operation = MES_DECODE;
    pEsMsg->HandleStyle = MES_FIXED_BUFFER_HANDLE;
    pEsMsg->Buffer = (unsigned char *)Buffer;
    pEsMsg->BufferSize = BufferSize;
 
    *pHandle = (handle_t)pEsMsg;
 
    return RPC_S_OK;
}

MesDecodeIncrementalHandleCreate()

RPC_STATUS RPC_ENTRY MesDecodeIncrementalHandleCreate	(	void *	UserState,
		MIDL_ES_READ	ReadFn,
		handle_t *	pHandle
	)

Definition at line 79 of file ndr_es.c.

{
    MIDL_ES_MESSAGE *pEsMsg;
 
    TRACE("(%p, %p, %p)\n", UserState, ReadFn, pHandle);
 
    pEsMsg = malloc(sizeof(*pEsMsg));
    if (!pEsMsg)
        return RPC_S_OUT_OF_MEMORY;
 
    init_MIDL_ES_MESSAGE(pEsMsg);
 
    pEsMsg->Operation = MES_DECODE;
    pEsMsg->UserState = UserState;
    pEsMsg->HandleStyle = MES_INCREMENTAL_HANDLE;
    pEsMsg->Read = ReadFn;
 
    *pHandle = (handle_t)pEsMsg;
 
    return RPC_S_OK;
}

MesEncodeDynBufferHandleCreate()

RPC_STATUS RPC_ENTRY MesEncodeDynBufferHandleCreate	(	char **	Buffer,
		ULONG *	pEncodedSize,
		handle_t *	pHandle
	)

Definition at line 220 of file ndr_es.c.

{
    MIDL_ES_MESSAGE *pEsMsg;
 
    TRACE("(%p, %p, %p)\n", Buffer, pEncodedSize, pHandle);
 
    if (!pEncodedSize)
        return RPC_S_INVALID_ARG;
 
    pEsMsg = malloc(sizeof(*pEsMsg));
    if (!pEsMsg)
        return RPC_S_OUT_OF_MEMORY;
 
    init_MIDL_ES_MESSAGE(pEsMsg);
 
    pEsMsg->Operation = MES_ENCODE;
    pEsMsg->HandleStyle = MES_DYNAMIC_BUFFER_HANDLE;
    pEsMsg->pDynBuffer = (unsigned char **)Buffer;
    pEsMsg->pEncodedSize = pEncodedSize;
 
    *pHandle = (handle_t)pEsMsg;
 
    return RPC_S_OK;
}

MesEncodeFixedBufferHandleCreate()

RPC_STATUS RPC_ENTRY MesEncodeFixedBufferHandleCreate	(	char *	Buffer,
		ULONG	BufferSize,
		ULONG *	pEncodedSize,
		handle_t *	pHandle
	)

Definition at line 184 of file ndr_es.c.

{
    MIDL_ES_MESSAGE *pEsMsg;
    RPC_STATUS status;
 
    TRACE("(%p, %ld, %p, %p)\n", Buffer, BufferSize, pEncodedSize, pHandle);
 
    if ((status = validate_mes_buffer_pointer(Buffer)))
        return status;
 
    if (!pEncodedSize)
        return RPC_S_INVALID_ARG;
 
    /* FIXME: check BufferSize too */
 
    pEsMsg = malloc(sizeof(*pEsMsg));
    if (!pEsMsg)
        return RPC_S_OUT_OF_MEMORY;
 
    init_MIDL_ES_MESSAGE(pEsMsg);
 
    pEsMsg->Operation = MES_ENCODE;
    pEsMsg->HandleStyle = MES_FIXED_BUFFER_HANDLE;
    pEsMsg->Buffer = (unsigned char *)Buffer;
    pEsMsg->BufferSize = BufferSize;
    pEsMsg->pEncodedSize = pEncodedSize;
 
    *pHandle = (handle_t)pEsMsg;
 
    return RPC_S_OK;
}

Referenced by test_MesEncodeFixedBufferHandleCreate().

MesEncodeIncrementalHandleCreate()

RPC_STATUS RPC_ENTRY MesEncodeIncrementalHandleCreate	(	void *	UserState,
		MIDL_ES_ALLOC	AllocFn,
		MIDL_ES_WRITE	WriteFn,
		handle_t *	pHandle
	)

Definition at line 51 of file ndr_es.c.

{
    MIDL_ES_MESSAGE *pEsMsg;
 
    TRACE("(%p, %p, %p, %p)\n", UserState, AllocFn, WriteFn, pHandle);
 
    pEsMsg = malloc(sizeof(*pEsMsg));
    if (!pEsMsg)
        return RPC_S_OUT_OF_MEMORY;
 
    init_MIDL_ES_MESSAGE(pEsMsg);
 
    pEsMsg->Operation = MES_ENCODE;
    pEsMsg->UserState = UserState;
    pEsMsg->HandleStyle = MES_INCREMENTAL_HANDLE;
    pEsMsg->Alloc = AllocFn;
    pEsMsg->Write = WriteFn;
 
    *pHandle = (handle_t)pEsMsg;
 
    return RPC_S_OK;
}

MesHandleFree()

RPC_STATUS RPC_ENTRY MesHandleFree

(

handle_t

Handle

)

Definition at line 163 of file ndr_es.c.

{
    TRACE("(%p)\n", Handle);
    free(Handle);
    return RPC_S_OK;
}

Referenced by test_MesEncodeFixedBufferHandleCreate().

MesIncrementalHandleReset()

RPC_STATUS RPC_ENTRY MesIncrementalHandleReset	(	handle_t	Handle,
		void *	UserState,
		MIDL_ES_ALLOC	AllocFn,
		MIDL_ES_WRITE	WriteFn,
		MIDL_ES_READ	ReadFn,
		MIDL_ES_CODE	Operation
	)

Definition at line 105 of file ndr_es.c.

{
    MIDL_ES_MESSAGE *pEsMsg = Handle;
 
    TRACE("(%p, %p, %p, %p, %p, %d)\n", Handle, UserState, AllocFn,
        WriteFn, ReadFn, Operation);
 
    init_MIDL_ES_MESSAGE(pEsMsg);
 
    pEsMsg->Operation = Operation;
    pEsMsg->UserState = UserState;
    pEsMsg->HandleStyle = MES_INCREMENTAL_HANDLE;
    pEsMsg->Alloc = AllocFn;
    pEsMsg->Write = WriteFn;
    pEsMsg->Read = ReadFn;
 
    return RPC_S_OK;
}

MesInqProcEncodingId()

RPC_STATUS RPC_ENTRY MesInqProcEncodingId	(	handle_t	,
		PRPC_SYNTAX_IDENTIFIER	,
		ULONG *
	)

NdrMesProcEncodeDecode()

void RPC_VAR_ENTRY NdrMesProcEncodeDecode	(	handle_t	Handle,
		const MIDL_STUB_DESC *	pStubDesc,
		PFORMAT_STRING	pFormat,
			...
	)

Definition at line 401 of file ndr_es.c.

{
    /* pointer to start of stack where arguments start */
    RPC_MESSAGE rpcMsg;
    MIDL_ES_MESSAGE *pEsMsg = Handle;
    /* size of stack */
    unsigned short stack_size;
    /* header for procedure string */
    const NDR_PROC_HEADER *pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0];
    const RPC_CLIENT_INTERFACE *client_interface;
    va_list args;
    unsigned int number_of_params;
    ULONG_PTR arg_buffer[256];
 
    TRACE("Handle %p, pStubDesc %p, pFormat %p, ...\n", Handle, pStubDesc, pFormat);
 
    /* Later NDR language versions probably won't be backwards compatible */
    if (pStubDesc->Version > 0x50002)
    {
        FIXME("Incompatible stub description version: 0x%lx\n", pStubDesc->Version);
        RpcRaiseException(RPC_X_WRONG_STUB_VERSION);
    }
 
    client_interface = pStubDesc->RpcInterfaceInformation;
    pEsMsg->InterfaceId = client_interface->InterfaceId;
 
    if (pProcHeader->Oi_flags & Oi_HAS_RPCFLAGS)
    {
        const NDR_PROC_HEADER_RPC *header_rpc = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
        stack_size = header_rpc->stack_size;
        pEsMsg->ProcNumber = header_rpc->proc_num;
        pFormat += sizeof(NDR_PROC_HEADER_RPC);
    }
    else
    {
        stack_size = pProcHeader->stack_size;
        pEsMsg->ProcNumber = pProcHeader->proc_num;
        pFormat += sizeof(NDR_PROC_HEADER);
    }
 
    if (pProcHeader->handle_type == 0)
    {
        switch (*pFormat) /* handle_type */
        {
        case FC_BIND_PRIMITIVE: /* explicit primitive */
            pFormat += sizeof(NDR_EHD_PRIMITIVE);
            break;
        case FC_BIND_GENERIC: /* explicit generic */
            pFormat += sizeof(NDR_EHD_GENERIC);
            break;
        case FC_BIND_CONTEXT: /* explicit context */
            pFormat += sizeof(NDR_EHD_CONTEXT);
            break;
        default:
            ERR("bad explicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
            RpcRaiseException(RPC_X_BAD_STUB_DATA);
        }
    }
 
    TRACE("stack size: 0x%x\n", stack_size);
    TRACE("proc num: %ld\n", pEsMsg->ProcNumber);
 
    memset(&rpcMsg, 0, sizeof(rpcMsg));
    pEsMsg->StubMsg.RpcMsg = &rpcMsg;
    pEsMsg->StubMsg.StubDesc = pStubDesc;
    pEsMsg->StubMsg.pfnAllocate = pStubDesc->pfnAllocate;
    pEsMsg->StubMsg.pfnFree = pStubDesc->pfnFree;
 
    /* create the full pointer translation tables, if requested */
    if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED)
        pEsMsg->StubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_CLIENT);
 
    TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags);
    TRACE("stubdesc version = 0x%lx\n", pStubDesc->Version);
    TRACE("MIDL stub version = 0x%lx\n", pStubDesc->MIDLVersion);
 
    /* needed for conformance of top-level objects */
    va_start( args, pFormat );
    pEsMsg->StubMsg.StackTop = va_arg( args, unsigned char * );
    va_end( args );
 
    pFormat = convert_old_args( &pEsMsg->StubMsg, pFormat, stack_size, FALSE,
                                arg_buffer, sizeof(arg_buffer), &number_of_params );
 
    switch (pEsMsg->Operation)
    {
    case MES_ENCODE:
        pEsMsg->StubMsg.BufferLength = mes_proc_header_buffer_size();
 
        client_do_args( &pEsMsg->StubMsg, pFormat, STUBLESS_CALCSIZE, FALSE, number_of_params, NULL );
 
        pEsMsg->ByteCount = pEsMsg->StubMsg.BufferLength - mes_proc_header_buffer_size();
        es_data_alloc(pEsMsg, pEsMsg->StubMsg.BufferLength);
 
        mes_proc_header_marshal(pEsMsg);
 
        client_do_args( &pEsMsg->StubMsg, pFormat, STUBLESS_MARSHAL, FALSE, number_of_params, NULL );
 
        es_data_write(pEsMsg, pEsMsg->ByteCount);
        break;
    case MES_DECODE:
        mes_proc_header_unmarshal(pEsMsg);
 
        es_data_read(pEsMsg, pEsMsg->ByteCount);
 
        client_do_args( &pEsMsg->StubMsg, pFormat, STUBLESS_UNMARSHAL, FALSE, number_of_params, NULL );
        break;
    default:
        RpcRaiseException(RPC_S_INTERNAL_ERROR);
        return;
    }
    /* free the full pointer translation tables */
    if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED)
        NdrFullPointerXlatFree(pEsMsg->StubMsg.FullPtrXlatTables);
}

NdrMesProcEncodeDeocde2()

CLIENT_CALL_RETURN RPC_VAR_ENTRY NdrMesProcEncodeDeocde2	(	handle_t	,
		const MIDL_STUB_DESC *	,
		PFORMAT_STRING	,
			...
	)

NdrMesSimpleTypeAlignSize()

SIZE_T RPC_ENTRY NdrMesSimpleTypeAlignSize

(

handle_t

)

NdrMesSimpleTypeDecode()

void RPC_ENTRY NdrMesSimpleTypeDecode	(	handle_t	,
		void *	,
		short
	)

NdrMesSimpleTypeEncode()

void RPC_ENTRY NdrMesSimpleTypeEncode	(	handle_t	,
		const MIDL_STUB_DESC *	,
		const void *	,
		short
	)

NdrMesTypeAlignSize()

SIZE_T RPC_ENTRY NdrMesTypeAlignSize	(	handle_t	,
		const MIDL_STUB_DESC *	,
		PFORMAT_STRING	,
		const void *
	)

NdrMesTypeAlignSize2()

SIZE_T RPC_ENTRY NdrMesTypeAlignSize2	(	handle_t	,
		const MIDL_TYPE_PICKLING_INFO *	,
		const MIDL_STUB_DESC *	,
		PFORMAT_STRING	,
		const void *
	)

NdrMesTypeDecode()

void RPC_ENTRY NdrMesTypeDecode	(	handle_t	,
		const MIDL_STUB_DESC *	,
		PFORMAT_STRING	,
		void *
	)

NdrMesTypeDecode2()

void RPC_ENTRY NdrMesTypeDecode2	(	handle_t	Handle,
		const MIDL_TYPE_PICKLING_INFO *	pPicklingInfo,
		const MIDL_STUB_DESC *	pStubDesc,
		PFORMAT_STRING	pFormatString,
		void *	pObject
	)

Definition at line 517 of file ndr_es.c.

{
    FIXME("(%p, %p, %p, %p, %p)\n", Handle, pPicklingInfo, pStubDesc, pFormatString, pObject);
}

NdrMesTypeEncode()

void RPC_ENTRY NdrMesTypeEncode	(	handle_t	,
		const MIDL_STUB_DESC *	,
		PFORMAT_STRING	,
		const void *
	)

NdrMesTypeEncode2()

void RPC_ENTRY NdrMesTypeEncode2	(	handle_t	Handle,
		const MIDL_TYPE_PICKLING_INFO *	pPicklingInfo,
		const MIDL_STUB_DESC *	pStubDesc,
		PFORMAT_STRING	pFormatString,
		const void *	pObject
	)

Definition at line 523 of file ndr_es.c.

{
    FIXME("(%p, %p, %p, %p, %p)\n", Handle, pPicklingInfo, pStubDesc, pFormatString, pObject);
}

NdrMesTypeFree2()

void RPC_ENTRY NdrMesTypeFree2	(	handle_t	Handle,
		const MIDL_TYPE_PICKLING_INFO *	pPicklingInfo,
		const MIDL_STUB_DESC *	pStubDesc,
		PFORMAT_STRING	pFormatString,
		void *	pObject
	)

Definition at line 529 of file ndr_es.c.

{
    FIXME("(%p, %p, %p, %p, %p)\n", Handle, pPicklingInfo, pStubDesc, pFormatString, pObject);
}