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

//

#include <f32file.h>

#include <bautils.h>

#include <mtp/cmtpdataproviderplugin.h>

#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/tmtptyperequest.h>

#include "cmtpconnection.h"

#include "cmtpconnectionmgr.h"

#include "cmtpsendobjectinfo.h"

#include "mtpdppanic.h"

#include "cmtpfsexclusionmgr.h"

#include "cmtpdataprovidercontroller.h"

#include "cmtpdataprovider.h"

// Class constants.

__FLOG_STMT(_LIT8(KComponent,"SendObjectInfo");)

/**

Verification data for the SendObjectInfo request

*/

const TMTPRequestElementInfo KMTPSendObjectInfoPolicy[] = 

    {

        {TMTPTypeRequest::ERequestParameter1, EMTPElementTypeStorageId, EMTPElementAttrWrite, 1, 0, 0},                

        {TMTPTypeRequest::ERequestParameter2, EMTPElementTypeObjectHandle, EMTPElementAttrDir, 2, KMTPHandleAll, KMTPHandleNone}

    };

/**

Two-phase construction method

@param aFramework  The data provider framework

@param aConnection The connection from which the request comes

@return a pointer to the created request processor object

*/ 

EXPORT_C MMTPRequestProcessor* CMTPSendObjectInfo::NewL(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection)

    {

    CMTPSendObjectInfo* self = new (ELeave) CMTPSendObjectInfo(aFramework, aConnection);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/**

Destructor

*/    

EXPORT_C CMTPSendObjectInfo::~CMTPSendObjectInfo()

    {

    __FLOG(_L8("~CMTPSendObjectInfo - Entry"));

    if ((iProgress == EObjectInfoSucceed ||

        iProgress == EObjectInfoFail || 

        iProgress == EObjectInfoInProgress) && !iNoRollback)

        {

        // Not finished SendObjectInfo/PropList SendObject pair detected.

        Rollback();

        }

    iDpSingletons.Close();

    delete iDateMod;

    delete iFileReceived;

    delete iParentSuid;    

    delete iReceivedObject;

    delete iObjectInfo;

    delete iObjectPropList;

    iSingletons.Close();

    __FLOG(_L8("~CMTPSendObjectInfo - Exit"));

    __FLOG_CLOSE; 

    }

/**

Standard c++ constructor

@param aFramework    The data provider framework

@param aConnection    The connection from which the request comes

*/    

CMTPSendObjectInfo::CMTPSendObjectInfo(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection) :

    CMTPRequestProcessor(aFramework, aConnection, 0, NULL)

    {

    }

/**

Verify the request

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

*/    

TMTPResponseCode CMTPSendObjectInfo::CheckRequestL()

    {

    __FLOG(_L8("CheckRequestL - Entry"));

    TMTPResponseCode result = CheckSendingStateL();

    if (result != EMTPRespCodeOK) 

        {

        return result;

        }

    if (iProgress == EObjectNone)    //this is the SendObjectInfo phase

        {

        iElementCount = sizeof(KMTPSendObjectInfoPolicy) / sizeof(TMTPRequestElementInfo);

        iElements = KMTPSendObjectInfoPolicy;            

        }

    else if (iProgress == EObjectInfoSucceed)

        {

        iElementCount = 0;

        iElements = NULL;

        }

    //coverity[var_deref_model]

	result = CMTPRequestProcessor::CheckRequestL();     	

    if (EMTPRespCodeOK == result)

        {

        result = MatchStoreAndParentL();

        }

    if (result == EMTPRespCodeOK && iOperationCode == EMTPOpCodeSendObjectPropList)

        {

        TMTPFormatCode formatCode = static_cast<TMTPFormatCode>(Request().Uint32(TMTPTypeRequest::ERequestParameter3));

        if (!iDpSingletons.ExclusionMgrL().IsFormatValid(formatCode))

            {

            result = EMTPRespCodeInvalidObjectFormatCode;

            }

        else

            {

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

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

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

            if (iStorageId == KMTPStorageDefault)

                {

                iStorageId = iFramework.StorageMgr().DefaultStorageId();

                }

            iObjectSize = MAKE_TUINT64(objectSizeHigh, objectSizeLow);

            if (IsTooLarge(iObjectSize))

                {

                result = EMTPRespCodeObjectTooLarge;            

                }

            //File size is limited to KMaxTInt64 that is 8ExaBytes

            //if the object size is more,then report this error.

            if (!CanStoreFileL(iStorageId, iObjectSize)||(iObjectSize > (KMaxTInt64)))

                {

                result = EMTPRespCodeStoreFull;

                }

            }

        }

    // If the previous request is not SendObjectInfo or SendObjectPropList, SendObject fails

    if (result == EMTPRespCodeOK && iOperationCode == EMTPOpCodeSendObject)

        {

        if (iPreviousTransactionID + 1 != Request().Uint32(TMTPTypeRequest::ERequestTransactionID))

            {

            result = EMTPRespCodeNoValidObjectInfo;

            }

        }

    __FLOG_VA((_L8("Result = 0x%04X"), result));

    __FLOG(_L8("CheckRequestL - Exit"));

    return result;    

    }

TBool CMTPSendObjectInfo::HasDataphase() const

    {

    return ETrue;

    }

/**

SendObjectInfo/SendObject request handler

NOTE: SendObjectInfo has to be comes before SendObject requests.  To maintain the state information

between the two requests, the two requests are combined together in one request processor.

*/    

void CMTPSendObjectInfo::ServiceL()

    {

    __FLOG(_L8("ServiceL - Entry"));

    if (iProgress == EObjectNone)

        {

        iIsFolder = EFalse;

        if (iOperationCode == EMTPOpCodeSendObjectInfo)

            {

            ServiceSendObjectInfoL();

            }

        else

            {

            ServiceSendObjectPropListL();

            }

        }

    else

        {

        ServiceSendObjectL();

        }    

    __FLOG(_L8("ServiceL - Exit"));

    }

/**

Second-phase construction

*/        

void CMTPSendObjectInfo::ConstructL()

    {

    __FLOG_OPEN(KMTPSubsystem, KComponent);

    __FLOG(_L8("ConstructL - Entry")); 

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

    iReceivedObject = CMTPObjectMetaData::NewL();

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

    iDpSingletons.OpenL(iFramework);

    iNoRollback = EFalse;

    iSingletons.OpenL();

    __FLOG(_L8("ConstructL - Exit"));

    }

/**

Override to match both the SendObjectInfo 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 CMTPSendObjectInfo::Match(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection) const

    {

    __FLOG(_L8("Match - Entry"));

    TBool result = EFalse;

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

    if ((operationCode == EMTPOpCodeSendObjectInfo || 

        operationCode == EMTPOpCodeSendObject ||

        operationCode == EMTPOpCodeSendObjectPropList) &&

        &iConnection == &aConnection)

        {

        result = ETrue;

        }

    __FLOG(_L8("Match - Exit"));

    return result;    

    }

/**

Override to handle the response phase of SendObjectInfo and SendObject requests

@return EFalse

*/

TBool CMTPSendObjectInfo::DoHandleResponsePhaseL()

    {

    __FLOG(_L8("DoHandleResponsePhaseL - Entry"));

    //to check if the sending/receiving data is successful

    TBool successful = !iCancelled;

    if (iProgress == EObjectInfoInProgress)

        {

        if (iOperationCode == EMTPOpCodeSendObjectInfo)

            {            

            successful = DoHandleSendObjectInfoCompleteL();

            }

        else

            {

            successful = DoHandleSendObjectPropListCompleteL();

            }

        iProgress = (successful ? EObjectInfoSucceed : EObjectInfoFail);

        if(iIsFolder && iProgress == EObjectInfoSucceed)

			{

			iProgress = EObjectNone;

			}

        }

    else if (iProgress == ESendObjectInProgress)

        {

        successful = DoHandleSendObjectCompleteL();

        iProgress = (successful ? ESendObjectSucceed : ESendObjectFail);

        }

    __FLOG(_L8("DoHandleResponsePhaseL - Exit"));

    return EFalse;

    }

/**

Override to handle the completing phase of SendObjectInfo and SendObject requests

@return ETrue if succesfully received the file, otherwise EFalse

*/    

TBool CMTPSendObjectInfo::DoHandleCompletingPhaseL()

    {

    __FLOG(_L8("DoHandleCompletingPhaseL - Entry"));

    TBool result = ETrue;

    CMTPRequestProcessor::DoHandleCompletingPhaseL();

    if (iProgress == EObjectInfoSucceed)

        {

        if (iOperationCode == EMTPOpCodeSendObjectInfo || iOperationCode == EMTPOpCodeSendObjectPropList)

            {

            iPreviousTransactionID = Request().Uint32(TMTPTypeRequest::ERequestTransactionID);

            }

        result = EFalse;

        }

    else if (iProgress == ESendObjectFail)

        {

        if (iOperationCode == EMTPOpCodeSendObject)

            {

            iPreviousTransactionID++;

            }

        iProgress = EObjectInfoSucceed;

        result = EFalse;

        }

    __FLOG(_L8("DoHandleCompletingPhaseL - Exit"));

    return result;    

    }

/**

Verify if the SendObject request comes after SendObjectInfo request

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

EMTPRespCodeNoValidObjectInfo

*/

TMTPResponseCode CMTPSendObjectInfo::CheckSendingStateL()

    {

    __FLOG(_L8("CheckSendingState - Entry"));

    TMTPResponseCode result = 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);

       	}        

    if (iProgress == EObjectNone)

        {

        if (iOperationCode == EMTPOpCodeSendObject)

            {

            result = EMTPRespCodeNoValidObjectInfo;

            }        

        }

    else if (iProgress == EObjectInfoSucceed) 

        {

        if (iOperationCode == EMTPOpCodeSendObjectInfo || iOperationCode == EMTPOpCodeSendObjectPropList)

            {

            //SendObjectInfo/SendObjectPropList sending the folder over which not necessarily

            //being followed by SendObject as per MTP Specification in which case we need unregister RouteRequest of 

            //SendObject made by previous SendObjectInfo/SendObjectPropList transaction without SendObject being followed.

            if( iIsFolder )

            	{

            	iFramework.RouteRequestUnregisterL(iExpectedSendObjectRequest, iConnection);

        		}

            delete iObjectInfo;

            iObjectInfo = NULL;

            delete iObjectPropList;

            iObjectPropList = NULL;

            iProgress = EObjectNone;

            }

        }

    else 

        {

        Panic(EMTPDpSendObjectStateInvalid);

        }

    __FLOG(_L8("CheckSendingState - Exit"));

    return result;    

    }

/**

SendObjectInfo request handler

*/

void CMTPSendObjectInfo::ServiceSendObjectInfoL()

    {

    __FLOG(_L8("ServiceSendObjectInfoL - Entry"));

    delete iObjectInfo;

    iObjectInfo = NULL;

    iObjectInfo = CMTPTypeObjectInfo::NewL();

    iCancelled = EFalse;

    ReceiveDataL(*iObjectInfo);

    iProgress = EObjectInfoInProgress;

    __FLOG(_L8("ServiceSendObjectInfoL - Exit"));

    }

/**

SendObjectPropList request handler

*/

void CMTPSendObjectInfo::ServiceSendObjectPropListL()

    {

    __FLOG(_L8("ServiceSendObjectPropListL - Entry"));

    delete iObjectPropList;

    iObjectPropList = NULL;

    iObjectPropList = CMTPTypeObjectPropList::NewL();

    iCancelled = EFalse;

    iReceivedObject->SetUint(CMTPObjectMetaData::EFormatCode, iRequest->Uint32(TMTPTypeRequest::ERequestParameter3));

    ReceiveDataL(*iObjectPropList);

    iProgress = EObjectInfoInProgress;

    __FLOG(_L8("ServiceSendObjectPropListL - Exit"));

    }

/**

SendObject request handler

*/    

void CMTPSendObjectInfo::ServiceSendObjectL()

    {

    __FLOG(_L8("ServiceSendObjectL - Entry"));

    if (iIsFolder)

        {

        // A generic folder doesn't have anything interesting during its data phase

        ReceiveDataL(iNullObject);

        }

    else    

        {        

        ReceiveDataL(*iFileReceived);

        }

    iProgress = ESendObjectInProgress;

    __FLOG(_L8("ServiceSendObjectL - Exit"));

    }

/**

Get a default parent object, if the request does not specify a parent object.

*/

void CMTPSendObjectInfo::GetDefaultParentObjectL()

    {    

    __FLOG(_L8("GetDefaultParentObjectL - Entry"));

    if (iStorageId == KMTPStorageDefault)

        {

        iStorageId = iFramework.StorageMgr().DefaultStorageId();

        }

    TInt drive(iFramework.StorageMgr().DriveNumber(iStorageId));

    User::LeaveIfError(drive);

    // Obtain the root of the drive.  Logical storages can sometimes have a filesystem root

    // other than <drive>:\ .  For example an MP3 DP might have a root of c:\media\music\

    // The DevDP needs to be aware of this when handling associations (folders) so they are

    // created in the correct location on the filesystem.

    delete iParentSuid;

    iParentSuid = NULL;

    iParentSuid=(iFramework.StorageMgr().StorageL(iStorageId).DesC(CMTPStorageMetaData::EStorageSuid)).AllocL();

    iReceivedObject->SetUint(CMTPObjectMetaData::EParentHandle, KMTPHandleNoParent);

    __FLOG(_L8("GetDefaultParentObjectL - Exit"));        

    }

/**

Get parent object and storage id

@return EMTPRespCodeOK if successful, otherwise, EMTPRespCodeInvalidParentObject

*/

TMTPResponseCode CMTPSendObjectInfo::GetParentObjectAndStorageIdL()

    {

    __FLOG(_L8("GetParentObjectAndStorageIdL - Entry"));    

    __ASSERT_DEBUG(iRequestChecker, Panic(EMTPDpRequestCheckNull));

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

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

    //does not take ownership

    CMTPObjectMetaData* parentObjectInfo = iRequestChecker->GetObjectInfo(iParentHandle);

    if (!parentObjectInfo)

        {

        GetDefaultParentObjectL();    

        }

    else

        {        

        delete iParentSuid;

        iParentSuid = NULL;

        iParentSuid = parentObjectInfo->DesC(CMTPObjectMetaData::ESuid).AllocL();

        iReceivedObject->SetUint(CMTPObjectMetaData::EParentHandle, iParentHandle);

        }

    __FLOG_VA((_L8("iParentSuid = %S"), iParentSuid));

    __FLOG(_L8("GetParentObjectAndStorageIdL - Exit"));    

    return EMTPRespCodeOK;

    }

/**

Handling the completing phase of SendObjectInfo request

@return ETrue if the specified object can be saved on the specified location, otherwise, EFalse

*/    

TBool CMTPSendObjectInfo::DoHandleSendObjectInfoCompleteL()

    {

    __FLOG(_L8("DoHandleSendObjectInfoCompleteL - Entry"));    

    TBool result(ETrue);

    TUint16 format(iObjectInfo->Uint16L(CMTPTypeObjectInfo::EObjectFormat));

    result = iDpSingletons.ExclusionMgrL().IsFormatValid(TMTPFormatCode(format));

    if (result)

        {

        __FLOG_VA((_L8("ASSOCIATION TYPE IS: %X"), iObjectInfo->Uint16L(CMTPTypeObjectInfo::EAssociationType)));        

		if(format == EMTPFormatCodeAssociation)

			{

			if((iObjectInfo->Uint16L(CMTPTypeObjectInfo::EAssociationType) == EMTPAssociationTypeGenericFolder) ||

        		      (iObjectInfo->Uint16L(CMTPTypeObjectInfo::EAssociationType) == EMTPAssociationTypeUndefined))

				iIsFolder = ETrue;

			else{

				SendResponseL(EMTPRespCodeInvalidDataset);

	            result = EFalse;	

				}

			}

        delete iDateMod;

        iDateMod = NULL;

        iDateMod = iObjectInfo->StringCharsL(CMTPTypeObjectInfo::EDateModified).AllocL();

        TMTPResponseCode responseCode(GetParentObjectAndStorageIdL());

        if (responseCode != EMTPRespCodeOK)

            {

            SendResponseL(responseCode);

            result = EFalse;

            }

        }

    else

        {

        SendResponseL(EMTPRespCodeInvalidObjectFormatCode);

        }

    if (result)

        {

        iObjectSize = iObjectInfo->Uint32L(CMTPTypeObjectInfo::EObjectCompressedSize);

        if (IsTooLarge(iObjectSize))

            {

            SendResponseL(EMTPRespCodeObjectTooLarge);