/*

* Copyright (c) 2005 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 <e32math.h>

#include <sipinvitedialogassoc.h>

#include <sipfromheader.h>

#include <siptoheader.h>

#include <sipcontenttypeheader.h>

#include <sipextensionheader.h>

#include <sipaddress.h>

#include <sipprofile.h>

#include <sipmessageelements.h>

#include <sipsupportedheader.h>

#include <siprequireheader.h>

#include <sdpdocument.h>

#include <siprseqheader.h>

#include "mceactionset.h"

#include "mcecssession.h"

#include "mcecssessionimplementation.h"

#include "mcecomsession.h"

#include "mcecomrtpsink.h"

#include "mcecomrtpsource.h"

#include "mcecomspeakersink.h"

#include "mcecomfilesource.h"

#include "mcecommicsource.h"

#include "mcesipsession.h"

#include "mcemediamanager.h"

#include "mcesipconnection.h"

#include "mcesipextensions.h"

#include "mcesip.h"

#include "mcesrvlogs.h"

#include "mcetimermanager.h"

#include "mcereliablesender.h"

#include "mcecomcamerasource.h"

const TInt KMaxLengthOfSDPMessage = 1000;

const TInt KMaxLengthOfSessionExpires = 40;

#define MCE_HANDLER_WRITE( aType, aData )\

    aType writeBuf( aData );\

    iWriteData->Copy( writeBuf );

#define MCE_HANDLER_READ_DATA( aCastType, aType, aData, aBuffer )\

    aCastType readBuf;\

    readBuf.Copy( *aBuffer );\

    aType aData = readBuf();

#define MCE_HANDLER_READ( aCastType, aType, aData )\

    MCE_HANDLER_READ_DATA( aCastType, aType, aData, iReadData )

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

// TMceActionSet::TMceActionSet

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

//

TMceActionSet::TMceActionSet( CMceSipSession& aSession )

  : iSession ( aSession )

	{

	}

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

// TMceActionSet::StateChanged

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

//

void TMceActionSet::StateChanged( TMceStateIndex aNewState )

    {    

    iSession.NextState( aNewState );

    //for long session, once session established, key updated need to be turn on

    if ( aNewState ==  KMceStateEstablished && 

    	ActiveBody().SecureSession())

    	{

    	if ( ActiveBody().SecureSession()->iCryptoContextUpdate )

    		{

    		ActiveBody().SecureSession()->iKeyNeedUpdated = ETrue; 	

    		}

    	else 

    		{

			ActiveBody().SecureSession()->iKeyNeedUpdated = EFalse;

			}    	

    	}

    }

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

// TMceActionSet::ClientStateChanged

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

//

void TMceActionSet::ClientStateChanged( TMceIds& aIds, 

                                        CMceSession::TState aNewState,

                                        TInt aStatus )

    {

    MCESRV_DEBUG("TMceActionSet::ClientStateChanged( sync ), Entry");

    MCESRV_DEBUG_CLISTATE("new state", aNewState );

    MCESRV_DEBUG_DVALUE("status", aStatus );

    ActiveBody().iState = aNewState;

	aIds.iState = aNewState;

	aIds.iStatus = aStatus;

    MCESRV_DEBUG("TMceActionSet::ClientStateChanged( sync ), Exit");

    }

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

// TMceActionSet::ClientStateChangedL

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

//

void TMceActionSet::ClientStateChangedL( CMceSession::TState aNewState, 

                                         TInt aReason )

    {

    MCESRV_DEBUG("TMceActionSet::ClientStateChanged, Entry");

    MCESRV_DEBUG_CLISTATE("new state", aNewState );

    if ( &ActiveBody() )

        {

        ActiveBody().iState = aNewState;

        }

    TMceIds ids;

    ids.iCallbackID = EMceItcStateChanged;

	ids.iState = aNewState;

    if ( aReason == KErrNone )

        {

        iSession.SendToClient( ids );

        }

    else

        {

        MCESRV_DEBUG_DVALUE("error", aReason )

        ids.iStatus = aReason;

    	CMceMsgSIPReply* replyMsg = new (ELeave) CMceMsgSIPReply();

    	CleanupStack::PushL( replyMsg );

        replyMsg->iCode = aReason;

        SendSIPDataToClientL( ids, *replyMsg, NULL );

    	CleanupStack::PopAndDestroy( replyMsg );

        }

    MCESRV_DEBUG("TMceActionSet::ClientStateChanged, Exit");

    }

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

// TMceActionSet::ClientStateChangedL

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

//

void TMceActionSet::ClientStateChangedL( CMceSession::TState aNewState, 

                                         CSIPClientTransaction& aResponse,

                                         TInt aReason )

    {

    MCESRV_DEBUG("TMceActionSet::ClientStateChangedL( response ), Entry");

    MCESRV_DEBUG_CLISTATE("new state", aNewState );

    MCESRV_DEBUG_DVALUE("error", aReason );

    const CSIPResponseElements* response = aResponse.ResponseElements();

    if ( !response )

	    {

        ClientStateChangedL( aNewState, aReason );

        return;

	    }

    MCESRV_DEBUG_DVALUE("status code", response->StatusCode() );

    MCESRV_DEBUG_SVALUE("reason", response->ReasonPhrase().DesC() );

    ActiveBody().iState = aNewState;

    TMceIds ids;

    ids.iCallbackID = EMceItcStateChanged;

	ids.iState = aNewState;

    ids.iStatus = aReason;

    HBufC8* content = NULL;

	CMceMsgSIPReply* replyMsg = new (ELeave) CMceMsgSIPReply();

	CleanupStack::PushL( replyMsg );

    replyMsg->PushL();

    const CSIPMessageElements* elements = ResponseDataL( *replyMsg, aResponse, ActiveBody() );

    if ( elements )

        {

        content = elements->Content().AllocLC();

        }

    SendSIPDataToClientL( ids, *replyMsg, content );

    if ( content )

        {

        CleanupStack::Pop( content );

        }

	CleanupStack::PopAndDestroy( replyMsg );

    MCESRV_DEBUG("TMceActionSet::ClientStateChangedL( response ), Exit");

    }

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

// TMceActionSet::ReceiveExtensionResponseL

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

//

void TMceActionSet::ReceiveExtensionResponseL( CSIPClientTransaction& aResponse, 

														CMceComSession& aBody )

    {

	MCESRV_DEBUG("TMceActionSet::ReceiveExtensionResponseL( response ), Entry");

  	TUint count = KErrNone;

	TUint TransactoinID = KMceNotAssigned;

	count = iSession.PendingTransactions().Count();

  	if ( count )

  		{

  			for ( TUint i=0; i < count; i++ )

  				{

  				if ( *iSession.PendingTransactions()[i] == aResponse )

  					{

  					TransactoinID = reinterpret_cast <TUint> 

  										(iSession.PendingTransactions()[i]);

  					}

  				}

  		}

    const CSIPMessageElements* elements = NULL;

    const CSIPResponseElements* response = aResponse.ResponseElements();

    HBufC8* content = NULL;

    if ( response )

	    {

        MCESRV_DEBUG_DVALUE("status code", response->StatusCode() );

        MCESRV_DEBUG_SVALUE("reason", response->ReasonPhrase().DesC() );

        CMceMsgSIPReply* replyMsg = replyMsg = new (ELeave) CMceMsgSIPReply();

        CleanupStack::PushL( replyMsg );

        replyMsg->PushL();//takes ownership of its content 

        elements = ResponseDataL( *replyMsg, aResponse, aBody );

    	TMceIds ids;

		ids.iCallbackID = EMceItcResponseReceived;

		ids.iTransactionID = TransactoinID;

    	content = elements ? elements->Content().AllocLC() : NULL;

       	SendSIPDataToClientL( ids, *replyMsg, content );

    	if ( content )

	        {

	        CleanupStack::Pop( content );

	        }

		CleanupStack::PopAndDestroy( replyMsg );	        

	    MCESRV_DEBUG(

	        "TMceActionSet::ReceiveExtensionResponseL( session, response ), Exit");

	    }

    }

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

// TMceActionSet::ReceiveExtensionRequestL 

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

//

void TMceActionSet::ReceiveExtensionRequestL( TMceStateTransitionEvent& aEvent )

    {

	MCESRV_DEBUG("TMceActionSet::ReceiveExtensionRequestL, Entry");

	CSIPServerTransaction& serverTransaction  = aEvent.Session().Request();

    const CSIPMessageElements* elements = 

    								MceSip::ToMessageElements( serverTransaction );

	HBufC8* method = MceSip::Method( serverTransaction ).DesC().AllocLC();

	CDesC8Array* aSIPHeaders = NULL;

	if ( aEvent.Dialog())

		{

		aSIPHeaders = MceSip::UserHeadersToTextArrayL( serverTransaction,

                                               *aEvent.Dialog() );		

        CleanupStack::PushL( aSIPHeaders );                                       

		}

	else

		{

		aSIPHeaders = MceSip::UserHeadersToTextArrayL( serverTransaction,

 	                                     iSession.Dialog()->Dialog() );		

 	    CleanupStack::PushL( aSIPHeaders );                                 

		}

	HBufC8* aSIPContentType = ( elements && elements->ContentType() ) ? 

         	                         elements->ContentType()->ToTextValueL() :

        	                         KNullDesC8().AllocL();

	CleanupStack::PushL( aSIPContentType );  

    TMceIds ids;

    ids.iCallbackID = EMceItcRequestReceived;

    ids.iTransactionID = reinterpret_cast <TUint> (&serverTransaction);   

	CMceMsgSIPRequest* requestMsg = new (ELeave) CMceMsgSIPRequest( *method, 

											*aSIPHeaders, *aSIPContentType );

	requestMsg->PushL();													

	CleanupStack::Pop( aSIPContentType );

	CleanupStack::Pop( aSIPHeaders );

	CleanupStack::Pop( method );

	CleanupStack::PushL( requestMsg );

    HBufC8* content = 

    	elements ? elements->Content().AllocLC() : KNullDesC8().AllocLC();

    SendSIPDataToClientL( ids, *requestMsg, content );

    if ( content )

        {

        CleanupStack::Pop( content );

        }

	CleanupStack::PopAndDestroy( requestMsg );

	MCESRV_DEBUG("TMceActionSet::ReceiveExtensionRequestL, Exit");

	}

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

// TMceActionSet::ReceiveExtensionError 

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

//

void TMceActionSet::ReceiveExtensionError( CSIPTransactionBase& aTransaction, 

											TInt aError )

    {

	MCESRV_DEBUG("TMceActionSet::ReceiveExtensionErrorL, Entry");

	TUint count = KErrNone;

	TUint TransactoinID = KMceNotAssigned;

	TBool found = EFalse;

	// If Error is for Client Transaction:

	if ( aTransaction.IsSIPClientTransaction() )

		{

		MCESRV_DEBUG("Error Received for Client Transaction");

		CSIPClientTransaction& clientTransaction = 

            static_cast<CSIPClientTransaction&>( aTransaction );

		count = iSession.PendingTransactions().Count();

	  	if ( count )

	  		{

  			for ( TUint i=0; i < count; i++ )

  				{

  				if ( *iSession.PendingTransactions()[i] == clientTransaction )

  					{

  					TransactoinID = reinterpret_cast <TUint> 

  										(iSession.PendingTransactions()[i]);

  					found = ETrue;					

  					}

  				}

	  		}

		}

	// If Error is for Client Transaction:

	else

		{

		MCESRV_DEBUG("Error Received for Server Transaction");

		CSIPServerTransaction& serverTransaction = 

            static_cast<CSIPServerTransaction&>( aTransaction );

		count = iSession.PendingReceivedRequests().Count();

	  	if ( count )

	  		{

  			for ( TUint i=0; i < count; i++ )

  				{

  				if ( *iSession.PendingReceivedRequests()[i] == serverTransaction )

  					{

  					TransactoinID = reinterpret_cast <TUint> 

  										(iSession.PendingReceivedRequests()[i]);

  					found = ETrue;					

  					}

  				}

	  		}

		}

	// Send an Error Response to the Client if client or server transcation exisit

	// for which we receive an error.

	if ( found )

		{

		MCESRV_DEBUG("Tranaction Matched Sending Error Response");

	    TMceIds ids;

	    ids.iTransactionID = TransactoinID;  

		iSession.SendErrorToClient( ids, aError );

		}

	MCESRV_DEBUG("TMceActionSet::ReceiveExtensionErrorL, Exit");

    }

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

// TMceActionSet::SendExtensionResponseL

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

//

void TMceActionSet::SendExtensionResponseL( CMceMsgBase& aData, TMceIds& aIds )

    {

	MCESRV_DEBUG("TMceActionSet::SendExtensionResponseL, Entry");

	TUint count = KErrNone;

	TInt index = KErrNotFound;

	CSIPServerTransaction* PendingRequest = NULL;

	count = iSession.PendingReceivedRequests().Count();

  	if ( count )

  		{

  			for ( TUint i=0; i < count; i++ )

  				{

  				if ( reinterpret_cast <TUint> (iSession.PendingReceivedRequests()[i]) ==

  					aIds.iTransactionID )

  					{

  					PendingRequest = iSession.PendingReceivedRequests()[i];

  					index = i;

  					}

  				}

    	if ( index != KErrNotFound )

    		{

    		CMceMsgSIPReply* data = static_cast<CMceMsgSIPReply*>( &aData );  				

       		SendResponseL( *PendingRequest, *data );		

    		}

    	else 

    		{

    		User::Leave( KErrNotFound );

    		}

  		}

   	MCESRV_DEBUG("TMceActionSet::SendExtensionResponseL, Exit");

    }

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

// TMceActionSet::ClientStateChangedL

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

//

void TMceActionSet::ClientStateChangedL( CMceSession::TState aNewState, 

                                         CSIPServerTransaction& aRequest )

    {

    MCESRV_DEBUG("TMceActionSet::ClientStateChangedL( request ), Entry");

    MCESRV_DEBUG_CLISTATE("new state", aNewState );

    MCESRV_DEBUG_SVALUE("request", MceSip::Method( aRequest ).DesC() );

    const CSIPRequestElements* request = aRequest.RequestElements();

    if ( !request )

	    {

        ClientStateChangedL( aNewState );

        return;

	    }

    ActiveBody().iState = aNewState;

    TMceIds ids;

    ids.iCallbackID = EMceItcStateChanged;

	ids.iState = aNewState;

	CMceMsgSIPData* requestMsg = new (ELeave) CMceMsgSIPData();

	CleanupStack::PushL( requestMsg );

    requestMsg->PushL();

    const CSIPMessageElements* elements = 

        RequestDataL( *requestMsg, aRequest );

    HBufC8* content = elements ? elements->Content().AllocLC() : 

        KNullDesC8().AllocLC();

    SendSIPDataToClientL( ids, *requestMsg, content );

    if ( content )

        {

        CleanupStack::Pop( content );

        }

	CleanupStack::PopAndDestroy( requestMsg );

    MCESRV_DEBUG("TMceActionSet::ClientStateChangedL( request ), Exit");