// Copyright (c) 2008-2009 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:

// mw/remoteconn/mtpfws/mtpfw/dataproviders/dputility/src/cmtpsvccompoundprocessor.cpp

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/cmtpobjectmetadata.h>

#include <mtp/cmtptypefile.h>

#include <mtp/cmtptypeobjectinfo.h>

#include <mtp/cmtptypeobjectproplist.h>

#include <mtp/cmtptypestring.h>

#include <mtp/mmtpobjectmgr.h>

#include <mtp/mmtpstoragemgr.h>

#include <mtp/mtpprotocolconstants.h> 

#include <mtp/tmtptypeint128.h>

#include "cmtpsvccompoundprocessor.h"

#include "mmtpservicedataprovider.h"

#include "mmtpsvcobjecthandler.h"

#include "cmtpconnection.h"

#include "cmtpconnectionmgr.h"

#include "mtpsvcdpconst.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmtpsvccompoundprocessorTraces.h"

#endif

// Class constants.

EXPORT_C MMTPRequestProcessor* CMTPSvcCompoundProcessor::NewL(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection, MMTPServiceDataProvider& aDataProvider)

	{

	CMTPSvcCompoundProcessor* self = new (ELeave) CMTPSvcCompoundProcessor(aFramework, aConnection, aDataProvider);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CMTPSvcCompoundProcessor::~CMTPSvcCompoundProcessor()

	{

	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_CMTPSVCCOMPOUNDPROCESSOR_DES_ENTRY );

	delete iReceivedObjectMetaData;

	delete iObjectInfo;

	delete iObjectPropList;

	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_CMTPSVCCOMPOUNDPROCESSOR_DES_EXIT );

	}

CMTPSvcCompoundProcessor::CMTPSvcCompoundProcessor(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection, MMTPServiceDataProvider& aDataProvider) :

	CMTPRequestProcessor(aFramework, aConnection, 0, NULL),

	iDataProvider(aDataProvider), iState(EIdle), iIsCommited(EFalse), iIsRollBackHandlerObject(EFalse)

	{

	}

void CMTPSvcCompoundProcessor::ConstructL()

	{

	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_CONSTRUCTL_ENTRY );

	iExpectedSendObjectRequest.SetUint16(TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeSendObject);

	iReceivedObjectMetaData = CMTPObjectMetaData::NewL();

	iReceivedObjectMetaData->SetUint(CMTPObjectMetaData::EDataProviderId, iFramework.DataProviderId());

	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_CONSTRUCTL_EXIT );

	}

/**

Override to match both the SendObjectInfo/SendObjectPropList/UpdateObjectPropList and SendObject requests

@param aRequest    The request to match

@param aConnection The connection from which the request comes

@return ETrue if the processor can handle the request, otherwise EFalse

*/

TBool CMTPSvcCompoundProcessor::Match(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection) const

	{

	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_MATCH_ENTRY );

	TBool result = EFalse;

	TUint16 operationCode = aRequest.Uint16(TMTPTypeRequest::ERequestOperationCode);

	if ((&iConnection == &aConnection) && 

		(operationCode == EMTPOpCodeSendObjectInfo || 

		operationCode == EMTPOpCodeSendObject ||

		operationCode == EMTPOpCodeUpdateObjectPropList ||

		operationCode == EMTPOpCodeSendObjectPropList))

		{

		result = ETrue;

		}

	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_MATCH_EXIT );

	return result;

	}

TBool CMTPSvcCompoundProcessor::HasDataphase() const

	{

	return ETrue;

	}

/**

Verify the request

@return EMTPRespCodeOK if request is verified, otherwise one of the error response codes

*/

TMTPResponseCode CMTPSvcCompoundProcessor::CheckRequestL()

	{

	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTL_ENTRY );

	TMTPResponseCode responseCode = CMTPRequestProcessor::CheckRequestL();

	if (EMTPRespCodeOK == responseCode)

		{

		responseCode = CheckSendingStateL();

		if (EMTPRespCodeOK == responseCode)

			{

			responseCode = CheckRequestParametersL();

			}

		}

	OstTrace1( TRACE_NORMAL, CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTL, "Exit with code: 0x%04X", responseCode);

	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTL_EXIT );

	return responseCode;

	}

/**

Verify if the SendObject request comes after SendObjectInfo/SendObjectPropList request

@return EMTPRespCodeOK if SendObject request comes after a valid SendObjectInfo request, otherwise

EMTPRespCodeNoValidObjectInfo

*/

TMTPResponseCode CMTPSvcCompoundProcessor::CheckSendingStateL()

	{

	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_CHECKSENDINGSTATEL_ENTRY );

	TMTPResponseCode responseCode = EMTPRespCodeOK;

	iOperationCode = Request().Uint16(TMTPTypeRequest::ERequestOperationCode);

	if (iOperationCode == EMTPOpCodeSendObject)

		{

		//In ParseRouter everytime SendObject gets resolved then will be removed from Registry

		//Right away therefore we need reRegister it here again in case possible cancelRequest

		//Against this SendObject being raised.

		iExpectedSendObjectRequest.SetUint32(TMTPTypeRequest::ERequestSessionID, iSessionId);

		iFramework.RouteRequestRegisterL(iExpectedSendObjectRequest, iConnection);

		}

	switch (iState)

		{

		case EIdle:

			// Received an orphan SendObject

			if (iOperationCode == EMTPOpCodeSendObject)

				{

				responseCode = EMTPRespCodeNoValidObjectInfo;

				OstTrace0( TRACE_NORMAL, DUP1_CMTPSVCCOMPOUNDPROCESSOR_CHECKSENDINGSTATEL, "EIdle: Received an orphan SendObject request" );

				}

			break;

		case EObjectInfoSucceed:

			// If another SendObjectInfo or SendObjectPropList operation occurs before a SendObject

			// operation, the new ObjectInfo or ObjectPropList shall replace the previously held one. 

			// If this occurs, any storage or memory space reserved for the object described in the 

			// overwritten ObjectInfo or ObjectPropList dataset should be freed before overwriting and 

			// allocating the resources for the new data. 

			// Here is for the processor received another SendObjectInfo or SendObjectPropList 

			// before a SendObject or process SendObject failed,

			if (iOperationCode == EMTPOpCodeSendObjectInfo ||

				iOperationCode == EMTPOpCodeSendObjectPropList ||

				iOperationCode == EMTPOpCodeUpdateObjectPropList)

				{

				iFramework.RouteRequestUnregisterL(iExpectedSendObjectRequest, iConnection);

				if (!iIsCommited)

					{

					// Object Size != 0, need roll back all resource for the new SendInfo request

					CMTPSvcCompoundProcessor::RollBackObject(this);

					iFramework.ObjectMgr().UnreserveObjectHandleL(*iReceivedObjectMetaData);

					}

				delete iObjectInfo;

				iObjectInfo = NULL;

				delete iObjectPropList;

				iObjectPropList = NULL;

				delete iReceivedObjectMetaData;

				iReceivedObjectMetaData = NULL;

				iReceivedObjectMetaData = CMTPObjectMetaData::NewL();

				iReceivedObjectMetaData->SetUint(CMTPObjectMetaData::EDataProviderId, iFramework.DataProviderId());

				iObjectHandler = NULL;

				iState = EIdle;

				// Reset commit state to false

				iIsCommited = EFalse;

				OstTrace0( TRACE_NORMAL, DUP2_CMTPSVCCOMPOUNDPROCESSOR_CHECKSENDINGSTATEL, 

				        "EObjectInfoSucceed: Receive send obj info request again, return to EIdle" );

				}

			break;

		default:

		    OstTrace1( TRACE_ERROR, DUP3_CMTPSVCCOMPOUNDPROCESSOR_CHECKSENDINGSTATEL, "wrong iState %d", iState);

			User::Leave(KErrGeneral);

		}

	OstTraceExt2( TRACE_NORMAL, CMTPSVCCOMPOUNDPROCESSOR_CHECKSENDINGSTATEL, "Exit with code: 0x%04X, state: %u", (TUint32)responseCode, iState );

	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_CHECKSENDINGSTATEL_EXIT );

	return responseCode;

	}

/**

Validates the data type for a given property code.

@return EMTPRespCodeOK if the parent handle matches the store id, or another MTP response code if not

*/

TMTPResponseCode CMTPSvcCompoundProcessor::CheckRequestParametersL()

	{

	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTPARAMETERSL_ENTRY );

	TMTPResponseCode responseCode = EMTPRespCodeOK;

	switch (iOperationCode)

		{

		case EMTPOpCodeSendObject:

			{

			OstTrace0( TRACE_NORMAL, DUP1_CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTPARAMETERSL, 

			        "Check SendObject request parameters" );

			// Check SendObject's session ID

			if (iSessionId != iLastSessionID)

				{

				responseCode = EMTPRespCodeNoValidObjectInfo;

				}

			else if ((iLastTransactionID + 1) != iTransactionCode)

				{

				// Check SendObject's transaction ID

				responseCode = EMTPRespCodeInvalidTransactionID;

				}

			break;

			}

		case EMTPOpCodeSendObjectInfo:

			{

			OstTrace0( TRACE_NORMAL, DUP2_CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTPARAMETERSL, 

			        "Check SendObjectInfo request parameters" );

			responseCode = CheckStoreAndParent();

			break;

			}

		case EMTPOpCodeSendObjectPropList:

			{

			OstTrace0( TRACE_NORMAL, DUP3_CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTPARAMETERSL, 

			        "Check SendObjectPropList request parameters" );

			responseCode = CheckStoreAndParent();

			if (EMTPRespCodeOK == responseCode)

				{

				// SendObjectPropList need check format code and size in the request

				TUint32 objectSizeHigh = Request().Uint32(TMTPTypeRequest::ERequestParameter4);

				TUint32 objectSizeLow  = Request().Uint32(TMTPTypeRequest::ERequestParameter5);

				iObjectSize = MAKE_TUINT64(objectSizeHigh, objectSizeLow);

				iFormatCode = Request().Uint32(TMTPTypeRequest::ERequestParameter3);

				responseCode = CheckFmtAndSetHandler(iFormatCode);

				iReceivedObjectMetaData->SetUint(CMTPObjectMetaData::EFormatCode, iFormatCode);

				}

			break;

			}

		case EMTPOpCodeUpdateObjectPropList:

			{

			OstTrace0( TRACE_NORMAL, DUP4_CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTPARAMETERSL, 

			        "Check UpdateObjectPropList request parameters" );

			TUint32 objectHandle = Request().Uint32(TMTPTypeRequest::ERequestParameter1);

			if (objectHandle != KMTPHandleNone)

				{

				// Find the updating object information

				MMTPObjectMgr& objects(iFramework.ObjectMgr());

				if (objects.ObjectL(objectHandle, *iReceivedObjectMetaData))

					{

					iFormatCode = iReceivedObjectMetaData->Uint(CMTPObjectMetaData::EFormatCode);

					if (iReceivedObjectMetaData->Uint(CMTPObjectMetaData::EDataProviderId) != iFramework.DataProviderId())

						{

						responseCode = EMTPRespCodeInvalidObjectHandle;

						}

					else

						{

						responseCode = CheckFmtAndSetHandler(iFormatCode);

						}

					}

				else

					{

					responseCode = EMTPRespCodeInvalidObjectHandle;

					}

				}

			else

				{

				responseCode = EMTPRespCodeInvalidObjectHandle;

				}

			break;

			}

		default:

			// Unexpected operation code

			responseCode = EMTPRespCodeOperationNotSupported;

			break;

		}

	OstTrace1( TRACE_NORMAL, CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTPARAMETERSL, "exit with code: 0x%x", responseCode );

	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_CHECKREQUESTPARAMETERSL_EXIT );

	return responseCode;

	}

/**

Validates the data type for a given property code.

@return EMTPRespCodeOK if the parent handle matches the store id, or another MTP response code if not

*/

TMTPResponseCode CMTPSvcCompoundProcessor::CheckStoreAndParent()

	{

	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_CHECKSTOREANDPARENT_ENTRY );

	TMTPResponseCode responseCode = EMTPRespCodeOK;

	iStorageId = Request().Uint32(TMTPTypeRequest::ERequestParameter1);

	iParentHandle = Request().Uint32(TMTPTypeRequest::ERequestParameter2);

	// If the first parameter is unused, it should be set to 0x00000000, and the responder should decide

	// in which store to place the object

	if (iStorageId == KMTPStorageDefault)

		{

		// If the second parameter is used, the first parameter must also be used.

		// If the second parameter is unused, it should be set to 0x00000000

		if (iParentHandle != KMTPHandleNone)

			{

			responseCode = EMTPRespCodeInvalidParentObject;

			}

		else

			{

			// Set storage id as service dp's logical storage id.

			iStorageId = iDataProvider.StorageId();

			}

		}

	else

		{

		// Check logical storage id.

		if (iStorageId != iDataProvider.StorageId())

			{

			responseCode = EMTPRespCodeInvalidStorageID;

			}

		}

	OstTrace1( TRACE_NORMAL, CMTPSVCCOMPOUNDPROCESSOR_CHECKSTOREANDPARENT, "Exit with code: 0x%x", responseCode );

	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_CHECKSTOREANDPARENT_EXIT );

	return responseCode;

	}

/**

SendObjectInfo/SendObjectPropList/UpdateObjectPropList/SendObject request handler

To maintain the state information between the two requests, the two requests are 

combined together in one request processor.

*/

void CMTPSvcCompoundProcessor::ServiceL()

	{

	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_SERVICEL_ENTRY );

	switch (iState)

		{

		case EIdle:

			ServiceObjectPropertiesL();

			break;

		case EObjectInfoSucceed:

			ServiceSendObjectL();

			break;

		default:

			OstTrace0( TRACE_WARNING, CMTPSVCCOMPOUNDPROCESSOR_SERVICEL, "Wrong state in ServiceL" );

			break;

		}

	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_SERVICEL_EXIT );

	}

void CMTPSvcCompoundProcessor::ServiceObjectPropertiesL()

	{

	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_SERVICEOBJECTPROPERTIESL_ENTRY );

	switch (iOperationCode)

		{

		case EMTPOpCodeSendObjectInfo:

			ServiceSendObjectInfoL();

			break;

		case EMTPOpCodeSendObjectPropList:

		case EMTPOpCodeUpdateObjectPropList:

			ServiceSendObjectPropListL();

			break;

		default:

			break;

		}

	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_SERVICEOBJECTPROPERTIESL_EXIT );

	}

/**

SendObject request handler

*/

void CMTPSvcCompoundProcessor::ServiceSendObjectL()

	{

	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_SERVICESENDOBJECTL_ENTRY );

	MMTPSvcObjectHandler* pHandler = iDataProvider.ObjectHandler(iFormatCode);

	if (pHandler)

		{

		pHandler->GetBufferForSendObjectL(*iReceivedObjectMetaData, &iObjectContent);

		}

	else

		{

        OstTrace1( TRACE_ERROR, CMTPSVCCOMPOUNDPROCESSOR_SERVICESENDOBJECTL, 

                "can't get object handler for format code %d", iFormatCode);

		User::Leave(KErrGeneral);

		}

	ReceiveDataL(*iObjectContent);

	iState = EObjectSendProcessing;

	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_SERVICESENDOBJECTL_EXIT );

	}

/**

SendObjectInfo request handler

*/

void CMTPSvcCompoundProcessor::ServiceSendObjectInfoL()

	{

	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_SERVICESENDOBJECTINFOL_ENTRY );

	delete iObjectInfo;

	iObjectInfo = NULL;

	iObjectInfo = CMTPTypeObjectInfo::NewL();

	ReceiveDataL(*iObjectInfo);

	iState = EObjectInfoProcessing;

	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_SERVICESENDOBJECTINFOL_EXIT );

	}

/**

SendObjectPropList request handler

*/

void CMTPSvcCompoundProcessor::ServiceSendObjectPropListL()

	{

	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_SERVICESENDOBJECTPROPLISTL_ENTRY );

	delete iObjectPropList;

	iObjectPropList = NULL;

	iObjectPropList = CMTPTypeObjectPropList::NewL();

	ReceiveDataL(*iObjectPropList);

	iState = EObjectInfoProcessing;

	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_SERVICESENDOBJECTPROPLISTL_EXIT );

	}

/**

Override to handle the response phase of SendObjectInfo/SendObjectPropList and SendObject requests

@return EFalse

*/

TBool CMTPSvcCompoundProcessor::DoHandleResponsePhaseL()

	{

	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSEPHASEL_ENTRY );

	TBool successful = !iCancelled;

	switch (iState)

		{

		case EObjectInfoProcessing:

			{

			if (iOperationCode == EMTPOpCodeSendObjectInfo)

				{

				successful = DoHandleResponseSendObjectInfoL();

				}

			else if (iOperationCode == EMTPOpCodeSendObjectPropList)

				{

				successful = DoHandleResponseSendObjectPropListL();

				}

			else if (iOperationCode == EMTPOpCodeUpdateObjectPropList)

				{

				successful = DoHandleResponseUpdateObjectPropListL();

				}

			iState = (successful ? EObjectInfoSucceed : EIdle);

			break;

			}

		case EObjectSendProcessing:

			{

			successful = DoHandleResponseSendObjectL();

			iState = (successful ? EObjectSendSucceed : EObjectSendFail);

			break;

			}

		default:

			// Wrong State value.

			OstTrace1( TRACE_WARNING, CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSEPHASEL, 

			        "DoHandleResponsePhaseL enter an abnormal state %d", iState );

			break;

		}

	OstTraceFunctionExit0( CMTPSVCCOMPOUNDPROCESSOR_DOHANDLERESPONSEPHASEL_EXIT );

	return EFalse;

	}

/**

Override to handle the completing phase of SendObjectInfo/SendObjectPropList and SendObject requests

@return ETrue if succesfully received the object content, otherwise EFalse

*/

TBool CMTPSvcCompoundProcessor::DoHandleCompletingPhaseL()

	{

	OstTraceFunctionEntry0( CMTPSVCCOMPOUNDPROCESSOR_DOHANDLECOMPLETINGPHASEL_ENTRY );

	TBool result = ETrue;

	CMTPRequestProcessor::DoHandleCompletingPhaseL();

	OstTrace1( TRACE_WARNING, CMTPSVCCOMPOUNDPROCESSOR_DOHANDLECOMPLETINGPHASEL, 

	        "DoHandleCompletingPhaseL - Progress State: %u", iState );

	switch (iState)

		{

		case EObjectInfoSucceed:

			{

			// Two cases will come here:

			// 1. SendObjInfo OK, Store ID for next SendObject checking;

			// 2. SendObject check request fail, such as wrong transaction id or wrong session id.

			//    needn't change transaction id.

			if (iOperationCode == EMTPOpCodeSendObjectInfo || 

				iOperationCode == EMTPOpCodeUpdateObjectPropList ||

				iOperationCode == EMTPOpCodeSendObjectPropList)

				{

				// Reset transaction id for new SendObjInfo request, but ignore wrong SendObject.

				iLastTransactionID = iTransactionCode;

				iLastSessionID = iSessionId;

				iLastInfoOperationCode = iOperationCode;

				}

			result = EFalse;

			OstTraceExt2( TRACE_NORMAL, DUP1_CMTPSVCCOMPOUNDPROCESSOR_DOHANDLECOMPLETINGPHASEL, 

			        "EObjectInfoSucceed: Save send info transaction id: %u, operation: 0x%x", iLastTransactionID, iOperationCode );

			break;

			}

		case EObjectSendFail:

			{

			// When process SendObject fail, such as received size is wrong.

			iLastTransactionID++;

			iState = EObjectInfoSucceed;

			result = EFalse;

			break;

			}

		default:

			// The other cases will delete the processor: