// 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 "remotefunctioncall.h"

// Symbian User mode Panic & debugging information

#if defined(__SYMBIAN32__) && !defined(__KERNEL_MODE__)

#define USE_SYMBIAN_CLIENT_PANICS

#include <e32debug.h>

#include "serialisedapiuids.h"

// Guest Serialiser panic codes

typedef enum

	{

	ESerPanicMaxParamCountExceeded=1,

	ESerPanicRequestOperationHasOutParameter,

	ESerPanicVectorPtrIsNull,

	ESerPanicVectorSizeIsNegative,

	} TSerialiserPanic;

_LIT(KSerialiserPanicCategory, "Vghw Ser");

#ifdef _DEBUG

	#define VGSERPANIC_ASSERT(condition, panic, api, opcode, pcount) if (!(condition)) \

			{ SerialiserPanic(panic, #condition, __FILE__, __LINE__, api, opcode, pcount); }

#else

	#define VGSERPANIC_ASSERT(condition, panic, api, opcode, pcount) if (!(condition)) \

			{ SerialiserPanic(panic, NULL, NULL, __LINE__, api, opcode, pcount); }

#endif

void SerialiserPanic(TSerialiserPanic aPanicCode, char* aCondition, char* aFile, TInt aLine, TInt32 aApiUid, TInt32 aOpcode, TInt32 aParamCount)

	{

	if (aCondition && aFile)

		{

		RDebug::Printf("Vghw Serialiser Panic %d for failed Assert (%s), at %s:%d", aPanicCode, aCondition, aFile, aLine);

		}

	else

		{  

		RDebug::Printf("Vghw Serialiser Panic %d for failed Assert (line %d)", aPanicCode, aLine);

		}

	switch (aApiUid)

		{

		case SERIALISED_EGL_API_UID:

			RDebug::Printf("Api=SERIALISED_EGL_API_UID, aOpcode=%d, ParamCount=%d", aOpcode, aParamCount);

			break;

		case SERIALISED_OPENGLES_1_1_API_UID:

			RDebug::Printf("Api=SERIALISED_OPENGLES_1_1_API_UID, aOpcode=%d, ParamCount=%d", aOpcode, aParamCount);

			break;

		case SERIALISED_OPENVG_API_UID:

			RDebug::Printf("Api=SERIALISED_OPENVG_API_UID, aOpcode=%d, ParamCount=%d", aOpcode, aParamCount);

			break;

		default:

			RDebug::Printf("Api=%d, aOpcode=%d, ParamCount=%d", aApiUid, aOpcode, aParamCount);

			break;

		}

	User::Panic(KSerialiserPanicCategory, aPanicCode);

	}

#endif

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

// 

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

//

TUint32 RemoteFunctionCallData::TSimpleParam::Size() const

	{

	TUint32 size(0);

    size += sizeof( iDataType );

    size += sizeof( iDataTypeSize );

    size += iDataTypeSize;

	return size;

	}

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

// 

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

//

TUint32 RemoteFunctionCallData::TVectorParam::Size( TParamDirection aDir, TOperationType aOpType, TInt aIndexToAlign ) const

    {

    TUint32 size(0);

    size += sizeof( iDataType );

    size += sizeof( iVectorLength );

    size += sizeof( iCallerAddress );

    size += sizeof( iDataTypeSize );

    size += sizeof( iDataTypeAlignment );

    if ( ( (aDir & EIn) && ( EOpRequestWithReply == aOpType || EOpRequest == aOpType ) ) 

            ||

         ( ( aDir & EOut ) && aOpType == EOpReply ) 

        )

        {            

        if ( iVectorLength )

            {

            TInt aNewIndex = RemoteFunctionCallData::AlignIndex( aIndexToAlign + size, iDataTypeAlignment );

            size += aNewIndex - ( aIndexToAlign + size );

            }

        size += iDataTypeSize*iVectorLength;

        }

    return size;

    }

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

// 

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

//

TUint32 RemoteFunctionCallData::TParam::Size( TOperationType aOpType, TInt aIndexToAlign ) const

    {

	TUint32 size(0);

    size += sizeof( iDir );

    size += sizeof( iType );

    if ( TParam::ESimple == iType )

        {

        size += iSimpleParam.Size();

        }

    else if ( TParam::EVector == iType )

        {

        size += iVectorParam.Size( iDir, aOpType, aIndexToAlign + size );

        }

	return size;

    }

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

// 

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

//

SER_EXPORT_C void RemoteFunctionCallData::CopyData( TUint8* aDest, const TUint8* aSource, TInt32 aSize )

    {

    memcpy( aDest, aSource, aSize );

    }

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

// 

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

//

SER_EXPORT_C TInt RemoteFunctionCallData::AlignIndex( TInt aIndex, const TInt32 aAlignment )

    {

    const TInt remainder = aIndex % aAlignment;

    if ( remainder )

        {

        aIndex += aAlignment - remainder;

        }

    return aIndex;    

    }

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

// 

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

//

SER_EXPORT_C TUint32 RemoteFunctionCallData::SerialisedLength() const

    {

    TUint32 size(0);

    size += sizeof( iHeader.iOpCode );

    size += sizeof( iHeader.iTransactionId );

    size += sizeof( iHeader.iProcessId );

    size += sizeof( iHeader.iThreadId );

    size += sizeof( iHeader.iParameterCount );

    size += sizeof( iHeader.iOpType );

    size += sizeof( iHeader.iReturnValue );

    size += sizeof( iHeader.iApiUid );

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

        {

        size += iParameters[i].Size( (RemoteFunctionCallData::TOperationType)iHeader.iOpType, size );

        }

    return size;

    }

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

// 

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

//

SER_EXPORT_C void RemoteFunctionCallData::SetThreadInformation( const TUint32 aProcessId, const TUint32 aThreadId )

    { 

    iHeader.iProcessId = aProcessId; iHeader.iThreadId = aThreadId; 

    }

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

// 

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

//

SER_EXPORT_C void RemoteFunctionCallData::SetTransactionId( TUint32 aTransactionId )

    { 

    iHeader.iTransactionId = aTransactionId; 

    }

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

// 

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

//

SER_EXPORT_C void RemoteFunctionCallData::SetOperationType( TInt32 aOpType )

    { 

    iHeader.iOpType = aOpType; 

    }

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

// 

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

//

SER_EXPORT_C void RemoteFunctionCallData::SetReturnValue( TUint32 aRetVal )

    { 

    iHeader.iReturnValue = aRetVal; 

    }

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

// 

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

//

SER_EXPORT_C const RemoteFunctionCallData::THeader& RemoteFunctionCallData::Header() const 

    { 

    return iHeader; 

    }

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

// 

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

//

SER_EXPORT_C TInt RemoteFunctionCallData::ParameterCount()

    { 

    return iHeader.iParameterCount; 

    }

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

// 

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

//

SER_EXPORT_C RemoteFunctionCallData::TParam* RemoteFunctionCallData::Parameters()

    { 

    return iParameters; 

    }

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

// 

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

//

RemoteFunctionCallData::THeader& RemoteFunctionCallData::HeaderData()

    { 

    return iHeader; 

    }

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

// 

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

//

SER_EXPORT_C void RemoteFunctionCallData::GetVectorData( TInt32 aParamType, void** aData, TInt& aSize, TInt aIndex )

    {

    ASSERT( iParameters[aIndex].iVectorParam.iDataType == aParamType );

    ASSERT( aIndex < iHeader.iParameterCount );

    *aData = (void*)iParameters[aIndex].iVectorParam.iData;

    aSize = iParameters[aIndex].iVectorParam.iVectorLength;

    }

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

// 

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

//

SER_EXPORT_C void RemoteFunctionCallData::GetParamValue( TInt32 aParamType, TUint8* aData, TInt aIndex )

    {

    ASSERT( iParameters[aIndex].iSimpleParam.iDataType == aParamType );

    ASSERT( aIndex < iHeader.iParameterCount );

    RemoteFunctionCallData::CopyData( aData, (TUint8*)&iParameters[aIndex].iSimpleParam.iData, iParameters[aIndex].iSimpleParam.iDataTypeSize );

    }

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

// 

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

//

SER_EXPORT_C void RemoteFunctionCall::Init( TInt32 aOpCode, RemoteFunctionCallData::TOperationType aOpType )

    {

    iData.iHeader.iOpCode = aOpCode;

    iData.iHeader.iParameterCount = 0;

    iData.iHeader.iTransactionId = 0;

    iData.iHeader.iOpType = aOpType;

    iData.iHeader.iProcessId = 0;

    iData.iHeader.iThreadId = 0;

    iData.iHeader.iApiUid = GetAPIUid();

    }

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

// 

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

//

SER_EXPORT_C RemoteFunctionCall::RemoteFunctionCall( RemoteFunctionCallData& aData ):

    iData( aData )

    {

    }

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

// 

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

//

SER_EXPORT_C void RemoteFunctionCall::SetVectorData( TInt32 aParamType, const TUint8* aData, TInt aLength, TInt aIndex )

	{

	ASSERT( iData.iParameters[aIndex].iVectorParam.iDataType == aParamType );

	ASSERT( aIndex < iData.iHeader.iParameterCount );

	ASSERT( static_cast<TUint32>(aLength) <= iData.iParameters[aIndex].iVectorParam.iVectorLength );

	ASSERT( RemoteFunctionCallData::EIn != iData.iParameters[aIndex].iDir );

	iData.iParameters[aIndex].iVectorParam.iData = aData;

	iData.iParameters[aIndex].iVectorParam.iVectorLength = aLength;

	}

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

// 

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

//

SER_EXPORT_C void RemoteFunctionCall::SetParamData( TInt32 aParamType, const TUint8* aData, TInt aIndex )

    {

    ASSERT( iData.iParameters[aIndex].iSimpleParam.iDataType == aParamType );

    ASSERT( aIndex < iData.iHeader.iParameterCount );

    ASSERT( RemoteFunctionCallData::EIn != iData.iParameters[aIndex].iDir );

    RemoteFunctionCallData::CopyData( (TUint8*)&iData.iParameters[aIndex].iSimpleParam.iData, aData, iData.iParameters[aIndex].iSimpleParam.iDataTypeSize );    

    }

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

// 

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

//

SER_EXPORT_C void RemoteFunctionCall::AppendParam( TInt32 aParamType, const TUint8* aData, RemoteFunctionCallData::TParamDirection aDir )

    {

#ifdef USE_SYMBIAN_CLIENT_PANICS

	VGSERPANIC_ASSERT( iData.iHeader.iParameterCount < RemoteFunctionCallData::KMaxParameterCount,

		ESerPanicMaxParamCountExceeded, iData.iHeader.iApiUid, iData.iHeader.iOpCode, iData.iHeader.iParameterCount);

	VGSERPANIC_ASSERT( (RemoteFunctionCallData::EIn == aDir) || (iData.iHeader.iOpCode != RemoteFunctionCallData::EOpRequest),

		ESerPanicRequestOperationHasOutParameter, iData.iHeader.iApiUid, iData.iHeader.iOpCode, iData.iHeader.iParameterCount);

#else

	ASSERT( iData.iHeader.iParameterCount < RemoteFunctionCallData::KMaxParameterCount );

#endif

	RemoteFunctionCallData::TParam param;

    param.iType = RemoteFunctionCallData::TParam::ESimple;

    param.iDir = aDir;

    param.iSimpleParam.iDataType = aParamType;

    param.iSimpleParam.iDataTypeSize = GetTypeSize( param.iSimpleParam.iDataType );

    RemoteFunctionCallData::CopyData( (TUint8*)&param.iSimpleParam.iData, aData, param.iSimpleParam.iDataTypeSize );

    iData.iParameters[iData.iHeader.iParameterCount] = param;

    iData.iHeader.iParameterCount++;

    }

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

// 

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

//

SER_EXPORT_C void RemoteFunctionCall::AppendVector( TInt32 aParamType, TUint32 aLength, const TUint8* aData, RemoteFunctionCallData::TParamDirection aDir )

    {        

#ifdef USE_SYMBIAN_CLIENT_PANICS

	VGSERPANIC_ASSERT( iData.iHeader.iParameterCount < RemoteFunctionCallData::KMaxParameterCount,

		ESerPanicMaxParamCountExceeded, iData.iHeader.iApiUid, iData.iHeader.iOpCode, iData.iHeader.iParameterCount);

	VGSERPANIC_ASSERT( (aLength & 0x80000000) == 0,

		ESerPanicVectorSizeIsNegative, iData.iHeader.iApiUid, iData.iHeader.iOpCode, iData.iHeader.iParameterCount);

#else

	ASSERT( iData.iHeader.iParameterCount < RemoteFunctionCallData::KMaxParameterCount );

    ASSERT( (RemoteFunctionCallData::EIn == aDir) || (iData.iHeader.iOpCode != RemoteFunctionCallData::EOpRequest) );

#endif

	RemoteFunctionCallData::TParam param;

    param.iType = RemoteFunctionCallData::TParam::EVector;

    param.iDir = aDir;

    param.iVectorParam.iDataType = aParamType;

    param.iVectorParam.iData = aData;

    param.iVectorParam.iDataTypeSize = GetTypeSize( aParamType );

    param.iVectorParam.iDataTypeAlignment = GetTypeAlignment( aParamType );

	if ( aData )

		{

		param.iVectorParam.iVectorLength = aLength;

		}

	else

		{

#ifdef USE_SYMBIAN_CLIENT_PANICS

		VGSERPANIC_ASSERT( (aLength == 0) || (aDir != RemoteFunctionCallData::EIn),

				ESerPanicVectorPtrIsNull, iData.iHeader.iApiUid, iData.iHeader.iOpCode, iData.iHeader.iParameterCount);

#endif

		param.iVectorParam.iVectorLength = 0;

		}

    if ( RemoteFunctionCallData::EOut & aDir )

        {

#ifdef USE_SYMBIAN_CLIENT_PANICS

		VGSERPANIC_ASSERT( iData.iHeader.iOpCode != RemoteFunctionCallData::EOpRequest,

				ESerPanicRequestOperationHasOutParameter, iData.iHeader.iApiUid, iData.iHeader.iOpCode, iData.iHeader.iParameterCount);

#endif

        param.iVectorParam.iCallerAddress = const_cast<TUint8*>( aData );

        }

    else

        {

        param.iVectorParam.iCallerAddress = NULL;

        }

    iData.iParameters[iData.iHeader.iParameterCount] = param;

    iData.iHeader.iParameterCount++;

    }

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

// 

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

//

SER_EXPORT_C RemoteFunctionCallData& RemoteFunctionCall::Data()

    {

    return iData;

    }

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

// 

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

//

SER_EXPORT_C TUint32 RemoteFunctionCall::ReturnValue()

    {

    return iData.Header().iReturnValue;

    }

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

// 

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

//

SER_EXPORT_C void RemoteFunctionCall::SetReturnValue( TUint32 aRetValue )

    {

    iData.SetReturnValue( aRetValue );

    }