/*

* Copyright (c) 2005 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:  DM callback server sewssion source file

*

*/

#include <s32mem.h>

#include <smldmadapter.h>

#include <nsmlconstants.h>

#include <nsmldebug.h>

#include <nsmldmdbhandler.h>

#include "nsmldmcallbackserver.h"

#include "nsmldmcallbackserverdefs.h"

// ===========================================================================

// CNSmlDmCallbackSession

// ===========================================================================

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

// CNSmlDmCallbackSession::NewL()

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

CNSmlDmCallbackSession* CNSmlDmCallbackSession::NewL(

	CNSmlDmCallbackServer& aServer)

	{

	CNSmlDmCallbackSession* self=

		new (ELeave) CNSmlDmCallbackSession( aServer);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

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

// CNSmlDmCallbackSession::CNSmlDmCallbackSession()

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

CNSmlDmCallbackSession::CNSmlDmCallbackSession(

	CNSmlDmCallbackServer& aServer ) : iServer(aServer)

	{

	}

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

// CNSmlDmCallbackSession::ConstructL()

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

void CNSmlDmCallbackSession::ConstructL()

	{

	iUriSegList =

		new (ELeave) CArrayFixFlat <TSmlDmMappingInfo> (KGranularity);

	iServer.Increase();

	}

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

// CNSmlDmCallbackSession::~CNSmlDmCallbackSession()

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

CNSmlDmCallbackSession::~CNSmlDmCallbackSession()

	{

	iServer.Decrease();

	if ( iUriSegList )

		{

		iUriSegList->Reset();

		delete iUriSegList;

		}

	delete iLuid;

	delete iSegList;

	delete iACL;

	delete iACLUri;

	iAtomicAclURIs.ResetAndDestroy();

	iAtomicAcls.ResetAndDestroy();

 	}

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

// CNSmlDmCallbackSession::ServiceL( )

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

void CNSmlDmCallbackSession::ServiceL( const RMessage2& aMessage )

	{

	TRAPD(err,DispatchMessageL(aMessage));

	if(err!=KErrNone)

	    {

	    aMessage.Complete(err);

	    }

	}

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

// CNSmlDmCallbackSession::DispatchMessageL( )

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

void CNSmlDmCallbackSession::DispatchMessageL( const RMessage2& aMessage )

	{

	_DBG_FILE("CNSmlDmCallbackSession::DispatchMessageL(): begin");

	switch( aMessage.Function() )

        {

        case ECmdDMCallbackSetServer:

        	SetServerL(aMessage);

        	return;

     // requests

        case ECmdDMCallbackGetLuid:

			GetLuidL( aMessage );

			return;

        case ECmdDMCallbackGetSegmentList:

			GetUriSegListL(aMessage );

            return;

        case ECmdDMCallbackGetLuidLength:

			GenerateLuidL( aMessage );

			return;

        case ECmdDMCallbackGetSegmentListLength:

			GenerateUriSegListL(aMessage );

            return;

        case ECmdDMCallbackAddMappingInfo:

        	AddMappingInfoL(aMessage);

        	return;

        case ECmdDMCallbackRemoveMappingInfo:

        	RemoveMappingInfoL(aMessage);

        	return;

        case ECmdDMCallbackRenameMapping:

        	RenameMappingInfoL(aMessage);

        	return;

        case ECmdDMCallbackUpdateMapping:

        	UpdateMappingInfoL(aMessage);

        	return;

        case ECmdDMCallbackDeleteAcl:

        	DeleteAclL(aMessage);

        	return;

        case ECmdDMCallbackUpdateAcl:

        	UpdateAclL(aMessage);

        	return;

        case ECmdDMCallbackGetAclLength:

        	GetAclLengthL(aMessage);

        	return;

        case ECmdDMCallbackGetAcl:

        	GetAclL(aMessage);

        	return;

        case ECmdDMCallbackCheckAcl:

        	CheckAclL(aMessage);

        	return;

        case ECmdDMCallbackDefaultAclsToServer:

        	DefaultAclsToServerL(aMessage);

        	return;

        case ECmdDMCallbackDefaultAclsToChildren:

        	DefaultAclsToChildrenL(aMessage);

        	return;

        case ECmdDMCallbackEraseServerId:

        	EraseServerIdL(aMessage);

        	return;

        case ECmdDMCallbackStartAtomic:

        	StartAtomic(aMessage);

        	return;

        case ECmdDMCallbackCommitAtomic:

        	CommitAtomicL(aMessage);

        	return;

        case ECmdDMCallbackRollbackAtomic:

        	RollbackAtomic(aMessage);

        	return;

        case ECmdDMCallbackCloseSession:

            aMessage.Complete(KErrNone);

            return;

        case ECmdDMCallbackResourceCount:

		    aMessage.Complete(KErrNone);

            return;

        default:

            aMessage.Panic( KNSmlDmCallbackServerName, KErrArgument );

            return;

        }

	}

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

// CNSmlDmCallbackSession::SetServerL()

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

void CNSmlDmCallbackSession::SetServerL( const RMessage2& aMessage )

	{

	_DBG_FILE("CNSmlDmCallbackSession::SetServerL(): begin");

    HBufC8* server = HBufC8::NewLC( aMessage.GetDesLengthL(1) );

    TPtr8 serverPtr = server->Des();

    aMessage.ReadL( 1, serverPtr);

	iServer.DbHandler()->SetServerL(serverPtr);

	CleanupStack::PopAndDestroy(); //server

    aMessage.Complete(KErrNone);

	_DBG_FILE("CNSmlDmCallbackSession::SetServerL(): end");

	}

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

// CNSmlDmCallbackSession::GetLuidL()

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

void CNSmlDmCallbackSession::GetLuidL( const RMessage2& aMessage )

	{

	_DBG_FILE("CNSmlDmCallbackSession::GetLuidL(): begin");

	if(!iLuid)

		{

		iLuid = KNullDesC8().AllocL();

		}

	TPtr8 bufPtr=iLuid->Des();

    aMessage.WriteL( 3, bufPtr);

    aMessage.Complete(KErrNone);

    delete iLuid;

    iLuid = 0;

	_DBG_FILE("CNSmlDmCallbackSession::GetLuidL(): end");

	}

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

// CNSmlDmCallbackSession::GetUriSegListL()

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

void CNSmlDmCallbackSession::GetUriSegListL( const RMessage2& aMessage )

	{

	_DBG_FILE("CNSmlDmCallbackSession::GetUriSegListL(): begin");

	if(!iSegList)

		{

		iSegList = CBufFlat::NewL(1);

		}

	TPtr8 bufPtr=iSegList->Ptr(0);

    aMessage.WriteL( 3, bufPtr);

    aMessage.Complete(KErrNone);

	delete iSegList;

    iSegList = 0;

	_DBG_FILE("CNSmlDmCallbackSession::GetUriSegListL(): end");

	}

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

// CNSmlDmCallbackSession::GenerateLuidL()

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

void CNSmlDmCallbackSession::GenerateLuidL( const RMessage2& aMessage )

	{

	TInt ret(KErrNone);

	if(iLuid)

		{

		delete iLuid;

		iLuid =0;

		}

	HBufC8* luid = NULL;

	TUint32 adapterId = aMessage.Int0();

    HBufC8* uri = HBufC8::NewLC( aMessage.GetDesLengthL(1) );

    TPtr8 uriPtr = uri->Des();

    aMessage.ReadL( 1, uriPtr);

	ret = iServer.DbHandler()->GetMappingInfoLC(adapterId,uriPtr,luid);

	iLuid = luid->AllocL();

	CleanupStack::PopAndDestroy(2); //luid, uri

	TPckgBuf<TInt> len;

	len()=iLuid->Length();

    aMessage.WriteL(3, len, 0);

    aMessage.Complete(ret);

	}

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

// CNSmlDmCallbackSession::GenerateUriSegListL()

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

void CNSmlDmCallbackSession::GenerateUriSegListL( const RMessage2& aMessage )

	{

	TInt ret(KErrNone);

	if(iSegList)

		{

		delete iSegList;

		iSegList =0;

		}

	iSegList = CBufFlat::NewL(16);

	TUint32 adapterId = aMessage.Int0();

    HBufC8* uri = HBufC8::NewLC( aMessage.GetDesLengthL(1) );

    TPtr8 uriPtr = uri->Des();

    aMessage.ReadL( 1, uriPtr);

 	TRAPD(err,ret = iServer.DbHandler()->

 		GetURISegmentListL(adapterId,uriPtr,*iUriSegList));

	CleanupStack::PopAndDestroy(); //uri

	if(err!=KErrNone)

		{

		ret = err;

		}

 	RBufWriteStream writeStream(*iSegList,0);

	CleanupClosePushL(writeStream);

	TUint16 count=iUriSegList->Count();

	writeStream.WriteUint16L(count);

	for(TUint16 i=0;i<count;i++)

		{

		writeStream.WriteUint8L(iUriSegList->At(i).iURISeg.Length());

		writeStream.WriteL(iUriSegList->At(i).iURISeg);

		writeStream.WriteUint8L(iUriSegList->At(i).iURISegLUID.Length());

		writeStream.WriteL(iUriSegList->At(i).iURISegLUID);

		}

	iUriSegList->Reset();

	CleanupStack::PopAndDestroy(); //writeStream

    TPckgBuf<TInt> len(iSegList->Size());

    aMessage.WriteL(3, len, 0);

    aMessage.Complete(ret);

	}

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

// CNSmlDmCallbackSession::AddMappingInfoL

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

void CNSmlDmCallbackSession::AddMappingInfoL( const RMessage2& aMessage )

	{

	_DBG_FILE("CNSmlDmCallbackSession::AddMappingInfoL(): begin");

	TUint32 adapterId = aMessage.Int0();

    HBufC8* uri = HBufC8::NewLC( aMessage.GetDesLengthL(1) );

    TPtr8 uriPtr = uri->Des();

    aMessage.ReadL( 1, uriPtr);

    HBufC8* luid = HBufC8::NewLC( aMessage.GetDesLengthL(2) );

    TPtr8 luidPtr = luid->Des();

    aMessage.ReadL( 2, luidPtr);

	TInt ret = iServer.DbHandler()->AddMappingInfoL(adapterId,uriPtr,luidPtr);

	CleanupStack::PopAndDestroy(2); //uri, luid

	iServer.DbHandler()->WriteMappingInfoToDbL();	

    aMessage.Complete(ret);

	_DBG_FILE("CNSmlDmCallbackSession::AddMappingInfoL(): end");

	}

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

// CNSmlDmCallbackSession::RemoveMappingInfoL

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

void CNSmlDmCallbackSession::RemoveMappingInfoL( const RMessage2& aMessage )

	{

	_DBG_FILE("CNSmlDmCallbackSession::RemoveMappingInfoL(): begin");

	TUint32 adapterId = aMessage.Int0();

    HBufC8* uri = HBufC8::NewLC( aMessage.GetDesLengthL(1) );

    TPtr8 uriPtr = uri->Des();

    aMessage.ReadL( 1, uriPtr);

	TBool childAlso = aMessage.Int2();

	TInt ret = iServer.DbHandler()->

		RemoveMappingInfoL(adapterId,uriPtr,childAlso);

	CleanupStack::PopAndDestroy(); //uri

	iServer.DbHandler()->WriteMappingInfoToDbL();	

    aMessage.Complete(ret);

	_DBG_FILE("CNSmlDmCallbackSession::RemoveMappingInfoL(): end");

	}

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

// CNSmlDmCallbackSession::RenameMappingInfoL

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

void CNSmlDmCallbackSession::RenameMappingInfoL( const RMessage2& aMessage )

	{

	_DBG_FILE("CNSmlDmCallbackSession::RenameMappingInfoL(): begin");

	TUint32 adapterId = aMessage.Int0();

    HBufC8* uri = HBufC8::NewLC( aMessage.GetDesLengthL(1) );

    TPtr8 uriPtr = uri->Des();

    aMessage.ReadL( 1, uriPtr);

    HBufC8* newName = HBufC8::NewLC( aMessage.GetDesLengthL(2) );

    TPtr8 newNamePtr = newName->Des();

    aMessage.ReadL( 2, newNamePtr);

 	TInt ret = iServer.DbHandler()->

 		RenameMappingL(adapterId,uriPtr,newNamePtr);

	CleanupStack::PopAndDestroy(2); //uri, newName

	iServer.DbHandler()->WriteMappingInfoToDbL();	

    aMessage.Complete(ret);

	_DBG_FILE("CNSmlDmCallbackSession::RenameMappingInfoL(): end");

	}

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

// CNSmlDmCallbackSession::UpdateMappingInfoL

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

void CNSmlDmCallbackSession::UpdateMappingInfoL( const RMessage2& aMessage )

	{

	_DBG_FILE("CNSmlDmCallbackSession::UpdateMappingInfoL(): begin");

	TUint32 adapterId = aMessage.Int0();

    HBufC8* uri = HBufC8::NewLC( aMessage.GetDesLengthL(1) );

    TPtr8 uriPtr = uri->Des();

    aMessage.ReadL( 1, uriPtr);

    HBufC8* luidList = HBufC8::NewLC( aMessage.GetDesLengthL(2) );

    TPtr8 luidListPtr = luidList->Des();

    aMessage.ReadL( 2, luidListPtr);

    CBufBase *childList = CBufFlat::NewL(16);

    CleanupStack::PushL(childList);

    childList->InsertL(0,luidListPtr);

 	iServer.DbHandler()->UpdateMappingInfoL(adapterId,uriPtr,*childList);

	CleanupStack::PopAndDestroy(3); //uri, luid, childList

	iServer.DbHandler()->WriteMappingInfoToDbL();	

    aMessage.Complete(KErrNone);

	_DBG_FILE("CNSmlDmCallbackSession::UpdateMappingInfoL(): end");

	}

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

// CNSmlDmCallbackSession::DeleteAclL

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

void CNSmlDmCallbackSession::DeleteAclL( const RMessage2& aMessage )

	{

	_DBG_FILE("CNSmlDmCallbackSession::DeleteAclL(): begin");

    HBufC8* uri = HBufC8::NewLC( aMessage.GetDesLengthL(1) );

    TPtr8 uriPtr = uri->Des();

    aMessage.ReadL( 1, uriPtr);

	TInt ret = iServer.DbHandler()->DeleteAclL(uriPtr);

	CleanupStack::PopAndDestroy(); //uri

	iServer.DbHandler()->WriteAclInfoToDbL();	

    aMessage.Complete(ret);

	_DBG_FILE("CNSmlDmCallbackSession::DeleteAclL(): end");

	}

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

// CNSmlDmCallbackSession::UpdateAclL

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

void CNSmlDmCallbackSession::UpdateAclL( const RMessage2& aMessage )

	{

	_DBG_FILE("CNSmlDmCallbackSession::UpdateAclL(): begin");

    HBufC8* uri = HBufC8::NewLC( aMessage.GetDesLengthL(1) );

    TPtr8 uriPtr = uri->Des();

    aMessage.ReadL( 1, uriPtr);

    HBufC8* acl = HBufC8::NewLC( aMessage.GetDesLengthL(2) );

    TPtr8 aclPtr = acl->Des();

    aMessage.ReadL( 2, aclPtr);

    TInt ret(KErrNone);

    if(iAtomic)

    	{

    	iAtomicAcls.AppendL(acl);

		CleanupStack::Pop(); //acl

    	iAtomicAclURIs.AppendL(uri);

		CleanupStack::Pop(); //uri

    	}

    else

    	{

		ret = iServer.DbHandler()->UpdateAclL(uriPtr,aclPtr);

		CleanupStack::PopAndDestroy(2); //uri, acl

		iServer.DbHandler()->WriteAclInfoToDbL();	

    	}

    aMessage.Complete(ret);

	_DBG_FILE("CNSmlDmCallbackSession::UpdateAclL(): end");

	}

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

// CNSmlDmCallbackSession::GetAclLengthL

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

void CNSmlDmCallbackSession::GetAclLengthL( const RMessage2& aMessage )

	{

	_DBG_FILE("CNSmlDmCallbackSession::GetAclLengthL(): begin");

	delete iACLUri;

	iACLUri = 0;

	delete iACL;

	iACL = 0;

    iACLUri = HBufC8::NewL( aMessage.GetDesLengthL(1) );

    TPtr8 uriPtr = iACLUri->Des();

    aMessage.ReadL( 1, uriPtr);

    iACL = CBufFlat::NewL(16);