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

// Part of       : Registration

// Version       : SIP/6.0

//

#include "CSIPRegistrationRefreshBinding.h"

#include "CSIPRegistrationBinding.h"

#include "TSIPRegistrationUtility.h"

#include "CSIPRegistrar.h"

#include "CSIPRegistrarStore.h"

#include "CSIPRegistrationBindingStore.h"

#include "CSIPResponseUtility.h"

#include "MRegistrationOwner.h"

#include "sipresponse.h"

#include "siprequest.h"

#include "siptoheader.h"

#include "sipfromheader.h"

#include "sipaddress.h"

#include "sipcontactheader.h"

#include "uricontainer.h"

#include "sipuri.h"

#include "siphostport.h"

#include "siprouteheader.h"

#include "sipminexpiresheader.h"

#include "sipservicerouteheader.h"

#include "sippassociateduriheader.h"

#include "MSigComp.h"

#include "sipsec.h"

#include "siperr.h"

#include "SipLogs.h"

#include "SipAssert.h"

#include "sipcodecutils.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "csipregistering.h"

#include "csip423responsereceived.h"

#include "csipregistered.h"

#include "csipregisterupdating.h"

#include "csipunregistering.h"

#include "csipunregistered.h"

#include "TSIPTransportParams.h"

#include "MSIPTransportMgr.h"

#include <utf.h>

#define HEADER(H, M, N) static_cast<H*>((M).Header(N,0))

const TUint KDefaultSipPort = 5060;

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

// CSIPRegistrationBindingBase::ConstructL

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

//

void CSIPRegistrationBindingBase::ConstructL(CSIPRequest* aSIPRequest,

											 CURIContainer& aRemoteTarget)

	{

	__ASSERT_ALWAYS (aSIPRequest, User::Leave (KErrArgument));

    __ASSERT_ALWAYS (aSIPRequest->To(), User::Leave (KErrArgument));

    __ASSERT_ALWAYS (aSIPRequest->From(), User::Leave (KErrArgument));

	InitializeStatesL();

	// copy to header from request

	SetToHeaderL(*aSIPRequest);

	// copy from header from request

	SetFromHeaderL(*aSIPRequest);

	// copy contact header from request.

	SetContactHeaderL(*aSIPRequest);

	iRegistrationId = iBindingStore.NextRegistrationId();

	iRegistrar = iBindingStore.RegistrarStore().FindRegistrar(aRemoteTarget);

	if (!iRegistrar) // registrar not found

		{

		iRemoteTarget = CURIContainer::NewL(aRemoteTarget);

		}

	else

		{

		iRegistrar->AddRegistrationIdL(iRegistrationId);

		}

	}

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

// CSIPRegistrationBindingBase::InitializeStatesL

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

//

void CSIPRegistrationBindingBase::InitializeStatesL()

	{

	iRegistering = CSIPRegistering::NewL(*this);

	iRegistered = CSIPRegistered::NewL(*this);

	iResponse423Received = CSIP423ResponseReceived::NewL(*this);

	iUpdating = CSIPRegisterUpdating::NewL(*this);

	iUnregistering = CSIPUnregistering::NewL(*this);

	iUnregistered = CSIPUnregistered::NewL(*this);

	// set registering neighbour states.

	iRegistering->SetNeighbourStates(iResponse423Received, iRegistered,

		iUnregistered);

	// set current state to registering.

	iCurrentState = iRegistering;

	// set registered neighbour states.

	iRegistered->SetNeighbourStates(iUpdating, iUnregistering, iUnregistered,

		iResponse423Received);

	// set response 423 received neighbour states.

	iResponse423Received->SetNeighbourStates(iRegistered, iUnregistered);

	// set unregistering states.

	iUnregistering->SetNeighbourStates(iUnregistered);

	// set updating states.

	iUpdating->SetNeighbourStates(iResponse423Received, iRegistered,

		iUnregistered);

	}

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

// CSIPRegistrationBindingBase::CSIPRegistrationBindingBase

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

//

CSIPRegistrationBindingBase::CSIPRegistrationBindingBase (

    MTransactionUser&             aTransactionUser,

	MSigComp&                     aSigComp,

	CSIPSec&                      aSIPSec,

	CSIPRegistrationBindingStore& aBindingStore,

	MRegistrationOwner*           aRegistrationOwner,

	MSIPSecUser&                  aSIPSecUser,

	MSIPTransportMgr&             aTransportMgr,

	TBool 						  aSendWithExpires,

	TBool 						  aCacheOutboundProxyIP)

  : iTransactionUser     (aTransactionUser),

    iOwner               (aRegistrationOwner),

    iRegistrationId      (KEmptyRegistrationId),

	iSIPSecUser          (aSIPSecUser),    

    iSigComp             (aSigComp),

	iSIPSec              (aSIPSec),

    iBindingStore        (aBindingStore),

	iTransportMgr        (aTransportMgr),

	iSendWithExpires     (aSendWithExpires),

	iCacheOutboundProxyIP(aCacheOutboundProxyIP)

	{

	}

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

// CSIPRegistrationBindingBase::~CSIPRegistrationBindingBase

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

//

CSIPRegistrationBindingBase::~CSIPRegistrationBindingBase()

	{

	if (iRegistrar)

		{

		iRegistrar->BindingRemoved(iRegistrationId);

		}

	FreeProxyTransportResources();

	delete iPAssociatedURIHeader;

	delete iOutboundProxy;

	delete iOutboundProxyIP;

	delete iTo;

	delete iFrom;

	delete iContact;

	delete iRemoteTarget;

	iRouteSet.ResetAndDestroy();

	delete iRequest;

	// delete register states

	delete iRegistering;

	delete iRegistered;

	delete iResponse423Received;

	delete iUpdating;

	delete iUnregistering;

	delete iUnregistered;

	iTransportMgr.RemoveTransport(iTransportId);

	iSIPSec.ClearCache(this);

	iTransactionUser.FreeResources(*this);

	}

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

// CSIPRegistrationBindingBase::PassOnlyRealmsToUser

// From MSIPSecUser

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

//

TBool CSIPRegistrationBindingBase::PassOnlyRealmsToUser() const

    {

    return iSIPSecUser.PassOnlyRealmsToUser();

    }

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

// CSIPRegistrationBindingBase::RequestCredentialsL

// From MSIPSecUser

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

//

void CSIPRegistrationBindingBase::RequestCredentialsL(const TDesC8& aRealm)

    {

    iSIPSecUser.RequestCredentialsL(aRealm);

    }

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

// CSIPRegistrationBindingBase::RequestCredentialsL

// From MSIPSecUser

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

//

void CSIPRegistrationBindingBase::RequestCredentialsL(

    CSIPResponse& aResponse,

    TTransactionId aTransactionId,

    TRefreshId aRefreshId)

    {

    iSIPSecUser.RequestCredentialsL(aResponse,aTransactionId,aRefreshId);

    }

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

// CSIPRegistrationBindingBase::TrustedUser

// From MSIPSecUser

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

//

const MSIPSecUser* CSIPRegistrationBindingBase::TrustedUser(

    TRegistrationId /*aRegistrationId*/)

    {

    return NULL;

    }

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

// CSIPRegistrationBindingBase::ByPassSIPSec

// From MSIPSecUser

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

//

TBool CSIPRegistrationBindingBase::ByPassSIPSec() const

    {

    return iSIPSecUser.ByPassSIPSec();

    }

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

// CSIPRegistrationBindingBase::FlowFailure

// From MSIPNATBindingObserver

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

//

void CSIPRegistrationBindingBase::FlowFailure(TInt /*aError*/)

    {

    iOwner->RegistrationError(iTransactionId,iRegistrationId,

                              KErrSIPTransportFailure);

    ChangeState(iUnregistered);

    iTransactionUser.FreeResources(*this);

    }

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

// CSIPRegistrationBindingBase::RefreshId

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

//	

TRefreshId CSIPRegistrationBindingBase::RefreshId() const

    {

    return KEmptyRefreshId;

    }

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

// CSIPRegistrationBindingBase::SetRequest

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

//

void CSIPRegistrationBindingBase::SetRequest (CSIPRequest* aSIPRequest)

	{

	delete iRequest;

	iRequest = aSIPRequest;

	}

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

// CSIPRegistrationBindingBase::Owner

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

//

const MRegistrationOwner* CSIPRegistrationBindingBase::Owner() const

	{

	return iOwner;

	}

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

// CSIPRegistrationBindingBase::RegisterPending

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

//

TBool CSIPRegistrationBindingBase::RegisterPending () const

	{

	// return ETrue when binding is in following states.

	return (iCurrentState == iRegistering ||

		    iCurrentState == iUpdating ||

			iCurrentState == iUnregistering ||

			iCurrentState == iResponse423Received);

	}

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

// CSIPRegistrationBindingBase::UpdateBindingFromResponseL

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

//

void CSIPRegistrationBindingBase::UpdateBindingFromResponseL(

	CSIPResponse& aResponse)

	{

	// no related registrar, create one, add registrar pointer to binding

	if (!iRegistrar)

		{

		HBufC8* callId = CSIPResponseUtility::CallIdL(aResponse);

		CleanupStack::PushL(callId);

		iRegistrar = iBindingStore.RegistrarStore().CreateRegistrarL(

			*iRemoteTarget, *callId,

			CSIPResponseUtility::CSeqValueL(aResponse), iRegistrationId);

		CleanupStack::PopAndDestroy(callId);

		delete iRemoteTarget;

		iRemoteTarget = NULL;

		}

    const RStringF KTagParam = SIPStrings::StringF(SipStrConsts::ETag);

	if ((aResponse.From()) && (aResponse.From()->HasParam(KTagParam)))

		{

		iFrom->SetParamL(KTagParam,aResponse.From()->ParamValue(KTagParam));

		}

	SetRouteHeaderFromResponseL(aResponse);

	SetPAssociatedURIFromResponseL(aResponse);

	}

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

// CSIPRegistrationBindingBase::SetToHeaderL

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

//

void CSIPRegistrationBindingBase::SetToHeaderL(CSIPRequest& aSIPRequest)

	{

    CSIPToHeader* to = aSIPRequest.To();

	CSIPToHeader* tempTo = CSIPToHeader::NewL(*to);

	delete iTo;

	iTo = tempTo;

	}

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

// CSIPRegistrationBindingBase::SetFromHeaderL

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

//

void CSIPRegistrationBindingBase::SetFromHeaderL(CSIPRequest& aSIPRequest)

	{

	CSIPFromHeader* fromHeader = aSIPRequest.From();

	CSIPFromHeader* temp = CSIPFromHeader::NewL(*fromHeader);

	delete iFrom;

	iFrom = temp;

	}

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

// CSIPRegistrationBindingBase::SetContactHeaderL

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

//

void CSIPRegistrationBindingBase::SetContactHeaderL(CSIPRequest& aSIPRequest)

	{

    const RStringF KContactHeaderName = 

        SIPStrings::StringF(SipStrConsts::EContactHeader);	

    CSIPContactHeader* contact =

        HEADER(CSIPContactHeader, aSIPRequest, KContactHeaderName);

	CSIPContactHeader* tmp = static_cast<CSIPContactHeader*>(contact->CloneL());

	CleanupStack::PushL(tmp);

	if(iContact && tmp->ExpiresParameter() == KErrNotFound)

		tmp->SetExpiresParameterL(iContact->ExpiresParameter());

	delete iContact;

	CleanupStack::Pop(tmp);

	iContact = tmp;

	}

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

// CSIPRegistrationBindingBase::SetExpiresValueL

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

//

void CSIPRegistrationBindingBase::SetExpiresValueL(CSIPRequest& aSIPRequest)

	{

    const RStringF KContactHeaderName = 

        SIPStrings::StringF(SipStrConsts::EContactHeader);	

	CSIPContactHeader* contactHeader =

        HEADER(CSIPContactHeader, aSIPRequest, KContactHeaderName);

	iContact->SetExpiresParameterL(contactHeader->ExpiresParameter());

	}

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

// CSIPRegistrationBindingBase::SetMinExpiresToRequestL

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

//

void CSIPRegistrationBindingBase::SetMinExpiresToRequestL (

	CSIPResponse& aResponse)

	{

    const RStringF KContactHeaderName = 

        SIPStrings::StringF(SipStrConsts::EContactHeader);

	// the request must not be empty

	__SIP_ASSERT_LEAVE(iRequest, KErrArgument);

	__SIP_ASSERT_LEAVE(iRequest->HasHeader(KContactHeaderName),

		               KErrArgument);

    // get the Min expires header from response

	CSIPMinExpiresHeader* minExpiresHeader = HEADER(

		CSIPMinExpiresHeader, aResponse, 

		SIPStrings::StringF(SipStrConsts::EMinExpiresHeader));

	// get contact header from request

	CSIPContactHeader* contactInRequest = HEADER(

	    CSIPContactHeader, *iRequest, KContactHeaderName);

	// set the min expires value to contact in the original request

	contactInRequest->SetExpiresParameterL(minExpiresHeader->Value());

	}

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

// CSIPRegistrationBindingBase::SetRouteHeaderFromResponseL

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

//

void CSIPRegistrationBindingBase::SetRouteHeaderFromResponseL(

    CSIPResponse& aResponse)

	{

	iRouteSet.ResetAndDestroy();

	TSglQueIter<CSIPHeaderBase> iter =

        aResponse.Headers(

            SIPStrings::StringF(SipStrConsts::EServiceRouteHeader));

	for (CSIPHeaderBase* header = iter++; header; header = iter++)

		{

		CSIPServiceRouteHeader* routeHeader =

			static_cast<CSIPServiceRouteHeader*>(header);

		CSIPRouteHeader* newRouteHeader = 

		    SIPCodecUtils::CreateRouteHeaderLC(*routeHeader);

        iRouteSet.AppendL(newRouteHeader);

		CleanupStack::Pop(newRouteHeader);

		}

	}

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

// CSIPRegistrationBindingBase::ServiceRouteOk

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

//	

TBool CSIPRegistrationBindingBase::ServiceRouteOk(

    CSIPResponse& aResponse) const

    {

    // Check if the last Service-Route-header has changed

    TBool ok = ETrue;

    if (iRouteSet.Count() > 0)

        {

        TInt headerCount = 

            aResponse.HeaderCount(

                SIPStrings::StringF(SipStrConsts::EServiceRouteHeader));

        if (headerCount > 0)

            {

            CSIPRouteHeaderBase* myLastRoute = iRouteSet[iRouteSet.Count()-1];

            CSIPRouteHeaderBase* newLastRoute = 

                static_cast<CSIPRouteHeaderBase*>(

                    aResponse.Header(

                        SIPStrings::StringF(SipStrConsts::EServiceRouteHeader),

                        headerCount-1));      

            ok = (myLastRoute->SIPAddress() == newLastRoute->SIPAddress()); 

            }

        }

    return ok;

    }

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

// CSIPRegistrationBindingBase::SetPAssociatedURIFromResponseL

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

//	

void CSIPRegistrationBindingBase::SetPAssociatedURIFromResponseL(

    CSIPResponse& aResponse)

    {

    CSIPHeaderBase* headerInResponse = 

        aResponse.Header(

            SIPStrings::StringF(SipStrConsts::EPAssociatedURIHeader),0);

    CSIPHeaderBase* header = NULL;

    if (headerInResponse)

        {

        header = headerInResponse->CloneL();

        }

    delete iPAssociatedURIHeader;

    iPAssociatedURIHeader = static_cast<CSIPPAssociatedURIHeader*>(header);

    }

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

// CSIPRegistrationBindingBase::PAssociatedURIHeader

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

//    

const CSIPPAssociatedURIHeader* 

CSIPRegistrationBindingBase::PAssociatedURIHeader() const

    {

    return iPAssociatedURIHeader;

    }

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

// CSIPRegistrationBindingBase::FillTransportParams

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

//

TSIPTransportParams CSIPRegistrationBindingBase::FillTransportParams()

    {

    TSIPTransportParams transportParams(iOwner->TransportParams());

    transportParams.SetTransportId(iTransportId);

    transportParams.SetCompartmentId(iSigCompCompartmentId);

    transportParams.SetNATBindingObserver(this);

    return transportParams; 

    }    

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

// CSIPRegistrationBindingBase::HasTransaction

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

//

TBool CSIPRegistrationBindingBase::HasTransaction(

    const TTransactionId& aTransactionId) const

    {

    return (iTransactionId == aTransactionId || 

            iRetryTransactionId == aTransactionId);

    }	

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

// CSIPRegistrationBindingBase::OutboundProxyFailed

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

//	

void CSIPRegistrationBindingBase::OutboundProxyFailed()

    {

    if (!RegisterPending())

        {

        iCurrentState->TransactionEnded(KEmptyTransactionId,