/*

* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

* Implements CStsServer.

*

*/

/**

 @file

 @internalComponent

 @released

*/

#include "stsserver.h"

#include "stsserversession.h"

#include "usiflog.h"

#include <scs/securityutils.h>

namespace Usif

{

static const TUint stsServerRangeCount = 5;

static const TInt stsServerRanges[stsServerRangeCount] =

	{

	0,							                                      //Range 0 - 0 to EBaseSession-1. Not used.

	CScsServer::EBaseSession,	                                      //Range 1 - EBaseSession to (EBaseSession+ERegisterNew)-1. ==> from ECreateTransaction to EGetId inclusive

	CScsServer::EBaseSession|static_cast<TInt>(ERegisterNew),         //Range 2 - (EBaseSession+ERegisterNew) to (EBaseSession+ERollBackAllPending)-1 ==> from ERegisterNew to EOverwrite inclusive

	CScsServer::EBaseSession|static_cast<TInt>(ERollBackAllPending),  //Range 3 - (EBaseSession+ERollBackAllPending) to ((EBaseSession+ERollBackAllPending)+1)-1==> only ERollBackAllPending

	CScsServer::EBaseSession|static_cast<TInt>(ERollBackAllPending)+1 //Range 4 - (EBaseSession+ERollBackAllPending)+1 to KMaxTInt inclusive  (i.e: ScsImpl::EPreCloseSession)

	};

static const TUint8 stsServerElementsIndex[stsServerRangeCount] =

	{

	CPolicyServer::ENotSupported, // Range 0 : is not supported.

	CPolicyServer::EAlwaysPass,   // Range 1

	CPolicyServer::ECustomCheck,  // Range 2 : custom check will be made made for each function to see if client is authorised to do that

	0,                            // Range 3 : Can only be issued by KUidDaemon

	CPolicyServer::EAlwaysPass    // Range 4

	};							

static const CPolicyServer::TPolicyElement stsServerElements[] =

	{

	{_INIT_SECURITY_POLICY_S0(KUidDaemon), CPolicyServer::EFailClient}, //special handling of function ERollBackAllPending 

	};

static const CPolicyServer::TPolicy stsServerPolicy =

	{

	CPolicyServer::EAlwaysPass, // Allow all connects

	stsServerRangeCount,

	stsServerRanges,

	stsServerElementsIndex,

	stsServerElements,

	};

//

//CStsServer

//

CStsServer::CStsServer()

/**

	Intializes the STS server object with its version and policy.

 */

	:	CScsServer(TVersion(KStsVerMajor, KStsVerMinor, KStsVerBuild),stsServerPolicy)

		{

		//empty

		}

CStsServer::~CStsServer()

/**

	Destructor. Cleanup the STS server.

 */

	{

	iTransactionWrapperContainer.ResetAndDestroy();

	}

CStsServer* CStsServer::NewLC()

/**

	Factory function allocates new, initialized instance of CStsServer.

	@return		New, initialized instance of CStsServer

				which is left on the cleanup stack.

 */

	{

	CStsServer *so = new (ELeave) CStsServer();

	CleanupStack::PushL(so);

	so->ConstructL();

	return so;

	}

void CStsServer::ConstructL()

/**

	Second phase constructor starts the STS server.

 */

	{

	// Roll back all previous transactions in case the STS process died unexpectedly

	// Note: error returned from RollBackAllPendingL() is ignored at this point to prevent STS server startup from failing

	// It is important to roll back before calling CScsServer::ConstructL as the roll back may be longer than the shutdown period for the timer started by that function

	TRAP_IGNORE(RollBackAllPendingL());

	CScsServer::ConstructL(KStsServerShutdownPeriod); 

	StartL(KStsServerName);

	}

CScsSession* CStsServer::DoNewSessionL(const RMessage2& aMessage)

/**

	Implement CStsServer by allocating a new instance of CStsServerSession.

	@param	aMessage	Standard server-side handle to message.

	@return				New instance of CStsServerSession which is owned by the caller.

 */

	{

	return CStsServerSession::NewL(*this, aMessage);

	}

void CStsServer::RollBackAllPendingL()

/**

	Rolls back all pending transactions that have persistent information stored in the transaction

	path in the file system.

	Important note: this function can only be invoked if there are no active transactions in the server as it is

	not intended to roll back active transactions. (ie: intended to be invoked at boot-up time and STS start up only) 

 */

	{

	if(iTransactionWrapperContainer.Count()!=0) 

		{

		User::Leave(KErrInUse); //there can be no active transaction when this function is invoked 

		}

	CIntegrityServices::RollbackAllL();

	}

TInt TransactionWrapperLinearOrderByIdKey(const TStsTransactionId *id, const CReferenceCountedTransactionWrapper &aSecond)

	{

	return *id-aSecond.TransactionId();

	}

TInt TransactionWrapperLinearOrder(const CReferenceCountedTransactionWrapper &aFirst, const CReferenceCountedTransactionWrapper &aSecond)

	{

	return aFirst.TransactionId()-aSecond.TransactionId();

	}

TStsTransactionId CStsServer::CreateTransactionID()

	{

	TTime currentTime;

	TStsTransactionId transactionID;

	do

		{

		currentTime.UniversalTime();

		transactionID = I64LOW(currentTime.Int64());

		}

    while(IsExistingTransaction(transactionID));

    return transactionID;

	}

TBool CStsServer::IsExistingTransaction(TStsTransactionId aTransactionID)

	{

	return (FindActiveTransaction(aTransactionID)>=0);

	} 

CIntegrityServices* CStsServer::CreateTransactionL()

	{

	TStsTransactionId id = CreateTransactionID();

	CReferenceCountedTransactionWrapper* wrapper = CReferenceCountedTransactionWrapper::NewLC(id);

	iTransactionWrapperContainer.InsertInOrderL(wrapper, TLinearOrder<CReferenceCountedTransactionWrapper>(&TransactionWrapperLinearOrder));

	CleanupStack::Pop(wrapper);

	return wrapper->Attach();

	}

CIntegrityServices* CStsServer::AttachTransactionL(TStsTransactionId aTransactionID)

	{

	TInt pos=FindActiveTransaction(aTransactionID);

	if(pos>=0) //joining an existing active transaction

		{

		return iTransactionWrapperContainer[pos]->Attach();

		}

	User::Leave(KErrNotFound);

	return 0;

	}

void CStsServer::ReleaseTransactionL(CIntegrityServices* &aTransactionPtr, TBool aMarkAsCompleted /*=EFalse*/)

	{

	__ASSERT_DEBUG(aTransactionPtr, User::Invariant());

	TInt pos=FindActiveTransaction(aTransactionPtr->TransactionId());

	__ASSERT_DEBUG(pos>=0, User::Invariant());

	CReferenceCountedTransactionWrapper* wrapper=iTransactionWrapperContainer[pos];

	if(aMarkAsCompleted)

		wrapper->SetCompleted(); //set transaction as completed (this should be done after a succesful commit or rollback) 

	TInt refCount=wrapper->Detach();

	__ASSERT_DEBUG(refCount>=0, User::Invariant());

	if(refCount==0) 

		{

		if(!wrapper->IsCompleted()) //do an auto roll back if and only if the transaction has not been committed or rolled-back previously

			aTransactionPtr->RollBackL();

		delete wrapper;

		iTransactionWrapperContainer.Remove(pos);

		}

	aTransactionPtr=0;

	}

/*

 This function is a slight optimization of CStsServer::ReleaseTransactionL() as it is intended to be called

 on cleanup of a committed or rolled-back transaction that obviously don't need auto rollbak again.

 */

void CStsServer::FinaliseTransactionL(CIntegrityServices* &aTransactionPtr)

	{

	ReleaseTransactionL(aTransactionPtr, ETrue);

	}

TInt CStsServer::FindActiveTransaction(TStsTransactionId aTransactionID)

	{

	return iTransactionWrapperContainer.FindInOrder(aTransactionID, &TransactionWrapperLinearOrderByIdKey);

	}

CPolicyServer::TCustomResult CStsServer::CustomSecurityCheckL(const RMessage2& aMsg, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/)		

	{

	TInt functionId(StripScsFunctionMask(aMsg.Function()));

	CPolicyServer::TCustomResult ret(EFail);

	switch(functionId)

		{

		case ERegisterNew:

		case ECreateNew:

		case ERemove:

		case ERegisterTemporary:

		case ECreateTemporary:

		case EOverwrite:

			ret = CheckIfFileModificationAllowedL(aMsg)? EPass : EFail;

			break;

		}

	return ret;

	}

/*static*/TBool CStsServer::CheckIfFileModificationAllowedL(const RMessage2& aMsg)

	{

	RBuf filePath;

	filePath.CreateL(KMaxFileName);

	filePath.CleanupClosePushL();

	aMsg.ReadL(KFilePathIPCSlot, filePath, 0);

	// Retrieve the required capabilities for write access to this path

	TCapabilitySet requiredCapabilities = SecCommonUtils::FileModificationRequiredCapabilitiesL(filePath, aMsg.SecureId());

	TBool result = EFalse;

	TBool allFilesRequired = requiredCapabilities.HasCapability(ECapabilityAllFiles);

	TBool tcbRequired = requiredCapabilities.HasCapability(ECapabilityTCB);

	// Test whether the client has at least one of the required capabilities

	if (allFilesRequired)

		result = aMsg.HasCapability(ECapabilityAllFiles);

	if (!result && tcbRequired)

		result = aMsg.HasCapability(ECapabilityTCB);

	if (!allFilesRequired && !tcbRequired)

		result = ETrue;

	CleanupStack::PopAndDestroy(&filePath);

	return result;

	}	

}//end of namespace Usif