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

// Name          : InviteClientTa.cpp

// Part of       : Transaction

// Version       : SIP/5.0

//

#include "SipAssert.h"

#include "siperr.h"

#include "Lwtimer.h"

#include "uricontainer.h"

#include "sipcseqheader.h"

#include "siprequest.h"

#include "sipresponse.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "TimerValues.h"

#include "SIPMessageUtility.h"

#include "SIPRequestUtility.h"

#include "InviteClientTa.h"

#include "Transmitter.h"

#include "TransactionState.h"

#include "TransactionTimer.h"

#include "RestoreTransactionState.h"

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

// CInviteClientTransaction::NewL

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

//

CInviteClientTransaction* CInviteClientTransaction::NewL(

							CUserAgentBase& aUserAgent,

							CTransmitter& aTransmitter,

							MTimerManager& aTimers,

							CTransactionState& aInitialState,

							TTimerValues& aTimerValues,

							MTransactionStore& aTransactionStore,

							TBool aRetransmitInvite)

	{

	CInviteClientTransaction* self =

        new (ELeave) CInviteClientTransaction(aUserAgent,							

									          aTransmitter,

									          aTimers,

									          aInitialState,

									          aTimerValues,

									          aTransactionStore,

									          aRetransmitInvite);

	return self;

	}

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

// CInviteClientTransaction::CInviteClientTransaction

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

//

CInviteClientTransaction::CInviteClientTransaction(

						CUserAgentBase& aUserAgent,

						CTransmitter& aTransmitter,

						MTimerManager& aTimers,

						CTransactionState& aInitialState,

						TTimerValues& aTimerValues,

						MTransactionStore& aTransactionStore,

						TBool aRetransmitInvite) :

	CClientTransaction(aUserAgent,

					   aTransmitter,

					   aTimers,

					   aInitialState,

					   aTimerValues,

					   aTransactionStore),

	iRetransmitInvite(aRetransmitInvite),iDTimerErrCode(KErrNone)

	{

	}

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

// CInviteClientTransaction::~CInviteClientTransaction

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

//

CInviteClientTransaction::~CInviteClientTransaction()

	{

    //Scope operator to silence lint warning

    CInviteClientTransaction::CancelAllTimers();

	if (iTaOwnsRequest)

		{

		delete iOutgoingMsg;

		}

	//CInviteClientTransaction can own iTransmitter

	if (iDeleteMgr)

		{

		delete iTransmitter;

		}

	}

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

// CInviteClientTransaction::IsInviteTransaction

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

//

TBool CInviteClientTransaction::IsInviteTransaction() const

	{

	return ETrue;

	}

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

// CInviteClientTransaction::ReceiveResponseL

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

//

void CInviteClientTransaction::ReceiveResponseL(CSIPResponse* aResponse,

									const CTransactionState& aCurrent,

                                    const CTransactionState& aCompleted,

                                    CTransactionTimer* aTimer,

                          			CTransactionTimer* aTimer2)

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(aResponse, KErrArgument);

	CSIPRequest* ack = NULL;

	TBool isErrResponse = aResponse->IsErrorResponse();

	if ( isErrResponse )

	    {

	    ack = MakeAckLC(*aResponse);

        ChangeState(aCompleted);

	    }

	TRestoreTransactionState restoreState(*this, aCurrent, aTimer, aTimer2);

    CleanupStack::PushL(restoreState.CleanupItem());

	TRAPD(err,PassResponseToUserAgentL(aResponse));

	if( err != KErrNone )

		{

		if( err == KErrNoMemory || !isErrResponse )

			{

			User::Leave(err);

			}

		else

			{

			iDTimerErrCode = err;

			}

		}

    CleanupStack::Pop(); //cleanupItem  

    if (ack)

    	{

    	CleanupStack::Pop(ack);

		SendAck(ack);

    	}

	__TEST_INVARIANT;

	}

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

// CInviteClientTransaction::SendAck

// Can't leave as response's ownership has been passed. Cancel CTransmitter if

// needed so ACK can be sent. Transaction doesn't own INVITE, so ACK is put to

// iOutgoingMsg, in place of INVITE.

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

//

void CInviteClientTransaction::SendAck(CSIPRequest* aAck)

	{

	__TEST_INVARIANT;

	if (IsTransmitterSending())

		{

		iTransmitter->Cancel();

		}

	iOutgoingMsg = aAck;

	iTaOwnsRequest = ETrue;

	TRAPD(err, SendToTransmitterL());

	if (err != KErrNone)

		{

		TRAP_IGNORE(TerminatedL(err))

		}

	__TEST_INVARIANT;

	}

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

// CInviteClientTransaction::MakeAckLC

// Create ACK just once. Copy To-header from the response.

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

//

CSIPRequest* CInviteClientTransaction::MakeAckLC(CSIPResponse& aResp) const

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(!iTaOwnsRequest, KErrAlreadyExists);	

	CSIPRequest* ack =

		CSIPRequest::NewLC(SIPStrings::StringF(SipStrConsts::EAck));

	CopyHeadersFromInviteToAckL(*ack);

	RStringF to = SIPStrings::StringF(SipStrConsts::EToHeader);

	__SIP_ASSERT_LEAVE(aResp.HasHeader(to), KErrArgument);

	CSIPMessageUtility::CopyHeadersL(aResp, *ack, to);

	SIPRequestUtility::FillNewMaxForwardsL(*ack);

	CSIPMessageUtility::CopyAuthorizationHeadersL(iOutgoingMsg, *ack);

	SIPRequestUtility::FillSupportedSecAgreeL(*ack);

    __TEST_INVARIANT;

    return ack;

	}

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

// CInviteClientTransaction::CopyHeadersFromInviteToAckL

// Copy INVITE's Via header to ACK. Both have the same CSeq sequence number.

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

//

void

CInviteClientTransaction::CopyHeadersFromInviteToAckL(CSIPRequest& aAck) const

	{

	__TEST_INVARIANT;

    __SIP_ASSERT_LEAVE(iOutgoingMsg, KErrNotFound);

    RStringF from   = SIPStrings::StringF(SipStrConsts::EFromHeader);

    RStringF callId = SIPStrings::StringF(SipStrConsts::ECallIDHeader);

    RStringF via    = SIPStrings::StringF(SipStrConsts::EViaHeader);

    RStringF cseq   = SIPStrings::StringF(SipStrConsts::ECSeqHeader);

    __SIP_ASSERT_LEAVE(iOutgoingMsg->HasHeader(from) &&

    				   iOutgoingMsg->HasHeader(callId) &&

    				   iOutgoingMsg->HasHeader(via) &&

    				   iOutgoingMsg->HasHeader(cseq), KErrSIPMalformedMessage);

	const CURIContainer* origReqUri =

        static_cast<CSIPRequest*>(iOutgoingMsg)->RequestURI();

    __SIP_ASSERT_LEAVE(origReqUri != NULL, KErrSIPMalformedMessage);

	CURIContainer* reqUri = CURIContainer::NewLC(*origReqUri);

	aAck.SetRequestURIL(reqUri);

	CleanupStack::Pop(reqUri);

	CSIPMessageUtility::CopyHeadersL(*iOutgoingMsg, aAck, from);

	CSIPMessageUtility::CopyHeadersL(*iOutgoingMsg, aAck, callId);

	CSIPMessageUtility::CopyHeadersL(*iOutgoingMsg, aAck, via);

	TSglQueIter<CSIPHeaderBase> iter = iOutgoingMsg->Headers(cseq);

	CSIPMessageUtility::FillCSeqL(aAck,

								  static_cast<CSIPCSeqHeader&>(*iter).Seq(),

								  SIPStrings::StringF(SipStrConsts::EAck));

	CSIPMessageUtility::CopyHeadersL(*iOutgoingMsg,

							 aAck,

							 SIPStrings::StringF(SipStrConsts::ERouteHeader));

	}

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

// CInviteClientTransaction::StartTimerAL

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

//

void CInviteClientTransaction::StartTimerAL()

	{

	__TEST_INVARIANT;

    __SIP_ASSERT_LEAVE(!iTimerA, KErrAlreadyExists);

	if (iTimerADuration == 0)

		{

		iTimerADuration = iTimerValues.T1();

		}

	else

		{

		iTimerADuration = iTimerADuration << 1;

		}

	iTimerA = CTimerRetransmit::NewL(iTimers, this, iTimerADuration);

	__TEST_INVARIANT;

	}

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

// CInviteClientTransaction::StartTimerBUnlessExistsL

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

//

void CInviteClientTransaction::StartTimerBUnlessExistsL()

	{

	__TEST_INVARIANT;

	if (!iTimerB)

		{

		iTimerB = CTimerTerminateTa::NewL(iTimers,

										  this,

										  iTimerValues.Duration64xT1(),

										  KErrTimedOut);

		}

	__TEST_INVARIANT;

	}

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

// CInviteClientTransaction::StartTimerDUnlessExistsL

// Duration is 0s for reliable and 65*T1 for unreliable transports.

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

//

void CInviteClientTransaction::StartTimerDUnlessExistsL()

	{

	__TEST_INVARIANT;

    if (!iTimerD)

    	{

		TUint32 duration = 0;

		if (IsUnreliableTransportUsed())

			{

			duration = iTimerValues.Duration64xT1() + iTimerValues.T1();

			}

	    iTimerD = CTimerTerminateTa::NewL(iTimers, this, duration,iDTimerErrCode);

    	}

	__TEST_INVARIANT;

	}

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

// CInviteClientTransaction::StartTimerProceedingL

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

//

CTransactionTimer* CInviteClientTransaction::StartTimerProceedingL()

	{		

	__TEST_INVARIANT;

    __SIP_ASSERT_LEAVE(!iTimerProceeding, KErrAlreadyExists);

	iTimerProceeding =

        CTimerTerminateTa::NewL(iTimers,

								this,

								CTimerTerminateTa::KProceedingTimerDuration,

								KErrTimedOut);

	__TEST_INVARIANT;

	return iTimerProceeding;

	}

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

// CInviteClientTransaction::StartTimerNATL

// If 1xx comes before SendCompleteL, timer exists when handling SendCompleteL.

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

//

CTransactionTimer*  CInviteClientTransaction::StartTimerNATL()

	{

	__TEST_INVARIANT;

	if (!iTimerNAT && iRetransmitInvite && IsUnreliableTransportUsed())

		{

		iTimerNAT = CTimerRetransmit::NewL(iTimers,

									   this,

									   CTimerRetransmit::KNATBindingInterval);

		}

	__TEST_INVARIANT;

	return iTimerNAT;

	}

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

// CInviteClientTransaction::StopTimerA

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

//

void CInviteClientTransaction::StopTimerA()

	{

	__TEST_INVARIANT;

	delete iTimerA;

	iTimerA = NULL;

	__TEST_INVARIANT;

	}

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

// CInviteClientTransaction::StopTimerB

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

//

void CInviteClientTransaction::StopTimerB()

	{

	__TEST_INVARIANT;

	delete iTimerB;

	iTimerB = NULL;

	__TEST_INVARIANT;

	}

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

// CInviteClientTransaction::StopTimerD

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

//

void CInviteClientTransaction::StopTimerD()

	{

	__TEST_INVARIANT;

	delete iTimerD;

	iTimerD = NULL;

	__TEST_INVARIANT;

	}

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

// CInviteClientTransaction::StopTimerProceeding

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

//

void CInviteClientTransaction::StopTimerProceeding()

	{

	__TEST_INVARIANT;

	delete iTimerProceeding;

	iTimerProceeding = NULL;

	__TEST_INVARIANT;

	}

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

// CInviteClientTransaction::StopTimerNAT

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

//

void CInviteClientTransaction::StopTimerNAT()

	{

	__TEST_INVARIANT;

	delete iTimerNAT;

	iTimerNAT = NULL;

	__TEST_INVARIANT;

	}

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

// CInviteClientTransaction::DeleteTimer

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

//

void CInviteClientTransaction::DeleteTimer(const CTransactionTimer& aTimer)

	{

	__TEST_INVARIANT;    

	if (&aTimer == iTimerA)

		{

		StopTimerA();

		}

	if (&aTimer == iTimerB)

		{

		StopTimerB();		

		}

	if (&aTimer == iTimerD)

		{

		StopTimerD();		

		}

	if (&aTimer == iTimerProceeding)

		{

		StopTimerProceeding();

		}

	if (&aTimer == iTimerNAT)

		{		

		StopTimerNAT();

		}

	__TEST_INVARIANT;

	}

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

// CInviteClientTransaction::CancelAllTimers

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

//

void CInviteClientTransaction::CancelAllTimers()

	{

	__TEST_INVARIANT;

	StopTimerA();

	StopTimerB();

	StopTimerD();

	StopTimerProceeding();

	StopTimerNAT();

	__TEST_INVARIANT;

	}

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

// CInviteClientTransaction::Ptr

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

//

CInviteClientTransaction&

CInviteClientTransaction::Ptr(CTransaction& aTransaction)

	{

	return static_cast<CInviteClientTransaction&>(aTransaction);

	}

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

// CInviteClientTransaction::__DbgTestInvariant

// iTaOwnsRequest can be ETrue only if iOutgoingMsg is ACK.

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

//

void CInviteClientTransaction::__DbgTestInvariant() const

	{

	if (iOutgoingMsg &&

		iTaOwnsRequest &&

		!CSIPMessageUtility::IsAck(*iOutgoingMsg) &&

		(iRetransmitInvite && !iTimerNAT ||

		 !iRetransmitInvite && iTimerNAT))

		{

		User::Invariant();

		}

	}