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

// Part of       : Transaction

// Version       : SIP/5.0

//

#include "SipAssert.h"

#include "siperr.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "Lwtimer.h"

#include "siprequest.h"

#include "sipresponse.h"

#include "UserAgentBase.h"

#include "Transmitter.h"

#include "SIPMessageUtility.h"

#include "CTransaction.h"

#include "TransactionState.h"

#include "SipLogs.h"

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

// CTransaction::CTransaction

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

//

CTransaction::CTransaction(CUserAgentBase& aUserAgent,

						   CTransmitter& aTransmitter,

						   MTimerManager& aTimers,

						   CTransactionState& aInitialState,

						   TTimerValues& aTimerValues) :

	iUserAgent(&aUserAgent),

	iTransmitter(&aTransmitter),

	iTimers(aTimers),

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

	iTransportParams(aUserAgent.TransportParams()),

	iTimerValues(aTimerValues),

	iTerminated(EFalse),

	iState(&aInitialState)

	{

#if defined(USE_SIP_LOGS)

	WriteStateToLog(*iState);

#endif

	}

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

// CTransaction::~CTransaction

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

//

CTransaction::~CTransaction()

	{

	}

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

// CTransaction::TransactionId

// This function is only used by UAS. CClientTransaction overloads this.

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

//

TTransactionId CTransaction::TransactionId() const

	{

	__TEST_INVARIANT;

	__ASSERT_DEBUG(iUserAgent,

				   User::Panic(_L("CTransaction:TaId"), KErrGeneral));

	return iUserAgent->TransactionId();

	}

#if defined(USE_SIP_LOGS)

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

// CTransaction::WriteStateToLog

// Only INVITE transactions write logs.

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

//

void CTransaction::WriteStateToLog(const CTransactionState& aState) const

	{

	const TDesC8& log = aState.Log();

	if (log.Length() > 0)

		{

		//If INVITE-UAC stops transaction as a 2xx was received, UAC writes the

		//transaction state to log as transaction won't have the TransactionId.

		TTransactionId id = TransactionId();

		if (id != KEmptyTransactionId)

			{

			TBuf8<40> state;

			if (iTerminated)

				{

				state.Copy(_L8("Terminated"));

				}

			else

				{				

                if (log.Compare(

                    CTransactionState::EnteringThisStateIsntLogged()) == 0)

					{

					return;

					}

				state.Copy(log);

				}

			__SIP_INT_LOG1( "TU transaction, taID", id )

			__SIP_DES8_LOG( "TU transaction, state", state )

			}

		}

	}

#endif

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

// CTransaction::SendRequestL

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

//

void CTransaction::SendRequestL(CSIPRequest& aReq,

								const TInetAddr& aRemoteAddr,

								RStringF aProtocol,

								TBool aForceUDP,

								const TSIPTransportParams& aParams,

								CUri8* aOutboundProxy)

	{

	__TEST_INVARIANT;

    __SIP_ASSERT_LEAVE(CSIPMessageUtility::CheckTransport(aProtocol),

                       KErrArgument);

	if (iTerminated)

		{

		User::Leave(KErrSIPInvalidTransactionState);

		}

	iState->SendRequestL(*this,

						 aReq,

						 aRemoteAddr,

						 aProtocol,

						 aForceUDP,

						 aParams,

						 aOutboundProxy);

	__TEST_INVARIANT;

	}

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

// CTransaction::SendResponseL

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

//

void CTransaction::SendResponseL(CSIPResponse* aResp,

								 RStringF aProtocol,

								 const TSIPTransportParams& aParams)

	{

	__TEST_INVARIANT;

	CSIPInternalStates::TState state;

    this->GetState(state);

    __SIP_INT_LOG1("CTransaction::SendResponseL Transaciton state is: ", state)

	TTransactionId Id= this->TransactionId();

    __SIP_INT_LOG1("CTransaction::SendResponseL Transaciton ID is: ", Id)

	__SIP_ASSERT_LEAVE(aResp, KErrArgument);

	__SIP_ASSERT_LEAVE(CSIPMessageUtility::CheckTransport(aProtocol),

                       KErrArgument);

	if (iTerminated)

		{

		User::Leave(KErrSIPInvalidTransactionState);

		}

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

	__TEST_INVARIANT;

	}

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

// CTransaction::ReceiveL

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

//

void CTransaction::ReceiveL(CSIPRequest* aRequest)

    {

    __TEST_INVARIANT;

    __SIP_ASSERT_LEAVE(aRequest, KErrArgument);

	__SIP_MESSAGE_LOG("TransactionUser", *aRequest)

	if (iTerminated)

		{

		delete aRequest;

		}

	else

		{

		iState->ReceiveL(*this, aRequest);

		}

	__TEST_INVARIANT;

    }

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

// CTransaction::ReceiveL

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

//

void CTransaction::ReceiveL(CSIPResponse* aResponse)

    {

    __TEST_INVARIANT;

    __SIP_ASSERT_LEAVE(aResponse, KErrArgument);

	__SIP_MESSAGE_LOG("TransactionUser", *aResponse)

	if (iTerminated)

		{

		delete aResponse;

		}

	else

		{

		iState->ReceiveL(*this, aResponse);

		}

	__TEST_INVARIANT;

    }

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

// CTransaction::UpdateTransportProtocol

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

//

TBool CTransaction::UpdateTransportProtocol(CSIPMessage& aMsg)

	{

	__TEST_INVARIANT;

	return CSIPMessageUtility::TransportProtocol(aMsg, iTransportProtocol);

	}

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

// CTransaction::LeaveOccurred

// Use overloaded TerminatedL (not Terminated), to free detached transaction.

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

//

void CTransaction::LeaveOccurred(TInt aReason)

	{

	__TEST_INVARIANT;

	__ASSERT_DEBUG(aReason != KErrNone,

				   User::Panic(_L("CTransaction:LeaveOccurred"), KErrArgument));

    if (aReason != KErrSIPInvalidDialogResponse)

    	{

	    TRAP_IGNORE(TerminatedL(aReason))

		if (iUserAgent)

			{

			iUserAgent->Stop(aReason);

			}

    	}

	__TEST_INVARIANT;

	}

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

// CTransaction::TransportParams

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

//

const TSIPTransportParams& CTransaction::TransportParams() const

	{

	__TEST_INVARIANT;

	return iTransportParams;	

	}

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

// CTransaction::TimerExpiredL

// Ignore timer if terminated. Occurs e.g. if ClientTransaction has timers E and

// F, timer F expires so transaction terminates, but timer E isn't stopped until

// Transaction is deleted.

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

//

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

	{

	__TEST_INVARIANT;

    // Check if it is a Invite transaction

	if (IsInviteTransaction())

	{

		__SIP_LOG("It is invite transaction CTransaction::TimerExpiredL")

	}

	else

	{

		__SIP_LOG("It is non-invite transaction CTransaction::TimerExpiredL")

	}

	// Get the transacton state

	CSIPInternalStates::TState state;

	this->GetState(state);

	__SIP_INT_LOG1("CTransaction::TimerExpiredL Transaciton state is: ", state)

	TTransactionId Id= this->TransactionId();

    __SIP_INT_LOG1("CTransaction::TimerExpiredL Transaciton ID is: ", Id)

	if (!iTerminated)

		{

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

		}

	__TEST_INVARIANT;

	}

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

// CTransaction::SendCompleteL

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

//

void CTransaction::SendCompleteL()

	{

	__TEST_INVARIANT;

	if (!iTerminated)

		{

		iState->SendCompleteL(*this);

		}

	__TEST_INVARIANT;

	}

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

// CTransaction::SendFailedL

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

//

void CTransaction::SendFailedL(TInt aError)

	{

	__TEST_INVARIANT;

	if (!iTerminated)

		{

		iState->SendFailedL(*this, aError);

		}

	__TEST_INVARIANT;

	}

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

// CTransaction::LeaveFromTransmitter

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

//

void CTransaction::LeaveFromTransmitter(TInt aReason)

	{

	__TEST_INVARIANT;

	__ASSERT_DEBUG(aReason != KErrNone,

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

	LeaveOccurred(aReason);

	__TEST_INVARIANT;

	}

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

// CTransaction::IsUnreliableTransportUsed

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

//

TBool CTransaction::IsUnreliableTransportUsed() const

	{

	__TEST_INVARIANT;

	return iTransportProtocol == SIPStrings::StringF(SipStrConsts::EUDP);

	}

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

// CTransaction::IsTransmitterSending

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

//

TBool CTransaction::IsTransmitterSending() const

	{

	__TEST_INVARIANT;

	return iTransmitter && iTransmitter->IsActive();

	}

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

// CTransaction::IsInviteTransaction

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

//

TBool CTransaction::IsInviteTransaction() const

	{

	__TEST_INVARIANT;

	return EFalse;

	}

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

// CTransaction::State

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

//

const CTransactionState* CTransaction::State() const

	{

	__TEST_INVARIANT;

	return iState;

	}

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

// CTransaction::ChangeState

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

//

void CTransaction::ChangeState(const CTransactionState& aNewState)

	{

	__TEST_INVARIANT;

	iState = &aNewState;

#if defined(USE_SIP_LOGS)	

	WriteStateToLog(aNewState);

#endif

	__TEST_INVARIANT;

	}

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

// CTransaction::ClearSendBuffer

// If buffer has ACK, CInviteClientTransaction created and owns it.

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

//

TBool CTransaction::ClearSendBuffer()

	{

	__TEST_INVARIANT;

	if (iOutgoingMsg && CSIPMessageUtility::IsAck(*iOutgoingMsg))

		{

		return ETrue;

		}

	//Can't use iOutgoingMsg anymore. Cancel a possible sending so ConnectionMgr

	//won't use it either.

	iOutgoingMsg = NULL;

	if (iTransmitter)

    	{

		iTransmitter->Cancel();

    	}

	//A terminated transaction can continue without iOutgoingMsg

	return iTerminated || iState->CanContinueWithoutOutgoingMsg();

	}

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

// CTransaction::GetState

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

//

void CTransaction::GetState(CSIPInternalStates::TState& aState)

    {

    __TEST_INVARIANT;

    if (iTerminated)

        {

        aState = CSIPInternalStates::ETransactionTerminated;        

        }

    else

        {        

        iState->GetState(aState);

        }

    }

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

// CTransaction::Terminated

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

//

void CTransaction::Terminated()

	{

	__TEST_INVARIANT;

	if (!iTerminated)

		{

		iTerminated = ETrue;

#if defined(USE_SIP_LOGS)

		WriteStateToLog(*iState);

#endif

        if (iTransmitter)

        	{

			iTransmitter->DetachCallback(this);

        	}

		}

	__TEST_INVARIANT;

	}

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

// CTransaction::TerminatedL

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

//

void CTransaction::TerminatedL(TInt aReason)

	{

	__TEST_INVARIANT;

#if defined(USE_SIP_LOGS)

        WriteStateToLog(*iState);

#endif

	if (!iTerminated)

		{

		Terminated();

		if (iUserAgent)

			{

			iUserAgent->TransactionEndsL(aReason);

            }

		}

	__TEST_INVARIANT;

    }

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

// CTransaction::HasTerminated

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

//

TBool CTransaction::HasTerminated() const

	{

    __TEST_INVARIANT;

	return iTerminated;

	}

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

// CTransaction::DetachFromUserAgent

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

//

void CTransaction::DetachFromUserAgent()

	{

	__TEST_INVARIANT;

    __SIP_ASSERT_RETURN(iUserAgent, KErrNotFound);

	iUserAgent = NULL;

	__TEST_INVARIANT;

	}

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

// CTransaction::TransportProtocol

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

//

RStringF CTransaction::TransportProtocol() const

	{