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

// Part of     : sip ims agent

// implementation

// Version     : 1.0

//

// INCLUDE FILES

#include "sipimsprofilecontext.h"

#include "sipprflstatebase.h"

#include "sipconcreteprofile.h"

#include "sipmanagedprofile.h"

#include "sipimsprofileagent.h"

#include "sipregistrationbinding.h"

#include "sipclienttransaction.h"

#include "sipgendefs.h"

#include "siprefresh.h"

#include "sipmessagebuilder.h"

#include "sipaddress.h"

#include "siptoheader.h"

#include "siprouteheader.h"

#include "sipmessageelements.h"

#include "sipresponseelements.h"

#include "sipsecurityclientheader.h"

#include "sipextensionheader.h"

#include "sippassociateduriheader.h"

#include "sipsupportedheader.h"

#include "SipProfileLog.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "siperr.h"

#include "sip.h"

#include "sipcontactheader.h"

#include "CSIPRegEventHandler.h"

#include "sipdialogassocbase.h"

#include "Sipimsprofilesimrecord.h"

#include "sipunsupportedheader.h"

#include "sipretryafterheader.h"

_LIT8(KSIPIpSec3gpp, "ipsec-3gpp");

_LIT8(KTransportUdpParam, "transport=udp");

_LIT8(KTransportTcpParam, "transport=tcp");

// ============================ MEMBER FUNCTIONS ===============================

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

// CSIPIMSProfileContext::NewLC

// (other items were commented in a header).

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

//

CSIPIMSProfileContext* CSIPIMSProfileContext::NewLC(

    CSIPNotifyXmlBodyParser& aXMLParser,

	CSIP& aSIP,

	CSIPIMSConnectionContext& aConnection, 

	MSIPProfileAgentObserver& aObserver,

	CSIPPrflStateBase& aInitState,

	CSIPConcreteProfile& aProfile,

	CDeltaTimer& aDeltaTimer,

	CSIPProfileSIMRecord& aSIMRecord,

	CSipProfileAgentConfigExtension& aConfigExtension)

	{

	CSIPIMSProfileContext* self = 

	    new(ELeave)CSIPIMSProfileContext(aXMLParser, aSIP, aConnection, 

	        aObserver, aInitState, aProfile, aDeltaTimer, aSIMRecord,aConfigExtension);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

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

// CSIPIMSProfileContext::NewL

// (other items were commented in a header).

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

//

CSIPIMSProfileContext* CSIPIMSProfileContext::NewL(

    CSIPNotifyXmlBodyParser& aXMLParser,

	CSIP& aSIP,

	CSIPIMSConnectionContext& aConnection, 

	MSIPProfileAgentObserver& aObserver,

	CSIPPrflStateBase& aInitState,

	CSIPConcreteProfile& aProfile,

	CDeltaTimer& aDeltaTimer,

	CSIPProfileSIMRecord& aSIMRecord,

	CSipProfileAgentConfigExtension& aConfigExtension)

	{

	CSIPIMSProfileContext* self = 

	    CSIPIMSProfileContext::NewLC(aXMLParser, aSIP, aConnection, aObserver, 

	        aInitState, aProfile, aDeltaTimer, aSIMRecord,aConfigExtension);

	CleanupStack::Pop(self);

	return self;

	}

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

// CSIPIMSProfileContext::CSIPIMSProfileContext

// (other items were commented in a header).

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

//

CSIPIMSProfileContext::CSIPIMSProfileContext(

    CSIPNotifyXmlBodyParser& aXMLParser,

	CSIP& aSIP,

	CSIPIMSConnectionContext& aConnection,

	MSIPProfileAgentObserver& aObserver,

	CSIPPrflStateBase& aInitState,

	CSIPConcreteProfile& aProfile,

	CDeltaTimer& aDeltaTimer,

	CSIPProfileSIMRecord& aSIMRecord,

	CSipProfileAgentConfigExtension& aConfigExtension)

	: CSIPProfileContextBase(aSIP,

	                         *(aConnection.Connection()),

	                         aObserver,

	                         aInitState,

	                         aProfile,

	                         aDeltaTimer),	

	  iXMLParser(aXMLParser),

	  iConnectionContext(aConnection),

	  iSIMRecord(aSIMRecord),

	  iConnectionDropped(EFalse),

	  iDeactivatedByNetwork(EFalse),

	  iRetriedRegister(EFalse),

	  iRetryTimerUse(EFalse),

	  iUseDynamicProxyForTry(EFalse),

	  iConfigExtension(aConfigExtension)

	{

	}

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

// CSIPIMSProfileContext::ConstructL()

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

//	

void CSIPIMSProfileContext::ConstructL()

    {

    iPathStr = SIPStrings::Pool().OpenFStringL(KSIPpath());

    }

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

// CSIPIMSProfileContext::~CSIPIMSProfileContext

// (other items were commented in a header).

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

//

CSIPIMSProfileContext::~CSIPIMSProfileContext()

	{

	delete iRegEventHandler;

	delete iPAURI;

	iPathStr.Close();

	}

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

// CSIPIMSProfileContext::AgentObserver()

// (other items were commented in a header).

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

//

MSIPProfileAgentObserver& CSIPIMSProfileContext::AgentObserver() const

	{

	const MSIPProfileAgentObserver& obs = *this;

	return const_cast<MSIPProfileAgentObserver&>(obs);

	}

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

// CSIPIMSProfileContext::DestroyRegistration()

// (other items were commented in a header).

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

//

void CSIPIMSProfileContext::DestroyRegistration()

	{

	PROFILE_DEBUG3("SIPIMSProfileContext::DestroyRegistration", ProfileId())

	delete iRegistration;

	iRegistration = NULL;

	RemoveRegEventHandler();

	}

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

// CSIPIMSProfileContext::CreateRegistrationL

// (other items were commented in a header).

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

//

void CSIPIMSProfileContext::CreateRegistrationL()

	{

	ASSERT(iProfile);

    RStringF transport(SIPStrings::StringF(SipStrConsts::EEmpty));

    CleanupClosePushL(transport);	

	TUint pops = 0;

	CSIPRouteHeader* proxy = 0;

	CUri8* remoteUri = 0;

	CSIPRefresh* refresh = CSIPRefresh::NewLC();

	pops++;

	CSIPToHeader* to = 0;

	if (iConfiguredType == CSIPIMSProfileContext::EEarlyIMSType)

		{

		to = SIPMessageBuilder::CreateToLC(iSIMRecord.SIMPublicIdentity());

		}

	else if (iConfiguredType == CSIPIMSProfileContext::EIMSReleaseType)

		{

		to = SIPMessageBuilder::CreateToLC(iSIMRecord.PublicIdentity());

		}	

	else 

		{

		//CSIPIMSProfileContext::EClientConfiguredType

		to = SIPMessageBuilder::CreateToLC(iProfile->AOR());

		}

	pops++;

	const TDesC8& proxyAddr = ProxyAddressL();

	if (proxyAddr.Length()) //there's an outbound proxy defined

		{

		(iProfile->IsSigCompEnabled())?

		proxy = SIPMessageBuilder::CreateRouteLC(proxyAddr, ETrue):

		proxy = SIPMessageBuilder::CreateRouteLC(proxyAddr);

		pops++;	

		RStringF proxyTransport = TransportProtocol(proxy->SIPAddress().Uri8());	

		if (proxyTransport.DesC().Length() > 0)

			{

			transport = proxyTransport.Copy();

			}		

		}

	if (iConfiguredType == CSIPIMSProfileContext::EClientConfiguredType)

	    {

		if (iProfile->Server(KSIPRegistrar).Length()) // registrar defined

			{

			TUriParser8 parser;

			User::LeaveIfError(parser.Parse(iProfile->Server(KSIPRegistrar)));

            remoteUri = CUri8::NewLC(parser);			

			pops++;

			if (!proxy)

				{

				RStringF registrarTransport = TransportProtocol(*remoteUri);		

		        if (registrarTransport.DesC().Length() > 0)

			        {

			        transport = registrarTransport.Copy();

			        }

				}

			}

	    }

	else

		{

		HBufC8* temp = NULL;

		if (iConfiguredType == CSIPIMSProfileContext::EEarlyIMSType)

			{

		 	temp = iSIMRecord.AddSIPPrefixLC(

		 	    iSIMRecord.SIMHomeNetworkDomainName());

			}			

		if (iConfiguredType == CSIPIMSProfileContext::EIMSReleaseType)

			{

			temp = iSIMRecord.AddSIPPrefixLC(

			    iSIMRecord.HomeNetworkDomainName());

			}

	    if (temp)

	        {

			TUriParser8 parser;

			User::LeaveIfError(parser.Parse(*temp));

            remoteUri = CUri8::NewL(parser);

            CleanupStack::PopAndDestroy(temp);

            CleanupStack::PushL(remoteUri);

			pops++;

	        }

		}

	TBool sigcomp = iProfile->IsSigCompEnabled();

	const TDesC8* user = NULL;

	User::LeaveIfError(

		iProfile->ExtensionParameter(KSIPContactHeaderUser,user));	

	CSIPContactHeader* contact =

	    SIPMessageBuilder::CreateContactLC(*user,

	    		iConfigExtension.ExpiryValueL(TSIPProfileTypeInfo::EIms,

				CSipProfileAgentConfigExtension::EProfileRegistrationValue),

	    		iProfile->ContactHeaderParams(),

	    		transport, sigcomp);

	pops++;

	iRegistration = 

	    CSIPRegistrationBinding::NewL(*iConnectionContext.Connection(), 

		                              to, contact, refresh, proxy, remoteUri);

	CleanupStack::Pop(pops);

	CleanupStack::PopAndDestroy(1); // transport

	}

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

// CSIPIMSProfileContext::CreateMsgElementsLC()

// (other items were commented in a header).

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

//

CSIPMessageElements* CSIPIMSProfileContext::CreateMsgElementsLC()

	{

	ASSERT(iProfile);

	CSIPMessageElements* elements = CSIPMessageElements::NewLC();

    RPointerArray<CSIPHeaderBase> headers(CreateSIPHeadersL(*iProfile));

	CSIPHeaderBase::PushLC(&headers);

	if(iConfiguredType != CSIPIMSProfileContext::EEarlyIMSType)

		{

		CSIPExtensionHeader* authorization= NULL;

		if(iConfiguredType == CSIPIMSProfileContext::EClientConfiguredType)

			{

			authorization=

				(iProfile->PrivateIdentity().Length()>0)?

			    SIPMessageBuilder::CreateAuthorizationLC(

				    iProfile->Server(KSIPRegistrar),

				    iProfile->ServerParameter(KSIPRegistrar, KSIPDigestRealm),

				    iProfile->PrivateIdentity())

			    :

			    SIPMessageBuilder::CreateAuthorizationLC(

				    iProfile->Server(KSIPRegistrar),

				    iProfile->ServerParameter(KSIPRegistrar, KSIPDigestRealm),

				    iProfile->ServerParameter(KSIPRegistrar, KSIPDigestUserName));	

			}

		else

			{

			HBufC8* temp = 

			    iSIMRecord.AddSIPPrefixLC(iSIMRecord.HomeNetworkDomainName());

			authorization=

			    SIPMessageBuilder::CreateAuthorizationLC(

				    *temp,

				    iSIMRecord.HomeNetworkDomainName(),

				    iSIMRecord.PrivateIdentity());

			CleanupStack::Pop(authorization);

			CleanupStack::PopAndDestroy(temp);

			CleanupStack::PushL(authorization);

			}

		headers.AppendL(authorization);

		CleanupStack::Pop(authorization);

		}

	CSIPSupportedHeader* supported = CSIPSupportedHeader::NewLC(iPathStr);

	headers.AppendL(supported);

	CleanupStack::Pop(supported);

	AddSecurityClientHeaderL(headers,*iProfile);

    elements->SetUserHeadersL(headers);

	CleanupStack::PopAndDestroy(&headers); 

	return elements;

	}

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

// CSIPIMSProfileContext::CreateDeRegisterElementsL()

// (other items were commented in a header).

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

//

CSIPMessageElements* CSIPIMSProfileContext::CreateDeRegisterElementsL()

	{

	ASSERT(iProfile);	

	CSIPMessageElements* elements = CSIPMessageElements::NewLC();

    RPointerArray<CSIPHeaderBase> headers(CreateSIPHeadersL(*iProfile));

	CSIPHeaderBase::PushLC(&headers);	

	if (iConfiguredType == CSIPIMSProfileContext::EClientConfiguredType)

		{

		CSIPExtensionHeader* authorization= NULL;

		if(iProfile->PrivateIdentity().Length()>0)

			{

			authorization = SIPMessageBuilder::CreateAuthorizationLC(

				iProfile->Server(KSIPRegistrar),

				iProfile->ServerParameter(KSIPRegistrar, KSIPDigestRealm),

				iProfile->PrivateIdentity());

			}

		else

			{

			authorization =	SIPMessageBuilder::CreateAuthorizationLC(

				iProfile->Server(KSIPRegistrar),

				iProfile->ServerParameter(KSIPRegistrar, KSIPDigestRealm),

				iProfile->ServerParameter(KSIPRegistrar, KSIPDigestUserName));

			}

		headers.AppendL(authorization);

		CleanupStack::Pop(authorization);

		}

	AddSecurityClientHeaderL(headers,*iProfile);

    elements->SetUserHeadersL(headers);

	CleanupStack::PopAndDestroy(&headers); 

	CleanupStack::Pop(elements);

	return elements;

	}

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

// CSIPIMSProfileContext::UpdateContactHeaderParamsL

// (other items were commented in a header).

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

//

void CSIPIMSProfileContext::UpdateContactHeaderParamsL(

	CSIPConcreteProfile& aNewProfile)

	{

	ASSERT(iProfile);	

	CSIPContactHeader& contact = Registration()->ContactHeader();

    TPtrC8 paramName;

	TPtrC8 paramValue;

	for (TInt i = Profile()->ContactHeaderParams().MdcaCount()-1;i >= 0; i--)

		{

		TPtrC8 param(Profile()->ContactHeaderParams().MdcaPoint(i));

		SIPMessageBuilder::ParseParamL(param,paramName,paramValue);		

		RStringF name = SIPStrings::Pool().OpenFStringL(paramName);

		CleanupClosePushL(name);

		contact.DeleteParam(name);

		CleanupStack::PopAndDestroy();//name

		}

	for (TInt i = 0; &(aNewProfile.ContactHeaderParams()) && 

				     (i < aNewProfile.ContactHeaderParams().MdcaCount()); i++)

		{

		TPtrC8 param(aNewProfile.ContactHeaderParams().MdcaPoint(i));

		TBool hasValue = 

		    SIPMessageBuilder::ParseParamL(param,paramName,paramValue);

		RStringF name = SIPStrings::Pool().OpenFStringL(paramName);

		CleanupClosePushL(name);

		if (hasValue)

			{

			RStringF value = SIPStrings::Pool().OpenFStringL(paramValue);

			CleanupClosePushL(value);

			contact.SetParamL(name,value);

			CleanupStack::PopAndDestroy(); // value

			}

		else

			{

			contact.SetParamL(name);	

			}

		CleanupStack::PopAndDestroy(); // name	

		}

	CSIPMessageElements* elements = CreateMsgElementsForUpdateLC(aNewProfile);

	SetTransaction(Registration()->UpdateL(

			iConfigExtension.ExpiryValueL(TSIPProfileTypeInfo::EIms,

			CSipProfileAgentConfigExtension::EProfileRegistrationValue),

			elements));

	CleanupStack::Pop(elements);			

	}

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

// CSIPIMSProfileContext::RegEventSubscriptionActive()

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

//	

void CSIPIMSProfileContext::RegEventSubscriptionActive()

    {

    // Reg-event failure notifications after this must not lead to registration 

    // (see CSIPIMSProfileContext::RegEventSubscriptionFailedL)

    iConnectionDropped = EFalse;

    iDeactivatedByNetwork = EFalse;

    if (iProfile && iRegistration)

        {

        iObserver.SIPProfileStatusEvent(*iProfile,iRegistration->ContextId());

        }

    }

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

// CSIPIMSProfileContext::ExpirationTimeUpdatedL()

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

//

void CSIPIMSProfileContext::ExpirationTimeUpdatedL(TInt aExpirationTime)

	{

	__ASSERT_ALWAYS(aExpirationTime > 0 , User::Leave(KErrArgument));

	__ASSERT_ALWAYS(iRegistration != NULL, User::Leave(KErrNotReady));

	CSIPRefresh* refresh = iRegistration->SIPRefresh();

	if(refresh)

		{

		refresh->SetIntervalL(aExpirationTime);

		}

	}

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

// CSIPIMSProfileContext::ReRegister()

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

//	

void CSIPIMSProfileContext::ReRegister()

    {

    TBool handled = ETrue;

    CSIPProfileContextBase::ErrorOccured(KErrTotalLossOfPrecision,

                                         *Registration(),handled);    

    }

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

// CSIPIMSProfileContext::RegistrationDeactivated()

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

//

void CSIPIMSProfileContext::RegistrationDeactivated()

    {

    if (!iDeactivatedByNetwork)

        {

        // For the first deactivation indicate with an error 

        // that an initial reqistration must be performed

        iDeactivatedByNetwork = ETrue;

        ReRegister();     

        }

    else

        {

        // If the network deactivates registration twice in a row,

        // the profile registration fails

        RegistrationTerminated();

        }

    }

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

// CSIPIMSProfileContext::RegistrationTerminated()

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

//

void CSIPIMSProfileContext::RegistrationTerminated()

    {

    iCurrentState = iInitState;

    SetRetryPossible(EFalse);

    // A specific error code for network initiated de-registration

    iObserver.SIPProfileErrorEvent(*iProfile,KErrDisconnected);

    }

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

// CSIPIMSProfileContext::RegEventSubscriptionFailedL()

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

//

void CSIPIMSProfileContext::RegEventSubscriptionFailedL()

    {

    if (iConnectionDropped)

        {

        // Perform an initial registration again