/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Copyright (c) 1998 - 1999 Microsoft Corporation

Module Name :

    relmrl.c

Abstract :

    This file contains release of Marshaled Data (called before unmarshal).

Author :

    Yong Qu (yongqu@microsoft.com) Nov 1998

Revision History :

  ---------------------------------------------------------------------*/

#define USE_STUBLESS_PROXY
#define CINTERFACE
#include "ndrp.h"
#include "ndrole.h"
#include "rpcproxy.h"
#include "hndl.h"
#include "interp2.h"
#include "pipendr.h"
#include "attack.h"
#include "mulsyntx.h"

#include <stddef.h>
#include <stdarg.h>


/* client side: we only care about the [in] part. 
   it's basically like unmarshal on the server side, just that
   we immediately free the buffer (virtual stack) after unmarshalling.
   The call it not necessary always OLE call: one side raw RPC and 
   the other side OLE call is possible: do we support this?

   mostly code from NdrStubCall2, remove irrelavant code. 
*/

#define IN_BUFFER           0
#define OUT_BUFFER          1

#define IsSameDir(dwFlags,param) ((dwFlags == IN_BUFFER)? param.IsIn :param.IsOut)

HRESULT NdrpReleaseMarshalBuffer(
        RPC_MESSAGE *pRpcMsg,
        PFORMAT_STRING pFormat,
        PMIDL_STUB_DESC pStubDesc,
        DWORD dwFlags,
        BOOLEAN fServer)
{
    ushort		            StackSize;

    MIDL_STUB_MESSAGE       StubMsg;

    PPARAM_DESCRIPTION      Params;
    INTERPRETER_FLAGS       InterpreterFlags;
    INTERPRETER_OPT_FLAGS   OptFlags;
    long                    NumberParams;

    long                    n;
    PNDR_PROC_HEADER_EXTS   pHeaderExts = 0;
    HRESULT                 hr = S_OK;

    uchar *             pBuffer;
    PFORMAT_STRING      pFormatComplex;
    PFORMAT_STRING      pFormatTypes;

    NDR_ASSERT( ! ((ULONG_PTR)pRpcMsg->Buffer & 0x7),
                "marshaling buffer misaligned at server" );

    // must be auto handle.
    if (FC_AUTO_HANDLE != pFormat[0])
        return E_NOTIMPL;

    InterpreterFlags = *((PINTERPRETER_FLAGS)&pFormat[1]);
    pFormat += InterpreterFlags.HasRpcFlags ? 8 : 4;
    StackSize = *((ushort * &)pFormat)++;

    memset(&StubMsg,0,sizeof(MIDL_STUB_MESSAGE));
    StubMsg.FullPtrXlatTables = 0;


    //
    // Get new interpreter info.
    //
    NdrServerInitialize(pRpcMsg,&StubMsg,pStubDesc);
    SET_WALKIP( StubMsg.uFlags ); 

    OptFlags = *((PINTERPRETER_OPT_FLAGS)&pFormat[4]);

    NumberParams = (long) pFormat[5];

    Params = (PPARAM_DESCRIPTION) &pFormat[6];

    // Proc header extentions, from NDR ver. 5.2.
    // Params must be set correctly here because of exceptions.
    // need to setup correlation information.

    if ( OptFlags.HasExtensions )
        {
        pHeaderExts = (NDR_PROC_HEADER_EXTS *)Params;
        Params = (PPARAM_DESCRIPTION)((uchar*)Params + pHeaderExts->Size);
        StubMsg.fHasExtensions  = 1;
        StubMsg.fHasNewCorrDesc = pHeaderExts->Flags2.HasNewCorrDesc;
        }


    if ( InterpreterFlags.FullPtrUsed )
        StubMsg.FullPtrXlatTables = NdrFullPointerXlatInit( 0, XLAT_SERVER );

    //
    // context handle is not supported in object
    //

        pFormatTypes = pStubDesc->pFormatTypes;



    // Save the original buffer pointer to restore later.
        pBuffer = StubMsg.Buffer;

    // Get the type format string.
    RpcTryFinally
    {

        RpcTryExcept
        {
        //
        // Check if we need to do any walking .
        //
        if ( (fServer && dwFlags == OUT_BUFFER)
              &&
             (pRpcMsg->DataRepresentation & 0X0000FFFFUL) !=
                      NDR_LOCAL_DATA_REPRESENTATION )
                    {
                    NdrConvert2( &StubMsg,
                                 (PFORMAT_STRING) Params,
                                 NumberParams );
                    }

        for ( n = 0; n < NumberParams; n++ )
            {

            if ( (dwFlags == IN_BUFFER ) &&
                 Params[n].ParamAttr.IsPartialIgnore )
                {
                PMIDL_STUB_MESSAGE pStubMsg = &StubMsg;
                ALIGN( StubMsg.Buffer, 0x3 );
                StubMsg.Buffer += PTR_WIRE_SIZE;
                CHECK_EOB_RAISE_BSD( StubMsg.Buffer );
                continue;
                }

            if ( ! IsSameDir(dwFlags,Params[n].ParamAttr) ||
                    Params[n].ParamAttr.IsPipe)
                continue;

            if ( Params[n].ParamAttr.IsBasetype )
                {
                ALIGN(StubMsg.Buffer, SIMPLE_TYPE_ALIGNMENT( Params[n].SimpleType.Type ));
                StubMsg.Buffer += SIMPLE_TYPE_BUFSIZE( Params[n].SimpleType.Type );
                }
            else
                {
                //
                // Complex type or pointer to complex type.
                //
                pFormatComplex = pFormatTypes + Params[n].TypeOffset;

                (*pfnMemSizeRoutines[ROUTINE_INDEX(*pFormatComplex)])
                    ( &StubMsg,
                      pFormatComplex);
                };
            }
        }
        RpcExcept( EXCEPTION_EXECUTE_HANDLER )
        {
             hr = HRESULT_FROM_WIN32(RpcExceptionCode());
        }
        RpcEndExcept

    }
    RpcFinally
    {
        NdrFullPointerXlatFree( StubMsg.FullPtrXlatTables );

        StubMsg.Buffer = pBuffer;
    }
    RpcEndFinally

    return hr;

}


HRESULT NdrpClientReleaseMarshalBuffer(
        IReleaseMarshalBuffers *pRMB,
        RPC_MESSAGE *pRpcMsg,
        DWORD dwIOFlags,
        BOOLEAN  fAsync )
{
    CStdProxyBuffer *           pProxyBuffer;
    PMIDL_STUBLESS_PROXY_INFO   pProxyInfo;
    CInterfaceProxyHeader *     ProxyHeader;
    long                        ParamSize;
    ushort                      ProcNum;
    ushort                      FormatOffset;
    PFORMAT_STRING              pFormat;
    PMIDL_STUB_DESC             pStubDesc;
    void *                      This;
    HRESULT hr;

    pProxyBuffer = (CStdProxyBuffer *)
                  (((uchar *)pRMB) - offsetof( CStdProxyBuffer, pRMBVtbl ));

    // The channel queries for IReleaseMarshalBuffers interface and gets the interface pointer
    // only when proxy is the new proxy with bigger header, with ProxyInfo.
    // Just in case, check this condition again.
    if ( pRMB == 0 )
        return E_NOTIMPL;

    // quite often OLE pass in NULL buffer. Do an additional check here. 
    if ( NULL == pRpcMsg->Buffer )
        return E_INVALIDARG;    
    
    This = (void *)pProxyBuffer->pProxyVtbl;

    ProxyHeader = (CInterfaceProxyHeader *)
                  ( (char *)This - sizeof(CInterfaceProxyHeader));
    pProxyInfo = (PMIDL_STUBLESS_PROXY_INFO) (ProxyHeader->pStublessProxyInfo);


    // Hack just in case, the bit should not be set up, actually.
    ProcNum = pRpcMsg->ProcNum & ~RPC_FLAGS_VALID_BIT;

    // RPCMSG always has the synchronous proc number;
    if ( fAsync )
        ProcNum = 2 * ProcNum - 3;  // Begin method #

    if ( dwIOFlags != IN_BUFFER )
        return E_NOTIMPL;


    pStubDesc = pProxyInfo->pStubDesc;

#if defined(BUILD_NDR64)
    // check out ndr64
    if ( pStubDesc->mFlags & RPCFLG_HAS_MULTI_SYNTAXES  )   
        {
        SYNTAX_TYPE             SyntaxType;
        long           i;
        MIDL_SYNTAX_INFO    *   pSyntaxInfo;
        
        SyntaxType = NdrpGetSyntaxType( pRpcMsg->TransferSyntax );

        // branch into ndr64 if SyntaxType is NDR64. fall through otherwise
        if ( XFER_SYNTAX_NDR64 == SyntaxType )
            {
            for ( i = 0; i < (long)pProxyInfo->nCount; i++ )
            {
            if ( SyntaxType == NdrpGetSyntaxType( &pProxyInfo->pSyntaxInfo[i].TransferSyntax ) )
                {
                pSyntaxInfo = &pProxyInfo->pSyntaxInfo[i];
                break;
                }
            }
            return Ndr64pReleaseMarshalBuffer( pRpcMsg, pSyntaxInfo, ProcNum, pStubDesc, dwIOFlags, FALSE );
            }
        }
#endif
        
    FormatOffset = pProxyInfo->FormatStringOffset[ProcNum];
    pFormat      = &((pProxyInfo->ProcFormatString)[FormatOffset]);

    // only support Oicf mode
    if ( (MIDL_VERSION_3_0_39 > pStubDesc->MIDLVersion ) ||
         !(pFormat[1] &  Oi_OBJ_USE_V2_INTERPRETER ))
         return E_NOTIMPL;

    hr = NdrpReleaseMarshalBuffer( pRpcMsg,
                                   pFormat,
                                   pStubDesc,
                                   dwIOFlags, 
                                   FALSE );    // client

    return hr;        
}


HRESULT NdrpServerReleaseMarshalBuffer(
        IReleaseMarshalBuffers *pRMB,
        RPC_MESSAGE *pRpcMsg,
        DWORD dwIOFlags,
        BOOLEAN fAsync)
{
    CStdStubBuffer *        pStubBuffer ;
    PRPC_SERVER_INTERFACE   pServerIfInfo;
    PMIDL_SERVER_INFO       pServerInfo;
    ushort                  ProcNum;

    IUnknown *              pSrvObj;
    CInterfaceStubVtbl *    pStubVTable;

    ushort                  FormatOffset;
    PFORMAT_STRING          pFormat;
    PMIDL_STUB_DESC         pStubDesc;
    HRESULT                 hr;


    pStubBuffer = (CStdStubBuffer *) (((uchar *)pRMB) -
                                    offsetof(CStdStubBuffer, pRMBVtbl));

    // The channel queries for IReleaseMarshalBuffers interface and gets the interface pointer
    // only when proxy is the new proxy with bigger header, with ProxyInfo.
    // Just in case, check this condition again.
    if ( pRMB == 0 )
        return E_NOTIMPL;

    if ( NULL == pRpcMsg->Buffer )
        return E_INVALIDARG;
    
    pSrvObj = (IUnknown * )((CStdStubBuffer *)pStubBuffer)->pvServerObject;

    pStubVTable = (CInterfaceStubVtbl *)
                  ((uchar *)pStubBuffer->lpVtbl - sizeof(CInterfaceStubHeader));

    pServerInfo = (PMIDL_SERVER_INFO) pStubVTable->header.pServerInfo;


    // Hack just in case, this should not be set up, actually.
    ProcNum = pRpcMsg->ProcNum & ~RPC_FLAGS_VALID_BIT;
    
    // RPCMSG always has the synchronous proc number;
    if ( fAsync )
        {
        ProcNum = 2 * ProcNum - 3;  // Begin method #

        if ( dwIOFlags != IN_BUFFER )
            ProcNum++;              // Finish method
        }

    pStubDesc = pServerInfo->pStubDesc;

#if defined(BUILD_NDR64)    
    if ( pStubDesc->mFlags & RPCFLG_HAS_MULTI_SYNTAXES  )   
        {
        SYNTAX_TYPE             SyntaxType;
        long                    i;
        MIDL_SYNTAX_INFO    *   pSyntaxInfo;
        
        SyntaxType = NdrpGetSyntaxType( pRpcMsg->TransferSyntax );

        if ( XFER_SYNTAX_NDR64 == SyntaxType )
            {
            for ( i = 0; i < (long)pServerInfo->nCount; i++ )
            {
            if ( SyntaxType == NdrpGetSyntaxType( &pServerInfo->pSyntaxInfo[i].TransferSyntax ) )
                {
                pSyntaxInfo = &pServerInfo->pSyntaxInfo[i];
                break;
                }
            }
            return Ndr64pReleaseMarshalBuffer( pRpcMsg, pSyntaxInfo, ProcNum, pStubDesc, dwIOFlags, TRUE );
            }
        }
#endif

    FormatOffset = pServerInfo->FmtStringOffset[ProcNum];
    pFormat = &((pServerInfo->ProcString)[FormatOffset]);
    
    // only support Oicf mode
    if ( (MIDL_VERSION_3_0_39 > pStubDesc->MIDLVersion ) ||
         !(pFormat[1] &  Oi_OBJ_USE_V2_INTERPRETER ))
         return E_NOTIMPL;
         
    hr = NdrpReleaseMarshalBuffer(pRpcMsg,pFormat,pStubDesc,dwIOFlags,TRUE);

    return hr;        
   
}