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

// Part of       : SIPDialogs

// Version       : SIP/4.0 

//

#include "CSipDialogMgr.h"

#include "sipfromheader.h"

#include "DialogStateBase.h"

#include "MSipRegistrationContact.h"

#include "MTransactionUser.h"

#include "MSipRefreshMgr.h"

#include "MDialogOwner.h"

#include "DeleteMgr.h"

#include "sipcontactheader.h"

#include "siprequest.h"

#include "sipresponse.h"

#include "siptoheader.h"

#include "sipcallidheader.h"

#include "sipcseqheader.h"

#include "SipLogs.h"

#include "sipaddress.h"

#include "siphostport.h"

#include "uricontainer.h"

#include "sipuri.h"

#include "sipcodecutils.h"

#include "sipinternalstates.h"

#include "MTransactionHeaders.h"

#include "siprouteheader.h"

#include "DialogsStore.h"

#include "SipAssert.h"

#include "RefreshItem.h"

#include "TransactionItem.h"

#include "TransactionItemStore.h"

#include "Establishing.h"

#include "Early.h"

#include "Confirmed.h"

#include "Terminated.h"

#include "CSigCompMgr.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "siperr.h"

#include "TSIPTransportParams.h"

_LIT8(KLocalHostSIPURI, "sip:localhost");

const TUint K100Response = 100;

const TUint K400Response = 400;

const TUint K481Response = 481;

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

// CSipDialogMgr::NewL

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

//

CSipDialogMgr* CSipDialogMgr::NewL(

    MTransactionUser& aTU,

    MSipRefreshMgr& aRefreshMgr,

    MSipRegistrationContact& aRegistrationContact,

    CSIPSec& aSIPSec,

    MSigComp& aSigComp)

	{

	CSipDialogMgr* self = new(ELeave)CSipDialogMgr(aTU,aRefreshMgr, 

                                                   aRegistrationContact,

                                                   aSIPSec, aSigComp);	

	CleanupStack::PushL(self);	

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

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

// CSipDialogMgr::CSipDialogMgr

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

//

CSipDialogMgr::CSipDialogMgr (MTransactionUser& aTU,  

                              MSipRefreshMgr& aRefreshMgr,

							  MSipRegistrationContact& aRegistratinonContact,

							  CSIPSec& aSIPSec,

							  MSigComp& aSigComp)

: iTU(aTU), 

  iRefreshMgr(aRefreshMgr), 

  iRegistrationContact(aRegistratinonContact),

  iSIPSec(aSIPSec),

  iSigComp(aSigComp)

	{

	iContactHeaderName = SIPStrings::StringF(SipStrConsts::EContactHeader);

	iRouteHeaderName = SIPStrings::StringF(SipStrConsts::ERouteHeader);

	iTagParamName = SIPStrings::StringF(SipStrConsts::ETag);

    iPhraseCallTransactionDoesNotExist = 

        SIPStrings::StringF(SipStrConsts::EPhraseCallTransactionDoesNotExist);

    iPhraseBadRequest = SIPStrings::StringF(SipStrConsts::EPhraseBadRequest);

	}

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

// CSipDialogMgr::ConstructL

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

//

void CSipDialogMgr::ConstructL ()

	{

	iDialogsStore = CDialogsStore::NewL();

	iDeleteMgr = CDeleteMgr::NewL();

	}

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

// CSipDialogMgr::~CSipDialogMgr

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

//

CSipDialogMgr::~CSipDialogMgr ()

	{

	delete iDialogsStore;

	delete iDeleteMgr;

	}

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

// CSipDialogMgr::SendAndCreateDialogL

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

//

void CSipDialogMgr::SendAndCreateDialogL (TTransactionId& aTransactionId,

                                          TRefreshId& aRefreshId,

                                          TRegistrationId aRegistrationId,

                                          TDialogId& aDialogId,

                                          CSIPRequest* aRequest,

                                          CURIContainer& aRemoteTarget,

                                          MDialogOwner* aOwner,

                                          MSIPSecUser& aSIPSecUser,

                                          TBool aRefresh)	

	{

    __SIP_ASSERT_LEAVE(aOwner, KErrArgument);

	__SIP_ASSERT_LEAVE(aRequest, KErrArgument);

	__SIP_ASSERT_LEAVE(aRequest->To(), KErrSIPMalformedMessage);

	__SIP_ASSERT_LEAVE(aRequest->From(), KErrSIPMalformedMessage);

	__SIP_ASSERT_LEAVE(aRequest->Method().DesC().Length() > 0, 

                       KErrSIPMalformedMessage);

	__SIP_ASSERT_LEAVE(aRequest->HeaderCount(iContactHeaderName) <= 1,

                       KErrSIPMalformedMessage);

	__SIP_MESSAGE_LOG("Dialogs", *aRequest)

    TBool newDialogCreated = EFalse;

    CSipDialogItem* dialog = iDialogsStore->FindDialogItem(aDialogId,aOwner);

    if (!dialog)

        {

	    dialog = CSipDialogItem::NewLC(*iDialogsStore,aOwner,aSIPSecUser,iTU,

                                       iRefreshMgr,iSIPSec,*iDeleteMgr,

                                       iSigComp,aRegistrationId);

        newDialogCreated = ETrue;

        }

	dialog->SetLocalAddressL(aRequest->From()->SIPAddress());

	dialog->SetRemoteAddressL(aRequest->To()->SIPAddress());

	dialog->SetInitialRemoteTargetL(aRemoteTarget);

	dialog->SetRouteSetUsingRouteL(*aRequest);

	AddContactHeaderL(dialog->IapId(),aRegistrationId,

	                  *aRequest,aRequest->From());

	dialog->SetLocalTargetWithMsgL(*aRequest,EFalse);

    CTransactionItemBase* transactionItem = 0;

	if (aRefresh)

		{

        transactionItem = CRefreshItem::NewLC(iRefreshMgr,dialog,

                                              *dialog,aRequest->Method());

		}

	else

		{

        transactionItem = CTransactionItem::NewLC(iTU,dialog,

                                                  aRequest->Method());

        }

    transactionItem->SetTargetRefresh();

	dialog->CurrentState().SendL(aTransactionId,aRequest,*transactionItem,

	                             *dialog->RemoteTarget());

    dialog->TransactionItems().AddItem(transactionItem);

    CleanupStack::Pop(transactionItem);

    dialog->SetFirstTransactionId(aTransactionId);

    if (newDialogCreated)

        {

        aDialogId = dialog->DialogId();

	    iDialogsStore->AddDialogItem(dialog);

	    CleanupStack::Pop(dialog);

        }

	if (aRefresh)

	    {

	    aRefreshId = static_cast<CRefreshItem*>(transactionItem)->RefreshId();

	    }

	}

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

// CSipDialogMgr::SendWithinDialogL

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

//

void CSipDialogMgr::SendWithinDialogL (TTransactionId& aTransactionId,

                                       TRefreshId& aRefreshId,

                                       const TDialogId& aDialogId,

                                       CSIPRequest* aRequest,

                                       const MDialogOwner* aOwner,

                                       TBool aRefresh,

                                       TBool aAllowOverlap, 

                                       TBool aTargetRefresh)

	{

	__SIP_ASSERT_LEAVE(aDialogId, KErrArgument);

	__SIP_ASSERT_LEAVE(aRequest, KErrArgument);

	__SIP_ASSERT_LEAVE(aRequest->Method().DesC().Length() != 0, 

                       KErrSIPMalformedMessage);

	__SIP_ASSERT_LEAVE(aRequest->HeaderCount(iContactHeaderName) <= 1, 

                       KErrSIPMalformedMessage);

	__ASSERT_ALWAYS(!aRequest->HasHeader(iRouteHeaderName), 

                    User::Leave(KErrSIPMalformedMessage));

	CSipDialogItem* dialog = iDialogsStore->FindDialogItem(aDialogId,aOwner);

	__ASSERT_ALWAYS(dialog, User::Leave(KErrSIPInvalidDialogState));

	__ASSERT_ALWAYS(dialog->CurrentState().RequestsWithinDialogAllowed(),

					User::Leave(KErrSIPInvalidDialogState));

	RStringF method = aRequest->Method();

	if (dialog->TransactionItems().OverlappingRestricted(method))

        {

		User::Leave(KErrSIPRequestPending);

        }

	__SIP_MESSAGE_LOG("Dialogs", *aRequest)

	dialog->AddToHeaderInDialogL(*aRequest);

	dialog->AddFromHeaderInDialogL(*aRequest);

	dialog->AddCallIdHeaderInDialogL(*aRequest);

	dialog->AddRouteToMessageL(*aRequest);

	AddContactHeaderL(*dialog,*aRequest,aRequest->From(),aTargetRefresh);

	if (aTargetRefresh)

		{

		dialog->UpdateLocalTargetL(*aRequest);

		}

	if (method != SIPStrings::StringF(SipStrConsts::EAck))

        {

		dialog->AddCSeqHeaderInDialogL(*aRequest);

        }		

    CTransactionItemBase* transactionItem = 0;

	if (aRefresh)

		{

        transactionItem = 

			CRefreshItem::NewLC(iRefreshMgr,dialog,*dialog,method);

		}

    else

        {

        transactionItem = CTransactionItem::NewLC(iTU,dialog,method);

        }

    transactionItem->SetOverlappingRestricted(!aAllowOverlap);

    transactionItem->SetTargetRefresh(aTargetRefresh);

	dialog->CurrentState().SendL(aTransactionId,aRequest,*transactionItem,

	                             *dialog->RemoteTarget());

    dialog->TransactionItems().AddItem(transactionItem);

	CleanupStack::Pop(transactionItem);

	if (aRefresh)

	    {

	    aRefreshId = static_cast<CRefreshItem*>(transactionItem)->RefreshId();

	    }

	}

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

// CSipDialogMgr::SendAndUpdateRefreshL

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

//

void CSipDialogMgr::SendAndUpdateRefreshL (TTransactionId& aTransactionId,

                                           const TRefreshId& aRefreshId,

                                           const TDialogId& aDialogId,

                                           CSIPRequest* aRequest,

                                           const MDialogOwner* aOwner)

    {

	__SIP_ASSERT_LEAVE(aRefreshId, KErrArgument);

	__SIP_ASSERT_LEAVE(aDialogId, KErrArgument);

	__SIP_ASSERT_LEAVE(aRequest, KErrArgument);

	__SIP_ASSERT_LEAVE(aRequest->HeaderCount(iContactHeaderName) <= 1, 

                       KErrSIPMalformedMessage);

	__ASSERT_ALWAYS (!aRequest->HasHeader(iRouteHeaderName), 

                     User::Leave(KErrSIPMalformedMessage));

	CSipDialogItem* dialog = iDialogsStore->FindDialogItem(aDialogId,aOwner);

	__ASSERT_ALWAYS(dialog, User::Leave(KErrSIPInvalidDialogState));

	__ASSERT_ALWAYS(dialog->CurrentState().RequestsWithinDialogAllowed(),

					User::Leave(KErrSIPInvalidDialogState));

    CTransactionItemBase* refreshItem = 

        dialog->TransactionItems().FindRefreshItem(aRefreshId);

    __ASSERT_ALWAYS(refreshItem,User::Leave(KErrSIPInvalidTransactionState));

	__SIP_MESSAGE_LOG("Dialogs", *aRequest)

	dialog->AddToHeaderInDialogL(*aRequest);

	dialog->AddFromHeaderInDialogL(*aRequest);

	dialog->AddCallIdHeaderInDialogL(*aRequest);

    if (aRequest->Method().DesC().Length() == 0)

        {

        aRequest->SetMethodL(refreshItem->Method());

        }

	dialog->AddRouteToMessageL(*aRequest);

    TBool targetRefresh = refreshItem->TargetRefresh();

	AddContactHeaderL(*dialog,*aRequest,aRequest->From(),targetRefresh);

	if (targetRefresh)

		{

		dialog->UpdateLocalTargetL(*aRequest);

		}

	dialog->CurrentState().SendL(aTransactionId,aRequest,*refreshItem,

	                             *dialog->RemoteTarget());

    }

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

// CSipDialogMgr::SendAndCreateDialogL

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

//

void CSipDialogMgr::SendAndCreateDialogL (const TTransactionId& aTransactionId,

										  TRegistrationId aRegistrationId,

                                          TDialogId& aDialogId,

                                          CSIPResponse* aResponse,

                                          MDialogOwner* aOwner,

                                          MSIPSecUser& aSIPSecUser)

	{

	__SIP_ASSERT_LEAVE (aTransactionId != 0, KErrArgument);

	__SIP_ASSERT_LEAVE (!aDialogId, KErrNotSupported);

	__SIP_ASSERT_LEAVE (aResponse, KErrArgument);

	__SIP_ASSERT_LEAVE (aOwner, KErrArgument);

	__SIP_ASSERT_LEAVE (aResponse->ResponseCode() > K100Response, KErrArgument);

	__SIP_MESSAGE_LOG("Dialogs", *aResponse)

	CSipDialogItem* dialog = 

        CSipDialogItem::NewLC(*iDialogsStore,aOwner,aSIPSecUser,

                              iTU,iRefreshMgr,iSIPSec,*iDeleteMgr,iSigComp, aRegistrationId);

    TSIPTransportParams transportParams(

        dialog->TransportParams(aRegistrationId));

	MTransactionHeaders* trHeaders = iTU.TransactionHeadersL(aTransactionId);

	__ASSERT_ALWAYS(trHeaders, User::Leave(KErrSIPInvalidTransactionState));

    TCleanupItem cleanupItem(DeleteTransactionHeaders,trHeaders);

	CleanupStack::PushL (cleanupItem);

	// Remote target 

    CSIPContactHeader* remoteContact = 

        ExtractContactL(aTransactionId,*trHeaders,transportParams,ETrue);

    CleanupStack::PushL(remoteContact);

	dialog->SetRemoteTargetL(remoteContact->SIPAddress()->URI());

	CleanupStack::PopAndDestroy(remoteContact);

	// Remote CSeq

	dialog->SetRemoteSeqNum(trHeaders->CSeqNumber());

	// Call-ID 

	CSIPCallIDHeader* callId = trHeaders->CallIDHeader();

	__SIP_ASSERT_LEAVE(callId, KErrSIPInvalidDialogRequest);

	dialog->SetCallId(callId);

    // Route-set

	RPointerArray<CSIPRouteHeaderBase>* route = trHeaders->RecordRoute();

	if (route)

		{

		TCleanupItem routeCleanupItem(DeleteRouteSet,route);

		CleanupStack::PushL (routeCleanupItem);

		CheckRecordRouteL(aTransactionId,*route,transportParams);

		dialog->SetRouteSetL(*route);

		CleanupStack::PopAndDestroy(1);// routeCleanupItem

		}

    // From

	CSIPFromHeader* from = trHeaders->FromHeader();

	CleanupStack::PushL(from);

	__SIP_ASSERT_LEAVE(from, KErrSIPInvalidDialogRequest);

	dialog->SetRemoteAddressL(from->SIPAddress());

	if (from->HasParam(iTagParamName))

        {

		dialog->SetRemoteTagL(from);

        }

	aResponse->AddHeaderL(from);

	CleanupStack::Pop(from);

	// To

	CSIPToHeader* to = trHeaders->ToHeader();

	CleanupStack::PushL(to);

	__SIP_ASSERT_LEAVE(to, KErrSIPInvalidDialogRequest);    

	dialog->SetLocalAddressL(to->SIPAddress());

	if (!to->HasParam(iTagParamName))

        {

		HBufC8* tagBuf = HBufC8::NewLC(MTransactionUser::KTagLength);

		TPtr8 tagPtr = tagBuf->Des();

		iTU.MakeTagL(tagPtr);

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

		CleanupClosePushL(tag);

        to->SetParamL(iTagParamName,tag);

        CleanupStack::PopAndDestroy(); // tag

        CleanupStack::PopAndDestroy(tagBuf); 

		}

	dialog->SetLocalTag(to->ParamValue(iTagParamName));

	aResponse->AddHeaderL(to);

	CleanupStack::Pop(to);

	// Local target (Contact)

	CURIContainer* requestURI = trHeaders->RequestURI();

	__SIP_ASSERT_LEAVE(requestURI, KErrSIPInvalidDialogRequest);

	CleanupStack::PushL(requestURI);

	if (!aResponse->IsErrorResponse())

	    {

	    AddContactHeaderL(dialog->IapId(),*aResponse,aResponse->To(),

	                      *requestURI);

	    }

	CleanupStack::PopAndDestroy(requestURI);

	dialog->SetLocalTargetWithMsgL(*aResponse);

	dialog->AddRecordRouteToMessageL(*aResponse);

	dialog->AddCallIdHeaderInDialogL(*aResponse);

	dialog->SetFirstTransactionId(aTransactionId);

    CTransactionItem* transactionItem = 

        CTransactionItem::NewLC(iTU,dialog,aTransactionId);

	dialog->CurrentState().SendL(*transactionItem,aResponse);

    dialog->TransactionItems().AddItem(transactionItem);

	iDialogsStore->AddDialogItem(dialog);

    aDialogId = dialog->DialogId();

    CleanupStack::Pop(transactionItem); 

    CleanupStack::PopAndDestroy(); // trHeaders

    CleanupStack::Pop(dialog);

	}

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

// CSipDialogMgr::SendWithinDialogL

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

//

void CSipDialogMgr::SendWithinDialogL (const TTransactionId& aTransactionId,

                                       const TDialogId& aDialogId,

                                       CSIPResponse* aResponse,

                                       const MDialogOwner* aOwner,

                                       TBool aTargetRefresh)

	{

	__SIP_ASSERT_LEAVE (aTransactionId, KErrArgument);

	__SIP_ASSERT_LEAVE (aDialogId, KErrSIPInvalidDialogState);

	__SIP_ASSERT_LEAVE (aResponse, KErrArgument);

	__SIP_ASSERT_LEAVE (aResponse->ResponseCode() > K100Response, KErrArgument);

	__SIP_MESSAGE_LOG("Dialogs", *aResponse)

	CSipDialogItem* dialog = iDialogsStore->FindDialogItem(aDialogId,aOwner);

	__ASSERT_ALWAYS(dialog, User::Leave(KErrSIPInvalidDialogState));

    CTransactionItemBase* transactionItem = 

        dialog->TransactionItems().FindItem(aTransactionId);

    __ASSERT_ALWAYS(transactionItem,

                    User::Leave(KErrSIPInvalidTransactionState));

	MTransactionHeaders* trHeaders = iTU.TransactionHeadersL(aTransactionId);

	__ASSERT_ALWAYS(trHeaders, User::Leave(KErrSIPInvalidTransactionState));

    TCleanupItem cleanupItem(DeleteTransactionHeaders,trHeaders);

	CleanupStack::PushL (cleanupItem);

    // To

	CSIPToHeader* to = trHeaders->ToHeader();

	CleanupStack::PushL(to);

	if (!to->HasParam(iTagParamName))

		{

		to->SetParamL(iTagParamName,dialog->LocalTag());

		}

	aResponse->AddHeaderL(to);

	CleanupStack::Pop(to);

    // Add Record-Route only to the responses to the first transaction

    if (aTransactionId == dialog->FirstTransactionId())

        {

	    dialog->AddRecordRouteToMessageL(*aResponse);

        }

    // Remote and local target

	if (!aResponse->IsErrorResponse())

	    {    

        AddContactHeaderL(*dialog,*aResponse,aResponse->To(),aTargetRefresh);

	    }

	if (aTargetRefresh && aResponse->Type() == CSIPResponse::E2XX)

		{		

		CSIPContactHeader* remoteContact = 

		    ExtractContactL(aTransactionId,*trHeaders,

                            dialog->TransportParams(KEmptyRegistrationId),

                            EFalse);

		if (remoteContact) 

		    {

		    CleanupStack::PushL(remoteContact);

            CURIContainer& remoteTarget = remoteContact->SIPAddress()->URI();

    	    dialog->SetRemoteTargetL(remoteTarget);

    		CleanupStack::PopAndDestroy(remoteContact);		    

		    }    

		dialog->UpdateLocalTargetL(*aResponse);

		}

    CleanupStack::PopAndDestroy(); // trHeaders

	dialog->CurrentState().SendL(*transactionItem, aResponse);	

	}

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

// CSipDialogMgr::TerminateDialog

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

//

TInt CSipDialogMgr::TerminateDialog (const TDialogId& aDialogId,

                                     const MDialogOwner* aOwner)

	{

	CSipDialogItem* dialog = iDialogsStore->FindDialogItem(aDialogId,aOwner);

	if(!dialog) 

        {

		return KErrNotFound;

        }

	return iDialogsStore->Remove(dialog);

	}

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

// CSipDialogMgr::TerminateDialogsFor

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