/*

* 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:  A common session class for all the specialized 

*				 DM Host Servers.

*

*/

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

// Includes

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

//

#include <s32mem.h>

#include <s32strm.h>

#include <implementationinformation.h>

#include <ecom.h>

#include <nsmlconstants.h>

#include <nsmldebug.h>

#include <smldmadapter.h>

// FOTA

#include <nsmldmconst.h>

// FOTA end

#include <nsmldmuri.h>

#include <e32property.h>

#include "nsmldminternalpskeys.h"

#include "nsmldmclientandserver.h"

#include "nsmldmhostserver.h"

#include "nsmldmhostsession.h"

#include "nsmldmcmdarghandler.h"

#include "nsmldmimpluids.h"

#include <featmgr.h>

#ifndef __WINS__

// This lowers the unnecessary compiler warning (armv5) to remark.

// "Warning:  #174-D: expression has no effect..." is caused by 

// DBG_ARGS8 macro in no-debug builds.

#pragma diag_remark 174

#endif

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

// Constants

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

//

// Granularity of the lists; mapping info and prevUriSegList

const TInt KNSmlDmGranularity = 8;

// This means the dm adapter doesn't support streaming

const TInt KNSmlDmNotSupported = -1;

// During the fetch link serving the callbacks are handled differently

const TInt KNSmlDmNoRef = -1; 

// A safety margin (in bytes) which is left unreserved in the chunk

const TInt KNSmlDmChunkMarginal = 128;

// A cross-reference to the interner adapter is recognized using these strings

_LIT8 ( KNSmlDmApAdapterURI1, "AP" );

_LIT8 ( KNSmlDmApAdapterURI2, "./AP" );

// Identifies the server which owns the internet DM plug-in adapter

const TInt KNSmlDmApAdapterServerId = 1;

// Tells to the session class that it is acting as a fetch link server

const TInt KNSmlDmFetchLinkServerId = 99;

// The constant part of the result item size in bytes: 	

//  iResultRef => 2 bytes

//  iResult->Size => 4 bytes

//  iMimeType->Length => 2 bytes

const TInt KNSmlDmConstItemSize = 8;

// FOTA

const TInt KNSmlDmLastPackage = 1;

// FOTA end

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

// CNSmlDMHostSession::CNSmlDMHostSession

//	C++ constructor.

//	@param aServer. The server instance, owner of session.

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

//

CNSmlDMHostSession::CNSmlDMHostSession ( CNSmlDMHostServer& aServer ) : 

    iServer(aServer)

	{

	_DBG_FILE("CNSmlDMHostSession::CNSmlDMHostSession(): begin");

	iServer.IncSessionCount();

	_DBG_FILE("CNSmlDMHostSession::CNSmlDMHostSession(): end");

	}

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

// CNSmlDMHostSession::~CNSmlDMHostSession

//  C++ destructor.

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

//

CNSmlDMHostSession::~CNSmlDMHostSession()

	{	

	_DBG_FILE("CNSmlDMHostSession::~CNSmlDMHostSession(): begin");

	if ( iCbSessConnected )

		{

		iCbSession.Close();		

		}

	iServer.DecSessionCount();

	delete iMgmtTree;

	if ( iOwnId != KNSmlDmFetchLinkServerId )

		{

		iChunk.Close(); 		

		}

	for ( TInt i=0; i<iResultList.Count(); i++ )

		{

		delete iResultList[i];

		}

	iResultList.Close();

	iStatusCodeList.Close();

	iCallbackList.Close();

	if ( iLargeWriteStream.streamPtr )

		{

		iLargeWriteStream.streamPtr->Close();		

		}

	if ( iResultReadStream )

		{

		iResultReadStream->Close();		

		}

	// delete all loaded adapters

	for ( TInt i=0; i<iAdapters.Count(); i++ )

		{

		delete iAdapters[i].adapterPtr;

		}

	iAdapters.Close();

	REComSession::FinalClose();	

	if ( iMapUris )

		{

		iMapUris->ResetAndDestroy();

		delete iMapUris;	

		}

	if ( iMapLuids )

		{

		iMapLuids->ResetAndDestroy();

		delete iMapLuids;

		}

	delete iSemaphoreName;

	delete iResultOtherAdapter;

	delete iLargeObject;

	DeletePrevParams();

	FeatureManager::UnInitializeLib();

	_DBG_FILE("CNSmlDMHostSession::~CNSmlDMHostSession(): end");

	}

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

// CNSmlDMHostSession::NewL

//	Creates a new session object.

//	@param aServer. Reference to server is needed in order to increase and decrease session counts.

//	@return CNSmlDMHostSession*. New instance of this class.

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

//

CNSmlDMHostSession* CNSmlDMHostSession::NewL ( CNSmlDMHostServer& aServer )

	{

	_DBG_FILE("CNSmlDMHostSession::NewL(): begin");

	CNSmlDMHostSession* self= new (ELeave) CNSmlDMHostSession ( aServer );

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	_DBG_FILE("CNSmlDMHostSession::NewL(): end");

	return self;

	}

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

// CNSmlDMHostSession::ConstructL

//	Symbian 2nd phase constructor

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

//

void CNSmlDMHostSession::ConstructL()

	{

	_DBG_FILE("CNSmlDMHostSession::ConstructL(): begin");

	iMgmtTree = CNSmlDmMgmtTree::NewL();

	iCommitStatus.iStreamingOngoing = EFalse;

	iCommitStatus.iStreamCommitted = EFalse;

	FeatureManager::InitializeLibL();

	_DBG_FILE("CNSmlDMHostSession::ConstructL(): end");

	}

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

// CNSmlDMHostSession::ServiceL

//	Handles the servicing of client requests.

//	Entry point for arriving messages.

//	@param aMessage. An object which encapsulates a client request.

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

//

void CNSmlDMHostSession::ServiceL ( const RMessage2& aMessage )

	{

	_DBG_FILE("CNSmlDMHostSession::ServiceL(): begin");

	if(!aMessage.HasCapability(ECapabilityDiskAdmin))

	    {

	    _DBG_FILE("CNSmlDMHostSession::ServiceL(): capability fail");

	    aMessage.Complete( KErrPermissionDenied );

	    return;

	    }

	TRAPD ( err, DispatchMessageL ( aMessage ) );

	aMessage.Complete( err );

	_DBG_FILE("CNSmlDMHostSession::ServiceL(): end");

	}

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

// CNSmlDMHostSession::DispatchMessageL

//	Extracts the operation code from the message. 

//	Based on that calls the right private function.

//	@param aMessage. An object which encapsulates a client request.

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

//

void CNSmlDMHostSession::DispatchMessageL ( const RMessage2& aMessage )

	{

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

	switch( aMessage.Function() )

        {

		case ENSmlDMCloseSession:

        	CloseSessionL();

        	break;

		case ENSmlDMGetDDF:

        	GetDDFStructureL ( aMessage );

        	break;

        case ENSmlDMUpdateLeaf:

        	UpdateLeafOrExecuteL ( aMessage, ENSmlDMUpdateLeaf );

        	break;

        case ENSmlDMExecute:

        	UpdateLeafOrExecuteL ( aMessage, ENSmlDMExecute );

        	break;

        case ENSmlDMUpdateLeafLarge:

        	UpdateLeafOrExecuteLargeL ( aMessage, ENSmlDMUpdateLeafLarge );

        	break;

        case ENSmlDMExecuteLarge:

        	UpdateLeafOrExecuteLargeL ( aMessage, ENSmlDMExecuteLarge );

        	break;        	

        case ENSmlDMAddNode:

        	AddCopyOrDeleteL ( aMessage, ENSmlDMAddNode );

        	break;

        case ENSmlDMCopy:

        	AddCopyOrDeleteL ( aMessage, ENSmlDMCopy );

        	break;

        case ENSmlDMDelete:

        	AddCopyOrDeleteL ( aMessage, ENSmlDMDelete );

        	break;        

        case ENSmlDMStartAtomic:

        	StartAtomicL ( aMessage );

        	break;

        case ENSmlDMCommitAtomic:

        	CommitAtomicL ( aMessage );

        	break;

        case ENSmlDMRollbackAtomic:

        	RollbackAtomicL ( aMessage );

        	break;

        case ENSmlDMCompleteCommands:

        	CompleteCommandsL ( aMessage );

        	break;

        case ENSmlDMFetchLeaf:

        	FetchLeafChildUrisOrSizeL ( aMessage, ENSmlDMFetchLeaf );

        	break;

        case ENSmlDMFetchLink:

        	FetchLinkL ( aMessage );

        	break;

        case ENSmlDMFetchLeafSize:

        	FetchLeafChildUrisOrSizeL ( aMessage, ENSmlDMFetchLeafSize );

        	break;

        case ENSmlDMChildUriList:

        	FetchLeafChildUrisOrSizeL ( aMessage, ENSmlDMChildUriList );

        	break;

    	case ENSmlDMChunkHandle:

        	SetChunkHandleL ( aMessage ); 

        	break;

    	case ENSmlDMGetMappings:

        	GetMappingsL ( aMessage ); 

        	break;

    	case ENSmlDMGetStatuses:

        	GetStatusesL ( aMessage ); 

        	break;

    	case ENSmlDMGetResults:

        	GetResultsL ( aMessage ); 

        	break;

    	case ENSmlDMGetMore:

        	GetResultsL ( aMessage ); 

        	break;

        // FOTA

    	case ENSmlDMGenericAlertsSent:

    	if(!FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112  ))

    	{

    	_DBG_FILE(" CNSmlDMHostSession::DispatchMessageL(): calling new MarkGenAlertsSentL(message)");

        	MarkGenAlertsSentL(aMessage); 	

    	}

    	else

    	{

    	_DBG_FILE(" CNSmlDMHostSession::DispatchMessageL(): calling old  MarkGenAlertsSentL ");

        MarkGenAlertsSentL();	

    	}

        	break;

        // FOTA end

		default:

			PanicClient ( aMessage, KErrNotSupported );

        }

	_DBG_FILE("CNSmlDMHostSession::DispatchMessageL(): end");

	}

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

// CNSmlDMHostSession::PanicClient

//	Panics the client

//	@param aMessage. Message from client to panic.

//	@param aReason. Reason code.

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

//

void CNSmlDMHostSession::PanicClient ( const RMessage2& aMessage, TInt aReason ) const

	{

	_DBG_FILE("CNSmlDMHostSession::PanicClient(): begin");

	aMessage.Panic ( _L( "CNSmlDMHostSession" ), aReason );

	_DBG_FILE("CNSmlDMHostSession::PanicClient(): end");

	}

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

// CNSmlDMHostSession::CloseSessionL

//	Empty function.

//	Kept here for possible future needs. 

//	Freeing of resources is done in the destructor.

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

//

void CNSmlDMHostSession::CloseSessionL() const

	{

	_DBG_FILE("CNSmlDMHostSession::CloseSessionL(): begin");

	_DBG_FILE("CNSmlDMHostSession::CloseSessionL(): end");

	}

void CNSmlDMHostSession::MarkGenAlertsSentL(const RMessage2& aMessage)

	{

	_DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(RMessage2): begin");

	HBufC8* tempPtr = HBufC8::NewLC(aMessage.GetDesLength(0));

	_DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(RMessage2): crating hBufC for length of URI ");

	TPtr8 uRI = tempPtr->Des();

   _DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(RMessage2): TPrt got from HBufC ");

	aMessage.ReadL(0, uRI, 0);

	TUint32 adId(0);

	TNSmlDmDDFFormat nodeType;

	_DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(RMessage2): Before calling adapterIdFromUriL  ");

	TBool adapterFound = AdapterIdFromUriL ( uRI, adId, nodeType );

	_LIT8(KSCOMONODE, "SCOMO");

	// For AM Adapter check for Node "SCOMO" if present in Uri then use Adapter Implementation UID

	if(uRI.Compare(KSCOMONODE) == KErrNone)

	{

		adId = KNSmlDMAMAdapterImplUid;

		adapterFound = ETrue;

	}

	_DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(RMessage2): After calling adapterIdFromUriL ");

	if ( adapterFound )

		{

	_DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(RMessage2): adapter is found ! ");	  

        CSmlDmAdapter* adapter = NULL;

        adapterFound = EFalse;

	    for ( TInt i(0); i<iAdapters.Count(); i++ )

		{

		if ( iAdapters[i].adapterId == adId )

			{

			adapterFound = ETrue;

			if ( !iAdapters[i].adapterPtr )

				{

				adapter = LoadNewAdapterL ( i, adId );

				if ( !adapter )

					{

					User::Leave ( KErrArgument );

					}

				}

			// Call overloaded function of the  adapter to request

			// the  adapter to mark Generic Alerts sent.

			TInt resetGenAlerts ( KNSmlDMResetGenAlerts );

			iAdapters[i].adapterPtr->StreamingSupport ( resetGenAlerts );

			}

		}

	}

	CleanupStack::PopAndDestroy(); //tempPtr

	if ( !adapterFound )

	    {

	    _DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(RMessage2): adapter NOT :-( found ! ");	  

		User::Leave ( KErrNotFound );	    

	    }

	_DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(): end");

	}

// FOTA

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

// CNSmlDMHostSession::MarkGenAlertsSentL

//	This function is called only for the FOTA adapter.

//	Makes a request for the FOTA adapter to mark generic alerts sent.

//	In other words, the written generic alerts are issued without

//	errors to the remote server.

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

//

void CNSmlDMHostSession::MarkGenAlertsSentL()

	{

	_DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(): begin");

	CSmlDmAdapter* adapter = NULL;

	TBool adapterFound ( EFalse );

	for ( TInt i(0); i<iAdapters.Count(); i++ )

		{

		if ( iAdapters[i].adapterId == KNSmlDMFotaAdapterImplUid )

			{

			adapterFound = ETrue;

			if ( !iAdapters[i].adapterPtr )

				{

				adapter = LoadNewAdapterL ( i, KNSmlDMFotaAdapterImplUid );

				if ( !adapter )

					{

					User::Leave ( KErrArgument );

					}

				}

			// Call overloaded function of the FOTA adapter to request

			// the FOTA adapter to mark Generic Alerts sent.

			TInt resetGenAlerts ( KNSmlDMResetGenAlerts );

			iAdapters[i].adapterPtr->StreamingSupport ( resetGenAlerts );

			}

		else if ( iAdapters[i].adapterId == KNSmlDMAMAdapterImplUid )

			{

			adapterFound = ETrue;

			if ( !iAdapters[i].adapterPtr )

				{

				adapter = LoadNewAdapterL ( i, KNSmlDMAMAdapterImplUid );

				if ( !adapter )

					{

					User::Leave ( KErrArgument );

					}

				}

			// Call overloaded function of the AM adapter to request

			// the AM adapter to mark Generic Alerts sent.

			TInt resetGenAlerts ( KNSmlDMResetGenAlerts );

			iAdapters[i].adapterPtr->StreamingSupport ( resetGenAlerts );

			}

		}

	if ( !adapterFound )

	    {

		User::Leave ( KErrNotFound );	    

	    }

	_DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(): end");

	}

// FOTA end

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

// CNSmlDMHostSession::GetDDFStructureL

//	Gets DDF structure from the dm adapters.

//	aMessage parameter contains a list of adapters which are already loaded.

//	Writes the combined DDF structure to the chunk in the WBXML format.

//	Returns also a checksum of the DDF structure to the client. 

//	@param aMessage. A list of already loaded adapters, and place for checksum.

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

//

void CNSmlDMHostSession::GetDDFStructureL ( const RMessage2& aMessage )

	{

	_DBG_FILE("CNSmlDMHostSession::GetDDFStructureL(): begin");

	RImplInfoPtrArray allDmAdapters;

	CleanupStack::PushL ( PtrArrCleanupItemRArr ( CImplementationInformation, &allDmAdapters ) );

	RArray<TUint32> dontLoadThese;

	CleanupClosePushL ( dontLoadThese );

	ReadUidsL ( aMessage, dontLoadThese );

	TUid ifUid = { KSmlDMInterfaceUid };

	REComSession::ListImplementationsL ( ifUid, allDmAdapters );

	RemoveAlreadyLoadedL ( allDmAdapters, dontLoadThese );

	CleanupStack::PopAndDestroy();  // dontLoadThese

	RPointerArray<HBufC8> versions;

	CleanupStack::PushL ( PtrArrCleanupItemRArr ( HBufC8, &versions ) );

	RArray<TInt32> uids;

	CleanupClosePushL ( uids );

	CSmlDmAdapter* adapter = NULL;

	for ( TInt i=0; i<allDmAdapters.Count(); i++ )

		{

		TRAPD ( err, ( adapter = CSmlDmAdapter::NewL ( allDmAdapters[i]->ImplementationUid(), *this ) ) );

		if ( err == KErrNone && adapter )

			{

			CleanupStack::PushL(adapter);

			AskInfoFromAdapterL ( adapter, versions, uids, allDmAdapters[i]->ImplementationUid().iUid );		

			CleanupStack::PopAndDestroy(); //adapter

			}

		} 

	TUint16 crc = CalcCheckSumL ( versions, uids );

	CleanupStack::PopAndDestroy(3); // uids, versions, allDmAdapters

	WriteTreeToChunkL();

	aMessage.WriteL ( 2, TPckgBuf<TInt> (crc) );

	TPckgBuf<TInt> cb = ( iCallbackList.Count() ) ? iCallbackList[0].callBack : ENSmlDmCallbackNone;

	aMessage.WriteL ( 3, cb );	

	_DBG_FILE("CNSmlDMHostSession::GetDDFStructureL(): end");

	}

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

// CNSmlDMHostSession::ReadUidsL

//	Auxiliary function called by GetDDFStructureL.

//	Reads the UIDs of the loaded adapters from the message, 

//	and stores those to internal list. 

//	@param aMessage. An object which encapsulates a client request.

//	@param aUids. A reference parameter, a place for extracted list of UIDs.

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

//