ndr_stubless.h File Reference

#include "ndrtypes.h"
#include "pshpack1.h"
#include "poppack.h"

Include dependency graph for ndr_stubless.h:

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

Go to the source code of this file.

Classes
struct	_NDR_PROC_HEADER
struct	_NDR_PROC_HEADER_RPC
struct	_NDR_PROC_PARTIAL_OIF_HEADER
struct	_NDR_PARAM_OI_BASETYPE
struct	_NDR_PARAM_OI_OTHER
struct	NDR_PARAM_OIF
struct	_NDR_EHD_PRIMITIVE
struct	_NDR_EHD_GENERIC
struct	_NDR_EHD_CONTEXT
struct	async_call_data

Typedefs
typedef struct _NDR_PROC_HEADER	NDR_PROC_HEADER
typedef struct _NDR_PROC_HEADER_RPC	NDR_PROC_HEADER_RPC
typedef struct _NDR_PROC_PARTIAL_OIF_HEADER	NDR_PROC_PARTIAL_OIF_HEADER
typedef struct _NDR_PARAM_OI_BASETYPE	NDR_PARAM_OI_BASETYPE
typedef struct _NDR_PARAM_OI_OTHER	NDR_PARAM_OI_OTHER
typedef struct _NDR_EHD_PRIMITIVE	NDR_EHD_PRIMITIVE
typedef struct _NDR_EHD_GENERIC	NDR_EHD_GENERIC
typedef struct _NDR_EHD_CONTEXT	NDR_EHD_CONTEXT

Enumerations
enum	stubless_phase {   STUBLESS_UNMARSHAL , STUBLESS_INITOUT , STUBLESS_CALLSERVER , STUBLESS_CALCSIZE ,   STUBLESS_GETBUFFER , STUBLESS_MARSHAL , STUBLESS_MUSTFREE , STUBLESS_FREE }

Functions
void	client_do_args (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, enum stubless_phase phase, BOOLEAN fpu_args, unsigned short number_of_params, unsigned char *pRetVal)
PFORMAT_STRING	convert_old_args (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, unsigned int stack_size, BOOL object_proc, void *buffer, unsigned int size, unsigned int *count)
RPC_STATUS	NdrpCompleteAsyncClientCall (RPC_ASYNC_STATE *pAsync, void *Reply)
RPC_STATUS	NdrpCompleteAsyncServerCall (RPC_ASYNC_STATE *pAsync, void *Reply)

Typedef Documentation

NDR_EHD_CONTEXT

typedef struct _NDR_EHD_CONTEXT NDR_EHD_CONTEXT

NDR_EHD_GENERIC

typedef struct _NDR_EHD_GENERIC NDR_EHD_GENERIC

NDR_EHD_PRIMITIVE

typedef struct _NDR_EHD_PRIMITIVE NDR_EHD_PRIMITIVE

NDR_PARAM_OI_BASETYPE

typedef struct _NDR_PARAM_OI_BASETYPE NDR_PARAM_OI_BASETYPE

NDR_PARAM_OI_OTHER

typedef struct _NDR_PARAM_OI_OTHER NDR_PARAM_OI_OTHER

NDR_PROC_HEADER

typedef struct _NDR_PROC_HEADER NDR_PROC_HEADER

NDR_PROC_HEADER_RPC

typedef struct _NDR_PROC_HEADER_RPC NDR_PROC_HEADER_RPC

NDR_PROC_PARTIAL_OIF_HEADER

typedef struct _NDR_PROC_PARTIAL_OIF_HEADER NDR_PROC_PARTIAL_OIF_HEADER

Enumeration Type Documentation

stubless_phase

enum stubless_phase

Enumerator
STUBLESS_UNMARSHAL
STUBLESS_INITOUT
STUBLESS_CALLSERVER
STUBLESS_CALCSIZE
STUBLESS_GETBUFFER
STUBLESS_MARSHAL
STUBLESS_MUSTFREE
STUBLESS_FREE

Definition at line 246 of file ndr_stubless.h.

{
    STUBLESS_UNMARSHAL,
    STUBLESS_INITOUT,
    STUBLESS_CALLSERVER,
    STUBLESS_CALCSIZE,
    STUBLESS_GETBUFFER,
    STUBLESS_MARSHAL,
    STUBLESS_MUSTFREE,
    STUBLESS_FREE
};

Function Documentation

client_do_args()

void client_do_args	(	PMIDL_STUB_MESSAGE	pStubMsg,
		PFORMAT_STRING	pFormat,
		enum stubless_phase	phase,
		BOOLEAN	fpu_args,
		unsigned short	number_of_params,
		unsigned char *	pRetVal
	)

Definition at line 484 of file ndr_stubless.c.

{
    const NDR_PARAM_OIF *params = (const NDR_PARAM_OIF *)pFormat;
    unsigned int i;
 
    for (i = 0; i < number_of_params; i++)
    {
        unsigned char *pArg = pStubMsg->StackTop + params[i].stack_offset;
        PFORMAT_STRING pTypeFormat = (PFORMAT_STRING)&pStubMsg->StubDesc->pFormatTypes[params[i].u.type_offset];
 
#ifndef __i386__  /* floats are passed as doubles through varargs functions */
        float f;
 
        if (params[i].attr.IsBasetype &&
            params[i].u.type_format_char == FC_FLOAT &&
            !params[i].attr.IsSimpleRef &&
            !fpu_args)
        {
            f = *(double *)pArg;
            pArg = (unsigned char *)&f;
        }
#endif
 
        TRACE("param[%d]: %p type %02x %s\n", i, pArg,
              params[i].attr.IsBasetype ? params[i].u.type_format_char : *pTypeFormat,
              debugstr_PROC_PF( params[i].attr ));
 
        switch (phase)
        {
        case STUBLESS_INITOUT:
            if (*(unsigned char **)pArg)
            {
                if (param_needs_alloc(params[i].attr))
                    memset( *(unsigned char **)pArg, 0, calc_arg_size( pStubMsg, pTypeFormat ));
                else if (param_is_out_basetype(params[i].attr))
                    memset( *(unsigned char **)pArg, 0, basetype_arg_size( params[i].u.type_format_char ));
            }
            break;
        case STUBLESS_CALCSIZE:
            if (params[i].attr.IsSimpleRef && !*(unsigned char **)pArg)
                RpcRaiseException(RPC_X_NULL_REF_POINTER);
            if (params[i].attr.IsIn) call_buffer_sizer(pStubMsg, pArg, &params[i]);
            break;
        case STUBLESS_MARSHAL:
            if (params[i].attr.IsIn) call_marshaller(pStubMsg, pArg, &params[i]);
            break;
        case STUBLESS_UNMARSHAL:
            if (params[i].attr.IsOut)
            {
                if (params[i].attr.IsReturn && pRetVal) pArg = pRetVal;
                call_unmarshaller(pStubMsg, &pArg, &params[i], 0);
            }
            break;
        case STUBLESS_FREE:
            if (!params[i].attr.IsBasetype && params[i].attr.IsOut && !params[i].attr.IsByValue)
                NdrClearOutParameters( pStubMsg, pTypeFormat, *(unsigned char **)pArg );
            break;
        default:
            RpcRaiseException(RPC_S_INTERNAL_ERROR);
        }
    }
}

Referenced by do_ndr_async_client_call(), ndr_client_call(), NdrMesProcEncodeDecode(), NdrpClientCall2(), and NdrpCompleteAsyncClientCall().

convert_old_args()

PFORMAT_STRING convert_old_args	(	PMIDL_STUB_MESSAGE	pStubMsg,
		PFORMAT_STRING	pFormat,
		unsigned int	stack_size,
		BOOL	object_proc,
		void *	buffer,
		unsigned int	size,
		unsigned int *	count
	)

Definition at line 596 of file ndr_stubless.c.

{
    NDR_PARAM_OIF *args = buffer;
    unsigned int i, stack_offset = object_proc ? sizeof(void *) : 0;
 
    for (i = 0; stack_offset < stack_size; i++)
    {
        const NDR_PARAM_OI_BASETYPE *param = (const NDR_PARAM_OI_BASETYPE *)pFormat;
        const NDR_PARAM_OI_OTHER *other = (const NDR_PARAM_OI_OTHER *)pFormat;
 
        if (i + 1 > size / sizeof(*args))
        {
            FIXME( "%u args not supported\n", i );
            RpcRaiseException( RPC_S_INTERNAL_ERROR );
        }
 
        args[i].stack_offset = stack_offset;
        memset( &args[i].attr, 0, sizeof(args[i].attr) );
 
        switch (param->param_direction)
        {
        case FC_IN_PARAM_BASETYPE:
            args[i].attr.IsIn = 1;
            args[i].attr.IsBasetype = 1;
            break;
        case FC_RETURN_PARAM_BASETYPE:
            args[i].attr.IsOut = 1;
            args[i].attr.IsReturn = 1;
            args[i].attr.IsBasetype = 1;
            break;
        case FC_IN_PARAM:
            args[i].attr.IsIn = 1;
            args[i].attr.MustFree = 1;
            break;
        case FC_IN_PARAM_NO_FREE_INST:
            args[i].attr.IsIn = 1;
            args[i].attr.IsDontCallFreeInst = 1;
            break;
        case FC_IN_OUT_PARAM:
            args[i].attr.IsIn = 1;
            args[i].attr.IsOut = 1;
            args[i].attr.MustFree = 1;
            break;
        case FC_OUT_PARAM:
            args[i].attr.IsOut = 1;
            break;
        case FC_RETURN_PARAM:
            args[i].attr.IsOut = 1;
            args[i].attr.IsReturn = 1;
            break;
        }
        if (args[i].attr.IsBasetype)
        {
            args[i].u.type_format_char = param->type_format_char;
            stack_offset += type_stack_size( param->type_format_char );
            pFormat += sizeof(NDR_PARAM_OI_BASETYPE);
        }
        else
        {
            args[i].u.type_offset = other->type_offset;
            args[i].attr.IsByValue = is_by_value( &pStubMsg->StubDesc->pFormatTypes[other->type_offset] );
            stack_offset += other->stack_size * sizeof(void *);
            pFormat += sizeof(NDR_PARAM_OI_OTHER);
        }
    }
    *count = i;
    return (PFORMAT_STRING)args;
}

Referenced by do_ndr_async_client_call(), NdrAsyncServerCall(), NdrMesProcEncodeDecode(), NdrpClientCall2(), and NdrStubCall2().

NdrpCompleteAsyncClientCall()

RPC_STATUS NdrpCompleteAsyncClientCall	(	RPC_ASYNC_STATE *	pAsync,
		void *	Reply
	)

Definition at line 1755 of file ndr_stubless.c.

{
    /* pointer to start of stack where arguments start */
    PMIDL_STUB_MESSAGE pStubMsg;
    struct async_call_data *async_call_data;
    /* header for procedure string */
    const NDR_PROC_HEADER * pProcHeader;
    RPC_STATUS status = RPC_S_OK;
 
    if (!pAsync->StubInfo)
        return RPC_S_INVALID_ASYNC_HANDLE;
 
    async_call_data = pAsync->StubInfo;
    pStubMsg = async_call_data->pStubMsg;
    pProcHeader = async_call_data->pProcHeader;
 
    /* order of phases:
     * 1. CALCSIZE - calculate the buffer size
     * 2. GETBUFFER - allocate the buffer
     * 3. MARSHAL - marshal [in] params into the buffer
     * 4. SENDRECEIVE - send buffer
     * Then in NdrpCompleteAsyncClientCall:
     * 1. SENDRECEIVE - receive buffer
     * 2. UNMARSHAL - unmarshal [out] params from buffer
     */
 
    /* 1. SENDRECEIVE */
    TRACE( "RECEIVE\n" );
    pStubMsg->RpcMsg->RpcFlags |= RPC_BUFFER_ASYNC;
    /* receive the [out] params */
    if (pProcHeader->handle_type == FC_AUTO_HANDLE)
#if 0
        NdrNsReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
#else
    FIXME("using auto handle - call NdrNsReceive when it gets implemented\n");
#endif
    else
    {
        status = I_RpcReceive(pStubMsg->RpcMsg);
        if (status != RPC_S_OK)
            goto cleanup;
        pStubMsg->BufferLength = pStubMsg->RpcMsg->BufferLength;
        pStubMsg->BufferStart = pStubMsg->RpcMsg->Buffer;
        pStubMsg->BufferEnd = pStubMsg->BufferStart + pStubMsg->BufferLength;
        pStubMsg->Buffer = pStubMsg->BufferStart;
    }
 
    /* convert strings, floating point values and endianness into our
     * preferred format */
#if 0
    if ((pStubMsg->RpcMsg.DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
        NdrConvert(pStubMsg, pFormat);
#endif
 
    /* 2. UNMARSHAL */
    TRACE( "UNMARSHAL\n" );
    client_do_args(pStubMsg, async_call_data->pParamFormat, STUBLESS_UNMARSHAL,
                   FALSE, async_call_data->number_of_params, Reply);
 
cleanup:
    if (pStubMsg->fHasNewCorrDesc)
    {
        /* free extra correlation package */
        NdrCorrelationFree(pStubMsg);
    }
 
    /* free the full pointer translation tables */
    if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED)
        NdrFullPointerXlatFree(pStubMsg->FullPtrXlatTables);
 
    /* free marshalling buffer */
    NdrFreeBuffer(pStubMsg);
    client_free_handle(pStubMsg, pProcHeader, async_call_data->pHandleFormat, async_call_data->hBinding);
 
    I_RpcFree(pStubMsg->StackTop);
    I_RpcFree(async_call_data);
 
    TRACE("-- 0x%lx\n", status);
    return status;
}

Referenced by RpcAsyncCompleteCall().

NdrpCompleteAsyncServerCall()

RPC_STATUS NdrpCompleteAsyncServerCall	(	RPC_ASYNC_STATE *	pAsync,
		void *	Reply
	)

Definition at line 2097 of file ndr_stubless.c.

{
    /* pointer to start of stack where arguments start */
    PMIDL_STUB_MESSAGE pStubMsg;
    struct async_call_data *async_call_data;
    /* the type of pass we are currently doing */
    enum stubless_phase phase;
    RPC_STATUS status = RPC_S_OK;
 
    if (!pAsync->StubInfo)
        return RPC_S_INVALID_ASYNC_HANDLE;
 
    async_call_data = pAsync->StubInfo;
    pStubMsg = async_call_data->pStubMsg;
 
    TRACE("pAsync %p, pAsync->StubInfo %p, pFormat %p\n", pAsync, pAsync->StubInfo, async_call_data->pHandleFormat);
 
    if (async_call_data->retval_ptr)
    {
        TRACE("stub implementation returned 0x%Ix\n", *(LONG_PTR *)Reply);
        *async_call_data->retval_ptr = *(LONG_PTR *)Reply;
    }
    else
        TRACE("void stub implementation\n");
 
    for (phase = STUBLESS_CALCSIZE; phase <= STUBLESS_FREE; phase++)
    {
        TRACE("phase = %d\n", phase);
        switch (phase)
        {
        case STUBLESS_GETBUFFER:
            if (async_call_data->pProcHeader->Oi_flags & Oi_OBJECT_PROC)
            {
                ERR("objects not supported\n");
                free(async_call_data->pStubMsg->StackTop);
                I_RpcFree(async_call_data);
                I_RpcFree(pAsync);
                RpcRaiseException(RPC_X_BAD_STUB_DATA);
            }
            else
            {
                pStubMsg->RpcMsg->BufferLength = pStubMsg->BufferLength;
                /* allocate buffer for [out] and [ret] params */
                status = I_RpcGetBuffer(pStubMsg->RpcMsg);
                if (status)
                    RpcRaiseException(status);
                pStubMsg->Buffer = pStubMsg->RpcMsg->Buffer;
            }
            break;
 
        case STUBLESS_CALCSIZE:
        case STUBLESS_MARSHAL:
        case STUBLESS_MUSTFREE:
        case STUBLESS_FREE:
            stub_do_args(pStubMsg, async_call_data->pHandleFormat, phase, async_call_data->number_of_params);
            break;
        default:
            ERR("shouldn't reach here. phase %d\n", phase);
            break;
        }
    }
 
#if 0 /* FIXME */
    if (ext_flags.HasNewCorrDesc)
    {
        /* free extra correlation package */
        NdrCorrelationFree(pStubMsg);
    }
 
    if (Oif_flags.HasPipes)
    {
        /* NdrPipesDone(...) */
    }
 
    /* free the full pointer translation tables */
    if (async_call_data->pProcHeader->Oi_flags & Oi_FULL_PTR_USED)
        NdrFullPointerXlatFree(pStubMsg->FullPtrXlatTables);
#endif
 
    /* free server function stack */
    free(async_call_data->pStubMsg->StackTop);
    I_RpcFree(async_call_data);
    I_RpcFree(pAsync);
 
    return S_OK;
}

Referenced by RpcAsyncCompleteCall().