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

// Part of     : sip ims plugin

// implementation

// Version     : 1.0

//

// INCLUDE FILES

#include <commsdat.h>

#include <commsdattypesv1_1.h>

#include <metadatabase.h>

#include <cdblen.h>

#include "sipimsprofileagent.h"

#include "sipconcreteprofile.h"

#include "sipprofileagentobserver.h"

#include "sipconnection.h"

#include "sipprflinitstate.h"

#include "sipprflresolvingproxiesstate.h"

#include "sipprflregisterrequestedstate.h"

#include "sipprflregisterdelayrequestedstate.h"

#include "sipprflregistrationinprogressstate.h"

#include "sipprflregisteredstate.h"

#include "sipprflderegistrationinprogressstate.h"

#include "sipprflderegisterrequestedstate.h"

#include "sipprflstatebase.h"

#include "sipimsprofilecontext.h"

#include "sipmanagedprofile.h"

#include "sipgendefs.h"

#include "SipProfileLog.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "CSIPNotifyXmlBodyParser.h"

#include "Sipimsprofileusimprovider.h"

#include "Sipimsprofilesimrecord.h"

#include "sipprofilequeuehandling.h"

#include "sip.h"

#include "siphttpdigest.h"

#include "sipservertransaction.h"

_LIT8(KSIPIMSProfileType, "ims");

const TInt KAuthorizedMicroSecsInSec = 1;

const TUint32 KRegAllowedWithUSIMandISIM = 1;

const TUint32 KRegAllowedWithISIM = 2;

#ifdef CPPUNIT_TEST

#define CPPUNIT_MEMORYLEAVE {	if (err == KErrNoMemory) User::Leave(KErrNoMemory);}

#else

#define CPPUNIT_MEMORYLEAVE

#endif

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

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

// CSIPIMSProfileAgent::NewL

// Two-phased constructor.

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

//

CSIPIMSProfileAgent* CSIPIMSProfileAgent::NewL(TAny* aInitParams)

	{

	PROFILE_DEBUG1("CSIPIMSProfileAgent::NewL")

	CSIPIMSProfileAgent* self = new (ELeave) CSIPIMSProfileAgent(

		static_cast<TSIPProfileAgentInitParams*>(aInitParams));

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

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

// CSIPIMSProfileAgent::CSIPIMSProfileAgent

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CSIPIMSProfileAgent::CSIPIMSProfileAgent(

    TSIPProfileAgentInitParams* aInitParams)

: iSIPProfileAgentObserver(aInitParams->iSIPProfileAgentObserver),

  iDeltaTimer(aInitParams->iDeltaTimer),

  iDeltaTimerCallBack(ASyncTimerExpired,this)

	{

	iType.iSIPProfileClass = TSIPProfileTypeInfo::EIms;

	iType.iSIPProfileName = KSIPIMSProfileType();

	iDeltaTimerEntry.Set(iDeltaTimerCallBack);

	}

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

// CSIPIMSProfileAgent::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSIPIMSProfileAgent::ConstructL()

    {

    PROFILE_DEBUG1("CSIPIMSProfileAgent::ConstructL")

    SIPStrings::OpenL();

	iSIP = CSIP::NewL(TUid::Null(),*this);

	iHttpDigest = CSIPHttpDigest::NewL(*iSIP,*this);    

    TBuf<KCommsDbSvrMaxFieldLength> tsyModuleName;

	GetTsyModuleNameL( tsyModuleName );

    User::LeaveIfError(iTelServer.Connect());    

    User::LeaveIfError(iTelServer.LoadPhoneModule(tsyModuleName));

    TInt numPhone(0);

    User::LeaveIfError(iTelServer.EnumeratePhones(numPhone));

    TName tsyName;

    TBool found = EFalse;

    RTelServer::TPhoneInfo phoneInfo;

    TInt i(0);

    while ( !found && i < numPhone )

        {

        User::LeaveIfError( iTelServer.GetPhoneInfo( i, phoneInfo ) );

        User::LeaveIfError( iTelServer.GetTsyName( i, tsyName ) );

        if ( tsyName.CompareF( tsyModuleName ) == 0 )

            {

            found = ETrue;

            }

        i++;

        }

    __ASSERT_ALWAYS(found, User::Leave(KErrNotFound));     

    iXMLParser = CSIPNotifyXmlBodyParser::NewL();

	iInit = CSIPPrflInitState::NewL(*this);

	iResolvingProxies = CSIPPrflResolvingProxiesState::NewL(*this);

	iRegRequested = CSIPPrflRegisterRequestedState::NewL(*this);

	iRegInProgress = CSIPPrflRegistrationInProgressState::NewL(*this);

	iRegistered = CSIPPrflRegisteredState::NewL(*this);

	iDeregRequested = CSIPPrflDeregisterRequestedState::NewL(*this);

	iDeregInProgress = CSIPPrflDeregistrationInProgressState::NewL(*this);

	iRegDelayRequested = CSIPPrflRegisterDelayRequestedState::NewL(*this);

	iInit->LinkStates(*iResolvingProxies, *iRegRequested, *iRegInProgress);

	iResolvingProxies->LinkStates(*iInit, *iRegRequested, *iRegInProgress);

	iRegRequested->LinkStates(*iInit, *iResolvingProxies, *iRegInProgress);

	iRegInProgress->LinkStates(*iRegRequested, *iInit, *iRegistered,

	                           *iRegDelayRequested);

	iRegistered->LinkStates(*iDeregRequested, *iDeregInProgress,

							 *iInit, *iRegRequested,*iRegDelayRequested);

	iDeregRequested->LinkStates(*iInit, *iRegistered, *iDeregInProgress);

	iDeregInProgress->LinkStates(*iInit);

	iRegDelayRequested->LinkStates(*iInit);

	iSIMRecord = CSIPProfileSIMRecord::NewL();	

	iProfileQueueHandling = CSIPProfileQueueHandling::NewL(*this);

	TRAPD(err, iUsimProvider = 

	    CSIPProfileUsimProvider::NewL(

	        *iSIMRecord, iTelServer, phoneInfo, *this));

	if(err == KErrNoMemory)

		{

		User::Leave(err);

		}

	iConfigExtension = NULL;

    }

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

// CSIPIMSProfileAgent::~CSIPIMSProfileAgent

// Symbian 2nd phase constructor can leave.

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

//

CSIPIMSProfileAgent::~CSIPIMSProfileAgent()

	{

	PROFILE_DEBUG1("CSIPIMSProfileAgent::~CSIPIMSProfileAgent")

	delete iInit;

	delete iResolvingProxies;

	delete iRegRequested;

	delete iRegistered;

	delete iRegInProgress;

	delete iDeregRequested;

	delete iDeregInProgress;

	delete iRegDelayRequested;

	delete iProfileQueueHandling;

	iDeltaTimer.Remove(iDeltaTimerEntry);

	iConnectionCtxArray.ResetAndDestroy();

	iConnectionCtxArray.Close();

	iWaitForRegisteringArray.Reset();

	iSIMWaitForAuthorizedArray.Reset();

	iUSimWaitForAuthorizedArray.Reset();

	iWaitForAuthorizedArray.Reset();

	iFailedProfilesArray.Reset();

	delete iXMLParser;

	delete iUsimProvider;

	delete iSIMRecord;

	iTelServer.Close();

	delete iHttpDigest;

	delete iSIP;

	SIPStrings::Close();	

	}

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

// CSIPIMSProfileAgent::RegAllowedWithUSIMorISIML

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

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

//

TBool CSIPIMSProfileAgent::RegAllowedWithUSIMorISIML(CSIPConcreteProfile& aProfile)

	{

	TBool allowed = ETrue;

	TUint32 confValue = 0;

	TInt result = 0;

	result = aProfile.ExtensionParameter( KSIPAllowIMSRegistration,confValue );

	if ( result != KErrNotFound )

		{

		if (confValue == KRegAllowedWithISIM && !iSIMRecord->IsISIMPresent())

			{

			allowed = EFalse;

			}		

		}

	return allowed;

	}

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

// CSIPIMSProfileAgent::RegAllowedWithSIM

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

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

//

TBool CSIPIMSProfileAgent::RegAllowedWithSIM(CSIPConcreteProfile& aProfile)

	{

	TBool allowed = ETrue;

	TUint32 confValue = 0;

	TInt result = 0;

	result = aProfile.ExtensionParameter( KSIPAllowIMSRegistration,confValue );

	if (result != KErrNotFound)

		{

		if (confValue == KRegAllowedWithISIM ||

				 confValue == KRegAllowedWithUSIMandISIM)

			{

			allowed = EFalse;

			}		

		}

	return allowed;

	}

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

// CSIPIMSProfileAgent::CheckIPSecRulesL

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

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

//

void CSIPIMSProfileAgent::CheckIPSecRulesL(CSIPConcreteProfile& aProfile)

	{

	TBool found = EFalse;

	TBool isRegInUse = EFalse;

	found = IsIPSecAlreadyInUse(isRegInUse);	

	if (found)

		{

		ResetISIMUpdateProfile( &aProfile );

		User::Leave(KErrArgument);

		}

	if (isRegInUse)

		{

		iWaitForRegisteringArray.AppendL(&aProfile);

		}

	else 

		{	

		ProfileToWaitingQueueL( &aProfile );

		}

	}

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

// CSIPIMSProfileAgent::ResetISIMUpdateProfile

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

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

//

void CSIPIMSProfileAgent::ResetISIMUpdateProfile( CSIPConcreteProfile* aSIPConcreteProfile )

	{

	if ( iISIMUpdateProfile && (iISIMUpdateProfile->Id() == aSIPConcreteProfile->Id()) )

		{

		iISIMUpdateProfile = 0;

		}

	}

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

// CSIPIMSProfileAgent::IsIPSecAlreadyInUse

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

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

//

TBool CSIPIMSProfileAgent::IsIPSecAlreadyInUse( TBool& aIsRegInProgress )

	{

	TBool found = EFalse;

	for (TInt i=0; i < iConnectionCtxArray.Count() && !found; i++)

		{

		found = iConnectionCtxArray[i]->IsIPSecAlreadyInUse( aIsRegInProgress );	

		}

	if ( !found && !aIsRegInProgress )

		{

		aIsRegInProgress = iProfileQueueHandling->FoundIPSecProfileCandidate();

		}

	return found;

	}

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

// CSIPIMSProfileAgent::Type

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

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

//

const TSIPProfileTypeInfo& CSIPIMSProfileAgent::Type() const

	{

	return iType;

	}

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

// CSIPIMSProfileAgent::CreateL

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

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

//

CSIPConcreteProfile* CSIPIMSProfileAgent::CreateL()

	{

	TSIPProfileTypeInfo type;		

	type.iSIPProfileClass = TSIPProfileTypeInfo::EIms;

	type.iSIPProfileName = KSIPIMSProfileType;

	CSIPConcreteProfile* profile = CSIPConcreteProfile::NewLC();

	profile->SetProfileType(type);

	profile->EnableSecurityNegotiation(ETrue);

	profile->EnableSigComp(ETrue);

	_LIT8(KSIPDefaultProxy, "sip:0.0.0.0");

	profile->SetServerL(KSIPOutboundProxy, KSIPDefaultProxy);

	CleanupStack::Pop(profile);

	return profile;

	}

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

// CSIPIMSProfileAgent::RegisterL

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

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

//

void CSIPIMSProfileAgent::RegisterL(

	CSIPConcreteProfile& aSIPConcreteProfile)

	{

	PROFILE_DEBUG3("CSIPIMSProfileAgent::RegisterL", aSIPConcreteProfile.Id())

	__ASSERT_ALWAYS (aSIPConcreteProfile.Server(KSIPOutboundProxy).Length(),

		User::Leave(KErrArgument));

	TBool isClientConfigured = EFalse;

	if (CheckIfConfigured(aSIPConcreteProfile))

		{

		if (!MandatoryValuesConfigured(aSIPConcreteProfile))

			{

			User::Leave(KErrArgument);

			}

		isClientConfigured = ETrue;

		}

	if (!iUsimProvider && !isClientConfigured)

		{//No USIM/SIM access available

		User::Leave(KErrArgument);

		}

	if (!isClientConfigured)

		{

		TUint32 confValue = 0;

		TInt result = 0;

		result = aSIPConcreteProfile.ExtensionParameter( KSIPAllowIMSRegistration,confValue );

		if (result != KErrNotFound)

			{

			if ((confValue == KRegAllowedWithUSIMandISIM || 

			    confValue == KRegAllowedWithISIM )

			    && !iUsimProvider->IsUsimSupported())

				{

				User::Leave(KErrNotSupported);

				}

			}

		}

	// If digest settings are configured, no need to do USIM/SIM authorization	

	if (iUsimProvider && 

	    !CSIPIMSProfileContext::IsHttpDigestSettingsConfigured(aSIPConcreteProfile))

	    {

	   	if (!iUsimProvider->IsUsimSupported())

    		{

    		iSIMWaitForAuthorizedArray.AppendL(&aSIPConcreteProfile);

    		iUsimProvider->RequestL(ETrue);

    		}

	    else

			{

			iUSimWaitForAuthorizedArray.AppendL(&aSIPConcreteProfile);

			iUsimProvider->RequestL();

			}

	    }

    else

		{

		iWaitForAuthorizedArray.AppendL(&aSIPConcreteProfile);

		AsyncDeltaTimer();

		}

	}

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

// CSIPIMSProfileAgent::UpdateL

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

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

//

void CSIPIMSProfileAgent::UpdateL(

	CSIPConcreteProfile& aNewProfile, 

	CSIPConcreteProfile& aOldProfile)

	{

	PROFILE_DEBUG3("CSIPIMSProfileAgent::UpdateL", aOldProfile.Id())

	iProfileQueueHandling->Cleanup(aOldProfile,&aNewProfile);

	CSIPIMSProfileContext* context = FindProfileContext(aOldProfile);

	if (!context)

	    {

	    User::Leave(KErrNotFound);

	    }

	context->UpdateL(aNewProfile);

	}

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

// CSIPIMSProfileAgent::DeregisterL

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

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

//

void CSIPIMSProfileAgent::DeregisterL(

	CSIPConcreteProfile& aSIPConcreteProfile)

	{

	PROFILE_DEBUG3("CSIPIMSProfileAgent::DeregisterL", aSIPConcreteProfile.Id())

	CSIPIMSProfileContext* context = FindProfileContext(aSIPConcreteProfile);

	if ( context )

		{

		if (!DeregisterToWaitingQueueL( context ))

			{

			context->DeregisterL();

			}

		}

	else

		{

		PROFILE_DEBUG1("CSIPIMSProfileAgent::DeregisterL RemoveProfileFromQueue")

		if (! iProfileQueueHandling->RemoveProfileFromRegQueueL(aSIPConcreteProfile) )

			{

			if (!RemoveProfileFromWaitingQueue(iWaitForRegisteringArray,

												aSIPConcreteProfile) )

				{

				if (!RemoveProfileFromWaitingQueue(iUSimWaitForAuthorizedArray,

												    aSIPConcreteProfile))

					{

					if (!RemoveProfileFromWaitingQueue(iSIMWaitForAuthorizedArray,

														aSIPConcreteProfile))

						{

						RemoveProfileFromWaitingQueue(iWaitForAuthorizedArray,

															aSIPConcreteProfile);

						}

					}

				}

			}

		}	   

	}

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

// CSIPIMSProfileAgent::GetProfileState

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

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

//

TInt CSIPIMSProfileAgent::GetProfileState(

	CSIPConcreteProfile::TStatus& aState, 

	CSIPConcreteProfile& aProfile) const

	{

	CSIPIMSProfileContext* context = FindProfileContext(aProfile);

	if (context)

		{

		aState = context->CurrentMappedState();

		return KErrNone;

		}

	else

		{

		return KErrNotFound;

		}

	}

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

// CSIPIMSProfileAgent::IsIdle

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

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

//

TBool CSIPIMSProfileAgent::IsIdle()

	{

	CleanIdleConnectionContexts();

	return (iConnectionCtxArray.Count()==0 &&

	        iProfileQueueHandling->IsEmpty() &&

	        iWaitForRegisteringArray.Count()==0 &&

	        iUSimWaitForAuthorizedArray.Count()==0 &&

	        iSIMWaitForAuthorizedArray.Count()==0 &&

	        iWaitForAuthorizedArray.Count()==0 &&

	        !iSIMRecord->IsISIMPresent() );

	}

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

// CSIPIMSProfileAgent::RegisterPending

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

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

//	

TBool CSIPIMSProfileAgent::RegisterPending(

    CSIPConcreteProfile& aSIPProfile) const

    {

	CSIPIMSProfileContext* context = FindProfileContext(aSIPProfile);

	if (context)

		{

		return context->IsRegisterPending();

		}

	return EFalse;

    }

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

// CSIPIMSProfileAgent::TerminateHandling

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

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

//

TInt CSIPIMSProfileAgent::TerminateHandling(CSIPConcreteProfile& aProfile)

	{

	CSIPIMSProfileContext* context = FindProfileContext(aProfile);

	if (context)