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