// Copyright (c) 2002-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          : CErrorHandler.cpp
// Part of       : ConnectionMgr
// Version       : SIP/4.0
//




#include "CErrorHandler.h"
#include "CTransport.h"
#include "sipuri.h"
#include "siprequest.h"
#include "sipresponse.h"
#include "siptoheader.h"
#include "sipfromheader.h"
#include "sipviaheader.h"
#include "sipcallidheader.h"
#include "sipcseqheader.h"
#include "sipstrings.h"
#include "sipstrconsts.h"
#include "TSIPTransportParams.h"
#include "CommonConsts.h"

// -----------------------------------------------------------------------------
// CTransportErrorHandler::NewL
// -----------------------------------------------------------------------------
//
CTransportErrorHandler* CTransportErrorHandler::NewL(CTransportBase& aTransport)
	{
	CTransportErrorHandler* self = NewLC(aTransport);
	CleanupStack::Pop(self);
	return self;	
	}

// -----------------------------------------------------------------------------
// CTransportErrorHandler::NewLC
// -----------------------------------------------------------------------------
//
CTransportErrorHandler*
CTransportErrorHandler::NewLC(CTransportBase& aTransport)
	{
	CTransportErrorHandler* self =
		new (ELeave) CTransportErrorHandler(aTransport);
	CleanupStack::PushL(self);
	return self;	
	}

// -----------------------------------------------------------------------------
// CTransportErrorHandler::SendErrorResponseL
// -----------------------------------------------------------------------------
//
void CTransportErrorHandler::SendErrorResponseL(
    const TSIPTransportParams& aParams,
    TUint aResponseCode,	
    RStringF aReasonPhrase, 
	CSIPMessage& aMessage,
	const TInetAddr& aAddr)
	{	
	if (!aMessage.HasHeader(SIPStrings::StringF(SipStrConsts::EViaHeader)))
	    {
	    User::Leave(KErrArgument);
	    }
	    
	if ( !IsActive() )
		{
		if (iTransport->ProtocolType() == KProtocolInetUdp)
			{
			iTransport->CancelResponseSend(iId, ETrue);
			delete iResponse; 
			iResponse = 0;
			CreateResponseL(aResponseCode, aReasonPhrase, aMessage);
			iAddr = aAddr;
			iTransport->Send(aParams, *iResponse, iId, iStatus);
			}
		else
			{
			CreateResponseL(aResponseCode, aReasonPhrase, aMessage);
			iAddr = aAddr;
			iTransport->Send(aParams, *iResponse, iAddr, iStatus);
			}
		SetActive();
		}
		
	}

// -----------------------------------------------------------------------------
// CTransportErrorHandler::CreateResponseL
// -----------------------------------------------------------------------------
//
void CTransportErrorHandler::CreateResponseL(TUint aResponseCode,	
							RStringF aReasonPhrase, 
							CSIPMessage& aMessage)
	{
	iResponse = CSIPResponse::NewL(aResponseCode, aReasonPhrase);
	SetViaToResL(aMessage);
	if (aMessage.HasHeader(SIPStrings::StringF(SipStrConsts::EToHeader)))
	    {
		SetToToResL(aMessage);
	    }
	if (aMessage.HasHeader(SIPStrings::StringF(SipStrConsts::EFromHeader)))
	    {
		SetFromToResL(aMessage);
	    }
	if (aMessage.HasHeader(SIPStrings::StringF(SipStrConsts::ECallIDHeader)))
	    {
		SetCallIdToResL(aMessage);
	    }
	if (aMessage.HasHeader(SIPStrings::StringF(SipStrConsts::ECSeqHeader)))
	    {
		SetCSeqToResL(aMessage);
	    }

	}

// -----------------------------------------------------------------------------
// CTransportErrorHandler::RunL
// -----------------------------------------------------------------------------
//
void CTransportErrorHandler::RunL()
	{
	TUint protocol( iTransport->ProtocolType() );
	if( protocol == KProtocolInetTcp || protocol == KProtocolTls )
		{
		delete iResponse;
		iResponse = 0;
		}
	}

// -----------------------------------------------------------------------------
// CTransportErrorHandler::DoCancel
// -----------------------------------------------------------------------------
//
void CTransportErrorHandler::DoCancel()
	{
	iTransport->CancelSend(iStatus);
	if(iResponse)
		{
		delete iResponse;
		iResponse = 0;
		}
	}

// -----------------------------------------------------------------------------
// CTransportErrorHandler::RunError
// -----------------------------------------------------------------------------
//
TInt CTransportErrorHandler::RunError(TInt aError)
	{
	if(aError == KErrNoMemory)
		{
		return aError;
		}
	return KErrNone;
	}

// -----------------------------------------------------------------------------
// CTransportErrorHandler::SetViaToResL
// -----------------------------------------------------------------------------
//
void CTransportErrorHandler::SetViaToResL(CSIPMessage& aMessage)
	{
	TSglQueIter<CSIPHeaderBase> iter = 
	        aMessage.Headers(SIPStrings::StringF(SipStrConsts::EViaHeader));
	CSIPHeaderBase* header;
	iter.SetToFirst();
	while((header = iter++) != 0)
		{
		CSIPHeaderBase* viaHeader = 
		                    static_cast<CSIPViaHeader*>(header)->CloneL();
		CleanupStack::PushL(viaHeader);
		iResponse->AddHeaderL(static_cast<CSIPViaHeader*>(viaHeader));
		CleanupStack::Pop(viaHeader);
		}
	}

// -----------------------------------------------------------------------------
// CTransportErrorHandler::SetToToResL
// -----------------------------------------------------------------------------
//
void CTransportErrorHandler::SetToToResL(CSIPMessage& aMessage)
	{
	TSglQueIter<CSIPHeaderBase> iter = 
	        aMessage.Headers(SIPStrings::StringF(SipStrConsts::EToHeader));
	CSIPHeaderBase* header = 0;
	iter.SetToFirst();
	header = iter;
	CSIPToHeader* toHeader =
		CSIPToHeader::NewLC(static_cast<CSIPToHeader&>(*header));
	iResponse->AddHeaderL(toHeader);
	CleanupStack::Pop(toHeader);
	}

// -----------------------------------------------------------------------------
// CTransportErrorHandler::SetFromToResL
// -----------------------------------------------------------------------------
//
void CTransportErrorHandler::SetFromToResL(CSIPMessage& aMessage)
	{
	TSglQueIter<CSIPHeaderBase> iter = 
	        aMessage.Headers(SIPStrings::StringF(SipStrConsts::EFromHeader));
	CSIPHeaderBase* header = 0;
	iter.SetToFirst();
	header = iter;
	CSIPFromHeader* fromHeader =
		CSIPFromHeader::NewLC(static_cast<CSIPFromHeader&>(*header));
	iResponse->AddHeaderL(fromHeader);
	CleanupStack::Pop(fromHeader);
	}

// -----------------------------------------------------------------------------
// CTransportErrorHandler::SetCallIdToResL
// -----------------------------------------------------------------------------
//
void CTransportErrorHandler::SetCallIdToResL(CSIPMessage& aMessage)
	{
	TSglQueIter<CSIPHeaderBase> iter =
		aMessage.Headers(SIPStrings::StringF(SipStrConsts::ECallIDHeader));
	CSIPHeaderBase* header = 0;
	iter.SetToFirst();
	header = iter;
	CSIPHeaderBase* callIdHeader = 
	                        static_cast<CSIPCallIDHeader*>(header)->CloneL();
	CleanupStack::PushL(callIdHeader);
	iResponse->AddHeaderL(static_cast<CSIPCallIDHeader*>(callIdHeader));
	CleanupStack::Pop(callIdHeader);
	}

// -----------------------------------------------------------------------------
// CTransportErrorHandler::SetCSeqToResL
// -----------------------------------------------------------------------------
//
void CTransportErrorHandler::SetCSeqToResL(CSIPMessage& aMessage)
	{
	TSglQueIter<CSIPHeaderBase> iter = aMessage.Headers(
	                        SIPStrings::StringF(SipStrConsts::ECSeqHeader));
	CSIPHeaderBase* header = 0;
	iter.SetToFirst();
	header = iter;

    CSIPHeaderBase* cseqheader = static_cast<CSIPCSeqHeader*>(header)->CloneL();
    CleanupStack::PushL(cseqheader);
	iResponse->AddHeaderL(static_cast<CSIPCSeqHeader*>(cseqheader));
	CleanupStack::Pop(cseqheader);
	}

// -----------------------------------------------------------------------------
// CTransportErrorHandler::~CTransportErrorHandler
// -----------------------------------------------------------------------------
//
CTransportErrorHandler::~CTransportErrorHandler()
	{
	Cancel();
	delete iResponse;
	}

// -----------------------------------------------------------------------------
// CTransportErrorHandler::CTransportErrorHandler
// -----------------------------------------------------------------------------
//
CTransportErrorHandler::CTransportErrorHandler(CTransportBase& aTransport) :
	CActive(CActive::EPriorityStandard),
	iTransport(&aTransport)
	{
	CActiveScheduler::Add(this);
	iResponse = 0;
	iId = 0;
	}