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



#include "SipAssert.h"
#include "siperr.h"
#include "sipstrings.h"
#include "sipstrconsts.h"
#include "siprequest.h"
#include "sipresponse.h"
#include "UserAgentBase.h"
#include "SIPMessageUtility.h"

#include "ServerTransaction.h"
#include "ResponseQueue.h"
#include "ResponseQueueItem.h"
#include "Transmitter.h"


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

// -----------------------------------------------------------------------------
// CServerTransaction::ConstructServerTaL
// -----------------------------------------------------------------------------
//
void CServerTransaction::ConstructServerTaL()
	{
	iSendQueue = CResponseQueue::NewL();
	iSentResponses = CResponseQueue::NewL();
	}

// -----------------------------------------------------------------------------
// CServerTransaction::~CServerTransaction
// -----------------------------------------------------------------------------
//
CServerTransaction::~CServerTransaction()
	{	
	delete iOutgoingMsg;
	delete iSendQueue;
	delete iSentResponses;	
	}

// -----------------------------------------------------------------------------
// CServerTransaction::PassRequestToUserAgentL
// -----------------------------------------------------------------------------
//
void CServerTransaction::PassRequestToUserAgentL(CSIPRequest* aReq)
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(aReq, KErrArgument);
	__SIP_ASSERT_LEAVE(iUserAgent, KErrNotFound);
	__SIP_ASSERT_LEAVE(!iRequestPassedToUA, KErrAlreadyExists);

	iUserAgent->ReceiveL(aReq);
	iRequestPassedToUA = ETrue;

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CServerTransaction::RequestPassedToUA
// -----------------------------------------------------------------------------
//
TBool CServerTransaction::RequestPassedToUA() const
	{
	__TEST_INVARIANT;
	return iRequestPassedToUA;	
	}

// -----------------------------------------------------------------------------
// CServerTransaction::Create100L
// If no To-tag in aReq, it is not added to response.
// iOutgoingMsg can theorically already have 100, if leave occurs after
// Create100L and a retransmitted request is received before transaction stops.
// -----------------------------------------------------------------------------
//
void CServerTransaction::Create100L(CSIPRequest& aReq)
	{
	__TEST_INVARIANT;
    if (!iOutgoingMsg)
    	{
		CSIPResponse* resp = CSIPResponse::NewLC(100,
			SIPStrings::StringF(SipStrConsts::EPhraseTrying));

		CSIPMessageUtility::CopyHeadersL(aReq, *resp,
							SIPStrings::StringF(SipStrConsts::EToHeader));
		CSIPMessageUtility::CopyHeadersL(aReq, *resp,
							SIPStrings::StringF(SipStrConsts::EFromHeader));
		CSIPMessageUtility::CopyHeadersL(aReq, *resp,
							SIPStrings::StringF(SipStrConsts::ECallIDHeader));
		CSIPMessageUtility::CopyHeadersL(aReq, *resp,
							SIPStrings::StringF(SipStrConsts::ECSeqHeader));
		CSIPMessageUtility::CopyHeadersL(aReq, *resp,
							SIPStrings::StringF(SipStrConsts::EViaHeader));

		CleanupStack::Pop(resp);
		iOutgoingMsg = resp;
    	}

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CServerTransaction::SendToTransmitterL
// -----------------------------------------------------------------------------
//
void CServerTransaction::SendToTransmitterL()
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(iOutgoingMsg, KErrNotFound);
	__SIP_ASSERT_LEAVE(!iOutgoingMsg->IsRequest(), KErrSIPMalformedMessage);

	iTransmitter->SendResponseL(static_cast<CSIPResponse&>(*iOutgoingMsg),
								iTransportParams,
								this,
								TransactionId());
	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CServerTransaction::SendAndStoreResponseL
// -----------------------------------------------------------------------------
//
void CServerTransaction::SendAndStoreResponseL(CResponseQueueItem* aRespItem)
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(aRespItem, KErrArgument);
    __SIP_ASSERT_LEAVE(CSIPMessageUtility::CheckTransport(iTransportProtocol),
                       KErrArgument);	

	SendAndStoreResponseL(aRespItem, iTransportProtocol);

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CServerTransaction::SendAndStoreResponseL
// -----------------------------------------------------------------------------
//
void CServerTransaction::SendAndStoreResponseL(CResponseQueueItem* aRespItem,
											   RStringF aTransportProtocol)
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(aRespItem, KErrArgument);
    __SIP_ASSERT_LEAVE(CSIPMessageUtility::CheckTransport(aTransportProtocol),
                       KErrArgument);

	CResponseQueueItem* previousRespItem = NULL;
	if (iOutgoingMsg)
        {
        //Earlier response must be a 1xx, as UAS sends only one final response.
        __ASSERT_DEBUG(!CSIPMessageUtility::IsFinalResponse(
        	static_cast<CSIPResponse&>(*iOutgoingMsg)),
            User::Panic(_L("ServTa:SendAndStoreRespL"), KErrAlreadyExists));
		previousRespItem =
			CResponseQueueItem::NewLC(static_cast<CSIPResponse*>(iOutgoingMsg),
									  iTransportParams,
									  //aRespItem has same value for "is INVITE"
									  aRespItem->IsRespToInvite());
        }

	iTransmitter->SendResponseL(aRespItem->Response(),
								aRespItem->TransportParams(),
								this,
								TransactionId());
    if (iOutgoingMsg)
        {
		TInt status = iSentResponses->Add(previousRespItem);
        if (status != KErrNone)
            {
            //ConnectionMgr must not use the response
			iTransmitter->CancelSendResponses(TransactionId(), ETrue);
            User::Leave(status);
            }
        CleanupStack::Pop(previousRespItem);
		}

	iTransportProtocol = aTransportProtocol;
	iTransportParams = aRespItem->TransportParams();

	iOutgoingMsg = &aRespItem->Response();
	aRespItem->SetResponseOwnership(EFalse);
	delete aRespItem;

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CServerTransaction::AddResponseToSendQueueL
// -----------------------------------------------------------------------------
//
void
CServerTransaction::AddResponseToSendQueueL(CResponseQueueItem* aRespItem) const
	{
	__TEST_INVARIANT;
	__SIP_ASSERT_LEAVE(aRespItem, KErrArgument);

    User::LeaveIfError(iSendQueue->Add(aRespItem));    
	}

// -----------------------------------------------------------------------------
// CServerTransaction::GetResponseFromSendQueue
// -----------------------------------------------------------------------------
//
CResponseQueueItem* CServerTransaction::GetResponseFromSendQueue() const
	{
	__TEST_INVARIANT;
	return iSendQueue->GetNext();
	}

// -----------------------------------------------------------------------------
// CServerTransaction::IcmpErrorL
// ServerTransaction ignores ICMP error
// -----------------------------------------------------------------------------
//
void CServerTransaction::IcmpErrorL(const TInetAddr& /*aAddress*/,
								    CSipConnectionMgr::TICMPError /*aError*/)
	{
	}

// -----------------------------------------------------------------------------
// CServerTransaction::TerminatedL
// -----------------------------------------------------------------------------
//
void CServerTransaction::TerminatedL(TInt aReason)
	{
	__TEST_INVARIANT;

	if (!iTerminated)
        {
		if (iTransmitter)
			{
            //Responses will be deleted, ConnectionMgr must not use them.
			iTransmitter->CancelSendResponses(TransactionId(),
											  !IsInviteTransaction());
			}

		CTransaction::TerminatedL(aReason);
		}

	__TEST_INVARIANT;
	}

// -----------------------------------------------------------------------------
// CServerTransaction::__DbgTestInvariant
// -----------------------------------------------------------------------------
//

void CServerTransaction::__DbgTestInvariant() const
	{
	if (!iSendQueue || !iSentResponses)
		{	
		User::Invariant();
		}
	}