/*

* Copyright (c) 2004-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 "log.h"

#include "cleanuputils.h"

#include "operationfunctions.h"

#include <f32file.h>

using namespace Swi;

namespace Swi

{

/**

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

	}

} //namespace

EXPORT_C CIntegrityServices* CIntegrityServices::NewL(TInt64 aTransactionID, const TDesC& aPath)

	{

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

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CIntegrityServices* CIntegrityServices::NewLC(TInt64 aTransactionID, const TDesC& aPath)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aPath);

	return self;

	}

EXPORT_C CIntegrityServices::CIntegrityServices(TInt64 aTransactionID) : iTransactionID(aTransactionID)

	{

	}

EXPORT_C CIntegrityServices::~CIntegrityServices()

	{

	delete iJournal;

	iFs.Close();

	iLoader.Close();

	}

EXPORT_C void CIntegrityServices::ConstructL(const TDesC& aPath)

	{

	DEBUG_PRINTF2(_L8("Integrity Services - Opening session with  Session ID %Ld."), iTransactionID);

	// check that the supplied path is valid

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

	User::LeaveIfError(iFs.IsValidName(aPath));

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

	// store the journal path and create the journal

	TParsePtrC pathPtr(aPath);

	iJournalPath = pathPtr.Path();

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

	iSystemDrive = RFs::GetSystemDrive();

	}

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

	{

	// only implemented in derived test class

	}

/*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);

		}			

}

EXPORT_C void CIntegrityServices::AddL(const TDesC& aFileName)

	{

	DEBUG_PRINTF3(_L("Integrity Services - Session %Ld, Adding 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 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);

	iJournal->TemporaryL(backupTmpName);

	SimulatePowerFailureL(EFailAddingTempFile, EAfterJournal, backupTmpName);	

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

	CleanupStack::PushL(fileMan);

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

	DEBUG_PRINTF4(_L("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("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("CopyToBackupL: RLoader::Delete %S returned error %d"), &aSource, err);

	User::LeaveIfError(err);

	}

EXPORT_C void CIntegrityServices::RemoveL(const TDesC& aFileName)

	{

	DEBUG_PRINTF3(_L("Integrity Services - Session %Ld, Removing File: %S"), iTransactionID, &aFileName);

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

	TEntry entry;

	User::LeaveIfError(iFs.Entry(aFileName, entry));

	// 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);

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

			{

			User::Leave(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("Renamed %S as %S error %d"), &localFilename, &backupFileName, err);

			User::LeaveIfError(err);

			}				

		SimulatePowerFailureL(EFailRemovingFile, EAfterAction, aFileName);

		}

	else

		{

		DEBUG_PRINTF2(_L("%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

	}

EXPORT_C void CIntegrityServices::TemporaryL(const TDesC& aFileName)

	{

	DEBUG_PRINTF3(_L("Integrity Services - Session %Ld, Temporary File: %S."),

		iTransactionID, &aFileName);

	// record the temporary file or directory in the journal

	SimulatePowerFailureL(EFailAddingTempFile, EBeforeJournal, aFileName);

	iJournal->TemporaryL(aFileName);

	SimulatePowerFailureL(EFailAddingTempFile, EAfterJournal, aFileName);

	}

EXPORT_C void CIntegrityServices::CommitL()

	{

	DEBUG_PRINTF2(_L8("Integrity Services - Commiting Session %Ld."), iTransactionID);

	iJournal->SynchL();

	iJournal->StartCommitL();

	SimulatePowerFailureL(EFailInstallComplete, EBeforeJournal, KNullDesC);

	iJournal->WriteJournalEventL(EInstallComplete);

	SimulatePowerFailureL(EFailInstallComplete, EAfterJournal, KNullDesC);

	DeleteFilesL(*iJournal, EBackupFile);

	SimulatePowerFailureL(EFailBackupFilesRemoved, EBeforeJournal, KNullDesC);

	iJournal->WriteJournalEventL(EBackupFilesRemoved);

	SimulatePowerFailureL(EFailBackupFilesRemoved, EAfterJournal, KNullDesC);

	DeleteFilesL(*iJournal, ETempFile);

	SimulatePowerFailureL(EFailTempFilesRemoved, EBeforeJournal, KNullDesC);

	iJournal->WriteJournalEventL(ETempFilesRemoved);

	SimulatePowerFailureL(EFailTempFilesRemoved, EAfterJournal, KNullDesC);

	iJournal->FinishCommitL();

	}

EXPORT_C void CIntegrityServices::RollBackL(TBool aAllTransactions)

	{

	DEBUG_PRINTF2(_L8("Integrity Services - Rolling Back Session %Ld."), iTransactionID);

	if (aAllTransactions)

		{

		// search for and rollback any transaction drive list

		TDriveUnit systemDrive(iSystemDrive);

		RBuf fileSpec;

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

		CleanupClosePushL(fileSpec);

		fileSpec.Append(iJournalPath);

		fileSpec.Append(KMatchAny);

		fileSpec.Append(KExtDelimiter);

		fileSpec.Append(KDriveExt);

		RDir dir;

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

		if (err == KErrNone)

			{

			CEntryArray* entryArrayContainer = new (ELeave) CEntryArray;

			CleanupStack::PushL(entryArrayContainer);

			TEntryArray& entryArray = (*entryArrayContainer)();

			err = dir.Read(entryArray);

			dir.Close();

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

				{

				User::Leave(err);

				}

			TInt entryCount = entryArray.Count();

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

				{

				// check that the entry is not a directory

				if(!entryArray[index].IsDir())

					{

					TLex lex(entryArray[index].iName);

					TInt64 transactionID;

					if(lex.Val(transactionID, EHex) == KErrNone)

						{

						CJournal* journal = NULL;

						TRAP(err, journal = CJournal::NewL(iFs, iLoader, transactionID, iJournalPath));

						if(err == KErrNone)

							{

							CleanupStack::PushL(journal);

							// start the recovery, do not let corrupt journals prevent

							// recovery of other journals

							iStartedJournalRollback = ETrue;

							TRAP(err, RollBackJournalL(*journal));

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

								{

								// unexpected error

								User::Leave(err);

								}

							CleanupStack::PopAndDestroy(journal);

							}

						}

					}

				}

			CleanupStack::PopAndDestroy(entryArrayContainer);

			}

		else if(err != KErrPathNotFound && err != KErrNotFound && err != KErrNotReady)

			{

			// unexpected error

			User::Leave(err);

			}

		CleanupStack::PopAndDestroy(&fileSpec);

		}

	else

		{

		// rollback only this transaction

		TRAPD(err, RollBackJournalL(*iJournal));

		if(err != KErrNone && err != KErrPathNotFound && err != KErrNotFound

				&& err != KErrNotReady)

			{

			// unexpected error

			User::Leave(err);

			}

		}

	}

void CIntegrityServices::RollBackJournalL(CJournal& aJournal)

	{

	aJournal.SynchL();

#ifdef __WINSCW__

	// For 2 minutes after initial boot, DLLs are not unloaded. If we are doing a

	// rollback, we need to make sure any pending unloadeds are actioned, otherwise a

	// previously loaded DLL could cause the rollback to fail on windows (on arm it is legal to

	// delete a loaded DLL/EXE, whilst on windows it is not).

	RLoader loader;

	TInt r = loader.Connect();

	if(r == KErrNone)

		{

		(void)loader.CancelLazyDllUnload();

		loader.Close();

		}

#endif

	for(TInt index = 0; index < aJournal.Drives().Count(); index++)

		{

		// check to see if this drive has already been completed

		if(aJournal.CompletedDrives().Find(aJournal.Drives()[index]) != KErrNotFound)

			{

			continue;

			}

		// only attempt to recover writeable drives that are present

		TDriveInfo info;

		User::LeaveIfError(iFs.Drive(info, aJournal.Drives()[index]));

		if (!(info.iMediaAtt & KMediaAttWriteProtected) && info.iType!=EMediaNotPresent)

			{

			TRAPD(err, RollBackDriveL(aJournal, aJournal.Drives()[index]));

			if(err != KErrNone && err != KErrPathNotFound && err != KErrNotFound

				&& err != KErrNotReady)

				{

				// unexpected error

				User::Leave(err);

				}

			}

		}

	}

void CIntegrityServices::RollBackDriveL(CJournal& aJournal, TInt aDrive)

	{

	aJournal.StartRollbackL(aDrive);

	DEBUG_PRINTF3(_L8("Integrity Services - Rolling Back drive %d, last event %d."), aDrive, aJournal.LastEvent());

	switch (aJournal.LastEvent())

		{

		// Transaction did not complete, rollback required

		case ERemovedFile:

		case EBackupFile:

		case ETempFile:

		case EAddedFile:

		case EAddedFilesRemoved:

		case ERemovedFilesRestored:

			// rollback this individual journal from where it last got to.

			switch (aJournal.LastEventL(aDrive))

				{

			case ERemovedFile:

			case EBackupFile:

			case ETempFile:

			case EAddedFile:

				DeleteFilesL(aJournal, EAddedFile, aDrive);

				SimulatePowerFailureL(EFailNewFilesRemoved, EBeforeJournal, KNullDesC);

				aJournal.WriteJournalEventL(EAddedFilesRemoved, aDrive);

				SimulatePowerFailureL(EFailNewFilesRemoved, EAfterJournal, KNullDesC);

				RestoreFilesL(aJournal, aDrive);

				SimulatePowerFailureL(EFailOldFilesRestored, EBeforeJournal, KNullDesC);

				aJournal.WriteJournalEventL(ERemovedFilesRestored, aDrive);

				SimulatePowerFailureL(EFailOldFilesRestored, EAfterJournal, KNullDesC);

				DeleteFilesL(aJournal, ETempFile, aDrive);

				SimulatePowerFailureL(EFailTempFilesRemoved, EBeforeJournal, KNullDesC);

				aJournal.WriteJournalEventL(ETempFilesRemoved, aDrive);

				SimulatePowerFailureL(EFailTempFilesRemoved, EAfterJournal, KNullDesC);

				break;

			// Transaction did not complete, rollback did not complete, resume rollback

			case EAddedFilesRemoved:

				RestoreFilesL(aJournal, aDrive);

				SimulatePowerFailureL(EFailOldFilesRestored, EBeforeJournal, KNullDesC);

				aJournal.WriteJournalEventL(ERemovedFilesRestored, aDrive);

				SimulatePowerFailureL(EFailOldFilesRestored, EAfterJournal, KNullDesC);

				DeleteFilesL(aJournal, ETempFile, aDrive);

				SimulatePowerFailureL(EFailTempFilesRemoved, EBeforeJournal, KNullDesC);

				aJournal.WriteJournalEventL(ETempFilesRemoved, aDrive);

				SimulatePowerFailureL(EFailTempFilesRemoved, EAfterJournal, KNullDesC);

				break;

			case ERemovedFilesRestored:

				DeleteFilesL(aJournal, ETempFile, aDrive);

				SimulatePowerFailureL(EFailTempFilesRemoved, EBeforeJournal, KNullDesC);

				aJournal.WriteJournalEventL(ETempFilesRemoved, aDrive);

				SimulatePowerFailureL(EFailTempFilesRemoved, EAfterJournal, KNullDesC);

				break;

			case ETempFilesRemoved:

				break;

			// nothing was done, just delete the journal file

			case ENone:

				break;

			// Erk! Bad state, bad state!

			default:

				User::Leave(KErrCorrupt);

				break;

				}

			break;

		// Transaction complete, just need to remove the backup

		case EInstallComplete:

		case EBackupFilesRemoved:

			switch (aJournal.LastEventL(aDrive))

				{

			// At least one journal had a complete transaction...

			// roll forwards all journal files.

			case ERemovedFile:

			case EBackupFile:

			case ETempFile:

			case EAddedFile:

			case EInstallComplete:

				DeleteFilesL(aJournal, EBackupFile, aDrive);

				SimulatePowerFailureL(EFailBackupFilesRemoved, EBeforeJournal, KNullDesC);

				aJournal.WriteJournalEventL(EBackupFilesRemoved, aDrive);

				SimulatePowerFailureL(EFailBackupFilesRemoved, EAfterJournal, KNullDesC);

				DeleteFilesL(aJournal, ETempFile, aDrive);

				SimulatePowerFailureL(EFailTempFilesRemoved, EBeforeJournal, KNullDesC);

				aJournal.WriteJournalEventL(ETempFilesRemoved, aDrive);

				SimulatePowerFailureL(EFailTempFilesRemoved, EAfterJournal, KNullDesC);

				break;

			case EBackupFilesRemoved:

		 		DeleteFilesL(aJournal, ETempFile, aDrive);

				SimulatePowerFailureL(EFailTempFilesRemoved, EBeforeJournal, KNullDesC);

				aJournal.WriteJournalEventL(ETempFilesRemoved, aDrive);

				SimulatePowerFailureL(EFailTempFilesRemoved, EAfterJournal, KNullDesC);