// 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          : CSIPRegistrationBinding.cpp

// Part of       : Registration

// Version       : SIP/4.0 

//

#include "CSIPRegistrationBinding.h"

#include "CSIPRegistrar.h"

#include "CSIPRegistrationBindingStore.h"

#include "CSIPResponseUtility.h"

#include "MRegistrationOwner.h"

#include "csipregistrationstate.h"

#include "sipresponse.h"

#include "siprequest.h"

#include "siptoheader.h"

#include "sipaddress.h"

#include "sipminexpiresheader.h"

#include "sipcontactheader.h"

#include "uricontainer.h"

#include "SipLogs.h" 

#include "SipAssert.h"

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

// CSIPRegistrationBinding::NewLC

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

//

CSIPRegistrationBinding* CSIPRegistrationBinding::NewLC(

	CSIPRequest*                  aSIPRequest,

	MSigComp&                     aSigComp,

	CSIPSec&                      aSIPSec,

	MTimerManager&                aTimerMgr,

	MTransactionUser&             aTransactionUser,

	CSIPRegistrationBindingStore& aBindingStore,

	MRegistrationOwner*           aRegistrationOwner,

	MSIPSecUser&                  aSIPSecUser,

	MSIPTransportMgr&             aTransportMgr,

	CURIContainer&                aRemoteTarget,

	TBool						  aSendWithExpires,

	TBool						  aCacheOutboundProxyIP)

	{

	CSIPRegistrationBinding* self = new (ELeave) CSIPRegistrationBinding(

		aSigComp, aSIPSec, aTimerMgr, aTransactionUser, aBindingStore,

		aRegistrationOwner, aSIPSecUser, aTransportMgr,aSendWithExpires,

		aCacheOutboundProxyIP);

	CleanupStack::PushL(self);

	self->ConstructL(aSIPRequest, aRemoteTarget);

	return self;

	}

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

// CSIPRegistrationBinding::CSIPRegistrationBinding

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

//

CSIPRegistrationBinding::CSIPRegistrationBinding(

	MSigComp&                     aSigComp,

	CSIPSec&                      aSIPSec,

	MTimerManager&                aTimerManager, 

	MTransactionUser&             aTransactionUser,

	CSIPRegistrationBindingStore& aBindingStore,

	MRegistrationOwner*           aRegistrationOwner,

	MSIPSecUser&                  aSIPSecUser,

	MSIPTransportMgr&             aTransportMgr,

	TBool						  aSendWithExpires,

	TBool						  aCacheOutboundProxyIP)

  : CSIPRegistrationBindingBase (aTransactionUser, aSigComp, aSIPSec, 

                                 aBindingStore, aRegistrationOwner, 

                                 aSIPSecUser, aTransportMgr,aSendWithExpires,

                                 aCacheOutboundProxyIP),

    iTimerMgr         (aTimerManager)

	{

	}

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

// CSIPRegistrationBinding::~CSIPRegistrationBinding

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

//

CSIPRegistrationBinding::~CSIPRegistrationBinding() 

	{

	iTransactionUser.ClearTransactionOwner(this);

	iTimerMgr.Stop(iTimerId);

	}

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

// CSIPRegistrationBinding::IsRefresh

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

//

TBool CSIPRegistrationBinding::IsRefresh() const

	{

	return EFalse;

	}

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

// CSIPRegistrationBinding::DoRegisterL

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

//

void CSIPRegistrationBinding::DoRegisterL(TTransactionId&  aTransactionId, 

		                                  CSIPRequest*     aSIPRequest,

						                  CSIPRouteHeader* aOutboundProxy)

	{

	if (aOutboundProxy)

		{

		SetOutboundProxyL(aOutboundProxy); 

		// If SendL fails the aOutboundProxy is detached from binding

		CleanupStack::PushL(TCleanupItem(DetachOutboundProxy, this));

		}

    TSIPTransportParams transportParams(FillTransportParams());

	if (iRegistrar)

		{

		iTransactionUser.SendL(aTransactionId, iRegistrationId, aSIPRequest, 

			this, const_cast<CURIContainer&>(iRegistrar->Registrar()), 

			transportParams, EFalse);

		}

	else

		{

		iTransactionUser.SendL(aTransactionId, iRegistrationId, aSIPRequest,   

			this, *iRemoteTarget, transportParams, EFalse);

		}

	if (aOutboundProxy)

		{

		CleanupStack::Pop(); // TCleanupItem

		}

	if ( iCurrentState->Retrying() )

		{

		iRetryTransactionId = aTransactionId;

		}

	else 

		{

		iTransactionId = aTransactionId;

		}

	}

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

// CSIPRegistrationBinding::DoUpdateL

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

//

void CSIPRegistrationBinding::DoUpdateL(TTransactionId& aTransactionId, 

		                                CSIPRequest*    aSIPRequest)

	{

    TSIPTransportParams transportParams(FillTransportParams());	

	iTransactionUser.SendL(iTransactionId, iRegistrationId, 

		aSIPRequest, this, const_cast<CURIContainer&>(iRegistrar->Registrar()), 

		transportParams, EFalse);

	aTransactionId = iTransactionId;

	iTimerMgr.Stop(iTimerId);

	}

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

// CSIPRegistrationBinding::DoUnregisterL

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

//

void CSIPRegistrationBinding::DoUnregisterL(TTransactionId& aTransactionId, 

		                                    CSIPRequest*    aSIPRequest)

	{

    TSIPTransportParams transportParams(FillTransportParams());	

	iTransactionUser.SendL(iTransactionId, iRegistrationId, 

		aSIPRequest, this, const_cast<CURIContainer&>(iRegistrar->Registrar()), 

		transportParams, EFalse);

	aTransactionId = iTransactionId;

	iTimerMgr.Stop(iTimerId);

	}

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

// CSIPRegistrationBinding::ReceiveL

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

//

void CSIPRegistrationBinding::ReceiveL(TUint32        /*aIapId*/,

									   TTransactionId /*aTransactionId*/, 

									   CSIPRequest*   /*aSIPRequest*/)

	{

	// this function call is not supported

	User::Leave (KErrNotSupported);

	}

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

// CSIPRegistrationBinding::ReceiveL

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

//

void CSIPRegistrationBinding::ReceiveL(TTransactionId aTransactionId, 

									   CSIPResponse*  aSIPResponse)

	{

	__SIP_ASSERT_LEAVE(aSIPResponse, KErrArgument);

    __SIP_ASSERT_LEAVE(aSIPResponse->To(), KErrArgument);

	__SIP_ASSERT_LEAVE(aTransactionId != KEmptyTransactionId, KErrArgument);

	// panic if transaction id is not equal to the one has sent

	__SIP_ASSERT_LEAVE(aTransactionId == iTransactionId || 

					   aTransactionId == iRetryTransactionId, KErrArgument);

    __SIP_MESSAGE_LOG("Registrations: ReceiveL", *aSIPResponse)

	__TEST_INVARIANT;

	iCurrentState->ReceiveL(iTransactionId, aSIPResponse);

	}

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

// CSIPRegistrationBinding::TransactionEnded

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

//

TInt CSIPRegistrationBinding::TransactionEnded(TUint32        /*aIapId*/,

                                               TTransactionId aTransactionId, 

											   TInt           aReason)

	{

	__SIP_ASSERT_RETURN_VALUE (aTransactionId != KEmptyTransactionId, 

		                       KErrArgument);

	__SIP_ASSERT_RETURN_VALUE (aTransactionId == iTransactionId, 

		                       KErrArgument);

	__TEST_INVARIANT;

	TInt res = KErrNone;

	if (aReason != KErrNone)

		{

	    res = RemoveBinding ();

		}

	if(res != KErrNone)

		{

		return res;

		}

	return iCurrentState->TransactionEnded(aTransactionId, aReason);

	}

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

// CSIPRegistrationBinding::NextCSeq

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

//

TInt CSIPRegistrationBinding::NextCSeq(TUint& aCSeq)

	{

	if (iRegistrar)

		{

		iRegistrar->IncreaseCSeqNumber();

		aCSeq = iRegistrar->CSeqNumber();

		}

	else

		{

		aCSeq++; 

		}

	return KErrNone;

	}

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

// CSIPRegistrationBinding::SIPSecUser

// From MTransactionOwner:

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

//    

const MSIPSecUser* CSIPRegistrationBinding::SIPSecUser() const

    {

    return this;

    } 	

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

// CSIPRegistrationBinding::TimerExpiredL

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

//

void CSIPRegistrationBinding::TimerExpiredL(TTimerId aTimerId, 

											TAny*    /*aTimerParam*/)

	{	

	__SIP_ASSERT_LEAVE(iTimerId == aTimerId, KErrArgument);

	// if register is in registered or unregistered states, 

	// binding can be removed. 

	// otherwise, the registration is pending, do not delete the binding.

	if (!RegisterPending()) 

		{

		ClearTransactionOwner();

		User::LeaveIfError(RemoveBinding());

		}

	}

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

// CSIPRegistrationBinding::StartTimerL

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

//

void CSIPRegistrationBinding::StartTimerL(TUint aExpiresValue)

	{

	const TUint KMilliSecondsInSecond = 1000;

	const TUint KTimerValue = (aExpiresValue * KMilliSecondsInSecond); 

	iTimerId = iTimerMgr.StartL(this,KTimerValue);

	iContact->SetExpiresParameterL(aExpiresValue);

	}

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

// CSIPRegistrationBinding::ClearTransactionOwner

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

//

void CSIPRegistrationBinding::ClearTransactionOwner ( TBool aUseRetryId )

	{

	TTransactionId id( iTransactionId );

	if ( aUseRetryId )

		{

		// If retry-register is sent, we should clear retry transaction

		id = iRetryTransactionId;

		}

	iTransactionUser.ClearTransactionOwner( id );

	}

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

// CSIPRegistrationBinding::__DbgTestInvariant

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

//

void CSIPRegistrationBinding::__DbgTestInvariant() const

	{

	if (!iOwner)

		{	

		User::Invariant();

		}

	}