ndr_stubless.c

这是一个开放源代码的与WINNT/WIN2K/WIN2003兼容的操作系统

    unsigned short offset;

    /* zero-based index on rundown routine in apfnNdrRundownRoutines field
     * of MIDL_STUB_DESC */
    unsigned char context_rundown_routine_index;

    /* varies depending on NDR version used.
     * V1: zero-based index into parameters 
     * V2: zero-based index into handles that are parameters */
    unsigned char param_num;
} NDR_EHD_CONTEXT;

#include "poppack.h"

void WINAPI NdrRpcSmSetClientToOsf(PMIDL_STUB_MESSAGE pMessage)
{
#if 0 /* these functions are not defined yet */
    pMessage->pfnAllocate = NdrRpcSmClientAllocate;
    pMessage->pfnFree = NdrRpcSmClientFree;
#endif
}

static void WINAPI dump_RPC_FC_PROC_PF(PARAM_ATTRIBUTES param_attributes)
{
    if (param_attributes.MustSize) TRACE(" MustSize");
    if (param_attributes.MustFree) TRACE(" MustFree");
    if (param_attributes.IsPipe) TRACE(" IsPipe");
    if (param_attributes.IsIn) TRACE(" IsIn");
    if (param_attributes.IsOut) TRACE(" IsOut");
    if (param_attributes.IsReturn) TRACE(" IsReturn");
    if (param_attributes.IsBasetype) TRACE(" IsBasetype");
    if (param_attributes.IsByValue) TRACE(" IsByValue");
    if (param_attributes.IsSimpleRef) TRACE(" IsSimpleRef");
    if (param_attributes.IsDontCallFreeInst) TRACE(" IsDontCallFreeInst");
    if (param_attributes.SaveForAsyncFinish) TRACE(" SaveForAsyncFinish");
    if (param_attributes.ServerAllocSize) TRACE(" ServerAllocSize = %d", param_attributes.ServerAllocSize * 8);
}

/* FIXME: this will be different on other plaftorms than i386 */
#define ARG_FROM_OFFSET(args, offset) (*(unsigned char **)args + offset)

/* the return type should be CLIENT_CALL_RETURN, but this is incompatible
 * with the way gcc returns structures. "void *" should be the largest type
 * that MIDL should allow you to return anyway */
LONG_PTR WINAPIV NdrClientCall2(PMIDL_STUB_DESC pStubDesc, PFORMAT_STRING pFormat, ...)
{
    /* pointer to start of stack where arguments start */
    /* FIXME: not portable */
    unsigned char *args = (unsigned char *)(&pFormat+1);
    RPC_MESSAGE rpcMsg;
    MIDL_STUB_MESSAGE stubMsg;
    handle_t hBinding = NULL;
    /* procedure number */
    unsigned short procedure_number;
    /* size of stack */
    unsigned short stack_size;
    /* current stack offset */
    unsigned short current_stack_offset;
    /* number of parameters. optional for client to give it to us */
    unsigned char number_of_params = ~0;
    /* counter */
    unsigned short i;
    /* cache of Oif_flags from v2 procedure header */
    unsigned char Oif_flags = 0;
    /* cache of extension flags from NDR_PROC_EXTENSION */
    unsigned char ext_flags = 0;
    /* the type of pass we are currently doing */
    int phase;
    /* header for procedure string */
    const NDR_PROC_HEADER * pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0];
    /* offset in format string for start of params */
    int parameter_start_offset;
    /* current format string offset */
    int current_offset;
    /* -Oif or -Oicf generated format */
    BOOL bV2Format = FALSE;
    /* the value to return to the client from the remote procedure */
    LONG_PTR RetVal = 0;
    /* the pointer to the object when in OLE mode */
    void * This = NULL;

    TRACE("pStubDesc %p, pFormat %p, ...\n", pStubDesc, pFormat);
    TRACE("&first_argument = %p -> %p\n", args, ARG_FROM_OFFSET(args, 0));

    /* 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);
    }

    if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
    {
        NDR_PROC_HEADER_RPC * pProcHeader = (NDR_PROC_HEADER_RPC *)&pFormat[0];
        stack_size = pProcHeader->stack_size;
        procedure_number = pProcHeader->proc_num;
        current_offset = sizeof(NDR_PROC_HEADER_RPC);
    }
    else
    {
        stack_size = pProcHeader->stack_size;
        procedure_number = pProcHeader->proc_num;
        TRACE("proc num: %d\n", procedure_number);
        current_offset = sizeof(NDR_PROC_HEADER);
    }

    TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags);
    TRACE("MIDL stub version = 0x%lx\n", pStubDesc->MIDLVersion);

    /* we only need a handle if this isn't an object method */
    if (!(pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT))
    {
        /* binding */
        switch (pProcHeader->handle_type)
        {
        /* explicit binding: parse additional section */
        case RPC_FC_BIND_EXPLICIT:
            switch (pFormat[current_offset]) /* handle_type */
            {
            case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */
                {
                    NDR_EHD_PRIMITIVE * pDesc = (NDR_EHD_PRIMITIVE *)&pFormat[current_offset];

                    TRACE("Explicit primitive handle @ %d\n", pDesc->offset);

                    if (pDesc->flag) /* pointer to binding */
                        hBinding = **(handle_t **)ARG_FROM_OFFSET(args, pDesc->offset);
                    else
                        hBinding = *(handle_t *)ARG_FROM_OFFSET(args, pDesc->offset);
                    current_offset += sizeof(NDR_EHD_PRIMITIVE);
                    break;
                }
            case RPC_FC_BIND_GENERIC: /* explicit generic */
                FIXME("RPC_FC_BIND_GENERIC\n");
                RpcRaiseException(RPC_X_WRONG_STUB_VERSION); /* FIXME: remove when implemented */
                current_offset += sizeof(NDR_EHD_GENERIC);
                break;
            case RPC_FC_BIND_CONTEXT: /* explicit context */
                {
                    NDR_EHD_CONTEXT * pDesc = (NDR_EHD_CONTEXT *)&pFormat[current_offset];
                    TRACE("Explicit bind context\n");
                    hBinding = NDRCContextBinding(*(NDR_CCONTEXT *)ARG_FROM_OFFSET(args, pDesc->offset));
                    /* FIXME: should we store this structure in stubMsg.pContext? */
                    current_offset += sizeof(NDR_EHD_CONTEXT);
                    break;
                }
            default:
                ERR("bad explicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
                RpcRaiseException(RPC_X_BAD_STUB_DATA);
            }
            break;
        case RPC_FC_BIND_GENERIC: /* implicit generic */
            FIXME("RPC_FC_BIND_GENERIC\n");
            RpcRaiseException(RPC_X_BAD_STUB_DATA); /* FIXME: remove when implemented */
            break;
        case RPC_FC_BIND_PRIMITIVE: /* implicit primitive */
            TRACE("Implicit primitive handle\n");
            hBinding = *pStubDesc->IMPLICIT_HANDLE_INFO.pPrimitiveHandle;
            break;
        case RPC_FC_CALLBACK_HANDLE: /* implicit callback */
            FIXME("RPC_FC_CALLBACK_HANDLE\n");
            break;
        case RPC_FC_AUTO_HANDLE: /* implicit auto handle */
            /* strictly speaking, it isn't necessary to set hBinding here
            * since it isn't actually used (hence the automatic in its name),
            * but then why does MIDL generate a valid entry in the
            * MIDL_STUB_DESC for it? */
            TRACE("Implicit auto handle\n");
            hBinding = *pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle;
            break;
        default:
            ERR("bad implicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
            RpcRaiseException(RPC_X_BAD_STUB_DATA);
        }
    }

    bV2Format = (pStubDesc->Version >= 0x20000);

    if (bV2Format)
    {
        NDR_PROC_PARTIAL_OIF_HEADER * pOIFHeader =
            (NDR_PROC_PARTIAL_OIF_HEADER*)&pFormat[current_offset];

        Oif_flags = pOIFHeader->Oif_flags;
        number_of_params = pOIFHeader->number_of_params;

        current_offset += sizeof(NDR_PROC_PARTIAL_OIF_HEADER);
    }

    TRACE("Oif_flags = 0x%02x\n", Oif_flags);

    if (Oif_flags & RPC_FC_PROC_OI2F_HASEXTS)
    {
        NDR_PROC_EXTENSION * pExtensions =
            (NDR_PROC_EXTENSION *)&pFormat[current_offset];
        ext_flags = pExtensions->ext_flags;
        current_offset += pExtensions->extension_version;
    }

    if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
    {
        /* object is always the first argument */
        This = *(void **)ARG_FROM_OFFSET(args, 0);
        NdrProxyInitialize(This, &rpcMsg, &stubMsg, pStubDesc, procedure_number);
    }
    else
        NdrClientInitializeNew(&rpcMsg, &stubMsg, pStubDesc, procedure_number);

    /* create the full pointer translation tables, if requested */
    if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
#if 0
        stubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_CLIENT);
#else
        FIXME("initialize full pointer translation tables\n");
#endif

    stubMsg.BufferLength = 0;

    /* store the RPC flags away */
    if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
        rpcMsg.RpcFlags = ((NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;

    /* use alternate memory allocation routines */
    if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC)
        NdrRpcSmSetClientToOsf(&stubMsg);

    if (Oif_flags & RPC_FC_PROC_OI2F_HASPIPES)
    {
        FIXME("pipes not supported yet\n");
        RpcRaiseException(RPC_X_WRONG_STUB_VERSION); /* FIXME: remove when implemented */
        /* init pipes package */
        /* NdrPipesInitialize(...) */
    }
    if (ext_flags & RPC_FC_PROC_EXT_NEWCORRDESC)
    {
        /* initialize extra correlation package */
        FIXME("new correlation description not implemented\n");
        stubMsg.fHasNewCorrDesc = TRUE;
    }

    parameter_start_offset = current_offset;

    /* order of phases:
     * 1. PROXY_CALCSIZE - calculate the buffer size
     * 2. PROXY_GETBUFFER - allocate the buffer
     * 3. PROXY_MARHSAL - marshal [in] params into the buffer
     * 4. PROXY_SENDRECEIVE - send/receive buffer
     * 5. PROXY_UNMARHSAL - unmarshal [out] params from buffer
     */
    for (phase = PROXY_CALCSIZE; phase <= PROXY_UNMARSHAL; phase++)
    {
        TRACE("phase = %d\n", phase);
        switch (phase)
        {
        case PROXY_GETBUFFER:
            /* allocate the buffer */
            if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
                NdrProxyGetBuffer(This, &stubMsg);
            else if (Oif_flags & RPC_FC_PROC_OI2F_HASPIPES)
                /* NdrGetPipeBuffer(...) */
                FIXME("pipes not supported yet\n");
            else
            {
                if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
#if 0
                    NdrNsGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
#else
                    FIXME("using auto handle - call NdrNsGetBuffer when it gets implemented\n");
#endif
                else
                    NdrGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
            }
            break;
        case PROXY_SENDRECEIVE:
            /* send the [in] params and receive the [out] and [retval]
             * params */
            if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
                NdrProxySendReceive(This, &stubMsg);
            else if (Oif_flags & RPC_FC_PROC_OI2F_HASPIPES)
                /* NdrPipesSendReceive(...) */
                FIXME("pipes not supported yet\n");
            else
            {
                if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
#if 0
                    NdrNsSendReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
#else
                    FIXME("using auto handle - call NdrNsSendReceive when it gets implemented\n");
#endif
                else
                    NdrSendReceive(&stubMsg, stubMsg.Buffer);
            }

            /* convert strings, floating point values and endianess into our
             * preferred format */
            if ((rpcMsg.DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
                NdrConvert(&stubMsg, pFormat);

            break;
        case PROXY_CALCSIZE:
        case PROXY_MARSHAL:
        case PROXY_UNMARSHAL:
            current_offset = parameter_start_offset;
            current_stack_offset = 0;

            /* NOTE: V1 style format does't terminate on the number_of_params
             * condition as it doesn't have this attribute. Instead it
             * terminates when the stack size given in the header is exceeded.
             */
            for (i = 0; i < number_of_params; i++)
            {
                if (bV2Format) /* new parameter format */
                {
                    NDR_PARAM_OIF_BASETYPE * pParam =
                        (NDR_PARAM_OIF_BASETYPE *)&pFormat[current_offset];
                    unsigned char * pArg;

                    current_stack_offset = pParam->stack_offset;
                    pArg = ARG_FROM_OFFSET(args, current_stack_offset);

                    TRACE("param[%d]: new format\n", i);
                    TRACE("\tparam_attributes:"); dump_RPC_FC_PROC_PF(pParam->param_attributes); TRACE("\n");
                    TRACE("\tstack_offset: 0x%x\n", current_stack_offset);
                    TRACE("\tmemory addr (before): %p\n", pArg);

                    if (pParam->param_attributes.IsBasetype)
                    {
                        const unsigned char * pTypeFormat =
                            &pParam->type_format_char;

                        if (pParam->param_attributes.IsSimpleRef)
                            pArg = *(unsigned char **)pArg;

                        TRACE("\tbase type: 0x%02x\n", *pTypeFormat);

                        switch (phase)
                        {
                        case PROXY_CALCSIZE:
                            if (pParam->param_attributes.IsIn)
                                call_buffer_sizer(&stubMsg, pArg, pTypeFormat);
                            break;
                        case PROXY_MARSHAL:
                            if (pParam->param_attributes.IsIn)
                                call_marshaller(&stubMsg, pArg, pTypeFormat);
                            break;
                        case PROXY_UNMARSHAL:
                            if (pParam->param_attributes.IsOut)
                            {
                                unsigned char *pRetVal = (unsigned char *)&RetVal;
                                if (pParam->param_attributes.IsReturn)
                                    call_unmarshaller(&stubMsg, &pRetVal, pTypeFormat, 0);
                                else
                                    call_unmarshaller(&stubMsg, &pArg, pTypeFormat, 0);
                                TRACE("pRetVal = %p\n", pRetVal);
                            }
                            break;
                        default:
                            RpcRaiseException(RPC_S_INTERNAL_ERROR);
                        }

                        current_offset += sizeof(NDR_PARAM_OIF_BASETYPE);
                    }
                    else
                    {
                        NDR_PARAM_OIF_OTHER * pParamOther =
                            (NDR_PARAM_OIF_OTHER *)&pFormat[current_offset];

                        const unsigned char * pTypeFormat =
                            &(pStubDesc->pFormatTypes[pParamOther->type_offset]);