// Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

#include "serializedfunctioncall.h"

#include "remotefunctioncall.h"

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

TInt SerializedFunctionCall::Write( TUint8* aDest, TInt& aDestIndex, const TInt aDestSize,

        const TUint8* aSource, const TInt aSize, TInt& aSourceIndex, const TInt aOffset, TBool aVector )

    {        

    if ( aSourceIndex + aSize > aOffset )

        {

        TInt32 offset(0);

        TInt32 size( aSize );  

        if ( aOffset - aSourceIndex > 0 )

            {

            offset = aOffset - aSourceIndex;

            size = aSize - offset;

            }

        if ( aDestIndex + size >= aDestSize )

            {

            size = aDestSize - aDestIndex;

            }

        if ( aSource )

            {

            if ( iDataCopier && aVector )

                {

                iDataCopier->CopyVector( &aDest[aDestIndex], &aSource[offset], size );

                }

            else if ( iDataCopier )

                {

                iDataCopier->CopyData( &aDest[aDestIndex], &aSource[offset], size );            

                }

            else

                {

				RemoteFunctionCallData::CopyData( &aDest[aDestIndex], &aSource[offset], size );

                }

            }

        aSourceIndex += size;

        aDestIndex += size;

        }

    else

        {

        aSourceIndex += aSize;

        }

    return aDestSize - aDestIndex; 

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

TInt SerializedFunctionCall::WriteParam( const TUint8* aParam, const TInt aParamSize )

    {

    ASSERT( aParam );

    return Write( iWriteState.iBuffer, iWriteState.iDestIndex, iWriteState.iStreamMaxLength,

            aParam, aParamSize, iWriteState.iSourceIndex, iWriteState.iOffset, 0 );        

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

TInt SerializedFunctionCall::WriteVector( const TUint8* aParam, const TInt32 aDataTypeSize, const TInt aVectorSize, const TInt8 aDataTypeAlignment )

    {

    ASSERT( aParam );

    iWriteState.iDestIndex = RemoteFunctionCallData::AlignIndex( iWriteState.iDestIndex, aDataTypeAlignment );

    return Write( iWriteState.iBuffer, iWriteState.iDestIndex, iWriteState.iStreamMaxLength,

            aParam, aVectorSize*aDataTypeSize, iWriteState.iSourceIndex, iWriteState.iOffset, 1 );        

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

TInt SerializedFunctionCall::ReadParam( TUint8* aParam, const TInt aParamSize )

    {

    return Read( aParam, iReadState.iReadDestOffset, aParamSize, 

        iReadState.iReadBuffer, iReadState.iReadBufferIndex, iReadState.iReadBufferLength, 0 );        

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

TInt SerializedFunctionCall::ReadVectorParam( TUint8* aParam, 

		const TInt32 aDataTypeSize, const TInt aVectorSize, const TInt8 aDataTypeAlignment )

    {

	iReadState.iReadBufferIndex = RemoteFunctionCallData::AlignIndex( iReadState.iReadBufferIndex, aDataTypeAlignment );

    return Read( aParam, iReadState.iReadDestOffset, aVectorSize*aDataTypeSize, 

        iReadState.iReadBuffer, iReadState.iReadBufferIndex, iReadState.iReadBufferLength, 1 );        

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

TUint8* SerializedFunctionCall::ReadVectorPointer( 

		const TInt32 aDataTypeSize, const TInt aVectorSize, const TInt8 aDataTypeAlignment )

    {

	iReadState.iReadBufferIndex = RemoteFunctionCallData::AlignIndex( iReadState.iReadBufferIndex, aDataTypeAlignment );

	TUint8* data = const_cast<TUint8*>(&iReadState.iReadBuffer[iReadState.iReadBufferIndex]);

	iReadState.iReadBufferIndex += aVectorSize*aDataTypeSize;

    iReadState.iReadDestOffset += 0;

	return data;

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

TInt SerializedFunctionCall::Read( TUint8* aDest, TInt& aDestIndex, const TInt aDestSize,

        const TUint8* aSource, TInt& aSourceIndex, const TInt aSourceSize, TBool aVector )

    {

    TInt ret(1);

    TInt size = aDestSize - aDestIndex;

    if ( aSourceIndex + size > aSourceSize )

        {

        //Read buffer overflow

        iError = EMoreData;

        ret = 0;

        size = aSourceSize - aSourceIndex; 

        }

    if ( iDataCopier && aVector )

        {

        iDataCopier->CopyVector( &aDest[aDestIndex], &aSource[aSourceIndex], size );

        }

    else if ( iDataCopier )

        {

        iDataCopier->CopyData( &aDest[aDestIndex], &aSource[aSourceIndex], size );            

        }

    else

        {

		RemoteFunctionCallData::CopyData( &aDest[aDestIndex], &aSource[aSourceIndex], size );

        }

    aSourceIndex += size;

    aDestIndex += size;

    if ( ret )

        {

        aDestIndex = 0;

        }

    return ret;

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

void SerializedFunctionCall::StartRead( const TUint8* aBuffer, const TInt aBufferLength )

    {

    iReadState.iReadBuffer = aBuffer;

    iReadState.iReadBufferIndex = 0;

    iReadState.iReadBufferLength = aBufferLength;

    iReadState.iParseState = EReadingApiUid;

    iReadState.iReadDestOffset = 0;

    iError = ESuccess;

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

TInt SerializedFunctionCall::ReadHeaderFromBuffer( const TUint8* aBuffer, const TInt aBufferLength )

    {

    iReadState.iParamsIndex = 0;

    StartRead( aBuffer, aBufferLength );

    if ( EReadingApiUid == iReadState.iParseState )

        {

        if ( !ReadParam( (TUint8*)&iRFC.HeaderData().iApiUid, 

                sizeof(iRFC.HeaderData().iApiUid) ) )

            {

            return 0;

            }

        iReadState.iParseState = EReadingOpCode;

        }

	if ( EReadingOpCode == iReadState.iParseState )

        {

        if ( !ReadParam( (TUint8*)&iRFC.HeaderData().iOpCode, 

                sizeof(iRFC.HeaderData().iOpCode) ) )

            {

            return 0;

            }

        iReadState.iParseState = EReadingTransactionId;

        }

    if ( iReadState.iParseState == EReadingTransactionId )

        {

        if ( !ReadParam( (TUint8*)&iRFC.HeaderData().iTransactionId, 

                sizeof(iRFC.HeaderData().iTransactionId) ) )

            {

            return 0;

            }

        iReadState.iParseState = EReadingParameterCount;

        }

    if ( iReadState.iParseState == EReadingParameterCount )

        {

        if ( !ReadParam( (TUint8*)&iRFC.HeaderData().iParameterCount, 

                sizeof(iRFC.HeaderData().iParameterCount) ) )

            {

            return 0;

            }

        iReadState.iParseState = EReadingProcessId;

        }

    if ( iReadState.iParseState == EReadingProcessId )

        {

        if ( !ReadParam( (TUint8*)&iRFC.HeaderData().iProcessId, 

                sizeof(iRFC.HeaderData().iProcessId) ) )

            {

            return 0;

            }

        iReadState.iParseState = EReadingThreadId;

        }

    if ( iReadState.iParseState == EReadingThreadId )

        {

        if ( !ReadParam( (TUint8*)&iRFC.HeaderData().iThreadId, 

                sizeof(iRFC.HeaderData().iThreadId) ) )

            {

            return 0;

            }

        iReadState.iParseState = EReadingOpType;

        }

    if ( iReadState.iParseState == EReadingOpType )

        {

        if ( !ReadParam( (TUint8*)&iRFC.HeaderData().iOpType, 

                sizeof(iRFC.HeaderData().iOpType) ) )

            {

            return 0;

            }

        iReadState.iParseState = EReadingReturnValue;

        }

    if ( iReadState.iParseState == EReadingReturnValue )

        {

        if ( !ReadParam( (TUint8*)&iRFC.HeaderData().iReturnValue, 

                sizeof(iRFC.HeaderData().iReturnValue) ) )

            {

            return 0;

            }

        iReadState.iParseState = EReadingParamDir;

        }

    return 1;

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

SER_EXPORT_C TInt SerializedFunctionCall::ParseBuffer( const TUint8* aBuffer, const TInt aBufferLength )

    {

    StartRead( aBuffer, aBufferLength );

    if ( ReadHeaderFromBuffer( aBuffer, aBufferLength ) )

        {        

        for ( ;iReadState.iParamsIndex < iRFC.Header().iParameterCount; iReadState.iParamsIndex++ )

            {

			RemoteFunctionCallData::TParam& param( iRFC.Parameters()[iReadState.iParamsIndex] );

            ReadParam( (TUint8*)&param.iDir, sizeof(param.iDir) );

            if ( ReadParam( (TUint8*)&param.iType, sizeof(param.iType) ) )

                {

                if ( RemoteFunctionCallData::TParam::ESimple == param.iType )

                    {

                    ReadParam( (TUint8*)&param.iSimpleParam.iDataType, sizeof(param.iSimpleParam.iDataType) ); 

                    ReadParam( (TUint8*)&param.iSimpleParam.iDataTypeSize, sizeof(param.iSimpleParam.iDataTypeSize) ); 

                    ReadParam( (TUint8*)&param.iSimpleParam.iData, param.iSimpleParam.iDataTypeSize );

                    }

                else if ( RemoteFunctionCallData::TParam::EVector == param.iType )

                    {

                    ReadParam( (TUint8*)&param.iVectorParam.iDataType, sizeof(param.iVectorParam.iDataType) );

                    ReadParam( (TUint8*)&param.iVectorParam.iVectorLength, sizeof(param.iVectorParam.iVectorLength) );            

                    ReadParam( (TUint8*)&param.iVectorParam.iCallerAddress, sizeof(param.iVectorParam.iCallerAddress) );

                    ReadParam( (TUint8*)&param.iVectorParam.iDataTypeSize, sizeof(param.iVectorParam.iDataTypeSize) );

                    ReadParam( (TUint8*)&param.iVectorParam.iDataTypeAlignment, sizeof(param.iVectorParam.iDataTypeAlignment) );

                    if ( !param.iVectorParam.iVectorLength )

                        {

                        param.iVectorParam.iData = NULL;

						param.iVectorParam.iCallerAddress = NULL;

                        }

                    else if ( (param.iDir & RemoteFunctionCallData::EIn) && ( RemoteFunctionCallData::EOpRequest == iRFC.Header().iOpType || RemoteFunctionCallData::EOpRequestWithReply == iRFC.Header().iOpType ) )

                        {

                        param.iVectorParam.iData = ReadVectorPointer( param.iVectorParam.iDataTypeSize, param.iVectorParam.iVectorLength, param.iVectorParam.iDataTypeAlignment );

                        }

                    else if ( (param.iDir & RemoteFunctionCallData::EOut) && iRFC.Header().iOpType == RemoteFunctionCallData::EOpReply ) 

                        {

                        ReadVectorParam( (TUint8*)param.iVectorParam.iCallerAddress, 

                                param.iVectorParam.iDataTypeSize, param.iVectorParam.iVectorLength, param.iVectorParam.iDataTypeAlignment );

                        }

                    }

                else

                    {

                    //Parse error

                    iError = EParseError;

                    return -1;

                    }

                }

            }

        iReadState.iParseState = EReadingDone;

        }

    else

        {

        iError = EParseError;

        return -1;

        }

    return iReadState.iReadBufferIndex;

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

void SerializedFunctionCall::StartWrite( TUint8* aBuffer, const TInt aStreamMaxLength, TInt aOffset )

    {

    iWriteState.iBuffer = aBuffer;

    iWriteState.iDestIndex = 0;

    iWriteState.iStreamMaxLength = aStreamMaxLength;

    iWriteState.iSourceIndex = 0;

    iWriteState.iOffset = aOffset;

    iError = ESuccess;    

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

TInt SerializedFunctionCall::WriteHeaderToBuffer( TUint8* aBuffer, const TInt aStreamMaxLength, TInt aOffset )

    {

    StartWrite( aBuffer, aStreamMaxLength, aOffset );

    if ( !WriteParam( (TUint8*)&iRFC.Header().iApiUid, 

            sizeof(iRFC.Header().iApiUid) ) )

        {

        return iWriteState.iSourceIndex;

        }

    if ( !WriteParam( (TUint8*)&iRFC.Header().iOpCode, 

            sizeof(iRFC.Header().iOpCode) ) )

        {

        return iWriteState.iSourceIndex;

        }

    if ( !WriteParam( (TUint8*)&iRFC.Header().iTransactionId, 

            sizeof(iRFC.Header().iTransactionId) ) )

        {

        return iWriteState.iSourceIndex;

        }

    if ( !WriteParam( (TUint8*)&iRFC.Header().iParameterCount, 

            sizeof(iRFC.Header().iParameterCount) ) )

        {

        return iWriteState.iSourceIndex;

        }

    if ( !WriteParam( (TUint8*)&iRFC.Header().iProcessId, 

            sizeof(iRFC.Header().iProcessId) ) )

        {

        return iWriteState.iSourceIndex;

        }

    if ( !WriteParam( (TUint8*)&iRFC.Header().iThreadId, 

            sizeof(iRFC.Header().iThreadId) ) )

        {

        return iWriteState.iSourceIndex;

        }

    if ( !WriteParam( (TUint8*)&iRFC.Header().iOpType, 

            sizeof(iRFC.Header().iOpType) ) )

        {

        return iWriteState.iSourceIndex;

        }

    if ( !WriteParam( (TUint8*)&iRFC.Header().iReturnValue, 

            sizeof(iRFC.Header().iReturnValue) ) )

        {

        return iWriteState.iSourceIndex;

        }

    return iWriteState.iSourceIndex;

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

SER_EXPORT_C TInt SerializedFunctionCall::WriteToBuffer( TUint8* aBuffer, const TInt aStreamMaxLength, TInt aOffset )

    {

    WriteHeaderToBuffer( aBuffer, aStreamMaxLength, aOffset );

    for ( TInt i = 0; i < iRFC.Header().iParameterCount; i++ )

        {

        const RemoteFunctionCallData::TParam& param( iRFC.Parameters()[i] );

        if ( !WriteParam( (TUint8*)&param.iDir, 

                sizeof(param.iDir) ) )

            {

            break;

            }

        if ( !WriteParam( (TUint8*)&param.iType, 

                sizeof(param.iType) ) )

            {

            break;

            }

		if ( RemoteFunctionCallData::TParam::ESimple == param.iType )

            {

            if ( !WriteParam( (TUint8*)&param.iSimpleParam.iDataType, 

                    sizeof(param.iSimpleParam.iDataType) ) )

                {

                break;

                }

            if ( !WriteParam( (TUint8*)&param.iSimpleParam.iDataTypeSize, 

                    sizeof(param.iSimpleParam.iDataTypeSize) ) )

                {

                break;

                }

			if ( !WriteParam( (TUint8*)&param.iSimpleParam.iData, param.iSimpleParam.iDataTypeSize ) )

                {

                break;

                }

            }

        else if ( RemoteFunctionCallData::TParam::EVector == param.iType )

            {

            if ( !WriteParam( (TUint8*)&param.iVectorParam.iDataType, sizeof(param.iVectorParam.iDataType) ))

                {

                break;

                }

            if ( !WriteParam( (TUint8*)&param.iVectorParam.iVectorLength, sizeof(param.iVectorParam.iVectorLength) ))

                {

                break;

                }

            if ( !WriteParam( (TUint8*)&param.iVectorParam.iCallerAddress, sizeof(param.iVectorParam.iCallerAddress) ))

                {

                break;

                }

            if ( !WriteParam( (TUint8*)&param.iVectorParam.iDataTypeSize, sizeof(param.iVectorParam.iDataTypeSize) ))

                {

                break;

                }

            if ( !WriteParam( (TUint8*)&param.iVectorParam.iDataTypeAlignment, sizeof(param.iVectorParam.iDataTypeAlignment) ))

                {

                break;

                }

            if ( param.iVectorParam.iVectorLength && ( ( (param.iDir & RemoteFunctionCallData::EIn) && ( RemoteFunctionCallData::EOpRequestWithReply == iRFC.Header().iOpType || RemoteFunctionCallData::EOpRequest == iRFC.Header().iOpType ) ) ||

                    ( (param.iDir & RemoteFunctionCallData::EOut) && iRFC.Header().iOpType == RemoteFunctionCallData::EOpReply ) ) )

                {

                //Only serialise vector data if data is valid and the direction matches

                if ( !WriteVector( param.iVectorParam.iData, param.iVectorParam.iDataTypeSize, param.iVectorParam.iVectorLength, param.iVectorParam.iDataTypeAlignment ) )

                    {

                    break;

                    }

                }

            }

        }

    return iWriteState.iDestIndex;

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

SER_EXPORT_C void SerializedFunctionCall::SetDataCopier( MDataCopier* aDataCopier )

    {

    iDataCopier = aDataCopier;        

    }

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

SER_EXPORT_C SerializedFunctionCall::SerializedFunctionCall( RemoteFunctionCallData& aRFC, MDataCopier* aDataCopier ):

	iRFC( aRFC ),

    iDataCopier( aDataCopier )

    {

    }