/*

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

* CIntegrityServices implementation

*

*/

/**

 @file 

 @released

 @internalTechnology

*/

#include "integrityservices.h"

#include "journal.h"

#include "operationfunctions.h"

#include "usiflog.h"

#include <f32file.h>

using namespace Usif;

_LIT(KTransactionPath, "\\sys\\install\\integrityservices\\");

CIntegrityServices::TFailType CIntegrityServices::iFailType = EFailNone;

CIntegrityServices::TFailPosition CIntegrityServices::iFailPosition = EBeforeJournal;

TFileName CIntegrityServices::iFailFileName;

TBool CIntegrityServices::iIsFailureTestingEnabled = EFalse;

/**

 * This is a trivial C class that just encapsulates a TEntryArray object in order to 

 * facilitate its storage on the heap.

 *

 * @released

 * @internalComponent 

 */

class CEntryArray : public CBase

	{

public:

	inline TEntryArray& operator()();

private:

	/**

	 * Container to hold file entries

	 */

	TEntryArray iEntryArray;

	};

inline TEntryArray& CEntryArray::operator()()

	{

	return iEntryArray;

	}

 CIntegrityServices* CIntegrityServices::NewL(TStsTransactionId aTransactionID)

	{

	CIntegrityServices* self = CIntegrityServices::NewLC(aTransactionID);

	CleanupStack::Pop(self);

	return self;

	}

 CIntegrityServices* CIntegrityServices::NewLC(TStsTransactionId aTransactionID)

	{

	CIntegrityServices* self = new(ELeave) CIntegrityServices(aTransactionID);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

 CIntegrityServices::CIntegrityServices(TStsTransactionId aTransactionID) : iTransactionID(aTransactionID)

	{

	}

 CIntegrityServices::~CIntegrityServices()

	{

	delete iJournal;

	iFs.Close();

	iLoader.Close();

	}

 void CIntegrityServices::ConstructL()

	{

	DEBUG_PRINTF2(_L("CIntegrityServices::ConstructL() - Opening session with  Session ID %X."), iTransactionID);

	User::LeaveIfError(iFs.Connect());

	User::LeaveIfError(iFs.ShareProtected()); //needed as new RFiles are to be passed back to client's side

	User::LeaveIfError(iLoader.Connect());

	// store the journal path and create the journal

	TParsePtrC pathPtr(KTransactionPath);

	iJournalPath = pathPtr.Path();

	iJournal = CJournal::NewL(iFs, iLoader, iTransactionID, iJournalPath);

	iSystemDrive = ::RFs::GetSystemDrive();

	}

const TInt KIntegrityServicesSimulatedBatteryFailure=-10205; 

/*static*/ void CIntegrityServices::SimulatePowerFailureL(TFailType aFailType, TFailPosition aFailPosition, const TDesC& aFailFileName)

	{

	if (!iIsFailureTestingEnabled)

		return;

	if(iFailType == aFailType && iFailPosition == aFailPosition && iFailFileName == aFailFileName)

		{

		User::Leave(KIntegrityServicesSimulatedBatteryFailure);

		}

	}

/*static*/ void CIntegrityServices::NormalizeDirectoryName(TDes& aFileName)

{

	// Directories are represented in the integrity tree and integrity journal exactly as files,

	// without the trailing slash 

	TInt lastCharPos = aFileName.Length() - 1;

	if ( lastCharPos >= 0 && aFileName[lastCharPos] == KPathDelimiter &&

		 aFileName.Locate(KPathDelimiter) != lastCharPos) // Take care not to remove slash from "c:\" and the like

		{

		aFileName.Delete(lastCharPos, 1);

		}			

}

void CIntegrityServices::CopyToBackupL(const TDesC& aSource, const TDesC& aBackup)

{

	// Copying a file isn't atomic so we create a temporary backup file first

	RBuf backupTmpName;

	backupTmpName.Create(aBackup.Length() + 4);

	CleanupClosePushL(backupTmpName);

	backupTmpName.Copy(aBackup);

	_LIT(KTmpExt, ".tmp");

	backupTmpName.Append(KTmpExt);

	// Copying a file is not an atomic operation so add the temporary

	// file to the journal to enable cleanup if a power failure occurs before

	// the rename

	SimulatePowerFailureL(EFailAddingTempFile, EBeforeJournal, backupTmpName);

	RegisterTemporaryL(backupTmpName);

	SimulatePowerFailureL(EFailAddingTempFile, EAfterJournal, backupTmpName);	

	CFileMan* fileMan = CFileMan::NewL(iFs);

	CleanupStack::PushL(fileMan);

	TInt err = fileMan->Copy(aSource, backupTmpName);

	DEBUG_PRINTF4(_L("CIntegrityServices::CopyToBackupL() - Copying %S to %S, err %d"), &aSource, &backupTmpName, err);

	User::LeaveIfError(err);

	// Backup is complete, use RFs::Rename as atomic 'commit' of backup

	err = iFs.Rename(backupTmpName, aBackup);			

	DEBUG_PRINTF2(_L("CIntegrityServices::CopyToBackupL() - Commit backup returned error %d"), err);	

	User::LeaveIfError(err);	

	CleanupStack::PopAndDestroy(2, &backupTmpName); // backupTmpName, fileMan 

	//  Now the backup is safe the original can be deleted

	err = iLoader.Delete(aSource);

	DEBUG_PRINTF3(_L("CIntegrityServices::CopyToBackupL() - RLoader::Delete %S returned error %d"), &aSource, err);

	User::LeaveIfError(err);

}

 void CIntegrityServices::RegisterNewL(const TDesC& aFileName)

	{

	DEBUG_PRINTF3(_L("CIntegrityServices::RegisterNewL() - Session %X, File: %S."),	iTransactionID, &aFileName);

	HBufC* localFilenameHeap = aFileName.AllocLC();

	TPtr localFilename = localFilenameHeap->Des();

	NormalizeDirectoryName(localFilename); // If it is a directory name, make sure to normalize it

	// Record the added file or directory in the journal

	SimulatePowerFailureL(EFailAddingNewFile, EBeforeJournal, aFileName);

	iJournal->AddL(localFilename);

	SimulatePowerFailureL(EFailAddingNewFile, EAfterJournal, aFileName);

	CleanupStack::PopAndDestroy(localFilenameHeap);

	}

 void VerifyMkDirErrorL(TInt err)

	{

	if(err != KErrNone && err != KErrAlreadyExists)

		{

		User::Leave(err);

		}	

	}

 void ProcessNewFileRegistrationResultL(TInt err, RFs& aFs, const TDesC& aFileName, RFile& aFile)

	{

	if(err!= KErrNone)

		{

		//if we hit this point it means we successfully created the new file however registering with the transaction has  failed

		//so we have to remove the new file to make the journal and the file system consistent

		aFile.Close();

		aFs.Delete(aFileName);

		User::Leave(err);

		}	

	}

 void CIntegrityServices::CreateNewL(const TDesC& aFileName, RFile &newFile, TUint aFileMode)

	{

	DEBUG_PRINTF3(_L("CIntegrityServices::CreateNewL() - Session %X, File: %S."),	iTransactionID, &aFileName);

	TInt err = iFs.MkDirAll(aFileName); //first we have to create the full directory path to aFileName otherwise RFs::Create will fail

	VerifyMkDirErrorL(err);

	User::LeaveIfError(newFile.Create(iFs, aFileName, aFileMode));

	TRAPD(regResult, RegisterNewL(aFileName));	

	ProcessNewFileRegistrationResultL(regResult, iFs, aFileName, newFile); //checks if the registration failed and cleans up the file in the filesystem if it did

	}

 void CIntegrityServices::RemoveL(const TDesC& aFileName)

	{

	DEBUG_PRINTF3(_L("CIntegrityServices::RemoveL() - Session %X, File: %S."), iTransactionID, &aFileName);

	// before doing anything check that the file or directory exists

	TEntry entry;

	TInt res = iFs.Entry(aFileName, entry);

	if (res == KErrNotFound || res == KErrPathNotFound)

		return; // If the file is not present, do nothing. Returning an error would require the user of the API to do additional checks

	User::LeaveIfError(res);

	// We might need to grow this buffer by one byte later

	HBufC* localFilenameHeap = HBufC::NewLC(aFileName.Length() + 1);

	TPtr localFilename = localFilenameHeap->Des();

	localFilename.Copy(aFileName);

	TBool isFilenameDir = entry.IsDir();

	// The "if" below is not functionally necessary, but it is a slight optimization - 

	// so that we won't attempt to normalize directory name on files. The optimization is not

	// done in AddL or NormalizeDirectoryName itself, since we don't have future use for TEntry there, and the cost for RFs::Entry overweighs the one for NormalizeDirectoryName

	if ( isFilenameDir ) 

		{

		NormalizeDirectoryName(localFilename);

		}

	RBuf backupFileName;

	backupFileName.CreateL(KMaxFileName);

	CleanupClosePushL(backupFileName);

	SimulatePowerFailureL(EFailRemovingFile, EBeforeJournal, aFileName);

	iJournal->RemoveL(localFilename, backupFileName);

	if (backupFileName.Length())

		{

		SimulatePowerFailureL(EFailRemovingFile, EAfterJournal, aFileName);

		TInt err = iFs.MkDirAll(backupFileName);

		VerifyMkDirErrorL(err);

		SimulatePowerFailureL(EFailRemovingFile, EBeforeAction, aFileName);

		_LIT(KSysBinMatch, "?:\\sys\\bin\\*");

		if (localFilename.MatchF(KSysBinMatch) == 0)

		{

			// A copy is slower than a rename to only use the 

			// demand paging safe API for files in sys\bin

			CopyToBackupL(localFilename, backupFileName);			

		}

		else

		{

			err = iFs.Rename(localFilename, backupFileName);

			DEBUG_PRINTF4(_L("CIntegrityServices::RemoveL() - Renamed %S as %S error %d"), &localFilename, &backupFileName, err);

			User::LeaveIfError(err);

		}				

		SimulatePowerFailureL(EFailRemovingFile, EAfterAction, aFileName);

		}

	else

		{

		DEBUG_PRINTF2(_L("CIntegrityServices::RemoveL() - %S already backed up"), &aFileName);

		SimulatePowerFailureL(EFailRemovingFile, EBeforeAction, aFileName);

		// If backupFileName is zero-length, the file was added earlier

		// in the same journal and doesn't need to be backed up.

		if (isFilenameDir)

			{

			CFileMan* fileman = CFileMan::NewL(iFs);

			CleanupStack::PushL(fileman);			

			// Make sure to append slash before calling RmDir - otherwise it deletes the parent directory

			if (localFilename[localFilename.Length()-1] != KPathDelimiter)

	  			{

  				localFilename.Append(KPathDelimiter);

  				}			

			User::LeaveIfError(fileman->RmDir(localFilename)); // A directory cannot be a paged exec., so we don't have to use iLoader

			CleanupStack::PopAndDestroy(fileman);

			}

		else

			{

			User::LeaveIfError(iLoader.Delete(aFileName));

			}

		SimulatePowerFailureL(EFailRemovingFile, EAfterAction, aFileName);			

		}

	// Don't leave an empty directory structure, try pruning it

	RemoveDirectoryTreeL(iFs, aFileName);

	CleanupStack::PopAndDestroy(2, localFilenameHeap); // backupFileName

	}

 void CIntegrityServices::RegisterTemporaryL(const TDesC& aFileName)

	{

	DEBUG_PRINTF3(_L("CIntegrityServices::RegisterTemporaryL() - Session %X, File: %S."), iTransactionID, &aFileName);

	// record the temporary file or directory in the journal

	SimulatePowerFailureL(EFailAddingTempFile, EBeforeJournal, aFileName);

	iJournal->TemporaryL(aFileName);

	SimulatePowerFailureL(EFailAddingTempFile, EAfterJournal, aFileName);

	}

 void CIntegrityServices::CreateTemporaryL(const TDesC& aFileName, RFile &newFile, TUint aFileMode)

	{

	DEBUG_PRINTF3(_L("CIntegrityServices::CreateTemporaryL() - Session %X, File: %S."), iTransactionID, &aFileName);

	TInt err = iFs.MkDirAll(aFileName); //first we have to create the full directory path to aFileName otherwise RFs::Create will fail

	VerifyMkDirErrorL(err);

	User::LeaveIfError(newFile.Create(iFs, aFileName, aFileMode));

	TRAPD(regResult, RegisterTemporaryL(aFileName));

	ProcessNewFileRegistrationResultL(regResult, iFs, aFileName, newFile);

	}

 void CIntegrityServices::OverwriteL(const TDesC& aFileName, RFile &newFile, TUint aFileMode)

	{

	DEBUG_PRINTF3(_L("CIntegrityServices::OverwriteL() - Session %X, File: %S."), iTransactionID, &aFileName);

	TBool b;

	TInt err;

	if((err=iFs.IsFileOpen(aFileName, b))== KErrNone) //returned error code shows whether the file exists or not; the bool value is ignored

		{

		//file exists remove first

		RemoveL(aFileName);

		}

	else

		{

		if(err != KErrNotFound)

			{

			User::Leave(err);

			}

		}

	CreateNewL(aFileName, newFile, aFileMode);

	}

 void CIntegrityServices::CommitL()

	{

	DEBUG_PRINTF2(_L("CIntegrityServices::CommitL() - Session %X."), iTransactionID);	

	iJournal->CommitL();

	}

 void CIntegrityServices::RollBackL(TBool aRecordAllRollbackEvents /* = ETrue */)

	{

	DEBUG_PRINTF2(_L("CIntegrityServices::RollBackL() - transaction %X"), iTransactionID);

	iJournal->RollBackL(aRecordAllRollbackEvents);

	}

/*static*/ void CIntegrityServices::GetListOfTransactionsL(RArray<TStsTransactionId>& aIdArray)

	{

	RFs fs;

	User::LeaveIfError(fs.Connect());

	CleanupClosePushL(fs);

	TDriveUnit systemDrive(::RFs::GetSystemDrive());

	RBuf fileSpec;

	fileSpec.CreateL(systemDrive.Name(), KMaxFileName);

	CleanupClosePushL(fileSpec);

	fileSpec.Append(KTransactionPath);

	fileSpec.Append(KMatchAny);

	fileSpec.Append(KExtDelimiter);

	fileSpec.Append(KDriveExt);

	RDir dir;

	TInt err = dir.Open(fs, fileSpec, KEntryAttNormal);

	CleanupStack::PopAndDestroy(&fileSpec);

	if (err == KErrPathNotFound || err == KErrNotFound)

		{

		CleanupStack::PopAndDestroy(&fs);

		return; // These errors are not considered fatal - there may be no journals present

		}

	User::LeaveIfError(err);

	CleanupClosePushL(dir);

	CEntryArray* entryArrayContainer = new (ELeave) CEntryArray;

	TEntryArray& entryArray = (*entryArrayContainer)();

	err = dir.Read(entryArray);

	CleanupStack::PopAndDestroy(&dir);

	CleanupStack::PushL(entryArrayContainer);	

	if (err != KErrNone && err != KErrEof)

		{

		User::Leave(err);

		}

	TInt entryCount(entryArray.Count());

	for (TInt index = 0; index < entryCount; ++index)

		{

		TStsTransactionId transactionID;

		if (CJournal::RecoverTransactionIdFromDrvFileName(

				entryArray[index].iName, transactionID) == KErrNone)

			{

			aIdArray.AppendL(transactionID);

			}

		}

	CleanupStack::PopAndDestroy(entryArrayContainer);

	CleanupStack::PopAndDestroy(&fs);

	}

/*static*/ void CIntegrityServices::RollbackAllL()

	{

	RArray<TStsTransactionId> transactionIDs;

	CleanupClosePushL(transactionIDs);

	CIntegrityServices::GetListOfTransactionsL(transactionIDs);

	TInt numberOfTransactions(transactionIDs.Count());

	TInt lastError=KErrNone;

	DEBUG_PRINTF2(_L("CIntegrityServices::RollbackAllL() %d transactions have been found."), numberOfTransactions );							

	for(TInt i=0; i<numberOfTransactions; ++i)

		{

		DEBUG_PRINTF2(_L("CIntegrityServices::RollbackAllL() Trying to roll back transaction %X"), transactionIDs[i]);

		TRAPD(err,

			CIntegrityServices* transactionPtr = CIntegrityServices::NewLC(transactionIDs[i]);

			transactionPtr->RollBackL(EFalse); // Specify not to record roll back events. If we failed in the middle of a previous roll back, due to lack of resources we shouldn't be trying to record more events

			CleanupStack::PopAndDestroy(transactionPtr);

			); //failing to roll back one transaction shouldn't affect the overall rollback all procedure

		if(err!=KErrNone)

			{

			lastError=err; //remember last error and leave with that error code indicating an error in the overall procedure

			}

		DEBUG_PRINTF2(_L("CIntegrityServices::RollbackAllL() Rolled back transaction %X"), transactionIDs[i]);			

		}

	CleanupStack::PopAndDestroy(&transactionIDs);

	User::LeaveIfError(lastError);

	}