// 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          : ClientTransaction.cpp
// Part of       : Transaction
// Version       : SIP/5.0
//



#include "uri8.h"
#include "SipAssert.h"
#include "siperr.h"
#include "siprequest.h"
#include "sipresponse.h"
#include "sipfromheader.h"
#include "sipstrings.h"
#include "sipstrconsts.h"
#include "DeleteMgr.h"
#include "UserAgentBase.h"
#include "SIPMessageUtility.h"
#include "MTransactionStore.h"

#include "Transmitter.h"
#include "ClientTransaction.h"


// -----------------------------------------------------------------------------
// CClientTransaction::CClientTransaction
// -----------------------------------------------------------------------------
//
CClientTransaction::CClientTransaction(CUserAgentBase& aUserAgent,
									   CTransmitter& aTransmitter,
									   MTimerManager& aTimers,
									   CTransactionState& aInitialState,
									   TTimerValues& aTimerValues,
									   MTransactionStore& aTransactionStore) :
	CTransaction(aUserAgent,
				 aTransmitter,
				 aTimers,
				 aInitialState,
				 aTimerValues),
	iTransactionStore(aTransactionStore)
	{	
	}

// -----------------------------------------------------------------------------
// CClientTransaction::~CClientTransaction
// -----------------------------------------------------------------------------
//
CClientTransaction::~CClientTransaction()
	{
	delete iOutboundProxy;
	}

// -----------------------------------------------------------------------------
// CClientTransaction::TransactionId
// If transaction is detached from UAC, transaction knows the TransactionId.
// -----------------------------------------------------------------------------
//
TTransactionId CClientTransaction::TransactionId() const
	{
	__TEST_INVARIANT;

	if (iUserAgent)
		{
		return iUserAgent->TransactionId();
		}

	return iTransactionId;
	}

// -----------------------------------------------------------------------------
// CClientTransaction::StoreRequest
// -----------------------------------------------------------------------------
//
void CClientTransaction::StoreRequest(CSIPRequest& aReq,
									  const TInetAddr& aAddress,
									  const TSIPTransportParams& aParams,
									  RStringF aTransportProtocol,
									  TBool aForceUDP,
									  CUri8* aOutboundProxy)
	{
	__TEST_INVARIANT;
	__ASSERT_ALWAYS(!iOutgoingMsg && !iOutboundProxy,
					User::Panic(_L("ClientTa:StoreRq"), KErrAlreadyExists));

	iOutgoingMsg = &aReq;
	iRemoteAddr = aAddress;
	iTransportParams = aParams;
	iTransportProtocol = aTransportProtocol;
	iForceUDP = aForceUDP;
	iOutboundProxy = aOutboundProxy;

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CClientTransaction::ClearProxy
// -----------------------------------------------------------------------------
//
void CClientTransaction::ClearProxy()
	{
	__TEST_INVARIANT;

	iOutboundProxy = NULL;
	
	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CClientTransaction::SendToTransmitterL
// -----------------------------------------------------------------------------
//
void CClientTransaction::SendToTransmitterL()
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(iOutgoingMsg && iTransmitter, KErrNotFound);    

	iTransmitter->SendRequestL(static_cast<CSIPRequest&>(*iOutgoingMsg),							   
							   iRemoteAddr,
							   iForceUDP,
							   iTransportParams,
							   iOutboundProxy,
							   this);
	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CClientTransaction::ShouldTaHandleResponse
// Drop invalid response, but don't terminate transaction just because a broken
// SIP response came from the network.
//
// A Non-INVITE transaction passes each response to upper layer only once and
// filters out retransmissions.
//
// INVITE transaction passes every 1xx to upper layer, as INVITE may've forked.
// -----------------------------------------------------------------------------
//
TBool CClientTransaction::ShouldTaHandleResponse(CSIPResponse* aResp) const
	{
	__TEST_INVARIANT;
	__ASSERT_DEBUG(aResp,
		User::Panic(_L("ClientTa:ShouldTaHandleResp !aResp"), KErrArgument));

    //After a final response, ShouldTaHandleResponse must not be used
	__ASSERT_DEBUG(iReceivedResponseCode < 200,
	   User::Panic(_L("ClientTa:ShouldTaHandleResp iRecvRespCode>=200"),
       KErrSIPInvalidTransactionState));

	if ( !CheckReceivedResponse(*aResp) ||
		 (!IsInviteTransaction() &&
	      (iReceivedResponseCode == aResp->ResponseCode())) )
	    {
	    delete aResp;
	    return EFalse;
	    }

	return ETrue;
	}

// -----------------------------------------------------------------------------
// CClientTransaction::PassResponseToUserAgentL
// -----------------------------------------------------------------------------
//
void CClientTransaction::PassResponseToUserAgentL(CSIPResponse* aResp)
	{
	__TEST_INVARIANT;
    __SIP_ASSERT_LEAVE(iUserAgent, KErrNotFound);
    __SIP_ASSERT_LEAVE(aResp, KErrArgument);

	TUint respCode = aResp->ResponseCode();
	iUserAgent->ReceiveL(aResp);
	iReceivedResponseCode = respCode;

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CClientTransaction::CheckReceivedResponse
// From-tag must match the request's tag. Response must have exactly one Via.
// -----------------------------------------------------------------------------
//
TBool CClientTransaction::CheckReceivedResponse(CSIPResponse& aResp) const
	{
	__TEST_INVARIANT;

	RStringF from = SIPStrings::StringF(SipStrConsts::EFromHeader);	
	if (!aResp.HasHeader(from))
		{
		return EFalse;
		}

	__ASSERT_DEBUG(iOutgoingMsg,
		User::Panic(_L("ClientTa:ChkRecvResp !iOutMsg"), KErrNotFound));

	TSglQueIter<CSIPHeaderBase> iterReq = iOutgoingMsg->Headers(from);
	TSglQueIter<CSIPHeaderBase> iterResp = aResp.Headers(from);

    return CSIPMessageUtility::CompareTags(
		static_cast<CSIPFromHeader&>(*iterReq),
		static_cast<CSIPFromHeader&>(*iterResp)) &&
		(aResp.HeaderCount(SIPStrings::StringF(SipStrConsts::EViaHeader)) == 1);
	}

// -----------------------------------------------------------------------------
// CClientTransaction::RunIndependently
// -----------------------------------------------------------------------------
//
void CClientTransaction::RunIndependently(TTransactionId aTransactionId,
										  CDeleteMgr* aDeleteMgr,
										  TBool aClearTransmitter)
	{
	__TEST_INVARIANT;
	__ASSERT_DEBUG(!iDeleteMgr,
		User::Panic(_L("ClientTa:RunIndependently iDM!=0"), KErrAlreadyExists));
    __SIP_ASSERT_RETURN(aDeleteMgr, KErrArgument);

	iTransactionId = aTransactionId;
	iDeleteMgr = aDeleteMgr;

	if (aClearTransmitter)
		{
		iTransmitter->DetachCallback(this);
		iTransmitter = NULL;
		}

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CClientTransaction::CheckForTransportChange
// -----------------------------------------------------------------------------
//
void CClientTransaction::CheckForTransportChange()
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_RETURN(iOutgoingMsg, KErrNotFound);

	UpdateTransportProtocol(*iOutgoingMsg);

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CClientTransaction::IcmpErrorL
// Terminate with KErrSIPICMPFailure if transaction sends using UDP to the failed address
// KErrSIPICMPFailure will be passed to observers like Profile Agent
// -----------------------------------------------------------------------------
//
void CClientTransaction::IcmpErrorL(const TInetAddr& aAddress,
								    CSipConnectionMgr::TICMPError /*aError*/)
	{
	__TEST_INVARIANT;

	if (IsUnreliableTransportUsed() &&
		CSIPMessageUtility::CompareTInetAddr(iRemoteAddr,
											 TransportProtocol(),
											 aAddress))
		{
        TerminatedL(KErrSIPICMPFailure);
		}

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CClientTransaction::TerminatedL
// -----------------------------------------------------------------------------
//
void CClientTransaction::TerminatedL(TInt aReason)
	{
	__TEST_INVARIANT;
	__SIP_INT_LOG1( "CClientTransaction::TerminatedL Error",
					aReason )
	if (!iTerminated)
		{		
		CTransaction::TerminatedL(aReason);

		if (iDeleteMgr)
			{
			//Transaction is detached from UAC, and must remove itself from
			//TransactionStore and use DeleteMgr to free itself.

			if (iDeleteMgr->AddDeleteRequest(this) == KErrNone)
				{
				iTransactionStore.Remove(iTransactionId);
				}
			else
				{
				//Mark transaction to be deleted later on by MTransactionStore
				iTransactionStore.UpdateTransactionId(iTransactionId,
													  KEmptyTransactionId);
				}
			}
		}

	__TEST_INVARIANT;
	}	

// -----------------------------------------------------------------------------
// CClientTransaction::__DbgTestInvariant
// -----------------------------------------------------------------------------
//

void CClientTransaction::__DbgTestInvariant() const
	{
	if (iOutgoingMsg && !iOutgoingMsg->IsRequest())
		{
		User::Invariant();
		}
	}