// 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:

//

/**

 @file

 @internalComponent

*/

#include <mtp/cmtpdataproviderplugin.h>

#include <mtp/mtpprotocolconstants.h>

#include <mtp/tmtptypeevent.h>

#include <mtp/tmtptyperequest.h>

#include <mtp/tmtptypeuint32.h>

#include "cmtpconnection.h"

#include "cmtpconnectionmgr.h"

#include "cmtpdataprovider.h"

#include "cmtpparserrouter.h"

#include "cmtpsession.h"

#include "mmtptransportconnection.h"

#ifdef MTP_CAPTURE_TEST_DATA

#include "cmtprequestlogger.h"

#endif

#define UNUSED_VAR(a) (a) = (a)

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

/**

CMTPConnection panics

*/

_LIT(KMTPPanicCategory, "CMTPConnection");

enum TMTPPanicReasons

    {

    EMTPPanicBusy = 0,

    EMTPPanicInvalidSession = 1,

    EMTPPanicInvalidState = 2,

    EMTPPanicPublishEvent = 3,

    };

LOCAL_C void Panic(TInt aReason)

    {

    User::Panic(KMTPPanicCategory, aReason);

    }

/**

CMTPConnection factory method. A pointer to the new CMTPConnection instance is

placed on the cleanup stack.

@param aConnectionId The unique identifier assigned to this connection by the 

MTP framework. 

@param aTransportConnection The MTP transport layer connection interface to 

which the CMTPConnection will bind.

@return Pointer to the new CMTPConnection instance. Ownership IS transfered.

@leave One of the system wide error codes if a processing failure occurs.

*/

CMTPConnection* CMTPConnection::NewLC(TUint aConnectionId, MMTPTransportConnection& aTransportConnection)

    {

    CMTPConnection* self = new(ELeave) CMTPConnection(aConnectionId, aTransportConnection);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

/**

Destructor.

*/

CMTPConnection::~CMTPConnection()

    {

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

    CloseAllSessions();

    // Remove any events not associated 

    // with a session

    TSglQueIter<CMTPEventLink> iter(iEventQ);

    iter.SetToFirst();

    CMTPEventLink* link = NULL;

    while ((link = iter++) != NULL)

    	{

    	delete link;

    	}

    iSessions.ResetAndDestroy();

    //close the property

    iProperty.Close();

    // delete the ‘name?property

    RProcess process;

    RProperty::Delete(process.SecureId(), EMTPConnStateKey);

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

	__FLOG_CLOSE;

    }

/**

Initiates MTP transaction data phase processing for initiator-to-responder

data flows. This method should only be invoked when the MTP transaction phase 

state is ERequestPhase. This is an asynchronous method.

@param aData The MTP data object sink.

@param aRequest The MTP request dataset of the active MTP transaction.

@param aStatus The status used to return asynchronous completion 

information regarding the request.

@leave KErrNotFound If the MTP request dataset specifies an invalid SessionID.

@panic CMTPConnection 0 If an asynchronous request is already pending on the 

connection.

@panic CMTPConnection 2 If the MTP transaction phase is invalid.

*/

void CMTPConnection::ReceiveDataL(MMTPType& aData, const TMTPTypeRequest& aRequest, TRequestStatus& aStatus)

    {   

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

    iDataReceiveResult = KErrNone;

    const TUint KValidPhases(ERequestPhase);

    CMTPSession& session(SessionL(aRequest, TMTPTypeRequest::ERequestSessionID));

    if (ValidFrameworkRequest(&session, KValidPhases, &aStatus))

        {

        session.SetTransactionPhase(EDataIToRPhase);

        session.SetRequestPending(aStatus);

        if(EMTPTypeFile == aData.Type())

            {

            ValidateAndPublishConnState(session, State());

            }

        iTransportConnection->ReceiveDataL(aData, aRequest);      

        }

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

    }

/**

Initiates MTP transaction data phase processing for responder-to-initiator

data flows. This method should only be invoked when the MTP transaction phase

state is ERequestPhase. This is an asynchronous method.

@param aData The MTP data object source.

@param aRequest The MTP request dataset of the active MTP transaction.

@param aStatus The status used to return asynchronous completion 

information regarding the request.

@leave KErrNotFound If the MTP request dataset specifies an invalid SessionID.

@panic CMTPConnection 0 If an asynchronous request is already pending on the 

connection.

@panic CMTPConnection 2 If the MTP transaction phase is invalid.

*/

void CMTPConnection::SendDataL(const MMTPType& aData, const TMTPTypeRequest& aRequest, TRequestStatus& aStatus)

    {

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

#ifdef MTP_CAPTURE_TEST_DATA

    iRequestLogger->WriteDataPhaseL(aData, EDataRToIPhase);

#endif

    const TUint KValidPhases(ERequestPhase);

    CMTPSession& session(SessionL(aRequest, TMTPTypeRequest::ERequestSessionID));

    if (ValidFrameworkRequest(&session, KValidPhases, &aStatus))

        {

        session.SetTransactionPhase(EDataRToIPhase);

        session.SetRequestPending(aStatus);

        if(EMTPTypeFile == aData.Type())

            {

            //In this case we should validate the state based on transaction phase then

            //publish the connection state info to the subscriber.

            ValidateAndPublishConnState(session, State());

            }

        iTransportConnection->SendDataL(aData, aRequest);

        }

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

    }

/**

Sends an MTP event dataset.

@param aEvent The MTP event dataset source.

@leave KErrNotFound If the MTP event dataset specifies an invalid SessionID.

*/

void CMTPConnection::SendEventL(const TMTPTypeEvent& aEvent)

    {

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

    const TUint KValidPhases(EIdlePhase | ERequestPhase | EDataIToRPhase| EDataRToIPhase | EResponsePhase | ECompletingPhase);

    if (ValidFrameworkRequest(NULL, KValidPhases, NULL))

        {

        // Validate the SessionID

        TUint32 sessionId(aEvent.Uint32(TMTPTypeEvent::EEventSessionID));

        if (sessionId != KMTPSessionAll)

            {

            User::LeaveIfError(iSessions.FindInOrder(sessionId, SessionOrder));

            }

		EnqueueEvent(new (ELeave) CMTPEventLink(aEvent));

		if (iPendingEventCount == 1)

			{

			// Forward the event to the transport connection layer.

			iTransportConnection->SendEventL(iEventQ.First()->iEvent);			

			}

        }

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

    }

/**

Initiates MTP transaction response phase processing. This method should only 

be invoked when the MTP transaction phase state is either ERequestPhase, or 

EResponsePhase. This is an asynchronous method.

@param aResponse The MTP response dataset source.

@param aRequest The MTP request dataset of the active MTP transaction.

@param aStatus The status used to return asynchronous completion 

information regarding the request.

@leave KErrNotFound If the MTP response dataset specifies an invalid SessionID.

@leave KErrArgument If the MTP response dataset does not match the specified 

request dataset.

@panic CMTPConnection 0 If an asynchronous request is already pending on the 

connection.

@panic CMTPConnection 2 If the MTP transaction phase is invalid.

*/

void CMTPConnection::SendResponseL(const TMTPTypeResponse& aResponse, const TMTPTypeRequest& aRequest, TRequestStatus& aStatus)

    {

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

#ifdef MTP_CAPTURE_TEST_DATA

    // Running under debug capture mode save this request off to disk.

    iRequestLogger->LogResponseL(aResponse);

#endif

    const TUint KValidPhases(ERequestPhase | EResponsePhase );

    CMTPSession& session(SessionL(aResponse, TMTPTypeResponse::EResponseSessionID));

    if (ValidFrameworkRequest(&session, KValidPhases, &aStatus))

        {

        if ((aResponse.Uint32(TMTPTypeResponse::EResponseSessionID) != aRequest.Uint32(TMTPTypeRequest::ERequestSessionID)) ||

            (aResponse.Uint32(TMTPTypeResponse::EResponseTransactionID) != aRequest.Uint32(TMTPTypeRequest::ERequestTransactionID)))

            {

            /* 

            Request/Response mismatch by the originating data provider plug-in. 

            Fail the transport connection to avoid leaving the current 

            transaction irrecoverably hanging.

            */

            UnrecoverableMTPError();

            User::Leave(KErrArgument);                

            }

        if (session.TransactionPhase() == ERequestPhase)

            {

            // Transaction has no data phase.

            session.SetTransactionPhase(EResponsePhase);

            }

        session.SetRequestPending(aStatus);

        iTransportConnection->SendResponseL(aResponse, aRequest);

        }

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

    }

/**

Deletes the session object assigned to the specified session and notifies all 

loaded data providers.

@param aMTPId The session identifier assigned by the MTP connection 

initiator.

@leave KErrNotFound, if a session with the specified SessionMTPId is not 

found.

@leave One of the system wide error codes, if a general processing failure 

occurs.

*/

EXPORT_C void CMTPConnection::SessionClosedL(TUint32 aMTPId)

    {

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

    if(0x0FFFFFFF != aMTPId)

    	{

    	TInt idx(iSessions.FindInOrder(aMTPId, SessionOrder));

	    __ASSERT_DEBUG((idx != KErrNotFound), Panic(EMTPPanicInvalidSession));

	    CloseSession(idx);

	    }

    else

	    {

	    CMTPSession* session = NULL;

	    for(TInt i =0;i<iSessions.Count();i++)

		    {

		    session = iSessions[i];

		    TUint id(session->SessionMTPId());	

	    	if(0 != id)

		    	{

		    	SessionClosedL(id);	

		    	}

		    session = NULL;

		    }

	    }

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

    }

/**

Creates a new session object for the specified session and notifies all loaded

data providers. The session is known by two identifiers:

    1. SessionMTPId - Assigned by the MTP connection initiator and unique only 

        to the MTP connection on which the session was opened. In a multiple-

        connection configuration this identifier may not uniquely identify the 

        session.

    2. SessionUniqueId - Assigned by the MTP daemon and guaranteed to uniquely

        identify the session in a multiple-connection configuration.

Currently the MTP daemon does not support multiple-connection configuration 

and both identifiers are assigned the same value.

@param aMTPId The session identifier assigned by the MTP connection 

initiator.

@leave KErrAlreadyExists, if a session with the specified SessionMTPId is 

already open.

@leave One of the system wide error codes, if a general processing failure 

occurs.

*/

EXPORT_C void CMTPConnection::SessionOpenedL(TUint32 aMTPId)

    {

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

    // Validate the SessionID

    if (SessionWithMTPIdExists(aMTPId))

        {

        User::Leave(KErrAlreadyExists);            

        }

    // Create a new session object

    CMTPSession* session = CMTPSession::NewLC(aMTPId, aMTPId);

    session->SetTransactionPhase(EIdlePhase);

    iSessions.InsertInOrder(session, CMTPConnection::SessionOrder);

    CleanupStack::Pop(session); 

    if (aMTPId != KMTPSessionNone)

        {

        // Notify the data providers if other than the null session is closing.

        // OpenSession Command coming and now it is really connected to host.

        PublishConnState(EConnectedToHost);

        TMTPNotificationParamsSessionChange params = {aMTPId, *this};

        iSingletons.DpController().NotifyDataProvidersL(EMTPSessionOpened, &params);

        }

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

    }

/*

 * Signals the connection is suspended, the connection state is set to EStateShutdown which 

 * means that all the current transaction will not be able to send/receive any data via the

 * connection

 * @return ETrue - there is an active transaction currently, and Connection will suspend when it finishes

 * EFalse - No active transaction, connection suspends immediately.

 */

TBool CMTPConnection::ConnectionSuspended()

    {

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

    TBool ret = EFalse;

    TUint currentState = State();

    if (currentState != EStateShutdown)

        {

        if (ActiveSessions() == 0 || currentState == EStateErrorShutdown)

            {

            CompleteCloseConnection();

            ret = ETrue;

            }

        SetState(EStateShutdown);

        PublishConnState(EDisconnectedFromHost);   

        }

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

    return ret;

    }

void CMTPConnection::CompleteCloseConnection()

    {

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

    CloseAllSessions();

    iSessions.Reset();

	if (iTransportConnection != NULL)

		{

		iTransportConnection->Unbind(*this);

		}

    //notify ConnectionMgr and corresponding transports of completion of connection close

    iSingletons.ConnectionMgr().ConnectionCloseComplete(iConnectionId);    

    iSingletons.Close();

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

    }

/*

 * Signals that the connection is resumed to EStateOpen state which means that data providers

 * can receive requests from host again.

 * @aTransportConnection The new transport connection object

 * @leave One of the system wide error codes, if a processing failure occurs.

 */

void CMTPConnection::ConnectionResumedL(MMTPTransportConnection& aTransportConnection)

    {

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

    TUint currentState = State();

    if (currentState != EStateOpen && currentState != EStateErrorRecovery)

        {

        iSingletons.OpenL();

        /* 

        Create the null session object which owns the transaction state for 

        transaction occuring outside a session (i.e. with SessionID == 0x00000000)

        */

        SessionOpenedL(KMTPSessionNone);            

        iTransportConnection = &aTransportConnection;

        iTransportConnection->BindL(*this); 

        SetState(EStateOpen); 

        }

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

    }

/**

Signals the completion of the current transaction processing sequence. This

method should only be invoked when the MTP transaction phase state is 

ECompletingPhase.

@param aRequest The MTP request dataset of the completed MTP transaction.

@leave KErrNotFound If the MTP request dataset specifies an invalid SessionID.

@panic CMTPConnection 2 If the MTP transaction phase is invalid.

*/

void CMTPConnection::TransactionCompleteL(const TMTPTypeRequest& aRequest)

    {

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

    const TUint KValidPhases(ECompletingPhase);

    CMTPSession& session(SessionL(aRequest, TMTPTypeRequest::ERequestSessionID));    

    if (ValidFrameworkRequest(&session, KValidPhases, NULL))

        {

        session.SetTransactionPhase(EIdlePhase);

		if (iTransportConnection != NULL)

            {

            iTransportConnection->TransactionCompleteL(aRequest);

            }

        if (State() == EStateShutdown && ActiveSessions() == 0)

            {     

            CompleteCloseConnection();

            }

        }

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

    }

TUint CMTPConnection::ConnectionId() const

    {

    return iConnectionId;

    }

TUint CMTPConnection::SessionCount() const

    {

    return iSessions.Count();

    }

TBool CMTPConnection::SessionWithMTPIdExists(TUint32 aMTPId) const

    {

    return (iSessions.FindInOrder(aMTPId, SessionOrder) != KErrNotFound);

    }

MMTPSession& CMTPConnection::SessionWithMTPIdL(TUint32 aMTPId) const

    {

    TInt idx(iSessions.FindInOrder(aMTPId, SessionOrder));

    User::LeaveIfError(idx);

    return *iSessions[idx];

    }

TBool CMTPConnection::SessionWithUniqueIdExists(TUint32 aUniqueId) const

    {

    return SessionWithMTPIdExists(aUniqueId);

    }

MMTPSession& CMTPConnection::SessionWithUniqueIdL(TUint32 aUniqueId) const

    {

    return SessionWithMTPIdL(aUniqueId);

    }

void CMTPConnection::ReceivedEventL(const TMTPTypeEvent& aEvent)

    {  

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

    TInt idx(KErrNotFound);

    // Validate the SessionID.

    TUint32 sessionId(aEvent.Uint32(TMTPTypeEvent::EEventSessionID));

    if (sessionId != KMTPSessionAll)

        {

        idx = iSessions.FindInOrder(sessionId, SessionOrder);

        User::LeaveIfError(idx);

        }

    // Check that this event is valid.

    CMTPSession& session(*iSessions[idx]);

    TMTPTypeRequest request; 

    TRAPD( err, MMTPType::CopyL(session.ActiveRequestL(), request) );

    if( err == KErrNotFound  )

    	{

    	session.StorePendingEventL(aEvent);

    	}

    else

    	{

	   	if (request.Uint32(TMTPTypeRequest::ERequestTransactionID) > 

	    	aEvent.Uint32(TMTPTypeEvent::EEventTransactionID) )

	        {

	        // Event to be queued for future use, we can only queue one event at a time

	        session.StorePendingEventL(aEvent);

	        }

	    if (request.Uint32(TMTPTypeRequest::ERequestTransactionID) == 

	         aEvent.Uint32(TMTPTypeEvent::EEventTransactionID) )

	        {     

	        // Event is valid	     

	        // Perform transport layer processing.

	        if (aEvent.Uint16(TMTPTypeEvent::EEventCode) == EMTPEventCodeCancelTransaction)

	            {

	            if (sessionId == KMTPSessionAll)

	                {

	                const TUint noSessions = iSessions.Count();

	                for (TUint i(0); (i < noSessions); i++)