// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).627

// 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          : UserAgentClient.cpp
// Part of       : TransactionUser
// Version       : SIP/6.0
//



#include "siperr.h"
#include "SipAssert.h"
#include "MSipRegistrations.h"
#include "sipcseqheader.h"
#include "sipuri.h"
#include "uricontainer.h"
#include "siphostport.h"
#include "sipaddress.h"
#include "sipcallidheader.h"
#include "sipviaheader.h"
#include "sipfromheader.h"
#include "siprouteheader.h"
#include "sipstrings.h"
#include "sipstrconsts.h"
#include "sipsec.h"
#include "siprequest.h"
#include "sipresponse.h"
#include "Transmitter.h"

#include "UserAgentClient.h"
#include "UserAgentState.h"
#include "CTransactionStore.h"
#include "SIPMessageUtility.h"
#include "SIPRequestUtility.h"
#include "MTransactionUser.h"
#include "MTransactionOwner.h"
#include "RouteSet.h"
#include "ResolvingResults.h"
#include "StopUserAgent.h"
#include "RestoreUaState.h"
#include "MSIPSecUser.h"

// -----------------------------------------------------------------------------
// CUserAgentClient::CUserAgentClient
// -----------------------------------------------------------------------------
//
CUserAgentClient::CUserAgentClient(CUserAgentCreateParams& aParams,
								   MSipUriResolver& aResolver,
                                   CSIPSec& aSIPSec,
					               TUint32 aCSeqNumber) :
	CUserAgent(aParams),
	iSIPSec(aSIPSec),
	iCSeqNumber(aCSeqNumber),
	iResolver(aResolver),
	iSipSecError(KErrNone),
    iFinalRespPassed(EFalse),
    iOutboundProxyHasBeenTried(EFalse),
    iLastError(KErrNone),
    iIgnoreSIPSecCallback(EFalse)
	{
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::ConstructL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::ConstructL()
	{
	iResolvingResults = CResolvingResults::NewL();	
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::~CUserAgentClient
// -----------------------------------------------------------------------------
//
CUserAgentClient::~CUserAgentClient()
	{
	iResolver.CancelGetByUri(this);
	CancelSIPSecRequest();
	delete iResolvingResults;	
    delete iRemoteTarget;
    delete iRouteSet;
    delete iRequestUri;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::IsUAS
// -----------------------------------------------------------------------------
//
TBool CUserAgentClient::IsUAS() const
	{
	__TEST_INVARIANT;
	return EFalse;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::RegistrationId
// -----------------------------------------------------------------------------
//
TRegistrationId CUserAgentClient::RegistrationId() const
	{
	__TEST_INVARIANT;
	return iRegisterId;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::CompletedL
// Resolving succeeded so clear the stored error.
// -----------------------------------------------------------------------------
//
void CUserAgentClient::CompletedL()
	{
	__TEST_INVARIANT;

	if (!HasStopped())
		{
		iLastError = KErrNone;
		delete iIncomingMsg;
		iIncomingMsg = NULL;
		State().AddressResolvedL(*this);
		}

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::ErrorOccured
// -----------------------------------------------------------------------------
//
void CUserAgentClient::ErrorOccured(TInt aError)
	{
	__TEST_INVARIANT;

	if (!HasStopped())
		{
		if (aError == KErrSIPResolvingFailure)
			{
			// URI fully resolved. Old results not needed.
			iResolvingResults->ClearAll();
			State().ResolvingFailed(*this);
			}
		else
			{
			// Leave came in MSIPServerResolverObserver::CompletedL
			Stop(aError);
			}
		}

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::SIPSecCacheUpdated
// Don't use __TEST_INVARIANT as destructor may lead here.
// -----------------------------------------------------------------------------
//
void CUserAgentClient::SIPSecCacheUpdated(TBool aSuccess)
	{
	if (!iIgnoreSIPSecCallback)
		{
		SIPSecReady(aSuccess);
		}
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::SIPSecTimerExpiredL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::SIPSecTimerExpiredL()
	{
	__TEST_INVARIANT;

	TInt err = SIPSecReady(ETrue);
	if (err != KErrNone)
		{
		User::Leave(err);
		}

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::SIPSecReady
// TRAP may delete UA. Check if UA exists before stopping. Don't use
// __TEST_INVARIANT after Stop.
// -----------------------------------------------------------------------------
//
TInt CUserAgentClient::SIPSecReady(TBool aSuccess)
	{
	__TEST_INVARIANT;

    TTransactionId transactionId = TransactionId();
    CTransactionStore& store = iTransactionStore;

	TRAPD(err, State().SIPSecCacheUpdatedL(*this, aSuccess));
	if (err != KErrNone && store.SearchById(transactionId))
		{
        Stop(err);
		}

	return err;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::HandleSendRequestL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::HandleSendRequestL(CSIPRequest* aReq,
										  TRegistrationId aRegisterId,
										  const CURIContainer& aRemoteTarget,
                                          const CUserAgentState& aResolve)
	{
	__TEST_INVARIANT;
    __SIP_ASSERT_LEAVE(aReq, KErrArgument);
    __SIP_ASSERT_LEAVE(!iRouteSet && !iRemoteTarget, KErrAlreadyExists);

	iRegisterId = aRegisterId;
    StoreRemoteTargetL(aRemoteTarget);
    iRouteSet = CRouteSet::NewL(*aReq, iRegistrations, iRegisterId);

    SIPRequestUtility::CheckOutgoingRequestL(*aReq);
	FillRequestL(*aReq);
	StoreRequestUriL(*aReq);
	
	TBool isRegMsg = (SIPStrings::StringF(SipStrConsts::ERegister) == aReq->Method());
	ResolveNextHopL(ETrue,!isRegMsg);

	UpdateInfoToStoreL(aReq);
	StoreOutgoingMsg(aReq);
    ChangeState(aResolve);

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::FillRequestL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::FillRequestL(CSIPRequest& aReq) const
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(iRouteSet && iRemoteTarget, KErrNotFound);

	CSIPMessageUtility::FillCSeqL(aReq, iCSeqNumber, aReq.Method());

	if (!aReq.HasHeader(SIPStrings::StringF(SipStrConsts::ECallIDHeader)))
		{
        FillNewCallIdL(aReq);
		}

	if (!aReq.HasHeader(SIPStrings::StringF(SipStrConsts::EMaxForwardsHeader)))
		{
		SIPRequestUtility::FillNewMaxForwardsL(aReq);
		}

	CheckContactHeadersL(aReq, aReq.From());
	SIPRequestUtility::FillRouteAndRequestUriL(aReq,
											   *iRouteSet,
											   *iRemoteTarget);
    FillNewViaL(aReq, SIPStrings::StringF(SipStrConsts::EEmpty));

    CSIPFromHeader* from = aReq.From();
    __SIP_ASSERT_LEAVE(from != NULL, KErrArgument);
	if (!from->HasParam(SIPStrings::StringF(SipStrConsts::ETag)))
		{
		AddTagL(*from);
		}
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::UpdateViaAndCSeqL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::UpdateViaAndCSeqL() const
	{
	__TEST_INVARIANT;
    __SIP_ASSERT_LEAVE(iOutgoingMsg, KErrNotFound);

	CSIPRequest* req = static_cast<CSIPRequest*>(iOutgoingMsg);
    FillNewViaL(*req, SIPStrings::StringF(SipStrConsts::EEmpty));

    CSIPCSeqHeader* cseqHeader = req->CSeq();
    __SIP_ASSERT_LEAVE(cseqHeader != NULL, KErrSIPMalformedMessage);
	TUint cseq = cseqHeader->Seq();

	if (iObserver)
		{
		User::LeaveIfError(iObserver->NextCSeq(cseq));
		}
	else
		{
		++cseq;
		}
	cseqHeader->SetSeq(cseq);
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::FillNewCallIdL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::FillNewCallIdL(CSIPRequest& aReq) const
	{
	__TEST_INVARIANT;

	TBuf8<MTransactionUser::KCallIDLength> callID;
	AddRandomStringL(callID, MTransactionUser::KCallIDLength, ETrue);
	CSIPCallIDHeader* callIdHeader = CSIPCallIDHeader::DecodeL(callID);
	CleanupStack::PushL(callIdHeader);
	aReq.AddHeaderL(callIdHeader);
	CleanupStack::Pop(callIdHeader);
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::SetBranchL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::SetBranchL(CSIPViaHeader& aVia, RStringF aBranch) const
	{
	__TEST_INVARIANT;

	if (aBranch == SIPStrings::StringF(SipStrConsts::EEmpty))
		{
		const TInt KBranchLength = 30;
    	__ASSERT_DEBUG(
    		KBranchLength > CSIPMessageUtility::BranchMagicCookie().Length(),
			User::Panic(_L("UAC:SetBranchL"), KErrOverflow));
		TBuf8<KBranchLength> branchBuf;
		branchBuf.Append(CSIPMessageUtility::BranchMagicCookie());
		AddRandomStringL(branchBuf, KBranchLength - branchBuf.Length(), EFalse);

		RStringF branch = SIPStrings::Pool().OpenFStringL(branchBuf);
		CleanupClosePushL(branch);
		aVia.SetParamL(SIPStrings::StringF(SipStrConsts::EBranch), branch);	
		CleanupStack::PopAndDestroy(); // branch
		}
	else
		{
		aVia.SetParamL(SIPStrings::StringF(SipStrConsts::EBranch), aBranch);
		}
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::FillNewViaL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::FillNewViaL(CSIPRequest& aReq, RStringF aBranch) const
	{
	__TEST_INVARIANT;

	CSIPViaHeader* via = CSIPMessageUtility::TopVia(aReq);
	if (via)
		{
		SetBranchL(*via, aBranch);
		via->SetTransportL(iTransportProtocol);
		}
	else
		{
		CSIPHostPort* hp = CSIPHostPort::DecodeL(
			SIPStrings::StringF(SipStrConsts::ELocalHost).DesC());
		CleanupStack::PushL(hp);
		via = CSIPViaHeader::NewL(iTransportProtocol, hp);
		CleanupStack::Pop(hp);
		CleanupStack::PushL(via);
	
		SetBranchL(*via, aBranch);

		aReq.AddHeaderL(via);
		CleanupStack::Pop(via);
		}
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::StoreRequestUriL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::StoreRequestUriL(CSIPRequest &aReq)
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(aReq.RequestURI() != NULL, KErrArgument);

	CURIContainer* newUri = CURIContainer::NewL(*aReq.RequestURI());
	delete iRequestUri;
	iRequestUri = newUri;

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::UpdateInfoToStoreL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::UpdateInfoToStoreL(CSIPRequest* aReq) const
	{
	__TEST_INVARIANT;

	iTransactionStore.UpdateL(TransactionId(), iTransaction, aReq);
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::ResolveNextHopL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::ResolveNextHopL(TBool aCheckSigComp,TBool aUseResolvedProxy)
	{
	__TEST_INVARIANT;

	CURIContainer& uri = NextHopL(aUseResolvedProxy);
	if (aCheckSigComp)
		{
		CheckSigCompL(uri);
		}

	iResolver.GetByURIL(uri,
						iResolvingResults->Addresses(),
						TransportParams(),
						this);
	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::CopyRemoteAddress
// Clear resolving results as CANCEL must use only one ip-address.
// -----------------------------------------------------------------------------
//
void CUserAgentClient::CopyRemoteAddress(const CUserAgentClient& aSrc)
	{
	__TEST_INVARIANT;

	iRemoteAddr = aSrc.iRemoteAddr;
	iForceUDP = aSrc.iForceUDP;

	iTransportProtocol.Close();
	if (aSrc.iTransaction)
		{
		iTransportProtocol = aSrc.iTransaction->TransportProtocol().Copy();
		}
	else
		{
		RStringF protocol = aSrc.iTransportProtocol;
		iTransportProtocol = protocol.Copy();
		}

	iResolvingResults->ClearAll();

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::CopyRouteSetAndRemoteTargetL
// -----------------------------------------------------------------------------
//
void
CUserAgentClient::CopyRouteSetAndRemoteTargetL(const CUserAgentClient& aSrc)
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(!iRouteSet && !iRemoteTarget, KErrAlreadyExists);
	__SIP_ASSERT_LEAVE(aSrc.iRouteSet && aSrc.iRemoteTarget, KErrNotFound);

	iRouteSet = CRouteSet::NewL(*aSrc.iRouteSet);
	iRemoteTarget = CURIContainer::NewL(*aSrc.iRemoteTarget);

    __TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::StoreRemoteTargetL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::StoreRemoteTargetL(const CURIContainer& aRemoteTarget)
	{
	__TEST_INVARIANT;

	CURIContainer* newRemoteTarget = CURIContainer::NewL(aRemoteTarget);
	delete iRemoteTarget;
	iRemoteTarget = newRemoteTarget;

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::NextHopL
// -----------------------------------------------------------------------------
//
CURIContainer& CUserAgentClient::NextHopL(TBool aUseResolvedProxy) const
	{
	__TEST_INVARIANT;
	__ASSERT_ALWAYS(iRouteSet && iRemoteTarget,
        			User::Panic(_L("UAC:NextHop"), KErrNotFound)); 
	
	if (aUseResolvedProxy && iRegistrations.HasOutboundProxy(iRegisterId))
	    {
	    if(iRegistrations.OutboundProxy(iRegisterId)->SIPAddress().URI() == 
	    	iRouteSet->NextHop(*iRemoteTarget))
	    	{
		    if(iRegistrations.IsCacheOutboundProxyIPEanbled(iRegisterId))
		    	{
		    	TRAPD(err,iRegistrations.OutboundProxyIPL(iRegisterId))
		    	if(KErrNone == err)
		    		{
		    		return iRegistrations.OutboundProxyIPL(iRegisterId).SIPAddress().URI();
		    		}
		    	}
		    }
	    }
	return iRouteSet->NextHop(*iRemoteTarget);
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::SetRequestOwnership
// -----------------------------------------------------------------------------
//
void CUserAgentClient::SetRequestOwnership(TBool aOwnsRequest)
	{
	__TEST_INVARIANT;

	iOwnsOutgoingMsg = aOwnsRequest;

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::StoreResponse
// -----------------------------------------------------------------------------
//
void CUserAgentClient::StoreResponse(CSIPResponse* aResponse)
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_RETURN(!iIncomingMsg, KErrAlreadyExists);

	iIncomingMsg = aResponse;

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::SelectNextRemoteAddressL
// -----------------------------------------------------------------------------
//
TBool CUserAgentClient::SelectNextRemoteAddressL()
	{
	__TEST_INVARIANT;

	iSIPSecCounter = 0; // Remote address changes, reset counter
	if (!iResolvingResults->GetNext(iRemoteAddr, iTransportProtocol, iForceUDP))
		{
		return EFalse;
		}
	if(iRemoteAddr.IsUnspecified())
		{
		return EFalse;
		}

	__SIP_ASSERT_LEAVE(iOutgoingMsg, KErrNotFound);
	CSIPMessageUtility::UpdateViaTransportL(*iOutgoingMsg, iTransportProtocol);

	__TEST_INVARIANT;
	return ETrue;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::RemoteAddressResolvedL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::RemoteAddressResolvedL(const CUserAgentState& aNextState)
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(SelectNextRemoteAddressL(), KErrNotFound);

	if (FillSecurityParamsL())	
		{
	    CreateTransactionL();
		UpdateInfoToStoreL(NULL /* don't update message headers */);
		SendRequestToNetworkL();
		ChangeState(aNextState);
		}

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::HandleResolvingFailure
// -----------------------------------------------------------------------------
//
void
CUserAgentClient::HandleResolvingFailure(const CUserAgentState& aResolve,
				  					     const CUserAgentState& aWaitResponse)
	{
	__TEST_INVARIANT;

	TBool retry(ETrue);
	TRAPD(err, retry = TryNextAddressL(KErrSIPResolvingFailure,
							 		   aResolve,
							 		   aWaitResponse));
	if (err != KErrNone || !retry)
		{
		StopWithLastError();
		}

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::FillSecurityParamsL
// -----------------------------------------------------------------------------
//
TBool CUserAgentClient::FillSecurityParamsL()
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(iOutgoingMsg && iRemoteTarget, KErrNotFound);

	if (!iObserver)
		{
		Stop(KErrNone);
		return EFalse;
		}

	if (UseSIPSec())
		{
		CUri8* remoteTarget = iRemoteTarget->CloneAsUri8L();
		CleanupStack::PushL(remoteTarget);
		TRAPD(err, iSIPSec.AddSecurityParamsL(
					iTransportParams,
					static_cast<CSIPRequest&>(*iOutgoingMsg),
					RegistrationId(),
					TransactionId(),
					iRemoteAddr,
					CSIPMessageUtility::UriDescriptor(NextHopL()),
					*remoteTarget,
					ProxyL(),
					const_cast<MSIPSecUser&>(*iObserver->SIPSecUser())));
		CleanupStack::PopAndDestroy(remoteTarget);
		HandleSIPSecErrorL(err);
		}

	__TEST_INVARIANT;
	return ETrue;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::HandleSIPSecErrorL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::HandleSIPSecErrorL(TInt aError)
	{
	__TEST_INVARIANT;
	
	if (aError != KErrNone)		
		{
		if (aError != KErrNoMemory)
			{
			aError = KErrSIPForbidden;
			}
		Stop(aError);
		User::Leave(aError);
		}
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::SIPSecCacheUpdatedL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::SIPSecCacheUpdatedL(TBool aSuccess,
	const CUserAgentState& aResolve,
	const CUserAgentState& aWaitResponse,
	const CUserAgentState& aWaitAckFromApp,
	const CUserAgentState& aWaitTransactionToEnd)
	{
	__TEST_INVARIANT;
    __SIP_ASSERT_LEAVE(iIncomingMsg, KErrNotFound);

	if (aSuccess)
		{
		CSIPResponse* resp = static_cast<CSIPResponse*>(iIncomingMsg);
		iIncomingMsg = NULL;
		CleanupStack::PushL(resp);
		ReceiveResponseL(resp,
						 aResolve,
					 	 aWaitResponse,
						 aWaitAckFromApp,
						 aWaitTransactionToEnd);
		CleanupStack::Pop(resp);
		}
	else
		{
        Stop(KErrSIPForbidden);
		}

    __TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::ProxyL
// -----------------------------------------------------------------------------
//
const TDesC8& CUserAgentClient::ProxyL() const
	{
	__TEST_INVARIANT;

	CURIContainer& nextHop = NextHopL();
	if (iRegistrations.IsOutboundProxy(nextHop))
		{
		return CSIPMessageUtility::UriDescriptor(nextHop);
		}
	return KNullDesC8;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::SendRequestToNetworkL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::SendRequestToNetworkL()
	{
	__TEST_INVARIANT;
    __SIP_ASSERT_LEAVE(iOutgoingMsg, KErrNotFound);

	CUri8* proxy(NULL);
    const CSIPRouteHeader* route = iRegistrations.OutboundProxy(iRegisterId);
    if (route)
        {
        proxy = route->SIPAddress().URI().CloneAsUri8L();
		}
	CleanupStack::PushL(proxy);

	if (CSIPMessageUtility::IsAck(*iOutgoingMsg))
		{
    	__SIP_ASSERT_LEAVE(iTransmitter, KErrNotFound);
		iTransmitter->SendRequestL(static_cast<CSIPRequest&>(*iOutgoingMsg),
							   	   iRemoteAddr,
							   	   iForceUDP,
							   	   TransportParams(),
							   	   proxy,
							   	   this);
		CleanupStack::PopAndDestroy(proxy);
		}
	else
		{
		__SIP_ASSERT_LEAVE(iTransaction, KErrNotFound);
		iTransaction->SendRequestL(static_cast<CSIPRequest&>(*iOutgoingMsg),
							   	   iRemoteAddr,
							   	   iTransportProtocol,
							   	   iForceUDP,
							   	   TransportParams(),
							   	   proxy);
		CleanupStack::Pop(proxy);
		}
	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::PassRespToTransactionOwnerL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::PassRespToTransactionOwnerL(CSIPResponse* aResp,
												   CUserAgent* aUserAgent,
												   CUserAgentTimer* aTimer)
	{
	__TEST_INVARIANT;
    __SIP_ASSERT_LEAVE(aResp, KErrArgument);
    __SIP_ASSERT_LEAVE(!iFinalRespPassed, KErrAlreadyExists);

    if (aResp->ResponseCode() == 100 && !IsInviteUAC())
        {
        delete aResp;
        }
    else
    	{
        TRestoreUaState restoreState(iFinalRespPassed, aUserAgent, aTimer);
        CleanupStack::PushL(restoreState.CleanupItem());
    	iFinalRespPassed = CSIPMessageUtility::IsFinalResponse(*aResp);

		PassMsgToTransactionOwnerL(aResp);

        CleanupStack::Pop(); // cleanupItem
    	}

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::FinalRespPassed
// -----------------------------------------------------------------------------
//
TBool CUserAgentClient::FinalRespPassed() const
	{
	__TEST_INVARIANT;
	return iFinalRespPassed;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::PassResponseToSIPSecL
// If no iObserver, ignore response and wait transaction to end.
// -----------------------------------------------------------------------------
//
TBool CUserAgentClient::PassResponseToSIPSecL(CSIPResponse& aResp)
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(iOutgoingMsg && iRemoteTarget, KErrNotFound);

	iResponseReceived = ETrue;
	TBool mustWait(EFalse);

	if (UseSIPSec() && CSIPMessageUtility::IsFinalResponse(aResp))  
		{
		CUri8* remoteTarget = iRemoteTarget->CloneAsUri8L();
		TRAPD(err, mustWait = iSIPSec.ResponseReceivedL(iTransportParams,
						 aResp,
					     static_cast<CSIPRequest&>(*iOutgoingMsg),
					     RegistrationId(),
					     TransactionId(),
	                     iRemoteAddr,
	                     CSIPMessageUtility::UriDescriptor(NextHopL()),              
	                     *remoteTarget,
	                   	 ProxyL(),
		                 const_cast<MSIPSecUser&>(*iObserver->SIPSecUser()),
		                 *this));
		delete remoteTarget;
		if( err != KErrNone )
			{
			User::Leave( KErrSIPForbidden );
			}
    	}

    __TEST_INVARIANT;
	return mustWait;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::ShouldUaTryAgainL
// If no iObserver ignore response. If send leaves, ConnectionMgr calls old
// transaction's MReceiverObserver::LeaveOccurred and cleanupItem stops UA.
// -----------------------------------------------------------------------------
//
TBool CUserAgentClient::ShouldUaTryAgainL(CSIPResponse* aResp,
										  const CUserAgentState& aResolve,
										  const CUserAgentState& aWaitResponse)
	{
	__TEST_INVARIANT;
    __SIP_ASSERT_LEAVE(aResp, KErrArgument);

    TBool retry(EFalse);
	if (!FinalRespPassed() && iObserver)
		{
        TStopUserAgent stopUa(TransactionId(),
        					  iTransactionStore,
        					  KErrSIPForbidden);
        CleanupStack::PushL(stopUa.CleanupItem());

		TInt respCode = aResp->ResponseCode();
		if (respCode == 503 || respCode == 408)
			{
			retry =	TryNextAddressL(KErrNone, aResolve, aWaitResponse, aResp);
			}
		
		if ((respCode == 401 || respCode == 407 || respCode == 494) && UseSIPSec())
		    {
		    if(iSipSecError)
		        {
		        __SIP_LOG( "Request can't be resubmitted because of insufficient information" ) 
		        }
		    else if(FillSecurityParamsL())
		        {
		        if (iSIPSecCounter > SIPRequestUtility::EMaxForwardsValue)
				{
				User::Leave(KErrSIPForbidden);
				}
		        ++iSIPSecCounter;
		        UpdateAndSendRequestL(aWaitResponse);
		        delete aResp;
		        retry = ETrue;
		        }
		    }
        CleanupStack::Pop(); // cleanupItem
		}

	__TEST_INVARIANT;
	return retry;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::TransactionEndsWithoutFinalResponseL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::TransactionEndsWithoutFinalResponseL(TInt aReason,
										const CUserAgentState& aResolve,
										const CUserAgentState& aWaitResponse)
	{
	__TEST_INVARIANT;

	TStopUserAgent stopUa(TransactionId(), iTransactionStore, KErrNoMemory);
    CleanupStack::PushL(stopUa.CleanupItem());

	TBool retry(EFalse);
	if (!IsCanceled())
		{
		if (aReason == KErrTimedOut)
			{
			retry = HandleTimeoutL(aResolve, aWaitResponse);
			}
		if (aReason == KErrSIPTransportFailure ||
			aReason == KErrSIPICMPFailure)
			{
			retry = TryNextAddressL(aReason, aResolve, aWaitResponse);
			}
		}

    CleanupStack::Pop(); // cleanupItem
    if (!retry)
    	{
		Stop(aReason);
		}

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::HandleTimeoutL
// If SigComp used, delete the compartment and close TCP connection.
// -----------------------------------------------------------------------------
//
TBool CUserAgentClient::HandleTimeoutL(const CUserAgentState& aResolve,
									   const CUserAgentState& aWaitResponse)
    {
    __TEST_INVARIANT;
    __SIP_ASSERT_LEAVE(iOutgoingMsg, KErrNotFound);

    if (CSIPMessageUtility::HasSigCompParam(NextHopL()))
        {
        UpdateTransportProtocol(*iOutgoingMsg);
        if (iTransportProtocol == SIPStrings::StringF(SipStrConsts::ETCP) ||
            iTransportProtocol == SIPStrings::StringF(SipStrConsts::ETLS))
            {
            iTransmitter->TcpDisconnect(iRemoteAddr, TransportParams());
            }
		CSIPURI* uri = NextHopL().SIPURI();
		__SIP_ASSERT_LEAVE(uri, KErrNotFound);

        iSigComp.SendFailedL(iTransportParams.CompartmentId());
        iTransportParams.SetCompartmentId(0);
        uri->DeleteParam(SIPStrings::StringF(SipStrConsts::EComp));
        SIPRequestUtility::FillRouteAndRequestUriL(
        							static_cast<CSIPRequest&>(*iOutgoingMsg),
									*iRouteSet,
									*iRemoteTarget);
        UpdateAndSendRequestL(aWaitResponse);

        __TEST_INVARIANT;
        return ETrue;
        }

    return TryNextAddressL(KErrTimedOut, aResolve, aWaitResponse);
    }

// -----------------------------------------------------------------------------
// CUserAgentClient::IgnoreResponseRetransmissionsL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::IgnoreResponseRetransmissionsL()
    {
    __TEST_INVARIANT;
    __SIP_ASSERT_LEAVE(!iTransaction, KErrSIPInvalidTransactionState);

    RemoveFromStore();
    CleanupStack::PushL(this);

    CTransactionBase::TTransactionType taType =
        CTransactionBase::KClientTransaction;
    if (IsInviteUAC())
        {
        taType = CTransactionBase::KClientInviteTransaction;
        }

    // Set message NULL, to prevent responses being routed to UAC
    iTransactionStore.AddL(TransactionId(), this, NULL, NULL, taType);
    CleanupStack::Pop(this);

    __TEST_INVARIANT;
    }

// -----------------------------------------------------------------------------
// CUserAgentClient::CancelSIPSecRequest
// No __TEST_INVARIANT as destructor may lead here.
// -----------------------------------------------------------------------------
//
void CUserAgentClient::CancelSIPSecRequest()
    {
    iIgnoreSIPSecCallback = ETrue;
    iSIPSec.CancelPendingOperations(*this);
    iIgnoreSIPSecCallback = EFalse;
    }

// -----------------------------------------------------------------------------
// CUserAgentClient::TryNextAddressL
// -----------------------------------------------------------------------------
//
TBool CUserAgentClient::TryNextAddressL(TInt aError,
										const CUserAgentState& aResolve,
										const CUserAgentState& aWaitResponse,
										CSIPResponse* aResp)
	{
	__TEST_INVARIANT;
	__SIP_INT_LOG1( "CUserAgentClient TryNextAddressL Error",
					aError )
	__SIP_ASSERT_LEAVE((aError != KErrNone && !aResp) ||
					   (aError == KErrNone && aResp), KErrArgument);

	if (SelectNextRemoteAddressL())
		{
		UpdateAndSendRequestL(aWaitResponse);
		delete aResp;
		return ETrue;
		}

	if (iResolvingResults->ContinueResolvingCurrentUri())
		{
		__SIP_ASSERT_LEAVE(!iIncomingMsg, KErrAlreadyExists);

		UpdateAndResolveL(ETrue, aResolve);
		iLastError = aError;
		iIncomingMsg = aResp;
		return ETrue;
		}

    if (iLastError != KErrNone)
        {
        aError = iLastError;
        }
    
	// If a stored response exists, next hop has responded.
	// Stateless proxy can result KErrTimedOut if its next hop doesn't respond,
	// even if the proxy is ok. So URIFailed isn't used for KErrTimedOut.	
	if ((aError == KErrSIPTransportFailure ||
		 aError == KErrSIPResolvingFailure ||
		 aError == KErrSIPICMPFailure) &&
		 !iIncomingMsg && !iResponseReceived)
		{
		iRegistrations.URIFailed(NextHopL());
		// Registrations may've used ClearTransactionOwner, stopping UA
		if (HasStopped())
			{
			return EFalse;
			}
		}

	TBool retry = TryOutboundProxyL(aResolve);
	if (retry)
		{
		delete aResp;
		}
	__TEST_INVARIANT;
	return retry;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::TryOutboundProxyL
// -----------------------------------------------------------------------------
//
TBool CUserAgentClient::TryOutboundProxyL(const CUserAgentState& aResolve)
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(iRouteSet && iRemoteTarget && iRequestUri, KErrNotFound);

    const CSIPRouteHeader* proxy = iRegistrations.OutboundProxy(iRegisterId);
	if (iRouteSet->PreconfigRouteExists() &&
        !iOutboundProxyHasBeenTried && proxy)
		{
        const CURIContainer& proxyUri = proxy->SIPAddress().URI();

      	if ( !((NextHopL() == proxyUri) || proxyUri == *iRequestUri) )
            {
			iRouteSet->AddToBeginningL(*proxy, EFalse /* append */);
			SIPRequestUtility::FillRouteAndRequestUriL(
							static_cast<CSIPRequest&>(*iOutgoingMsg),
							*iRouteSet,
							*iRemoteTarget);
			UpdateAndResolveL(ETrue, aResolve);
			iOutboundProxyHasBeenTried = ETrue;

			__TEST_INVARIANT;
			return ETrue;
            }
		}
	return EFalse;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::DetachCurrentTransactionL
// Request must've been updated or there'd be 2 transactions with a same branch
// -----------------------------------------------------------------------------
//
void CUserAgentClient::DetachCurrentTransactionL()
	{
	__TEST_INVARIANT;

	if (iTransaction)
		{
		if (iTransaction->HasTerminated())
			{
            // Cancel transaction's send so new transaction can send
			iTransmitter->Cancel();
            RequestDeletionOfTransactionL();
			RemoveFromStore();
			}
		else
			{			
			TTransactionId newId = iTransactionStore.NewTransactionId();
            PrepareTxForNewRequestL(newId);
			User::LeaveIfError(iTransactionStore.UpdateTransactionId(
										            TransactionId(), newId));
			if (IsInviteUAC())
				{
				__SIP_INT_LOG2( "TU taID changed, old -> new",
				                TransactionId(), newId )
                }
			iTransaction->DetachFromUserAgent();
			iTransaction->ClearSendBuffer();
			iTransaction = NULL;

			iTransactionStore.ClearUserAgent(newId);
			}

		CleanupStack::PushL(this);
        __SIP_ASSERT_LEAVE(!iTransaction, KErrAlreadyExists);
        __SIP_ASSERT_LEAVE(iOutgoingMsg, KErrNotFound);

		iTransactionStore.AddL(TransactionId(),
				   this,
				   iTransaction,
				   iOutgoingMsg,
                   CSIPMessageUtility::TransactionType(*iOutgoingMsg, EFalse));
		CleanupStack::Pop(this);
		}
	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::UpdateAndSendRequestL
// -----------------------------------------------------------------------------
//
void
CUserAgentClient::UpdateAndSendRequestL(const CUserAgentState& aWaitResponse)
	{
	__TEST_INVARIANT;
    __SIP_ASSERT_LEAVE(iOutgoingMsg, KErrNotFound);

	UpdateViaAndCSeqL();
	if (!CSIPMessageUtility::IsAck(*iOutgoingMsg))
		{
		DetachCurrentTransactionL();
		CreateTransactionL();
		}

	UpdateInfoToStoreL(static_cast<CSIPRequest*>(iOutgoingMsg));
	SendRequestToNetworkL();
	ChangeState(aWaitResponse);

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::UpdateAndResolveL
// -----------------------------------------------------------------------------
//
void CUserAgentClient::UpdateAndResolveL(TBool aCheckSigComp,
										 const CUserAgentState& aResolve)
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(iOutgoingMsg, KErrNotFound);

	UpdateViaAndCSeqL();	
	DetachCurrentTransactionL();
	UpdateInfoToStoreL(static_cast<CSIPRequest*>(iOutgoingMsg));
	ResolveNextHopL(aCheckSigComp);
	ChangeState(aResolve);

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::StopWithLastError
// -----------------------------------------------------------------------------
//
void CUserAgentClient::StopWithLastError()
	{
	__TEST_INVARIANT;

	if (iIncomingMsg)
		{
		CSIPMessage* msg = iIncomingMsg;
		iIncomingMsg = NULL;
		TRAPD(err, PassMsgToTransactionOwnerL(msg));
		if (err != KErrNone)
			{
			delete msg;
			}
		}
	else
		{
		if (iLastError == KErrNone)
			{
			// Resolving URI for the first time fails
			iLastError = KErrSIPResolvingFailure;
			}
		}
	Stop(iLastError);
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::DetachOutgoingMsg
// If transaction can't proceed w/o the message, terminate it silently.
// -----------------------------------------------------------------------------
//
void CUserAgentClient::DetachOutgoingMsg()
	{
	__TEST_INVARIANT;

	iOutgoingMsg = NULL;
	iTransmitter->Cancel();
    CancelSIPSecRequest();

	if (iTransaction && !iTransaction->ClearSendBuffer())
		{
		iTransaction->DetachFromUserAgent();
		iTransaction->Terminated();
		}
	else
		{
		if (State().CanContinueWithoutOutgoingMsg(iFinalRespPassed))
			{
			return;
			}
		}

	Stop(KErrNone);
	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::UseSIPSec
// -----------------------------------------------------------------------------
//
TBool CUserAgentClient::UseSIPSec() const
	{
	__TEST_INVARIANT;
	return (iObserver && 
	        iObserver->SIPSecUser() && 
	        !iObserver->SIPSecUser()->ByPassSIPSec());
	}

// -----------------------------------------------------------------------------
// CUserAgentClient::NextHopIP
// -----------------------------------------------------------------------------
//
const TInetAddr& CUserAgentClient::NextHopIP() const
    {
    return iRemoteAddr;
    }

// -----------------------------------------------------------------------------
// CUserAgentClient::__DbgTestInvariant
// -----------------------------------------------------------------------------
//

void CUserAgentClient::__DbgTestInvariant() const
	{
	if ((iOutgoingMsg && !iOutgoingMsg->IsRequest()) ||
		(iIncomingMsg && iIncomingMsg->IsRequest()) ||
        (iSIPSecCounter > SIPRequestUtility::EMaxForwardsValue + 1) ||        
        !iResolvingResults)
		{
		User::Invariant();
		}
	}