// Copyright (c) 2007-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          : UserAgent.cpp

// Part of       : TransactionUser

// Version       : SIP/6.0 

//

#include "siperr.h"

#include "SipAssert.h"

#include "siprequest.h"

#include "sipresponse.h"

#include "sipuri.h"

#include "uricontainer.h"

#include "siphostport.h"

#include "sipaddress.h"

#include "sipfromtoheaderbase.h"

#include "sipcontactheader.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "SipLogs.h"

#include "DeleteMgr.h"

#include "Transmitter.h"

#include "MSipRegistrationContact.h"

#include "MTransactionOwner.h"

#include "CUserAgent.h"

#include "UserAgentState.h"

#include "UserAgentCreateParams.h"

#include "CTransactionStore.h"

#include "SIPMessageUtility.h"

#include "MTransactionUser.h"

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

// CUserAgent::CUserAgent

// aObserver is NULL for UAS

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

//

CUserAgent::CUserAgent(const CUserAgentCreateParams& aParams) :	

	iObserver(aParams.iObserver),	

	iTimers(aParams.iTimers),

	iRegistrations(aParams.iRegistrations),

    iRegistrationContact(aParams.iRegistrationContact),

    iSigComp(aParams.iSigComp),

	iTransactionStore(aParams.iTransactionStore),

	iTransactionMgr(aParams.iTransactionMgr),	

	iTransportProtocol(SIPStrings::StringF(SipStrConsts::EUDP)),

	iTransportParams(aParams.iTransportParams),

	iTimerValues(aParams.iTimerValues),

	iOwnsOutgoingMsg(aParams.iOwnsOutgoingMsg),

	iDeleteMgr(aParams.iDeleteMgr),

	iSIPMsgUtility(aParams.iSIPMsgUtility),    

	iState(aParams.iInitialUaState),

	iTransactionId(aParams.iTransactionId)

	{

	__SIP_ASSERT_RETURN(iTransactionId != KEmptyTransactionId, KErrArgument);

    __SIP_ASSERT_RETURN(iState != NULL, KErrArgument);

	}

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

// CUserAgent::ConstructL

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

//

void CUserAgent::ConstructL(MSipConnectionMgr& aConnectionMgr)

	{

	iTransmitter = CTransmitter::NewL(aConnectionMgr);

	}

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

// CUserAgent::~CUserAgent

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

//

CUserAgent::~CUserAgent()

	{

	delete iTransmitter;

	delete iTransaction;

	if (iOwnsOutgoingMsg)

		{

		delete iOutgoingMsg;

		}

	delete iIncomingMsg;

	iTransportProtocol.Close();	

	}

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

// CUserAgent::TransportParams

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

//

const TSIPTransportParams& CUserAgent::TransportParams() const

    {

    __TEST_INVARIANT;

    return iTransportParams;

    }

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

// CUserAgent::CleanupSilently

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

//

void CUserAgent::CleanupSilently(TAny* aUserAgent)

	{

	__SIP_ASSERT_RETURN(aUserAgent, KErrArgument);

	CUserAgent* ua = reinterpret_cast<CUserAgent*>(aUserAgent);

	ua->ClearTransactionOwner(); // Prevent MTransactionOwner::TransactionEnded

	ua->Stop(KErrGeneral); 		 // End silently, error code doesn't matter

	}

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

// CUserAgent::SendRequestL

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

//

void CUserAgent::SendRequestL(CSIPRequest* aReq,

							  TRegistrationId aRegisterId,

							  const CURIContainer& aRemoteTarget)

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(aReq, KErrArgument);

    __ASSERT_ALWAYS(!iStopped, User::Leave(KErrSIPInvalidTransactionState));

	iState->SendRequestL(*this, aReq, aRegisterId, aRemoteTarget);

	__TEST_INVARIANT;

	}

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

// CUserAgent::SendResponseL

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

//

void CUserAgent::SendResponseL(CSIPResponse* aResp,

							   const TSIPTransportParams& aParams)

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(aResp, KErrArgument);

    __ASSERT_ALWAYS(!iStopped, User::Leave(KErrSIPInvalidTransactionState));

    iState->SendResponseL(*this, aResp, aParams);	

	__TEST_INVARIANT;

	}

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

// CUserAgent::SendCancelL

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

//

void CUserAgent::SendCancelL(TTransactionId aInviteTaId)

	{

	__TEST_INVARIANT;

    __ASSERT_ALWAYS(!iStopped, User::Leave(KErrSIPInvalidTransactionState));

	iState->SendCancelL(*this, aInviteTaId);

	__TEST_INVARIANT;

	}

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

// CUserAgent::TransactionOwner

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

//

const MTransactionOwner* CUserAgent::TransactionOwner() const

	{

	__TEST_INVARIANT;

	return iObserver;

	}

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

// CUserAgent::ClearTransactionOwner

// Detach iOutgoingMsg unless owned, as the upper layer can delete it.

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

//

void CUserAgent::ClearTransactionOwner()

	{

	__TEST_INVARIANT;

	iObserver = NULL;

	if (!iOwnsOutgoingMsg)

        {

        DetachOutgoingMsg();

        }

	if (iState->ShouldUASStop())

		{

		Stop(KErrNone);

		}

	__TEST_INVARIANT;

	}

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

// CUserAgent::DetachOutgoingMsg

// No action.

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

//

void CUserAgent::DetachOutgoingMsg()

	{

	}

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

// CUserAgent::ReceiveL

// Write request to log, if it came directly from ConnectionMgr.

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

//

void CUserAgent::ReceiveL(CSIPRequest* aRequest)

    {

    __TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(aRequest, KErrArgument);

	if (iStopped)

		{

		delete aRequest;

		}

	else

        {

		if (!iTransaction)

			{

			__SIP_MESSAGE_LOG("TransactionUser", *aRequest)

			}

		iState->ReceiveL(*this, aRequest);

		}

	__TEST_INVARIANT;

    }

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

// CUserAgent::ReceiveL

// Write response to log, if it came directly from ConnectionMgr.

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

//

void CUserAgent::ReceiveL(CSIPResponse* aResponse)

    {

    __TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(aResponse, KErrArgument);

	if (iStopped)

		{

		delete aResponse;

		}

	else

		{

		if (!iTransaction)

			{

			__SIP_MESSAGE_LOG("TransactionUser", *aResponse)

			}

		iState->ReceiveL(*this, aResponse);

		}

	__TEST_INVARIANT;

    }

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

// CUserAgent::LeaveOccurred

// If Dialog drops a response, it leaves with KErrSIPInvalidDialogResponse.

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

//

void CUserAgent::LeaveOccurred(TInt aReason)

	{

	__TEST_INVARIANT;

	__SIP_INT_LOG1( "CUser Agent :: LeaveOccured with reason", 

   			                aReason )

	if (aReason != KErrSIPInvalidDialogResponse)

		{

		Stop(aReason);

		}

	__TEST_INVARIANT;

	}

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

// CUserAgent::SendCompleteL

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

//

void CUserAgent::SendCompleteL()

	{

	__TEST_INVARIANT;

	if (!iStopped)

		{

		iState->SendCompleteL(*this);

		}

	__TEST_INVARIANT;

	}

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

// CUserAgent::SendFailedL

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

//

void CUserAgent::SendFailedL(TInt aError)

	{

	__TEST_INVARIANT;

	__SIP_INT_LOG1( "CUserAgent Sending failed with Error",

					aError )

	if (!iStopped)

        {

        iState->SendFailedL(*this, aError);

		}

	__TEST_INVARIANT;

	}

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

// CUserAgent::LeaveFromTransmitter

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

//

void CUserAgent::LeaveFromTransmitter(TInt aReason)

	{

	__TEST_INVARIANT;

	__ASSERT_DEBUG(aReason != KErrNone,

				   User::Panic(_L("UA:LeaveFromTransmitter"), KErrArgument));

	Stop(aReason);

	__TEST_INVARIANT;

	}

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

// CUserAgent::TimerExpiredL

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

//

void CUserAgent::TimerExpiredL(TTimerId aTimerId, TAny* aTimerParam)

	{

	__TEST_INVARIANT;

	if (!iStopped)

		{

		iState->TimerExpiredL(*this, aTimerId, aTimerParam);

		}

	__TEST_INVARIANT;

	}

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

// CUserAgent::DeleteTimer

// The concrete UA must implement DeleteTimer.

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

//

void CUserAgent::DeleteTimer(const CUserAgentTimer& /*aTimer*/) 

	{

	__TEST_INVARIANT;

    __SIP_ASSERT_RETURN(EFalse, KErrGeneral);

	}

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

// CUserAgent::StoreOutgoingMsg

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

//

void CUserAgent::StoreOutgoingMsg(CSIPMessage* aMsg)

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_RETURN(aMsg, KErrArgument);

	if (iOwnsOutgoingMsg)

		{

		delete iOutgoingMsg;

		}

	iOutgoingMsg = aMsg;

	__TEST_INVARIANT;

	}

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

// CUserAgent::IsInviteUAC

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

//

TBool CUserAgent::IsInviteUAC() const

	{

	__TEST_INVARIANT;

	return EFalse;

	}

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

// CUserAgent::IsSubInviteUAC

// Don't call __TEST_INVARIANT here to avoid recursion

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

//

TBool CUserAgent::IsSubInviteUAC() const

	{

	return EFalse;

	}

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

// CUserAgent::State

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

//

const CUserAgentState& CUserAgent::State() const

    {

    __TEST_INVARIANT;

    return *iState;

    }

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

// CUserAgent::ChangeState

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

//

void CUserAgent::ChangeState(const CUserAgentState& aNewState)

	{

	__TEST_INVARIANT;

	iState = &aNewState;

	__TEST_INVARIANT;

	}

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

// CUserAgent::IsResolving

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

//

TBool CUserAgent::IsResolving() const

	{

	__TEST_INVARIANT;

	return iState->IsResolving(); 

	}

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

// CUserAgent::UpdateTransactionOwner

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

//

void CUserAgent::UpdateTransactionOwner(MTransactionOwner* aNewObserver)

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_RETURN(aNewObserver, KErrArgument);

	iObserver = aNewObserver;

	__TEST_INVARIANT;

	}

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

// CUserAgent::TransactionEndsL

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

//

void CUserAgent::TransactionEndsL(TInt aReason)

	{

	__TEST_INVARIANT;

	iState->TransactionEndsL(*this, aReason);

	__TEST_INVARIANT;

	}

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

// CUserAgent::PassMsgToTransactionOwnerL

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

//

void CUserAgent::PassMsgToTransactionOwnerL(CSIPMessage* aMsg) const

	{

	__TEST_INVARIANT;

	__SIP_ASSERT_LEAVE(aMsg, KErrArgument);

	if (iObserver)

		{

		__SIP_INT_LOG1( "TU passes SIP message to owner, transaction ID", 

		                 iTransactionId )

		if (aMsg->IsRequest())

			{

			CSIPRequest* request = static_cast<CSIPRequest*>(aMsg);

			__SIP_DES8_LOG( "TU SIP request method", 

			                request->Method().DesC() )

			iObserver->ReceiveL(iTransportParams.IapId(),

                                iTransactionId,

								request);

			}

		else

			{

			CSIPResponse* response = static_cast<CSIPResponse*>(aMsg);

			__SIP_INT_LOG1( "TU SIP response code", 

			                response->ResponseCode() )

			iObserver->ReceiveL(iTransactionId, response);

			}

		}

	else

        {

    	__SIP_INT_LOG1(

    	    "TU msg not passed to owner, iObserver==NULL, transaction ID",

    	    iTransactionId )

		delete aMsg;

		}

	}

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

// CUserAgent::UpdateTransportProtocol

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

//

TBool CUserAgent::UpdateTransportProtocol(CSIPMessage& aMsg)

	{

	__TEST_INVARIANT;

	return CSIPMessageUtility::TransportProtocol(aMsg, iTransportProtocol);

	}

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

// CUserAgent::AddTagL

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

//

void CUserAgent::AddTagL(CSIPFromToHeaderBase& aToFromHeader) const

	{

	__TEST_INVARIANT;

	TBuf8<MTransactionUser::KTagLength> tagBuf;

	AddRandomStringL(tagBuf, MTransactionUser::KTagLength, EFalse);

	RStringF tag = SIPStrings::Pool().OpenFStringL(tagBuf);

	CleanupClosePushL(tag);

	aToFromHeader.SetParamL(SIPStrings::StringF(SipStrConsts::ETag), tag);

	CleanupStack::PopAndDestroy(); // tag