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

// Part of       : SIPDialogs

// Version       : SIP/6.0 

//

#include "CSipDialogItem.h"

#include "MSipRefreshMgr.h"

#include "MTransactionUser.h"

#include "sipsec.h"

#include "DeleteMgr.h"

#include "MDialogOwner.h"

#include "SipLogs.h"

#include "SipAssert.h"

#include "siprequest.h"

#include "sipresponse.h"

#include "sipcontactheader.h"

#include "siptoheader.h"

#include "sipfromheader.h"

#include "sipcseqheader.h"

#include "sipcallidheader.h"

#include "siprecordrouteheader.h"

#include "siprouteheader.h"

#include "sipaddress.h"

#include "uricontainer.h"

#include "sipuri.h"

#include "Establishing.h"

#include "Early.h"

#include "Confirmed.h"

#include "Terminated.h"

#include "DialogsStore.h"

#include "TransactionItemStore.h"

#include "TransactionItemBase.h"

#include "RefreshItem.h"

#include "TransactionItem.h"

#include "CSigCompMgr.h"

#include "MSigComp.h"

#include "sipcodecutils.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "sipcodecerr.h"

#include "siperr.h"

#include "TSIPTransportParams.h"

const TUint K100Response = 100;

const TUint K400Response = 400;

const TUint K500Response = 500;

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

// CSipDialogItem::NewLC

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

//

CSipDialogItem* CSipDialogItem::NewLC(CDialogsStore& aDialogStore,

                                      MDialogOwner* aDialogOwner,

                                      MSIPSecUser& aSIPSecUser,

                                      MTransactionUser& aTransactionUser, 

                                      MSipRefreshMgr& aRefreshMgr,

                                      CSIPSec& aSIPSec,

                                      CDeleteMgr& aDeleteMgr,

                                      MSigComp& aSigComp,

                                      TRegistrationId aRegistrationId)

	{

	CSipDialogItem* self = new(ELeave)CSipDialogItem(aDialogStore,

	                                                 aSIPSecUser,

                                                     aTransactionUser,

                                                     aRefreshMgr,

                                                     aSIPSec,

                                                     aDeleteMgr,

                                                     aSigComp,

                                                     aRegistrationId);

	CleanupStack::PushL(self);	

	self->ConstructL(aDialogOwner);

	return self;

	}

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

// CSipDialogItem::CSipDialogItem

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

//

CSipDialogItem::CSipDialogItem (CDialogsStore& aDialogStore,

                                MSIPSecUser& aSIPSecUser,

								MTransactionUser& aTransactionUser, 

								MSipRefreshMgr& aRefreshMgr,

								CSIPSec& aSIPSec,

								CDeleteMgr& aDeleteMgr,

								MSigComp& aSigComp,

								TRegistrationId aRegistrationId)

: iRegistrationId(aRegistrationId),

  iDialogStore(aDialogStore),

  iTU(aTransactionUser),

  iRefreshMgr(aRefreshMgr),

  iSIPSec(aSIPSec), 

  iDeleteMgr(aDeleteMgr),

  iSigComp(aSigComp),

  iSIPSecUser(aSIPSecUser),

  iTerminated(*this),

  iConfirmed(*this,iTerminated),

  iEarly(*this,iConfirmed,iTerminated),

  iEstablishing(*this,iEarly,iConfirmed,iTerminated),    

  iRemoteTagSet(EFalse)

  	{

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

  	iTransportParamName = SIPStrings::StringF(SipStrConsts::ETransport);

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

	}

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

// CSipDialogItem::ConstructL

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

//

void CSipDialogItem::ConstructL (MDialogOwner* aDialogOwner)

	{

    __SIP_ASSERT_LEAVE(aDialogOwner, KErrArgument);

    iDialogOwner = aDialogOwner;

    iTransactionItemStore = CTransactionItemStore::NewL();

    iSigCompMgr = CSigCompMgr::NewL(

        aDialogOwner->TransportParams(KEmptyRegistrationId).IapId(),iSigComp);

    iDialogId = iDialogStore.NewDialogId();

	ChangeState(iEstablishing);

	}

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

// CSipDialogItem::~CSipDialogItem

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

//

CSipDialogItem::~CSipDialogItem()

	{

    iTU.ClearTransactionOwner(this);

    delete iSigCompMgr;

	delete iCallId;

	iLocalTag.Close();

	iRemoteTag.Close();

	delete iLocalAddress;

	delete iRemoteAddress;

	delete iLocalTarget;

	delete iRemoteTarget;

	iRouteSet.ResetAndDestroy();

    delete iTransactionItemStore;

    iSIPSec.ClearCache(this);

	}

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

// CSipDialogItem::IapId

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

//

TUint32 CSipDialogItem::IapId()

    {

    return TransportParams(KEmptyRegistrationId).IapId();

    }

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

// CSipDialogItem::RegistrationId

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

//

TRegistrationId CSipDialogItem::RegistrationId() const

    {

    return iRegistrationId;

    }

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

// CSipDialogItem::Offset

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

//

TInt CSipDialogItem::Offset ()

	{

    return _FOFF(CSipDialogItem,iLink);

	}

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

// CSipDialogItem::ResetStateL

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

//

void CSipDialogItem::ResetStateL()

    {

    CTransactionItemStore* transactionStore = CTransactionItemStore::NewLC();

    CSigCompMgr* sigCompMgr = 

        CSigCompMgr::NewL(

            iDialogOwner->TransportParams(KEmptyRegistrationId).IapId(),

            iSigComp);

    CleanupStack::Pop(transactionStore);

    iTU.ClearTransactionOwner(this);

    iSIPSec.ClearCache(this);

    delete iTransactionItemStore;

    iTransactionItemStore = transactionStore;  

    delete iSigCompMgr;

    iSigCompMgr = sigCompMgr;

    iRemoteTag = SIPStrings::StringF(SipStrConsts::EEmpty);

    iRemoteTagSet = EFalse;

    ChangeState(iEstablishing);

    }

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

// CSipDialogItem::DialogOwner

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

//

MDialogOwner* CSipDialogItem::DialogOwner()

	{

	return iDialogOwner;

	}

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

// CSipDialogItem::DeleteMgr

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

//

CDeleteMgr& CSipDialogItem::DeleteMgr()

	{

	return iDeleteMgr;

	}

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

// CSipDialogItem::Match

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

//	

TBool CSipDialogItem::Match(CSIPRequest& aRequest) const

    {

	CSIPCallIDHeader* callId = aRequest.CallID();

	CSIPToHeader* to = aRequest.To();	

	CSIPFromHeader* from = aRequest.From();

	if ((callId && *callId == *iCallId) &&

		(to && 

		 to->HasParam(iTagParamName) && 

	     iLocalTag == to->ParamValue(iTagParamName)))

		{

		if (iRemoteTagSet)

			{

			if (from && 

			    from->HasParam(iTagParamName) &&

                iRemoteTag == from->ParamValue(iTagParamName))

                {

                return iCurrentState->Accept(aRequest);

                }

            }

        else

            {

			return iCurrentState->Accept(aRequest);

            }

		}

    return EFalse;

    }

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

// CSipDialogItem::ContactOk

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

//    

TBool CSipDialogItem::ContactOk(const CSIPContactHeader& aContact)

    {		

	if (aContact.Star() || !aContact.SIPAddress())

        {

        return EFalse;

        }

    return (aContact.SIPAddress()->URI().IsSIPURI());   

    }

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

// CSipDialogItem::SetFirstTransactionIdId

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

//

void CSipDialogItem::SetFirstTransactionId(const TTransactionId& aTransactionId)

	{

	iFirstTransactionId = aTransactionId;

	}

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

// CSipDialogItem::FirstTransactionId

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

//

TTransactionId CSipDialogItem::FirstTransactionId()

	{

	return iFirstTransactionId;

	}

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

// CSipDialogItem::DialogId

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

//

TDialogId CSipDialogItem::DialogId() const

	{

	return iDialogId;

	}

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

// CSipDialogItem::SelfDestruct

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

//

void CSipDialogItem::SelfDestruct ()

    {

	iTU.ClearTransactionOwner(this);

	ChangeState(iTerminated);

    iDialogStore.Remove(this);

    }

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

// CSipDialogItem::TerminateForkedDialogs

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

//

void CSipDialogItem::TerminateForkedDialogs (TTransactionId aTransactionId)

    {

    iDialogStore.RemoveAllEarlyDialogsWith(aTransactionId);

    }

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

// CSipDialogItem::IsEarly

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

//

TBool CSipDialogItem::IsEarly () const

    {

    return (iCurrentState == &iEarly);

    }

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

// CSipDialogItem::TransactionItems

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

//

CTransactionItemStore& CSipDialogItem::TransactionItems ()

    {

    return *iTransactionItemStore;

    }

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

// CSipDialogItem::HasTransactionItem

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

//

TBool CSipDialogItem::HasTransactionItem (TTransactionId aTransactionId)

    {

    return iTransactionItemStore->HasItem(aTransactionId);

    }

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

// CSipDialogItem::RemoveTransactionItem

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

//

TInt CSipDialogItem::RemoveTransactionItem(TTransactionId& aTransactionId)

    {

    return iTransactionItemStore->RemoveItem(aTransactionId);

    }

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

// CSipDialogItem::ChangeState

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

//

void CSipDialogItem::ChangeState(TDialogStateBase& aState)

	{

	if (iCurrentState != &aState)

		{

		iCurrentState = &aState;

		__SIP_INT_LOG1( "CSipDialogItem::ChangeState: ID", iDialogId )

		__SIP_DES8_LOG( "CSipDialogItem::ChangeState: state", aState.Name() )

		}

	}

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

// CSipDialogItem::CurrentState

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

//

TDialogStateBase& CSipDialogItem::CurrentState()

	{

	return *iCurrentState;

	}

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

// CSipDialogItem::CallId

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

//

CSIPCallIDHeader* CSipDialogItem::CallId()

	{

	return iCallId;

	}

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

// CSipDialogItem::SetCallId

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

//

void CSipDialogItem::SetCallId (CSIPCallIDHeader* aCallId)

	{

    delete iCallId;

	iCallId = aCallId;

	}

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

// CSipDialogItem::LocalTag

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

//

RStringF CSipDialogItem::LocalTag ()

	{

	return iLocalTag;

	}

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

// CSipDialogItem::SetLocalTag

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

//

void CSipDialogItem::SetLocalTag (RStringF aTag)

	{

	iLocalTag.Close();

	iLocalTag = aTag.Copy();

	}

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

// CSipDialogItem::RemoteTag

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

//

RStringF CSipDialogItem::RemoteTag ()

	{

	return iRemoteTag;

	}

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

// CSipDialogItem::RemoteTag

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

//

TBool CSipDialogItem::RemoteTagSet ()

	{

	return iRemoteTagSet;

	}

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

// CSipDialogItem::SetRemoteTagL

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

//

void CSipDialogItem::SetRemoteTagL (CSIPFromToHeaderBase* aFromTo)

	{

    if (aFromTo->HasParam(iTagParamName))

        {

	    if (iRemoteTagSet)

            {

            if (iRemoteTag != aFromTo->ParamValue(iTagParamName))

                {

                User::Leave (KErrAlreadyExists);

                }

            }

        else

            {

            RStringF tmp = aFromTo->ParamValue(iTagParamName);

			UpdateRemoteTagForRefreshesL(tmp);

	        iRemoteTag.Close();

            iRemoteTag = tmp.Copy();

			iRemoteTagSet = ETrue;

            }

        }

	}

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

// CSipDialogItem::LocalSeqNum

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

//

TUint CSipDialogItem::LocalSeqNum()

	{

	return iLocalSeqNum;

	}

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

// CSipDialogItem::SetLocalSeqNum

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

//

void CSipDialogItem::SetLocalSeqNum(TUint aNum)

	{

	iLocalSeqNum = aNum;

	}

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

// CSipDialogItem::RemoteSeqNum

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

//

TUint CSipDialogItem::RemoteSeqNum()

	{

	return iRemoteSeqNum;

	}

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

// CSipDialogItem::SetRemoteSeqNum

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

//

void CSipDialogItem::SetRemoteSeqNum(TUint aNum)

	{

	iRemoteSeqNum = aNum;

	}

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

// CSipDialogItem::LocalAddress

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

//

const CSIPAddress* CSipDialogItem::LocalAddress()

	{

	return iLocalAddress;

	}

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

// CSipDialogItem::SetLocalAddressL

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

//

void CSipDialogItem::SetLocalAddressL (const CSIPAddress& aAddr)

	{

	CSIPAddress* tmp = CSIPAddress::NewL(aAddr);

	delete iLocalAddress;

	iLocalAddress = tmp;

	}

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

// CSipDialogItem::RemoteAddress

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

//

const CSIPAddress* CSipDialogItem::RemoteAddress()

	{

	return iRemoteAddress;

	}

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

// CSipDialogItem::SetRemoteAddressL

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