/*
* Copyright (c) 2006-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: 
*
*/


#include "tintegrityservicesserver.h"
#include "tintegrityservicescommon.h"
#include "integrityservices.h"
#include <e32debug.h>

_LIT(KFailAddingNewFile, "EFailAddingNewFile");
_LIT(KFailRemovingFile, "EFailRemovingFile");
_LIT(KFailAddingTempFile, "EFailAddingTempFile");
_LIT(KFailRestoringFile, "EFailRestoringFile");
_LIT(KFailDeletingFile, "EFailDeletingFile");
_LIT(KFailInstallComplete, "EFailInstallComplete");
_LIT(KFailNewFilesRemoved, "EFailNewFilesRemoved");
_LIT(KFailOldFilesRestored, "EFailOldFilesRestored");
_LIT(KFailTempFilesRemoved, "EFailTempFilesRemoved");
_LIT(KFailBackupFilesRemoved, "EFailBackupFilesRemoved");

_LIT(KFailBeforeJournal, "EBeforeJournal");
_LIT(KFailAfterJournal, "EAfterJournal");
_LIT(KFailBeforeAction, "EBeforeAction");
_LIT(KFailAfterAction, "EAfterAction");

using namespace Usif;

static void PanicClient(const RMessagePtr2& aMessage, 
						TIntegrityServicesServerPanic aPanic)
	{
	aMessage.Panic(KIntegrityServicesServerName, aPanic);
	}

/////
///// CIntegrityServicesServer
/////

CIntegrityServicesServer* CIntegrityServicesServer::NewLC()
	{
	CIntegrityServicesServer* self = new(ELeave) CIntegrityServicesServer();
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}
	
void CIntegrityServicesServer::AddSession()
	{
	++iSessionCount;
	iShutdown->Cancel();
	}
	
void CIntegrityServicesServer::DropSession()
	{
	if (--iSessionCount==0)
		{
		iShutdown->Start();
		RDebug::Print(_L("Server shutting down"));
		}
	}

CIntegrityServicesServer::~CIntegrityServicesServer()
	{
	delete iShutdown;
	RDebug::Print(_L("Server destructor"));
	}

CIntegrityServicesServer::CIntegrityServicesServer() : CServer2(EPriorityNormal, ESharableSessions)
	{
	}

void CIntegrityServicesServer::ConstructL()
	{
	StartL(KIntegrityServicesServerName);
	
	iShutdown = CShutdownTimer::NewL();
	
	// Ensure that the server still exits even if the 1st client fails to
	// connect
	iShutdown->Start();
	}

CSession2* CIntegrityServicesServer::NewSessionL(const TVersion& /*aVersion*/, 
						 const RMessage2& /*aMessage*/) const
	{
	  return CIntegrityServicesSession::NewL();
	}

CIntegrityServicesSession* CIntegrityServicesSession::NewL()
	{
	CIntegrityServicesSession* self = CIntegrityServicesSession::NewLC();
	CleanupStack::Pop(self);
	return self;
	}
	
	
CIntegrityServicesSession* CIntegrityServicesSession::NewLC()
	{
	CIntegrityServicesSession* self = new(ELeave) CIntegrityServicesSession();
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

CIntegrityServicesSession::CIntegrityServicesSession() : CSession2()
	{
	}
	
void CIntegrityServicesSession::ConstructL()
	{
	iIntegrityServices = CIntegrityServices::NewL(0);
	}
	
void CIntegrityServicesSession::CreateL()
	{
	RDebug::Print(_L("Session CreateL"));
	Server().AddSession();
	}



CIntegrityServicesSession::~CIntegrityServicesSession()
	{
	delete iIntegrityServices;
	Server().DropSession();
	}

CIntegrityServicesServer& CIntegrityServicesSession::Server()
	{
	return *static_cast<CIntegrityServicesServer*>(
		const_cast<CServer2*>(CSession2::Server()));
	}

/////
///// CIntegrityServicesSession		
/////

void CreateTempTestFileL(TDesC& aFileName)
	{
	RFs fs;
	User::LeaveIfError(fs.Connect());
	CleanupClosePushL(fs);
	RFile tempFile;
	CleanupClosePushL(tempFile);
	CIntegrityServices::SimulatePowerFailureL(CIntegrityServices::EFailAddingTempFile, CIntegrityServices::EBeforeAction, aFileName);
	User::LeaveIfError(tempFile.Create(fs, aFileName, EFileWrite));
	CIntegrityServices::SimulatePowerFailureL(CIntegrityServices::EFailAddingTempFile, CIntegrityServices::EAfterAction, aFileName);
	CleanupStack::PopAndDestroy(2, &fs);
	}

void CreateNewTestFileL(TDesC& aFileName)
	{
	RFs fs;
	User::LeaveIfError(fs.Connect());
	CleanupClosePushL(fs);	
	if (aFileName.Length() > 0 && aFileName[aFileName.Length() - 1] == KPathDelimiter)
		{  // A new test directory is created
		User::LeaveIfError(fs.MkDir(aFileName));
		}
	else
		{  // A new test file is created
		RFile newFile;
		CleanupClosePushL(newFile);
		CIntegrityServices::SimulatePowerFailureL(CIntegrityServices::EFailAddingNewFile, CIntegrityServices::EBeforeAction, aFileName);
		User::LeaveIfError(newFile.Create(fs, aFileName, EFileWrite));
		CIntegrityServices::SimulatePowerFailureL(CIntegrityServices::EFailAddingNewFile, CIntegrityServices::EAfterAction, aFileName);
		CleanupStack::PopAndDestroy(&newFile);		
		}
	CleanupStack::PopAndDestroy(&fs);	
	}

void SetSimulatedFailureL(TPtrC16 aFailType, TPtrC16 aFailPosition, TPtrC16 aFailFileName)
	{
	if(aFailType.CompareF(KFailAddingNewFile) == 0)
		{
		CIntegrityServices::iFailType = CIntegrityServices::EFailAddingNewFile;
		}
	else if(aFailType.CompareF(KFailRemovingFile) == 0)
		{
		CIntegrityServices::iFailType = CIntegrityServices::EFailRemovingFile;
		}
	else if(aFailType.CompareF(KFailAddingTempFile) == 0)
		{
		CIntegrityServices::iFailType = CIntegrityServices::EFailAddingTempFile;
		}
	else if(aFailType.CompareF(KFailRestoringFile) == 0)
		{
		CIntegrityServices::iFailType = CIntegrityServices::EFailRestoringFile;
		}
	else if(aFailType.CompareF(KFailDeletingFile) == 0)
		{
		CIntegrityServices::iFailType = CIntegrityServices::EFailDeletingFile;
		}
	else if(aFailType.CompareF(KFailInstallComplete) == 0)
		{
		CIntegrityServices::iFailType = CIntegrityServices::EFailInstallComplete;
		}
	else if(aFailType.CompareF(KFailNewFilesRemoved) == 0)
		{
		CIntegrityServices::iFailType = CIntegrityServices::EFailNewFilesRemoved;
		}
	else if(aFailType.CompareF(KFailOldFilesRestored) == 0)
		{
		CIntegrityServices::iFailType = CIntegrityServices::EFailOldFilesRestored;
		}
	else if(aFailType.CompareF(KFailTempFilesRemoved) == 0)
		{
		CIntegrityServices::iFailType = CIntegrityServices::EFailTempFilesRemoved;
		}
	else if(aFailType.CompareF(KFailBackupFilesRemoved) == 0)
		{
		CIntegrityServices::iFailType = CIntegrityServices::EFailBackupFilesRemoved;
		}
	else
		{
		// default to EFailNone
		CIntegrityServices::iFailType = CIntegrityServices::EFailNone;
		}
	
	if(aFailPosition.CompareF(KFailBeforeJournal) == 0)
		{
		CIntegrityServices::iFailPosition = CIntegrityServices::EBeforeJournal;
		}
	else if(aFailPosition.CompareF(KFailAfterJournal) == 0)
		{
		CIntegrityServices::iFailPosition = CIntegrityServices::EAfterJournal;
		}
	else if(aFailPosition.CompareF(KFailBeforeAction) == 0)
		{
		CIntegrityServices::iFailPosition = CIntegrityServices::EBeforeAction;
		}
	else if(aFailPosition.CompareF(KFailAfterAction) == 0)
		{
		CIntegrityServices::iFailPosition = CIntegrityServices::EAfterAction;
		}
	else
		{
		if(CIntegrityServices::iFailType != CIntegrityServices::EFailNone)
			{
			// scripting error, FailType specified without FailPosition
			User::Leave(KErrCorrupt);
			}
		}
		
	CIntegrityServices::iFailFileName = aFailFileName;
	CIntegrityServices::iIsFailureTestingEnabled = CIntegrityServices::iFailType != CIntegrityServices::EFailNone;
	}

void CIntegrityServicesSession::ServiceL(const RMessage2& aMessage)
	{
	switch (aMessage.Function())
		{
		case EAdd:
			{
			RDebug::Print(_L("ServiceL EAdd"));
			HBufC16* fileName = HBufC16::NewLC(aMessage.GetDesLength(0));
		  	TPtr16 ptr(fileName->Des());
		  	aMessage.Read(0, ptr);

		  	TRAPD(err, iIntegrityServices->RegisterNewL(*fileName));

			aMessage.Complete(err);
			CleanupStack::PopAndDestroy(fileName);	
			break;
			}
		case ERemove:
			{
			RDebug::Print(_L("ServiceL ERemove"));
			HBufC16* fileName = HBufC16::NewLC(aMessage.GetDesLength(0));
		  	TPtr16 ptr(fileName->Des());
		  	aMessage.Read(0, ptr);

		  	TRAPD(err, iIntegrityServices->RemoveL(*fileName));

			aMessage.Complete(err);
			CleanupStack::PopAndDestroy(fileName);	
			
			break;
			}
		case ETemporary:
			{
			RDebug::Print(_L("ServiceL ETemporary"));
			HBufC16* fileName = HBufC16::NewLC(aMessage.GetDesLength(0));
		  	TPtr16 ptr(fileName->Des());
		  	aMessage.Read(0, ptr);

		  	TRAPD(err, iIntegrityServices->RegisterTemporaryL(*fileName));

			aMessage.Complete(err);
			CleanupStack::PopAndDestroy(fileName);	
			break;
			}
		case ECommit:
			{
			RDebug::Print(_L("ServiceL ECommit"));
			TRAPD(err, iIntegrityServices->CommitL());
			aMessage.Complete(err);
			break;
			}
		case ERollBack:
			{
			RDebug::Print(_L("ServiceL ERollBack"));
			TBool all;
			TPckg<TBool> allTransactions(all);
			aMessage.ReadL(0, allTransactions);
			TInt error=KErrNone;
			
			if(all)
				{
				CIntegrityServices::RollbackAllL();
				}
			else
				{
				TRAPD(err, iIntegrityServices->RollBackL());
				error=err;
				}
			aMessage.Complete(error);
			
			break;
			}
			
		case ESetSimulatedFailure:
			{
			HBufC16* aFailType = HBufC16::NewLC(256);
			HBufC16* aPosition = HBufC16::NewLC(256);
			HBufC16* aFailFileName = HBufC16::NewLC(256);
			TPtr16 failType(aFailType->Des());
			TPtr16 position(aPosition->Des());
			TPtr16 failFileName(aFailFileName->Des());
			
			aMessage.ReadL(0, failType);
			aMessage.ReadL(1, position);
			aMessage.ReadL(2, failFileName);
			RDebug::Print(_L("ServiceL ESetSimulatedFailure %S %S %S"), &aFailType, &aPosition, &aFailFileName);
			TRAPD(err, SetSimulatedFailureL(failType, position, failFileName));
			aMessage.Complete(err);
			CleanupStack::PopAndDestroy(3, aFailType);
			break;
			}
		case ECreateNewTestFile:
			{
			RDebug::Print(_L("ServiceL ECreateNewTestFile"));
			HBufC16* fileName = HBufC16::NewLC(aMessage.GetDesLength(0));
		  	TPtr16 ptr(fileName->Des());
		  	aMessage.Read(0, ptr);

		  	TRAPD(err, CreateNewTestFileL(*fileName));

			aMessage.Complete(err);
			CleanupStack::PopAndDestroy(fileName);	
			break;
			}
		case ECreateTempTestFile:
			{
			RDebug::Print(_L("ServiceL ECreateTempTestFile"));
			HBufC16* fileName = HBufC16::NewLC(aMessage.GetDesLength(0));
		  	TPtr16 ptr(fileName->Des());
		  	aMessage.Read(0, ptr);

		  	TRAPD(err, CreateTempTestFileL(*fileName));

			aMessage.Complete(err);
			CleanupStack::PopAndDestroy(fileName);	
			break;
			}
	default:
		{
		PanicClient(aMessage, EPanicIntegrityServicesServerIllegalFunction);
		break;
		}
		}
	}

void CIntegrityServicesSession::ServiceError(const RMessage2& aMessage, TInt aError)
	{
	if (aError==KErrBadDescriptor)
		{
		PanicClient(aMessage, EPanicIntegrityServicesServerIllegalFunction);
		}
	CSession2::ServiceError(aMessage, aError);
	}

/////
///// CShutdownTimer
/////
inline CShutdownTimer::CShutdownTimer() : CTimer(-1)
	{
	CActiveScheduler::Add(this);
	}

inline void CShutdownTimer::ConstructL()
	{
	CTimer::ConstructL();
	}

inline void CShutdownTimer::Start()
	{
	After(KShutdownDelay);
	}

CShutdownTimer* CShutdownTimer::NewL()
	{
	CShutdownTimer* self = new(ELeave) CShutdownTimer();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

// Initiate server exit when the timer expires
void CShutdownTimer::RunL()
	{
	CActiveScheduler::Stop();
	}