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
LONG_PTR CDECL	ndr_client_call (PMIDL_STUB_DESC pStubDesc, PFORMAT_STRING pFormat, void **stack_top, void **fpu_stack) DECLSPEC_HIDDEN
LONG_PTR CDECL	ndr_async_client_call (PMIDL_STUB_DESC pStubDesc, PFORMAT_STRING pFormat, void **stack_top) DECLSPEC_HIDDEN
void	client_do_args (PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, enum stubless_phase phase, void **fpu_args, unsigned short number_of_params, unsigned char *pRetVal) DECLSPEC_HIDDEN
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) DECLSPEC_HIDDEN
RPC_STATUS	NdrpCompleteAsyncClientCall (RPC_ASYNC_STATE *pAsync, void *Reply) DECLSPEC_HIDDEN
RPC_STATUS	NdrpCompleteAsyncServerCall (RPC_ASYNC_STATE *pAsync, void *Reply) DECLSPEC_HIDDEN

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,
		void **	fpu_args,
		unsigned short	number_of_params,
		unsigned char *	pRetVal
	)

Definition at line 478 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];
 
#ifdef __x86_64__  /* 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(), do_ndr_client_call(), ndr_client_call(), NdrMesProcEncodeDecode(), 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 590 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(), ndr_client_call(), NdrAsyncServerCall(), NdrMesProcEncodeDecode(), and NdrStubCall2().

ndr_async_client_call()

LONG_PTR CDECL ndr_async_client_call	(	PMIDL_STUB_DESC	pStubDesc,
		PFORMAT_STRING	pFormat,
		void **	stack_top
	)

Definition at line 1801 of file ndr_stubless.c.

{
    LONG_PTR ret = 0;
    const NDR_PROC_HEADER *pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0];
 
    TRACE("pStubDesc %p, pFormat %p, ...\n", pStubDesc, pFormat);
 
    if (pProcHeader->Oi_flags & Oi_HAS_COMM_OR_FAULT)
    {
        __TRY
        {
            do_ndr_async_client_call( pStubDesc, pFormat, stack_top );
        }
        __EXCEPT_ALL
        {
            FIXME("exception %x during ndr_async_client_call()\n", GetExceptionCode());
            ret = GetExceptionCode();
        }
        __ENDTRY
    }
    else
        do_ndr_async_client_call( pStubDesc, pFormat, stack_top);
 
    TRACE("returning %ld\n", ret);
    return ret;
}

Referenced by NdrAsyncClientCall().

ndr_client_call()

LONG_PTR CDECL ndr_client_call	(	PMIDL_STUB_DESC	pStubDesc,
		PFORMAT_STRING	pFormat,
		void **	stack_top,
		void **	fpu_stack
	)

Definition at line 850 of file ndr_stubless.c.

{
    /* pointer to start of stack where arguments start */
    MIDL_STUB_MESSAGE stubMsg;
    /* procedure number */
    unsigned short procedure_number;
    /* size of stack */
    unsigned short stack_size;
    /* number of parameters. optional for client to give it to us */
    unsigned int number_of_params;
    /* cache of Oif_flags from v2 procedure header */
    INTERPRETER_OPT_FLAGS Oif_flags = { 0 };
    /* cache of extension flags from NDR_PROC_HEADER_EXTS */
    INTERPRETER_OPT_FLAGS2 ext_flags = { 0 };
    /* header for procedure string */
    const NDR_PROC_HEADER * pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0];
    /* the value to return to the client from the remote procedure */
    LONG_PTR RetVal = 0;
    PFORMAT_STRING pHandleFormat;
    NDR_PARAM_OIF old_args[256];
 
    TRACE("pStubDesc %p, pFormat %p, ...\n", pStubDesc, pFormat);
 
    TRACE("NDR Version: 0x%x\n", pStubDesc->Version);
 
    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;
        procedure_number = header_rpc->proc_num;
        pFormat += sizeof(NDR_PROC_HEADER_RPC);
    }
    else
    {
        stack_size = pProcHeader->stack_size;
        procedure_number = pProcHeader->proc_num;
        pFormat += sizeof(NDR_PROC_HEADER);
    }
    TRACE("stack size: 0x%x\n", stack_size);
    TRACE("proc num: %d\n", procedure_number);
    TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags);
    TRACE("MIDL stub version = 0x%x\n", pStubDesc->MIDLVersion);
 
    pHandleFormat = pFormat;
 
    /* we only need a handle if this isn't an object method */
    if (!(pProcHeader->Oi_flags & Oi_OBJECT_PROC))
        pFormat += get_handle_desc_size(pProcHeader, pFormat);
 
    if (is_oicf_stubdesc(pStubDesc))  /* -Oicf format */
    {
        const NDR_PROC_PARTIAL_OIF_HEADER *pOIFHeader =
            (const NDR_PROC_PARTIAL_OIF_HEADER *)pFormat;
 
        Oif_flags = pOIFHeader->Oi2Flags;
        number_of_params = pOIFHeader->number_of_params;
 
        pFormat += sizeof(NDR_PROC_PARTIAL_OIF_HEADER);
 
        TRACE("Oif_flags = %s\n", debugstr_INTERPRETER_OPT_FLAGS(Oif_flags) );
 
        if (Oif_flags.HasExtensions)
        {
            const NDR_PROC_HEADER_EXTS *pExtensions = (const NDR_PROC_HEADER_EXTS *)pFormat;
            ext_flags = pExtensions->Flags2;
            pFormat += pExtensions->Size;
#ifdef __x86_64__
            if (pExtensions->Size > sizeof(*pExtensions) && fpu_stack)
            {
                int i;
                unsigned short fpu_mask = *(unsigned short *)(pExtensions + 1);
                for (i = 0; i < 4; i++, fpu_mask >>= 2)
                    switch (fpu_mask & 3)
                    {
                    case 1: *(float *)&stack_top[i] = *(float *)&fpu_stack[i]; break;
                    case 2: *(double *)&stack_top[i] = *(double *)&fpu_stack[i]; break;
                    }
            }
#endif
        }
    }
    else
    {
        pFormat = convert_old_args( &stubMsg, pFormat, stack_size,
                                    pProcHeader->Oi_flags & Oi_OBJECT_PROC,
                                    old_args, sizeof(old_args), &number_of_params );
    }
 
    if (pProcHeader->Oi_flags & Oi_OBJECT_PROC)
    {
        __TRY
        {
            RetVal = do_ndr_client_call(pStubDesc, pFormat, pHandleFormat,
                    stack_top, fpu_stack, &stubMsg, procedure_number, stack_size,
                    number_of_params, Oif_flags, ext_flags, pProcHeader);
        }
        __EXCEPT_ALL
        {
            /* 7. FREE */
            TRACE( "FREE\n" );
            client_do_args(&stubMsg, pFormat, STUBLESS_FREE, fpu_stack,
                           number_of_params, (unsigned char *)&RetVal);
            RetVal = NdrProxyErrorHandler(GetExceptionCode());
        }
        __ENDTRY
    }
    else if (pProcHeader->Oi_flags & Oi_HAS_COMM_OR_FAULT)
    {
        __TRY
        {
            RetVal = do_ndr_client_call(pStubDesc, pFormat, pHandleFormat,
                    stack_top, fpu_stack, &stubMsg, procedure_number, stack_size,
                    number_of_params, Oif_flags, ext_flags, pProcHeader);
        }
        __EXCEPT_ALL
        {
            const COMM_FAULT_OFFSETS *comm_fault_offsets = &pStubDesc->CommFaultOffsets[procedure_number];
            ULONG *comm_status;
            ULONG *fault_status;
 
            TRACE("comm_fault_offsets = {0x%hx, 0x%hx}\n", comm_fault_offsets->CommOffset, comm_fault_offsets->FaultOffset);
 
            if (comm_fault_offsets->CommOffset == -1)
                comm_status = (ULONG *)&RetVal;
            else if (comm_fault_offsets->CommOffset >= 0)
                comm_status = *(ULONG **)ARG_FROM_OFFSET(stubMsg.StackTop, comm_fault_offsets->CommOffset);
            else
                comm_status = NULL;
 
            if (comm_fault_offsets->FaultOffset == -1)
                fault_status = (ULONG *)&RetVal;
            else if (comm_fault_offsets->FaultOffset >= 0)
                fault_status = *(ULONG **)ARG_FROM_OFFSET(stubMsg.StackTop, comm_fault_offsets->FaultOffset);
            else
                fault_status = NULL;
 
            NdrMapCommAndFaultStatus(&stubMsg, comm_status, fault_status,
                                     GetExceptionCode());
        }
        __ENDTRY
    }
    else
    {
        RetVal = do_ndr_client_call(pStubDesc, pFormat, pHandleFormat,
                stack_top, fpu_stack, &stubMsg, procedure_number, stack_size,
                number_of_params, Oif_flags, ext_flags, pProcHeader);
    }
 
    TRACE("RetVal = 0x%lx\n", RetVal);
    return RetVal;
}

Referenced by NdrClientCall2().

NdrpCompleteAsyncClientCall()

RPC_STATUS NdrpCompleteAsyncClientCall	(	RPC_ASYNC_STATE *	pAsync,
		void *	Reply
	)

Definition at line 1829 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,
                   NULL, 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%x\n", status);
    return status;
}

Referenced by RpcAsyncCompleteCall().

NdrpCompleteAsyncServerCall()

RPC_STATUS NdrpCompleteAsyncServerCall	(	RPC_ASYNC_STATE *	pAsync,
		void *	Reply
	)

Definition at line 2133 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%lx\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");
                HeapFree(GetProcessHeap(), 0, 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 */
    HeapFree(GetProcessHeap(), 0, async_call_data->pStubMsg->StackTop);
    I_RpcFree(async_call_data);
    I_RpcFree(pAsync);
 
    return S_OK;
}

Referenced by RpcAsyncCompleteCall().