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

// Part of       : TransactionUser

// Version       : SIP/5.0

//

#include "SipAssert.h"

#include "siperr.h"

#include "siprequest.h"

#include "sipresponse.h"

#include "siptoheader.h"

#include "sipmaxforwardsheader.h"

#include "uricontainer.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "MSipRegistrations.h"

#include "MSipDialogs.h"

#include "MSIPRequestRouter.h"

#include "Transmitter.h"

#include "UserAgentServer.h"

#include "UserAgentState.h"

#include "UserAgentTimer.h"

#include "TimerValues.h"

#include "CTransactionStore.h"

#include "SIPMessageUtility.h"

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

// CUserAgentServer::CUserAgentServer

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

//

CUserAgentServer::CUserAgentServer(CUserAgentCreateParams& aParams,

                                   MSipDialogs& aDialogs,

                                   MSIPRequestRouter& aRouter) :

	CUserAgent(aParams),

    iDialogs(aDialogs),

    iRouter(aRouter)

	{

	}

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

// CUserAgentServer::~CUserAgentServer

// If transaction exists or InviteUAS sent a 2xx, inform ConnectionMgr to stop

// using the responses.

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

//

CUserAgentServer::~CUserAgentServer()

	{

	CancelGetOwnerRequest();

	iToTag.Close();

	if (iTransmitter)

		{

        iTransmitter->CancelSendResponses(CUserAgent::TransactionId(), ETrue);        

		}

	}

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

// CUserAgentServer::IsUAS

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

//

TBool CUserAgentServer::IsUAS() const

	{

	__TEST_INVARIANT;

	return ETrue;

	}

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

// CUserAgentServer::RegistrationId

// UAS doesn't have a registration ID.

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

//

TRegistrationId CUserAgentServer::RegistrationId() const

	{

	__TEST_INVARIANT;

	return KEmptyRegistrationId;

	}

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

// CUserAgentServer::OwnerFoundL

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

//

void

CUserAgentServer::OwnerFoundL(TUint32 aRequestId, MTransactionOwner* aOwner)

	{

	__TEST_INVARIANT;

    __SIP_ASSERT_LEAVE(aOwner && aRequestId == iRouterRequestId, KErrArgument);

	if (!HasStopped())

		{				

		State().OwnerFoundL(*this, aOwner);

		}

	__TEST_INVARIANT;

	}

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

// CUserAgentServer::OwnerNotFoundL

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

//

void CUserAgentServer::OwnerNotFoundL(TUint32 aRequestId, CSIPResponse* aResp)

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(aResp && aRequestId == iRouterRequestId, KErrArgument);

	if (HasStopped())

		{

		delete aResp;

		}

	else

		{

		State().OwnerNotFoundL(*this, aResp);

		}	

	__TEST_INVARIANT;

    }

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

// CUserAgentServer::ErrorOccurred

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

//

void CUserAgentServer::ErrorOccurred(TUint32 aRequestId, TInt aError)

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(aRequestId == iRouterRequestId, KErrArgument);

	StopTimerOwnerResolver();

	if (aError == KErrNoMemory)

		{

		Stop(aError);

		}

	else

		{

		TRAPD(err, RequestRouterErrorL());

		if (err != KErrNone)

			{

			Stop(aError);

			}

		}

	__TEST_INVARIANT;

	}

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

// CUserAgentServer::RequestRouterErrorL

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

//

void CUserAgentServer::RequestRouterErrorL()

    {

    __TEST_INVARIANT;

	if (!HasStopped())

		{

		State().RequestRouterErrorL(*this);

		}

	__TEST_INVARIANT;

    }

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

// CUserAgentServer::InitialRequestReceivedL

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

//

void CUserAgentServer::InitialRequestReceivedL(CSIPRequest* aReq,

									  const CUserAgentState& aGetTxOwner,

									  const CUserAgentState& aWaitRespFromApp,

									  const CUserAgentState& aErrorRespSent)

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(aReq, KErrArgument);

	if (!UpdateTransportProtocol(*aReq))

		{

		delete aReq;

		Stop(KErrNone);

		return;

		}

    StoreToTag(*aReq);

	TInt responseCode = 0;

	RStringF reasonPhrase;

	if (CheckReceivedRequest(*aReq, responseCode, reasonPhrase))

		{

		iTransactionStore.StoreContactHeadersL(TransactionId(), *aReq);        

		if (DoesDialogExistForRequestL(*aReq))

			{

			//Enter next state before passing request. If upper layer sends

			//response synchronously in PassMsgToTransactionOwnerL, UAS is in a

			//correct state to handle it.

			ChangeState(aWaitRespFromApp);

			PassMsgToTransactionOwnerL(aReq);

			}

		else

			{

			RequestOutsideDialogL(aReq, aGetTxOwner, aErrorRespSent);

			}

		}

	else

		{

		SendErrorResponseL(responseCode, reasonPhrase, aErrorRespSent);

		delete aReq;

		}

	__TEST_INVARIANT;

	}

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

// CUserAgentServer::CheckReceivedRequest

// If no To-tag, compare request to ongoing transactions to see if it is a

// merged request.

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

//

TBool CUserAgentServer::CheckReceivedRequest(CSIPRequest& aReq,

											 TInt& aResponseCode,

											 RStringF& aReasonPhrase) const

	{

	__TEST_INVARIANT;

    __ASSERT_ALWAYS(aReq.To() != NULL,

					User::Panic(_L("UAS:ChkRcvReq to"), KErrArgument));

	if (aReq.HasHeader(SIPStrings::StringF(SipStrConsts::EMaxForwardsHeader)))

		{

		TSglQueIter<CSIPHeaderBase> iter =

            aReq.Headers(SIPStrings::StringF(SipStrConsts::EMaxForwardsHeader));

		CSIPMaxForwardsHeader& maxForw =

            static_cast<CSIPMaxForwardsHeader&>(*iter);

		if (maxForw.Value() == 0)

			{

			aReasonPhrase =

				SIPStrings::StringF(SipStrConsts::EPhraseTooManyHops);

			aResponseCode = 483;

			return EFalse;

			}

        }

	if (!aReq.To()->HasParam(SIPStrings::StringF(SipStrConsts::ETag)) &&

		iTransactionStore.IsMergedRequest(*this, aReq))

		{

		aReasonPhrase =

				SIPStrings::StringF(SipStrConsts::EPhraseLoopDetected);		

		aResponseCode = 482;

		return EFalse;

		}

	return ETrue;

	}

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

// CUserAgentServer::DoesDialogExistForRequestL

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

//

TBool CUserAgentServer::DoesDialogExistForRequestL(CSIPRequest& aReq)

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(!iObserver && !iOutgoingMsg, KErrAlreadyExists);

	CSIPResponse* resp = NULL;

	iObserver = iDialogs.TransactionOwnerL(aReq, &resp);

    if (!iObserver && resp)

		{

		iOutgoingMsg = resp;

		}

    __TEST_INVARIANT;

    return iObserver != NULL;

	}

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

// CUserAgentServer::RequestOutsideDialogL

// If registration subsystem does not recognize the Request-URI, a 404 is sent.

// Record-Routes are only stored from requests outside dialog

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

//

void

CUserAgentServer::RequestOutsideDialogL(CSIPRequest* aReq,

										const CUserAgentState& aGetTxOwner,

										const CUserAgentState& aErrorRespSent)

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(aReq, KErrArgument);

	if (iOutgoingMsg)

		{

		HandleResponseFromDialogsL(aErrorRespSent);

		}

	else

		{		

		CURIContainer* uri = aReq->RequestURI();			

		if (uri && iRegistrations.CheckRequestURI(*uri))

			{

			TRAPD(err, iRouterRequestId =

		        iRouter.TransactionOwnerL(*aReq,

										  TransportParams().IapId(),

									      *this));

			if (err == KErrNone)

				{

	            StartTimerOwnerResolverL();

				iTransactionStore.StoreRecordRouteHeadersL(TransactionId(),

	                	                                   *aReq);

				__SIP_ASSERT_LEAVE(!iIncomingMsg, KErrAlreadyExists);

				iIncomingMsg = aReq;

				ChangeState(aGetTxOwner);

				return; //aReq is not deleted

				}

			SendErrorResponseL(603,

						   SIPStrings::StringF(SipStrConsts::EPhraseDecline),

						   aErrorRespSent);

			}

		else

			{

			SendErrorResponseL(404,

							SIPStrings::StringF(SipStrConsts::EPhraseNotFound),

							aErrorRespSent);

			}

	    }

	delete aReq;

	__TEST_INVARIANT;

	}

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

// CUserAgentServer::SendErrorResponseL

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

//

void CUserAgentServer::SendErrorResponseL(TInt aResponseCode,

										  RStringF aReasonPhrase,

										  const CUserAgentState& aErrorRespSent)

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(aResponseCode >= 300, KErrArgument);

	CSIPResponse* resp = CSIPResponse::NewLC(aResponseCode, aReasonPhrase);

	FillResponseL(*resp);

	ChangeState(aErrorRespSent);

	SendResponseToTransactionL(resp);

	CleanupStack::Pop(resp);

	__TEST_INVARIANT;

	}

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

// CUserAgentServer::CheckResponseL

// Via headers should not be present yet. UAS copies them from the request.

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

//

void CUserAgentServer::CheckResponseL(const CSIPResponse& aResp) const

	{

	__TEST_INVARIANT;

    if (aResp.HasHeader(SIPStrings::StringF(SipStrConsts::EViaHeader)))

        {

        User::Leave(KErrSIPMalformedMessage);

        }

	}

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

// CUserAgentServer::FillResponseL

// If the To-header doesn't yet have a tag, it's added unless the response is

// 100. If a tag has already been generated, it is used for all responses.

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

//

void CUserAgentServer::FillResponseL(CSIPResponse& aResp)

	{

	__TEST_INVARIANT;

	iTransactionStore.CopyHeadersToResponseL(TransactionId(), aResp);

    CheckContactHeadersL(aResp, aResp.To());

	RStringF tag = SIPStrings::StringF(SipStrConsts::ETag);

	if (aResp.ResponseCode() > 100)

		{

        CSIPToHeader* to = aResp.To();

        __SIP_ASSERT_LEAVE(to != NULL, KErrArgument);

        if (iToTag.DesC().Length() > 0)

            {

            if (!to->HasParam(tag))

                {

                to->SetParamL(tag, iToTag);

                }

            }

        else

            {

            if (!to->HasParam(tag))

                {

                //Generate the tag after CopyHeadersToResponseL so SIP headers

                //can be used as random input for tag.

				AddTagL(*to);

                }

			StoreToTag(aResp);

			//Put the tag to store. Routing of an ACK needs it.

			iTransactionStore.UpdateToTagL(TransactionId(), iToTag);

            }

		}

	__TEST_INVARIANT;

	}

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

// CUserAgentServer::StoreToTag

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

//

void CUserAgentServer::StoreToTag(CSIPMessage& aMsg)

    {

    __TEST_INVARIANT;

    __ASSERT_ALWAYS(iToTag.DesC().Length() == 0,

    				User::Panic(_L("StoreToTag exist"), KErrAlreadyExists));

    CSIPToHeader* to = aMsg.To();

    __ASSERT_ALWAYS(to != NULL,

    				User::Panic(_L("StoreToTag !to"), KErrArgument));

    if (to->HasParam(SIPStrings::StringF(SipStrConsts::ETag)))

        {

        iToTag.Close();

		iToTag = to->ParamValue(SIPStrings::StringF(SipStrConsts::ETag)).Copy();

        }

    __TEST_INVARIANT;

    }

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

// CUserAgentServer::SendResponseToTransactionL

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

//

void CUserAgentServer::SendResponseToTransactionL(CSIPResponse* aResp) const

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(iTransaction, KErrNotFound);

	__SIP_ASSERT_LEAVE(aResp, KErrArgument);

	iTransaction->SendResponseL(aResp, iTransportProtocol, TransportParams());

	}

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

// CUserAgentServer::HandleResponseFromDialogsL

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

//

void

CUserAgentServer::HandleResponseFromDialogsL(const CUserAgentState& aNextState)

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(iOutgoingMsg, KErrNotFound);

	CSIPResponse* resp = static_cast<CSIPResponse*>(iOutgoingMsg);

    __SIP_ASSERT_LEAVE(resp->IsErrorResponse(), KErrSIPMalformedMessage);

	FillResponseL(*resp);

	ChangeState(aNextState);

	SendResponseToTransactionL(resp);

	iOutgoingMsg = NULL;

	__TEST_INVARIANT;

	}

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

// CUserAgentServer::HandleOwnerFoundL

// Enter next state before passing request to MTransactionOwner. If upper layer

// sends response synchronously in MTransactionOwner::ReceiveL, UAS must be in a

// correct state to handle it.

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

//

void

CUserAgentServer::HandleOwnerFoundL(MTransactionOwner* aOwner,

								    const CUserAgentState& aWaitRespFromApp)

	{

	__TEST_INVARIANT;

	//Observer can be set only once by MSIPRequestRouter. But when application

	//sends a response, it can change MTransactionOwner with every SendL call.

	__SIP_ASSERT_LEAVE(!iObserver, KErrAlreadyExists);

	__SIP_ASSERT_LEAVE(aOwner, KErrArgument);

	iObserver = aOwner;

    StopTimerOwnerResolver();

	ChangeState(aWaitRespFromApp);

	PassStoredRequestToTransactionOwnerL();

	__TEST_INVARIANT;

	}

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

// CUserAgentServer::HandleOwnerNotFoundL

// Response can not be 2xx for INVITE since it has different state in the

// InviteUAS than the error responses.

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

//

void

CUserAgentServer::HandleOwnerNotFoundL(CSIPResponse* aResp,

 									   const CUserAgentState& aFinalRespSent)

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(iIncomingMsg, KErrNotFound);	

	__SIP_ASSERT_LEAVE(aResp && aResp->ResponseCode() >= 200, KErrArgument);

	if (static_cast<CSIPRequest*>(iIncomingMsg)->Method() ==

		SIPStrings::StringF(SipStrConsts::EInvite))

		{

		__SIP_ASSERT_LEAVE(aResp->ResponseCode() >= 300, KErrArgument);