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

#include <e32debug.h>
#include <e32math.h>
#include <f32file.h>
#include <s32file.h>

#include "clesrv.h"
#include "clesess.h"
#include <ssm/ssmcmd.hrh>


// This file is used to store the handles of the libraries which has unload option as ENeverUnload.
// This is also defined in cmdcustomcommand.cpp and the handles are written to this file if 
// the unload option is ENeverUnload.
_LIT(KNeverUnloadLibHandleFile, ":\\private\\2000d75b\\temp\\unloadlibhandles.bin");

// ------------------- Policy Server Security Setup ----------------------

const TInt KSsmServerSid = 0x2000D75B; //UID3 of sysstatemgr.exe

const TUint  KRangeCount = 3;
const TInt   KRanges[KRangeCount] =
	{
	0,
	ECleSrvExecuteCmdList,
	EEndOfCleOpCodes
	};

/**
 Maps to index 0 in the array KPolicyElements
 */
const TInt KSsmServerSidCheck = 0;

/**
 Specifies the appropriate action for each range in KRanges.
 The nth element of KElementsIndex specifies the appropriate action for the nth range in KRanges.
 */
const TUint8 KElementsIndex[KRangeCount] =
	{
	CPolicyServer::ENotSupported,
	KSsmServerSidCheck,
	CPolicyServer::ENotSupported,
	};

/**
 Array containing the different security checks performed by this server
 */
const CPolicyServer::TPolicyElement KPolicyElements[] =
	{
	{_INIT_SECURITY_POLICY_S0(KSsmServerSid), CPolicyServer::EFailClient} //lint !e778 suppress Constant expression evaluates to 0 in operation '+'
	};

/**
 Setup a security policy which requires all caps to be used by the SsmServer for all requests
 including creating a connection. We do not yet have a usecase for anyone else other than
 SsmServer using SusUtilServer. The caller's SID is matched against SsmServer's
 SID in each ServiceL call
 */
const CPolicyServer::TPolicy KCleServerPolicy =
	{
	KSsmServerSidCheck,	// map connection attempts as well to index [0] in KPolicyElements[]
	KRangeCount,
	KRanges,
	KElementsIndex,
	KPolicyElements
	};



void CCleServer::ExecuteCommandListL( CSsmCommandList* aCommandList, const RMessage2& aMessage, const TInt aSessionIndex )
	{
	__ASSERT_DEBUG( aCommandList->Count() > 0, User::Panic( KCleCmdListEmpty, KCleSrvBadCmdList) );
	__ASSERT_DEBUG( __IN_RANGE(aSessionIndex, iSessionInfoArray.Count()), User::Panic( KCleSrvBadIdx, KCleSrvArrayIndexInvalid ) );
			
	if( (0 == aCommandList->Count()) || !__IN_RANGE(aSessionIndex, iSessionInfoArray.Count()) )
		{
		User::Leave( KErrArgument );
		}
	
	CSsmCmdListExecutor* executor = CSsmCmdListExecutor::NewL( *this, aSessionIndex );
	
	iSessionInfoArray[ aSessionIndex ].iExecutor = executor;
	iSessionInfoArray[ aSessionIndex ].iMessagePtr = aMessage;

	executor->StartL( aCommandList );
	}



/**
 * Locate the CommandListExecutor associated with the session calling CommandListCancel.
 * Delete the Command list (which cancels its AO) then complete the client's RMessage with KErrCancel.
 */
void CCleServer::ExecuteCommandListCancel( TInt aSessionIndex )
	{
	__ASSERT_DEBUG( __IN_RANGE( aSessionIndex, iSessionInfoArray.Count()), User::Panic( KCleSrvBadIdx, KCleSrvArrayIndexInvalid ) );
	
	if( iSessionInfoArray[ aSessionIndex ].iExecutor )
		{
		iSessionInfoArray[ aSessionIndex ].iMessagePtr.Complete( KErrCancel );
		delete iSessionInfoArray[ aSessionIndex ].iExecutor;
		iSessionInfoArray[ aSessionIndex ].iExecutor = NULL;
		}
	}

	

/**
 * This function is inherited from MCommandListExecutionObserver
 * and called from CSsmCmdListExecutor to signal the completion of command list processing.
 */
void CCleServer::ListExecutionComplete( TInt aComplete, TInt aSessionIndex ,TCmdErrorSeverity /* aSeverity */ )
	{
	__ASSERT_DEBUG( __IN_RANGE(aSessionIndex, iSessionInfoArray.Count()), User::Panic( KCleSrvBadIdx, KCleSrvArrayIndexInvalid ) );
	iSessionInfoArray[ aSessionIndex ].iMessagePtr.Complete( aComplete );
	delete iSessionInfoArray[ aSessionIndex ].iExecutor;
	iSessionInfoArray[ aSessionIndex ].iExecutor = NULL;
	}



/**
  Used to create a new server-side session.
 @return A pointer to the new instance of CSession2.
 @leave KErrNotSupported if versions are incompatible.
 @publishedPartner
 @released
*/
EXPORT_C CSession2* CCleServer::NewSessionL( const TVersion& aVersion, const RMessage2& /*aMessage*/ ) const
	{
	if( !User::QueryVersionSupported(iVersion, aVersion) )
		{
		User::Leave( KErrNotSupported );
		}
	
	CCleServer& mutatedSelf = const_cast< CCleServer& >( *this );
	
	return CCleSession::NewL( mutatedSelf ); 
	}
	


/**
 Iterate through iSessionInfoArray to find an unused array element
 If found, use it. Otherwise, Append() a new SCleSessionInfo.
 This function is called during CSession construction.
*/
void CCleServer::RegisterSessionL( TInt& aSessionIndex )
	{
	const TInt count = iSessionInfoArray.Count();
	TBool slotFound = EFalse;
	
	for(TInt i = 0; i < count; i++ )
		{
		if( !iSessionInfoArray[ i ].iInUse )
			{
			iSessionInfoArray[ i ].iInUse = ETrue;
			ASSERT( NULL == iSessionInfoArray[ i ].iExecutor );
			aSessionIndex = i;
			slotFound = ETrue;
			iSessionCount++;			
			break;
			}
		}
	
	if( !slotFound )
		{
		SCleSessionInfo sessionInfo;
		sessionInfo.iExecutor = NULL;
		sessionInfo.iInUse = ETrue;
		iSessionInfoArray.AppendL( sessionInfo );
		aSessionIndex = iSessionCount++;
		}
	
	DEBUGPRINT2( _L("***** Registered in slot %d"), aSessionIndex );
	}



/**
 Called from CSession destructor.
*/
void CCleServer::DeregisterSession( const TInt& aSessionIndex )
	{
	__ASSERT_DEBUG( __IN_RANGE(aSessionIndex, iSessionInfoArray.Count()), User::Panic(KCleSrvBadIdx, KCleSrvArrayIndexInvalid) );
	
	if( iSessionInfoArray[ aSessionIndex ].iExecutor )
		{
		delete iSessionInfoArray[ aSessionIndex ].iExecutor;
		iSessionInfoArray[ aSessionIndex ].iExecutor = NULL;
		}

	iSessionInfoArray[ aSessionIndex ].iInUse = EFalse;
	iSessionCount--;

   // Remove unused elements at the end of the array, so iSessionInfoArray can be (granular) shrunk
	const TInt count = iSessionInfoArray.Count();
	TBool slotRemoved = EFalse;
	for(TInt i = count-1; i >= 0 ; i-- )
		{
		if( !iSessionInfoArray[ i ].iInUse )
			{
      		iSessionInfoArray.Remove(i);
      		slotRemoved = ETrue;
			}
		else
			{
			break;
			}
		}
	if (slotRemoved)
		{
		iSessionInfoArray.GranularCompress();
		}

	DEBUGPRINT2( _L("***** De-registered slot %d"), aSessionIndex );
 	}

// Release the libraries loaded by custom commands which has the unload option set to 'ENeverUnload'
TInt CCleServer::CloseNeverUnloadLibrariesL()
	{
	const TChar sysDrive = RFs::GetSystemDriveChar();
	RBuf filename;
	filename.CreateL(KNeverUnloadLibHandleFile().Length() + 1);
	filename.Append(sysDrive);
	filename.Append(KNeverUnloadLibHandleFile());
	filename.CleanupClosePushL();
	RFs fs;
	User::LeaveIfError(fs.Connect());
	CleanupClosePushL(fs);
	RFile file;
	CleanupClosePushL(file);
	TInt libsReleased = 0;
	const TInt error=file.Open(fs, filename, EFileShareReadersOnly|EFileStream|EFileRead);
	if (error==KErrNone)
		{
		RFileReadStream readStream;
		readStream.Attach(file);
		CleanupClosePushL(readStream);
		TInt handle=0;
		RLibrary lib;
		TRAPD(ret, handle = readStream.ReadInt32L());
		while(ret != KErrEof && handle > 0)
			{
			lib.SetHandle(handle);
			lib.Close();
			libsReleased++;
			TRAP(ret, handle = readStream.ReadInt32L());
			}
		CleanupStack::PopAndDestroy(&readStream);
		}
	fs.Delete(filename);//Ignore the error. Perhaps the file does not exist.
	CleanupStack::PopAndDestroy(3);
	return libsReleased;
	}


/**
 * Used to create a new CCleServer
 * @return A pointer to the CCleServer
 * @leave One of the system-wide error codes if construction fails.
 * @publishedPartner
 * @released
 */
EXPORT_C CCleServer* CCleServer::NewL(const TDesC& aServerName)
	{
	CCleServer* self = NewLC(aServerName);
	CleanupStack::Pop();
	return self;	
	}



/**
 * Used to create a new CCleServer
 * @return A pointer to the CCleServer
 * @leave One of the system-wide error codes if construction fails.
 * @publishedPartner
 * @released
 */
EXPORT_C CCleServer* CCleServer::NewLC(const TDesC& aServerName)
	{
	CCleServer* self = new(ELeave) CCleServer;	
	CleanupStack::PushL( self );
	self->ConstructL(aServerName);
	return self;	
	}
	


/**
 * Static function used to create and start CCleServer
 * 
 * @return KErrAlreadyExists if the server is already running
 * @publishedPartner
 * @released
 */
EXPORT_C TInt CCleServer::StartCleSrv(const TDesC& aServerName)
	{
	TAny* threadParam = reinterpret_cast<TAny*>(const_cast<TDesC*>(&aServerName));
	// Create a Unique name for the thread name
	TName name(aServerName);
	_LIT(KUnderScore, "_");
	name.Append(KUnderScore);
	name.AppendNum(Math::Random(), EHex);

	const TInt KCleSrvMinHeapSize = 0x2000;
	const TInt KCleSrvMaxHeapSize = 10 * KCleSrvMinHeapSize;
	RThread srvThread;
	TInt err = srvThread.Create( name, &CCleServer::CleSrvThreadFn, 
								 KDefaultStackSize, KCleSrvMinHeapSize, KCleSrvMaxHeapSize, 
								 threadParam, EOwnerProcess );

	if( KErrNone == err )
		{
		TRequestStatus trs;
		
		srvThread.Rendezvous( trs );
		srvThread.Resume();
		srvThread.Close();
		
		User::WaitForRequest( trs );	
		err = trs.Int();
		}

	return err;
	}



TInt CCleServer::CleSrvThreadFn( TAny* aAny )
	{
	const TDesC* serverName = const_cast<const TDesC*>(static_cast<TDesC*>(aAny));
	TInt err = KErrNoMemory;
    CTrapCleanup* cleanup = CTrapCleanup::New();
    if( cleanup )
    	{
	    TRAP( err,
	        {
	        CActiveScheduler* sched = new(ELeave) CActiveScheduler();
	        CleanupStack::PushL( sched );
	        CActiveScheduler::Install( sched );
	
	        CCleServer* cleSrv = CCleServer::NewLC(*serverName);
	        RThread::Rendezvous( KErrNone );
	    	// Must not use serverName after rendezvousing with client
	        serverName = NULL;
	        
	        CActiveScheduler::Start();
	
	        CleanupStack::PopAndDestroy( cleSrv );
	        CleanupStack::PopAndDestroy( sched );
	        });

	    delete cleanup;
    	}
 
    return err;
	}


/**

 */
CCleServer::CCleServer()
: CPolicyServer( EPriorityHigh, KCleServerPolicy, EUnsharableSessions ),
  iVersion( KCleSrvVersionMajor, KCleSrvVersionMinor, KCleSrvVersionBuild )
	{
	}
	
	
	
void CCleServer::ConstructL(const TDesC& aServerName)
	{
	//If the ENeverUnload file is left over, then it should be cleaned up.
	//Ignore the error. We don't want the server to be stopped due to this error.
	TRAP_IGNORE(CleanHandlesFileL());
	
	StartL( aServerName );
	// The starting thread is signalled in the thread function.
	}
	

// Delete the file which stores the handles of those libraries used by custom commands which has unload option set to ENeverUnload.
// Generally it will be deleted from the destructor. If it could not be deleted for some reason from the destructor, 
// then it should be deleted while starting the server.
void CCleServer::CleanHandlesFileL()
	{
	const TChar sysDrive = RFs::GetSystemDriveChar();
	RBuf filename;
	filename.CreateL(KNeverUnloadLibHandleFile().Length() + 1);
	filename.Append(sysDrive);
	filename.Append(KNeverUnloadLibHandleFile());
	filename.CleanupClosePushL();
	RFs fs;
	User::LeaveIfError(fs.Connect());
	fs.Delete(filename);//Ignore the error. Perhaps the file does not exist.
	fs.Close();
	CleanupStack::PopAndDestroy();
	}

CCleServer::~CCleServer()
	{
	const TInt count = iSessionInfoArray.Count();	
	for(TInt i = 0; i < count; i++ )
		{
		delete iSessionInfoArray[ i ].iExecutor;
		iSessionInfoArray[ i ].iExecutor = NULL;
		}
	iSessionInfoArray.Close();

	//Server is being destructed, so no need to leave from here.
	TRAP_IGNORE(CloseNeverUnloadLibrariesL());
	}