// 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        : sipprofilecssession

// Part of     : SIP Profile Server

// implementation

// Version     : 1.0

//

// INCLUDE FILES

#include "SipProfileCSServer.h"

#include "SipProfileCSSession.h"

#include "sipconcreteprofile.h"

#include "sipconcreteprofileholder.h"

#include "sipprofileslots.h"

#include "sipprofileplugins.h"

#include "SipProfileLog.h"

#include "sipprofile.h"

#include "sipmanagedprofile.h"

#include <s32mem.h>

const TUint KBufferSize = 100;

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

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

// CSIPProfileCSSession::NewL

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

//

CSIPProfileCSSession* CSIPProfileCSSession::NewL(CSIPProfileCSServer& aServer,

												 CSIPProfileServerCore& aCore)

	{

    CSIPProfileCSSession* self = CSIPProfileCSSession::NewLC(aServer, aCore);

    CleanupStack::Pop(self);

    return self;

	}

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

// CSIPProfileCSSession::NewLC

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

//

CSIPProfileCSSession* CSIPProfileCSSession::NewLC(CSIPProfileCSServer& aServer,

									 			  CSIPProfileServerCore& aCore)

	{

    CSIPProfileCSSession* self =

    	new (ELeave) CSIPProfileCSSession(aServer, aCore);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

	}

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

// CSIPProfileCSSession::CSIPProfileCSSession

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

//

 CSIPProfileCSSession::CSIPProfileCSSession(CSIPProfileCSServer& aServer,

							  				CSIPProfileServerCore& aCore) :

	iProfileServer(aServer),

  	iCore(aCore),

  	iClientReadyToReceive(EFalse),

  	iSessionTerminated(EFalse),

  	iALRObserverExists(EFalse)

	{

    iProfileServer.IncrementSessions();

	}

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

// CSIPProfileCSSession::ConstructL

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

//

void CSIPProfileCSSession::ConstructL()

	{

	iCore.SessionRegisterL(*this);

	}

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

// CSIPProfileCSSession::~CSIPProfileCSSession

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

//

CSIPProfileCSSession::~CSIPProfileCSSession()

	{

	iCore.SessionCleanup(*this);

	iEventQueue.Close();

    iProfileServer.DecrementSessions();

	}

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

// CSIPProfileCSSession::PanicClient

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

//

void CSIPProfileCSSession::PanicClient(TInt aError)

	{

    if (iClientReadyToReceive)

        {

		iEventMessage.Panic(KSipProfileServerName, aError);

		}

	iSessionTerminated = ETrue;	

	}

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

// CSIPProfileCSSession::ServiceL

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

//

void CSIPProfileCSSession::ServiceL(const RMessage2& aMessage)

	{

	TInt function = iHelper.ServiceFunction(aMessage);

    __ASSERT_ALWAYS (!(iSessionTerminated &&

		function != ESipProfileItcOpCancelReceive), 

		aMessage.Panic (KSipProfileServerName, EBadSipSessionHandle));

#ifndef PLAT_SEC_TEST

	PROFILE_DEBUG3("ProfileCSSession::ServiceL", function)

    switch (function)

		{

        case ESipProfileItcOpPluginsSize: ProfilePluginsSizeL(aMessage); break;

        case ESipProfileItcOpPlugins: ProfilePluginsL(aMessage); break;

        case ESipProfileItcOpAddProfile: AddProfileL(aMessage); break;

        case ESipProfileItcOpUpdateProfile: UpdateProfileL(aMessage); break;

        case ESipProfileItcOpRemoveProfile: RemoveProfileL(aMessage); break;

        case ESipProfileItcOpEnable: EnableL(aMessage); break;

        case ESipProfileItcOpDisable: DisableL(aMessage); break;

        case ESipProfileItcOpUsage: UsageL(aMessage); break;

        case ESipProfileItcOpProfileSize: SipProfileSizeL (aMessage); break;

        case ESipProfileItcOpProfileSizeDefault: SipProfileSizeDefaultL (aMessage); break;

        case ESipProfileItcOpProfile: SipProfileL (aMessage); break;

        case ESipProfileItcOpProfileRefresh: SipProfileRefreshL (aMessage); break;

        case ESipProfileItcOpProfilesSize: SipProfilesSizeL (aMessage); break;

        case ESipProfileItcOpProfiles: SipProfilesL (aMessage); break;

        case ESipProfileItcOpProfilesSizeByAOR: SipProfilesSizeByAORL (aMessage); break;

        case ESipProfileItcOpProfilesByAOR: SipProfilesByAORL (aMessage); break;

        case ESipProfileItcOpProfilesSizeByType: SipProfilesSizeByTypeL (aMessage); break;

        case ESipProfileItcOpProfilesByType: SipProfilesByTypeL (aMessage); break;

        case ESipProfileItcOpDeleteProfile: DeleteSipProfileL (aMessage); break;

        case ESipProfileItcOpCancelReceive: CancelClientReceiveL (); break;

        case ESipProfileItcOpCreateProfileSize: CreateProfileSizeL (aMessage); break;

        case ESipProfileItcOpCreateProfile: CreateProfileL (aMessage); break;

        case ESipProfileItcOpRegisteredAORs: RegisteredAORsL (aMessage); break;

        case ESipProfileItcOpRegisteredAORsSize: RegisteredAORsSizeL (aMessage); break;

        case ESipProfileItcOpNegotiatedSecurity: NegotiatedSecurityL (aMessage); break;

        case ESipProfileItcOpNegotiatedSecuritySize: NegotiatedSecuritySizeL (aMessage); break;

		case ESipProfileItcOpAllowMigration: AllowMigrationL (aMessage); break;

		case ESipProfileItcOpDisallowMigration: DisallowMigrationL (aMessage); break;

		case ESipProfileItcOpAddALRObserver: iALRObserverExists = ETrue; break;

		case ESipProfileItcOpRemoveALRObserver: iALRObserverExists = EFalse; break;

		case ESipProfileItcOpRefreshIapAvailability: RefreshIapAvailabilityL (aMessage); break;

		case ESipProfileItcOpForceDisable: ForceDisableL(aMessage); break;

        case ESipProfileItcOpReadyToReceive: // Asynchronous. Do not complete yet!

            ClientReadyToReceiveL (aMessage); return;

        default: aMessage.Panic (KSipProfileServerName, EBadRequest); break;

		}

#endif	

	iHelper.CompleteService(aMessage, KErrNone);

	}

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

// CSIPProfileCSSession::ProfilePluginsSizeL

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

//

void CSIPProfileCSSession::ProfilePluginsSizeL(const RMessage2& aMessage)

	{

	TSIPProfileSlots ids = iHelper.ReadSipIdsL(aMessage);

	const CSIPProfilePlugins& plugins = iCore.ProfilePluginsL();

	ids.iSlot1 = plugins.ExternalizedSize(); 

	iHelper.WriteL(aMessage, ids);

	}

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

// CSIPProfileCSSession::ProfilePluginsL

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

//

void CSIPProfileCSSession::ProfilePluginsL(const RMessage2& aMessage)

    {

	const CSIPProfilePlugins& plugins = iCore.ProfilePluginsL();

	CBufFlat* buf = ExternalizeLC (plugins);

	TPtr8 externalized = buf->Ptr(0);

	iHelper.WriteL(ESipProfileItcArgPlugins, aMessage, externalized);

	CleanupStack::PopAndDestroy(buf);

    }

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

// CSIPProfileCSSession::AddProfileL

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

//

void CSIPProfileCSSession::AddProfileL(const RMessage2& aMessage)

    {

	TSIPProfileSlots ids = iHelper.ReadSipIdsL(aMessage);

	HBufC8* profileBuf = iHelper.ReadLC(ESipProfileItcArgProfile,aMessage);

	CSIPConcreteProfile* profile = InternalizeProfileLC(*profileBuf);

	iCore.AddProfileL(profile, *this);

	CleanupStack::Pop(profile);

	CleanupStack::PopAndDestroy(profileBuf);

	ids.iProfileId = profile->Id(); 

	iHelper.WriteL(aMessage, ids);

	iCore.UpdateRegistrationL(profile->Id(), *this);

    }

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

// CSIPProfileCSSession::UpdateProfileL

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

//

void CSIPProfileCSSession::UpdateProfileL(const RMessage2& aMessage)

    {

	HBufC8* profileBuf = iHelper.ReadLC(ESipProfileItcArgProfile,aMessage);

	CSIPConcreteProfile* profile = InternalizeProfileLC(*profileBuf);

	TBool updateAllowed = iCore.IsUpdateAllowed(profile);

	//Save the dynamic Data before UpdateProfile happens

	TBool isProfile = EFalse;

	const CSIPConcreteProfile* aProfile = iCore.Profile(profile->Id());

	CDesC8ArrayFlat* aRegisteredAORs = NULL;

	HBufC8* aNegotiatedSecurityMechanism = NULL;

	CSIPConcreteProfile::TStatus status = CSIPConcreteProfile::EUnregistered;

	if(aProfile)

	    {

        isProfile = ETrue;

        status = aProfile->Status();

        //Copy registeredAors

        const MDesC8Array& aArray = aProfile->RegisteredAORs();

        aRegisteredAORs = new (ELeave) CDesC8ArrayFlat(1);

        CleanupStack::PushL(aRegisteredAORs);

        for (TInt i = 0; i < aArray.MdcaCount(); i++)

            {

            aRegisteredAORs->AppendL(aArray.MdcaPoint(i));

            }    

        //Copy NegotiatedSecurityMechanism

        aNegotiatedSecurityMechanism = aProfile->NegotiatedSecurityMechanism().AllocL();    

        CleanupStack::PushL(aNegotiatedSecurityMechanism);

	    }

	if(updateAllowed)

	    {

        TBool canProceed = iCore.UpdateProfileToStoreL(profile, *this);        

        if (canProceed)

            {

            iCore.UpdateRegistrationL(profile->Id(), *this);

            }

	    }

	else

	    {

	    User::Leave(KErrNotSupported);

	    }

    //If UpdateProfile has not resulted into deregistration and reregistration

	//copy the dynamic data extraced from previous copy of concrete profile to new copy

    //of concrete profile so that dynamic information is not lost.

	CSIPConcreteProfile* aUpdatedProfile = iCore.Profile(profile->Id());    

    if(aUpdatedProfile && (status == aUpdatedProfile->Status()))

       {

       if(0 == aUpdatedProfile->RegisteredAORs().MdcaCount() && aRegisteredAORs)           

           aUpdatedProfile->SetRegisteredAORsL(*aRegisteredAORs);

       if(0 == aUpdatedProfile->NegotiatedSecurityMechanism().Length() && aNegotiatedSecurityMechanism)

           aUpdatedProfile->SetNegotiatedSecurityMechanismL(*aNegotiatedSecurityMechanism);

       }

    if(isProfile)

        {

        CleanupStack::PopAndDestroy(aNegotiatedSecurityMechanism);

        CleanupStack::PopAndDestroy(aRegisteredAORs);

        }

    CleanupStack::Pop(profile);

    CleanupStack::PopAndDestroy(profileBuf);

    }

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

// CSIPProfileCSSession::RemoveProfileL

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

//

void CSIPProfileCSSession::RemoveProfileL(const RMessage2& aMessage)

    { 

	TUint id = iHelper.IPCArgTUintL(ESipProfileItcArgProfileId, aMessage);

	iCore.RemoveProfileL(id);

    }

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

// CSIPProfileCSSession::EnableL

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

//

void CSIPProfileCSSession::EnableL(const RMessage2& aMessage)

	{

	TSIPProfileSlots ids = iHelper.ReadSipIdsL(aMessage);

	ids.iSlot1 = iCore.EnableProfileL(ids.iProfileId, *this);

	iHelper.WriteL(aMessage, ids);

	}

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

// CSIPProfileCSSession::DisableL

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

//

void CSIPProfileCSSession::DisableL(const RMessage2& aMessage)

	{

	TSIPProfileSlots ids = iHelper.ReadSipIdsL(aMessage);

	ids.iSlot1 = iCore.DisableProfileL(ids.iProfileId, *this);

	iHelper.WriteL(aMessage, ids);	

	}

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

// CSIPProfileCSSession::ForceDisableL

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

//

void CSIPProfileCSSession::ForceDisableL(const RMessage2& aMessage)

	{

	TSIPProfileSlots ids = iHelper.ReadSipIdsL(aMessage);

	ids.iSlot1 = iCore.ForceDisableProfileL(ids.iProfileId, *this);

	iHelper.WriteL(aMessage, ids);	

	}

// CSIPProfileCSSession::UsageL

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

//

void CSIPProfileCSSession::UsageL(const RMessage2& aMessage)

	{

	TSIPProfileSlots ids = iHelper.ReadSipIdsL(aMessage);

	ids.iSlot1 = iCore.ProfileUsageL(ids.iProfileId);

	iHelper.WriteL(aMessage, ids);

	}

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

// CSIPProfileCSSession::SipProfileSizeL

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

//

void CSIPProfileCSSession::SipProfileSizeL(const RMessage2& aMessage)

	{

	TSIPProfileSlots ids = iHelper.ReadSipIdsL(aMessage);

	const CSIPConcreteProfile* profile = iCore.Profile(ids.iProfileId);

	if (profile) 

		{

		CSIPConcreteProfile* clonedProfile = 

			CloneProfileWithoutPasswordsLC(profile);

		ids.iSlot1 = clonedProfile->ExternalizedSizeL(); 

		CleanupStack::PopAndDestroy(clonedProfile);

		iHelper.WriteL(aMessage, ids);

		}

	}

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

// CSIPProfileCSSession::SipProfileSizeDefaultL

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

//

void CSIPProfileCSSession::SipProfileSizeDefaultL(const RMessage2& aMessage)

	{

	const CSIPConcreteProfile* profile = iCore.ProfileDefaultL();

	if (profile)

		{

		TSIPProfileSlots ids = iHelper.ReadSipIdsL(aMessage);

		CSIPConcreteProfile* clonedProfile = 

			CloneProfileWithoutPasswordsLC(profile);

		ids.iProfileId = clonedProfile->Id();

		ids.iSlot1 = clonedProfile->ExternalizedSizeL(); 

		CleanupStack::PopAndDestroy(clonedProfile);

		iHelper.WriteL(aMessage, ids);

		}

	}

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

// CSIPProfileCSSession::SipProfileL

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

//

void CSIPProfileCSSession::SipProfileL(const RMessage2& aMessage)

	{

	TUint id = iHelper.IPCArgTUintL(ESipProfileItcArgProfileId, aMessage);

	CSIPConcreteProfile* profile = 

		CloneProfileWithoutPasswordsLC(&iCore.ProfileL(id, *this));

	WriteProfileL( aMessage, profile ) ;

	CleanupStack::PopAndDestroy (profile);

	}

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

// CSIPProfileCSSession::SipProfileRefreshL

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

//

void CSIPProfileCSSession::SipProfileRefreshL(const RMessage2& aMessage)

	{

	TUint id = iHelper.IPCArgTUintL(ESipProfileItcArgProfileId, aMessage);

	CSIPConcreteProfile* profile = 

		CloneProfileWithoutPasswordsLC( &iCore.ProfileRefreshL(id, *this) );

	WriteProfileL( aMessage, profile );

	CleanupStack::PopAndDestroy (profile);	

	}

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

// CSIPProfileCSSession::SipProfilesSizeL

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

//

void CSIPProfileCSSession::SipProfilesSizeL(const RMessage2& aMessage)

	{

	TSIPProfileSlots ids = iHelper.ReadSipIdsL(aMessage);

	CSIPConcreteProfileHolder* holder = CSIPConcreteProfileHolder::NewLC();

	RPointerArray<CSIPConcreteProfile>& array = holder->SIPProfiles();

	iCore.ProfilesL(NULL, array);

	ids.iSlot1 = holder->ExternalizedSizeL();

	array.Reset();

	CleanupStack::PopAndDestroy(holder);

	iHelper.WriteL(aMessage, ids);

	}

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

// CSIPProfileCSSession::SipProfilesL

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

//

void CSIPProfileCSSession::SipProfilesL(const RMessage2& aMessage)

	{

	CSIPConcreteProfileHolder* holder = CSIPConcreteProfileHolder::NewLC();

	RPointerArray<CSIPConcreteProfile>& array = holder->SIPProfiles();

	iCore.ProfilesL(this, array);

	CBufFlat* buf = ExternalizeLC (*holder);

	TPtr8 externalized = buf->Ptr(0);

	iHelper.WriteL(ESipProfileItcArgProfiles, aMessage, externalized);

	array.Reset();

	CleanupStack::PopAndDestroy(buf);

	CleanupStack::PopAndDestroy(holder);

	}

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

// CSIPProfileCSSession::SipProfilesSizeByAORL

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

//

void CSIPProfileCSSession::SipProfilesSizeByAORL(const RMessage2& aMessage)

	{

	TSIPProfileSlots ids = iHelper.ReadSipIdsL(aMessage);

	HBufC8* aor = iHelper.ReadLC(ESipProfileItcArgNarrator,aMessage);

	CSIPConcreteProfileHolder* holder = CSIPConcreteProfileHolder::NewLC();

	RPointerArray<CSIPConcreteProfile>& array = holder->SIPProfiles();

	iCore.ProfilesByAORL(*aor, NULL, array);

	ids.iSlot1 = holder->ExternalizedSizeL();

	array.Reset();

	CleanupStack::PopAndDestroy(holder);

	CleanupStack::PopAndDestroy(aor);

	iHelper.WriteL(aMessage, ids);

	}

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

// CSIPProfileCSSession::SipProfilesByAORL

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

//

void CSIPProfileCSSession::SipProfilesByAORL(const RMessage2& aMessage)

	{

	HBufC8* aor = iHelper.ReadLC(ESipProfileItcArgNarrator,aMessage);

	CSIPConcreteProfileHolder* holder = CSIPConcreteProfileHolder::NewLC();

	RPointerArray<CSIPConcreteProfile>& array = holder->SIPProfiles();

	iCore.ProfilesByAORL(*aor, this, array);

	CBufFlat* buf = ExternalizeLC(*holder);

	TPtr8 externalized = buf->Ptr(0);

	iHelper.WriteL(ESipProfileItcArgProfiles, aMessage, externalized);

	array.Reset();

	CleanupStack::PopAndDestroy(buf);

	CleanupStack::PopAndDestroy(holder);

	CleanupStack::PopAndDestroy(aor);

	}

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

// CSIPProfileCSSession::SipProfilesSizeByTypeL

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

//

void CSIPProfileCSSession::SipProfilesSizeByTypeL(const RMessage2& aMessage)

	{

	TSIPProfileTypeInfo info;

	iHelper.ReadSIPProfileTypeInfoL(aMessage,info);

	TSIPProfileSlots ids = iHelper.ReadSipIdsL(aMessage);

	CSIPConcreteProfileHolder* holder = CSIPConcreteProfileHolder::NewLC();

	RPointerArray<CSIPConcreteProfile>& array = holder->SIPProfiles();

	iCore.ProfilesByTypeL(info, NULL, array);

	ids.iSlot1 = holder->ExternalizedSizeL();