// 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          : InviteUAC.cpp

// Part of       : TransactionUser

// Version       : SIP/6.0

//

#include "siperr.h"

#include "sipfromheader.h"

#include "sipviaheader.h"

#include "siprequest.h"

#include "sipresponse.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "MSipRegistrations.h"

#include "TransactionMgr.h"

#include "ClientTransaction.h"

#include "Transmitter.h"

#include "DeleteMgr.h"

#include "SipAssert.h"

#include "InviteUAC.h"

#include "InviteUACStates.h"

#include "CTransactionStore.h"

#include "SIPMessageUtility.h"

#include "SIPRequestUtility.h"

#include "TimerValues.h"

#include "UserAgentTimer.h"

#include "UserAgentCreateParams.h"

#include "RouteSet.h"

#include "ResolvingResults.h"

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

// CInviteUAC::NewL

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

//

CInviteUAC* CInviteUAC::NewL(CUserAgentCreateParams& aParams,							 

                             MSipConnectionMgr& aConnectionMgr,

                             MSipUriResolver& aResolver,							 

							 CSIPSec& aSIPSec,

							 TUint32 aCSeqNumber,

							 TBool aIsPrivateAddress,

							 CUserAgentState* aAckSenderState)

	{

	CInviteUAC* self = new (ELeave) CInviteUAC(aParams,

											   aConnectionMgr,

                                               aResolver,											   

											   aSIPSec,

											   aCSeqNumber,

											   aIsPrivateAddress,

											   aAckSenderState);

	CleanupStack::PushL(self);

	self->CUserAgent::ConstructL(aConnectionMgr);

	self->CUserAgentClient::ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

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

// CInviteUAC::CInviteUAC

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

//

CInviteUAC::CInviteUAC(CUserAgentCreateParams& aParams,					   

                       MSipConnectionMgr& aConnectionMgr,

                       MSipUriResolver& aResolver,					   

					   CSIPSec& aSIPSec,

					   TUint32 aCSeqNumber,

					   TBool aIsPrivateAddress,

					   CUserAgentState* aAckSenderState) :

	CUserAgentClient(aParams, aResolver, aSIPSec, aCSeqNumber),

	iConnectionMgr(aConnectionMgr),	

	iIsPrivateAddress(aIsPrivateAddress),

	iAckSenderState(aAckSenderState)

#ifdef CPPUNIT_TEST

    , iAckSenders(1)

#endif

	{

	}

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

// CInviteUAC::~CInviteUAC

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

//

CInviteUAC::~CInviteUAC()

	{

	CancelAllTimers();

	iAckSenders.ResetAndDestroy();

	delete iDeleteThisTransaction;

	}

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

// CInviteUAC::ReceiveResponseL

// Application sends ACK (uses ITC) to 2xx, so stop transaction and enter next

// state after PassRespToTransactionOwnerL, as ACK isn't sent inside it.

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

//

void CInviteUAC::ReceiveResponseL(CSIPResponse* aResp,

						  		  const CUserAgentState& aResolve,

						  		  const CUserAgentState& aWaitResponse,

								  const CUserAgentState& aWaitAckFromApp,

								  const CUserAgentState& aWaitTransactionToEnd)

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(aResp, KErrArgument);

	__SIP_ASSERT_LEAVE(!iTimerWait2xxRetransmissions, KErrAlreadyExists);

	if (!ShouldUaTryAgainL(aResp, aResolve, aWaitResponse))

		{

		CSIPResponse::TType type = aResp->Type();

		if (type == CSIPResponse::E2XX)

			{

			// UAC treats INVITE transaction completed 64*T1 after the first

			// 2xx. Expire with KErrNone as UAC ends successfully.

			iTimerWait2xxRetransmissions = CTimerStopUA::NewL(iTimers,

											   this,

											   iTimerValues.Duration64xT1(),

											   KErrNone);

			}

		PassRespToTransactionOwnerL(aResp,

									// If timer, set UA and timer pointers

									iTimerWait2xxRetransmissions ? this : NULL,

									iTimerWait2xxRetransmissions);

		if (type == CSIPResponse::E2XX)

			{

			StopTransaction();

			ChangeState(aWaitAckFromApp);

			}

	    else if (type == CSIPResponse::E1XX)

			{

			// Pass 1xx to upper layer

			}

	    else

	        {

	        // Transaction sends ACK, UAC waits it to end

			ChangeState(aWaitTransactionToEnd);

	        }

		}

	__TEST_INVARIANT;

	}

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

// CInviteUAC::PrepareTxForNewRequestL

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

//

void CInviteUAC::PrepareTxForNewRequestL(TTransactionId& aNewTransactionId)

	{

	__TEST_INVARIANT;

	CTransmitter* transmitter = CTransmitter::NewL(iConnectionMgr);

    static_cast<CClientTransaction*>(iTransaction)->

        RunIndependently(aNewTransactionId, &iDeleteMgr, EFalse);

    iTransmitter = transmitter;

	__TEST_INVARIANT;

	}

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

// CInviteUAC::CreateTransactionL

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

//

void CInviteUAC::CreateTransactionL()

	{

	__TEST_INVARIANT;

    __SIP_ASSERT_LEAVE(!iTransaction, KErrAlreadyExists);

	iTransaction = iTransactionMgr.CreateTransactionL(

		CTransactionBase::KClientInviteTransaction,

		*this,

		*iTransmitter,

		iTimerValues,

		iIsPrivateAddress && !iRegistrations.IsOutboundProxy(NextHopL()));

	__TEST_INVARIANT;

	}

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

// CInviteUAC::ClearTransactionOwner

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

//

void CInviteUAC::ClearTransactionOwner()

	{

	__TEST_INVARIANT;	

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

	    {

	    iAckSenders[i]->ClearTransactionOwner();

	    }

    CUserAgent::ClearTransactionOwner();

	__TEST_INVARIANT;

	}

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

// CInviteUAC::DeleteTimer

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

//

void CInviteUAC::DeleteTimer(const CUserAgentTimer& aTimer)

	{

	__TEST_INVARIANT;

	if (&aTimer == iTimerWait2xxRetransmissions)

		{

		StopTimerUaTimeout();

		}

	if (&aTimer == iSIPSecTimer)

		{

		StopTimerSIPSec();

		}

	__TEST_INVARIANT;

	}

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

// CInviteUAC::IsInviteUAC

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

//

TBool CInviteUAC::IsInviteUAC() const

	{

	__TEST_INVARIANT;

	return ETrue;

	}

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

// CInviteUAC::IsSubInviteUAC

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

//

TBool CInviteUAC::IsSubInviteUAC() const

	{

	__TEST_INVARIANT;

	return iAckSenderState == NULL;

	}

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

// CInviteUAC::IsCanceled

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

//

TBool CInviteUAC::IsCanceled() const

	{

	__TEST_INVARIANT;

	return iCanceled;

	}

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

// CInviteUAC::StartSIPSecTimerL

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

//

void CInviteUAC::StartSIPSecTimerL()

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(!iSIPSecTimer, KErrAlreadyExists);

	iSIPSecTimer = CTimerAsyncSIPSec::NewL(iTimers, this);

	__TEST_INVARIANT;

	}

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

// CInviteUAC::SendAckL

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

//

void CInviteUAC::SendAckL(CSIPRequest* aAck,

						  MTransactionOwner& aObserver,

						  const TSIPTransportParams& aParams,

						  TRegistrationId aRegisterId,

						  const CURIContainer& aRemoteTarget,

						  TBool aDeleteRequest,

						  RStringF aBranch)

	{

	__TEST_INVARIANT;

    __SIP_ASSERT_LEAVE(aAck, KErrArgument);

	State().SendAckL(*this,

					 aAck,

					 aObserver,

					 aParams,

					 aRegisterId,

					 aRemoteTarget,

					 aDeleteRequest,

					 aBranch);	

	__TEST_INVARIANT;

	}

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

// CInviteUAC::CancelInvite

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

//

void CInviteUAC::CancelInvite()

	{

	__TEST_INVARIANT;

	iCanceled = ETrue;

	__TEST_INVARIANT;

	}

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

// CInviteUAC::CopyRouteHeadersToCancelL

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

//

void CInviteUAC::CopyRouteHeadersToCancelL(CSIPRequest& aCancel)

	{

	__TEST_INVARIANT;

    __SIP_ASSERT_LEAVE(iOutgoingMsg, KErrNotFound);

	CSIPMessageUtility::CopyHeadersL(*iOutgoingMsg,

						 aCancel,

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

	__TEST_INVARIANT;

	}

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

// CInviteUAC::HandleIcmpErrorL

// Cancel send. If 2 UAs use same address, one gets ICMP error KErrSIPICMPFailure and its send ends

// but the other can be active. Unless UA stops, pass ICMP error to "sub UACs".

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

//

void CInviteUAC::HandleIcmpErrorL(const TInetAddr& aAddress,

								  const CUserAgentState& aResolveAckAddress,

								  const CUserAgentState& aWaitResponse)

	{

	__TEST_INVARIANT;

	if (CSIPMessageUtility::CompareTInetAddr(iRemoteAddr,

											 iTransportProtocol,

											 aAddress))

		{

		iTransmitter->Cancel();

		TInt error = KErrSIPICMPFailure;

		if (!TryNextAddressL(error, aResolveAckAddress, aWaitResponse))

			{

            Stop(error);

            return;

			}

		}

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

		{

        // Use any error code. "sub UAC" stops with CSIP::ETransportFailure.

		iAckSenders[i]->IcmpErrorL(aAddress,

								   CSipConnectionMgr::EHostUnreachable);

		}

	__TEST_INVARIANT;

	}

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

// CInviteUAC::CheckAckL

// Application must fill To-header, as many 2xx (each with a unique To-tag) can

// arrive and UAC won't know which tag to put in To-header.

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

//

void CInviteUAC::CheckAckL(CSIPRequest& aAck) const

	{

	__TEST_INVARIANT;

    if (!aAck.HasHeader(SIPStrings::StringF(SipStrConsts::EToHeader)) ||

        aAck.HasHeader(SIPStrings::StringF(SipStrConsts::EViaHeader)))

        {

        User::Leave(KErrSIPMalformedMessage);

        }

	}

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

// CInviteUAC::FillAckL

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

//

void CInviteUAC::FillAckL(CSIPRequest& aAck, RStringF aBranch)

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(iRemoteTarget, KErrNotFound);

	SIPRequestUtility::FillRouteAndRequestUriL(aAck,

											   *iRouteSet,

											   *iRemoteTarget);

    // Copy From-header before Contact-headers are handled

	iTransactionStore.CopyHeadersToRequestL(TransactionId(),

											aAck,

											EFalse, // Request-URI already set

											EFalse);// Don't copy Via

	CheckContactHeadersL(aAck, aAck.From());

	if (!aAck.HasHeader(SIPStrings::StringF(SipStrConsts::EMaxForwardsHeader)))

		{

		SIPRequestUtility::FillNewMaxForwardsL(aAck);

		}

    FillNewViaL(aAck, aBranch);

    // "sub UAC" has no iOutgoingMsg, but the authorization headers have already

    // been copied from the first ACK.

	CSIPMessageUtility::CopyAuthorizationHeadersL(iOutgoingMsg, aAck);

	SIPRequestUtility::FillSupportedSecAgreeL(aAck);

	__TEST_INVARIANT;

	}

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

// CInviteUAC::AckAddressResolvedL

// Remote address must exist.

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

//

void CInviteUAC::AckAddressResolvedL()

	{

	__TEST_INVARIANT;	

	__SIP_ASSERT_LEAVE(SelectNextRemoteAddressL(), KErrNotFound);

	if (FillSecurityParamsL())

		{

		SendRequestToNetworkL();

		}

	__TEST_INVARIANT;

	}

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

// CInviteUAC::SendFirstAckL

// Clear INVITE's route set and resolving results before resolving ACK address.

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

//

void CInviteUAC::SendFirstAckL(CSIPRequest* aAck,

							   MTransactionOwner& aObserver,

							   const TSIPTransportParams& aParams,

							   TRegistrationId aRegisterId,

							   const CURIContainer& aRemoteTarget,

							   TBool aDeleteRequest,

							   RStringF aBranch)

	{

	__TEST_INVARIANT;

    __SIP_ASSERT_LEAVE(aAck, KErrArgument);

    __SIP_ASSERT_LEAVE(!iObserverForFirstAck, KErrAlreadyExists);

    // Main-UAC must always use a new branch

    if (iAckSenderState && aBranch != SIPStrings::StringF(SipStrConsts::EEmpty))

    	{

    	User::Leave(KErrArgument);

    	}

	iObserver = &aObserver;

	iObserverForFirstAck = &aObserver;

	iRegisterId = aRegisterId;

	iTransportParams = aParams;	

    CheckAckL(*aAck);

	StoreRemoteTargetL(aRemoteTarget);

	delete iRouteSet;

    iRouteSet = NULL;

	iRouteSet = CRouteSet::NewL(*aAck, iRegistrations, iRegisterId);

	FillAckL(*aAck, aBranch);

	StoreRequestUriL(*aAck);

	iResolvingResults->ClearAll();

	ResolveNextHopL(ETrue);

	StoreOutgoingMsg(aAck);

	SetRequestOwnership(aDeleteRequest);

	__TEST_INVARIANT;

	}

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

// CInviteUAC::SendAdditionalAckL

// Get branch value before updating observer. Don't update iObserverForFirstAck.

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

//

void CInviteUAC::SendAdditionalAckL(CSIPRequest* aAck,

									MTransactionOwner& aObserver,

								    const TSIPTransportParams& aParams,

									TRegistrationId aRegisterId,

									const CURIContainer& aRemoteTarget,

									TBool aDeleteRequest)

	{

	__TEST_INVARIANT;

    __SIP_ASSERT_LEAVE(aAck, KErrArgument);

	iObserver = &aObserver;

	iRegisterId = aRegisterId;

	CUserAgentCreateParams* params =

        CUserAgentCreateParams::NewLC(iTransactionMgr,

                                      iTimers,

								      iSIPMsgUtility,

								      iTimerValues,

								      iRegistrations,

                                      iRegistrationContact,

                                      iSigComp,

                                      iTransactionStore,

                                      iDeleteMgr,

								      aDeleteRequest,

								      aParams);

	params->iTransactionId = TransactionId();	

	params->iObserver = iObserver;

	params->iInitialUaState = iAckSenderState;

	CInviteUAC* subUac =

		CInviteUAC::NewL(*params,

					     iConnectionMgr,

					     iResolver,

					     iSIPSec,

					     0, // CSeq value not used for ACK

					     iIsPrivateAddress, // Not used for ACK

					     NULL); // State is NULL for "sub UAC"

	CleanupStack::PopAndDestroy(params);

	CleanupStack::PushL(subUac);

	iAckSenders.AppendL(subUac);

    CleanupStack::Pop(subUac);

	CSIPMessageUtility::CopyAuthorizationHeadersL(iOutgoingMsg, *aAck);

	subUac->SendAckL(aAck,

					 *iObserver,

					 aParams,

					 iRegisterId,

					 aRemoteTarget,

					 aDeleteRequest,