/*

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

* CJournalFile implementation

*

*/

/**

 @file 

 @released

 @internalTechnology

*/

#include "journalfile.h"

#include "usiflog.h"

_LIT(KBackupExt, "bak"); // extension for removed files in backup location

namespace Usif

{

CJournalFile* CJournalFile::NewL(RFs& aFs, RLoader& aLoader, const TDesC& aFileName, TInt aDrive)

	{

	CJournalFile* self = CJournalFile::NewLC(aFs, aLoader, aFileName, aDrive);

	CleanupStack::Pop(self);

	return self;

	}

CJournalFile* CJournalFile::NewLC(RFs& aFs, RLoader& aLoader, const TDesC& aFileName, TInt aDrive)

	{

	CJournalFile* self = new(ELeave) CJournalFile(aFs, aLoader, aDrive);

	CleanupStack::PushL(self);

	self->ConstructL(aFileName);

	return self;

	}

CJournalFile::CJournalFile(RFs& aFs, RLoader& aLoader, TInt aDrive) 

	: iFs(aFs), iLoader(aLoader), iLastEvent(ENone), iDrive(aDrive)

	{

	}

CJournalFile::~CJournalFile()

	{

	iWriteStream.Close();

	delete iTreeRoot;

	}

void CJournalFile::ConstructL(const TDesC& aFileName)

	{

	DEBUG_PRINTF2(_L("CJournalFile::ConstructL() - aFileName %S"), &aFileName);							

	iJournalFileName = aFileName;

	TChar drive;

	User::LeaveIfError(iFs.DriveToChar(iDrive, drive));

	TBuf<2> driveSpec;

	driveSpec.Append(drive);

	driveSpec.Append(KDriveDelimiter);

	iTreeRoot = CIntegrityTreeNode::NewL(driveSpec);

	// read any existing entries from this journal

	TRAPD(err, ReadL());

	if(err != KErrNone)

		{

		DEBUG_PRINTF2(_L("CJournalFile::ConstructL() - CJournalFile::ReadL() has left with error %d"), err);							

		// if necessary create the path

		if(err == KErrPathNotFound)

			{

			User::LeaveIfError(iFs.MkDirAll(iJournalFileName));

			}

		else if (err != KErrNotFound)

			{

			DEBUG_PRINTF2(_L("CJournalFile::ConstructL() - Leaving with error %d"), err);							

			User::Leave(err);

			}

		}

	// now prepare for writing

	PrepareToWriteL();

	}

void CJournalFile::ReadL()

	{

	RFileReadStream journalStream;

	User::LeaveIfError(journalStream.Open(iFs, iJournalFileName, EFileRead | EFileShareAny));

	CleanupClosePushL(journalStream);

	// we need to check that any filenames read from the journal are on the

	// same drive as the journal itself

	TDriveUnit journalDrive(iJournalFileName);

	TInt err = KErrNone;

	while(err == KErrNone)

		{

		// read the next journal entry

		TRAP(err, ReadEntryL(journalStream, journalDrive));

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

			{

			DEBUG_PRINTF2(_L("CJournalFile::ReadL() - CJournalFile::ReadEntryL() has left with error %d Leaving with this error!"), err);							

			User::Leave(err);

			}

		}

	CleanupStack::PopAndDestroy(&journalStream);

	}

void VerifyIsFileEventL(TIntegrityServicesEvent aEvent)

	{

	if (aEvent != ERemovedFile &&

		aEvent != ETempFile && aEvent != EAddedFile)

		{

		User::Leave(KErrCorrupt);

		}	

	}

void VerifyIsEmptyOrFileEventL(TIntegrityServicesEvent aEvent)

	{

	if (aEvent == ENone)

		return;

	VerifyIsFileEventL(aEvent);

	}

void CJournalFile::ReadEntryL(RFileReadStream& aJournalStream, TInt aDrive)

	{

	TIntegrityServicesEvent event = static_cast<TIntegrityServicesEvent> (aJournalStream.ReadInt32L());

	HBufC* removedFile = NULL;

	HBufC* backupFile = NULL;

	HBufC* tempFile = NULL;

	HBufC* addedFile = NULL;

	switch(event)

		{

		case ERemovedFile:

			{

			VerifyIsEmptyOrFileEventL(iLastEvent);

			removedFile = HBufC::NewLC(aJournalStream, KMaxFileName);

			// should be followed by the backup event

			if(aJournalStream.ReadInt32L() != EBackupFile)

				{

				User::Leave(KErrCorrupt);

				}

			backupFile = HBufC::NewLC(aJournalStream, KMaxFileName);

			// make sure files are located on the same drive as the journal

			if(CJournalFile::CheckFileNameL(iFs, *removedFile) != aDrive 

				|| CJournalFile::CheckFileNameL(iFs, *backupFile) != aDrive)

				{

				User::Leave(KErrCorrupt);

				}

			CIntegrityTreeLeaf* removeLeaf = iTreeRoot->AddNodeL(*removedFile, ERemovedFile, iJournalFileName);

			CIntegrityTreeLeaf* backupLeaf = iTreeRoot->AddNodeL(*backupFile, EBackupFile, iJournalFileName);

			removeLeaf->SetPeer(backupLeaf);

			backupLeaf->SetPeer(removeLeaf);

			CleanupStack::PopAndDestroy(backupFile);

			CleanupStack::PopAndDestroy(removedFile);

			iBackupFilesCount++;

			iLastEvent = ERemovedFile;

			}

			break;

		case EBackupFile:

			// cannot have a backup file on its own

			User::Leave(KErrCorrupt);

			break;

		case ETempFile:

			VerifyIsEmptyOrFileEventL(iLastEvent);

			tempFile = HBufC::NewLC(aJournalStream, KMaxFileName);

			// make the file is located on the same drive as the journal

			if(CJournalFile::CheckFileNameL(iFs, *tempFile) != aDrive)

				{

				User::Leave(KErrCorrupt);

				}

			iTreeRoot->AddNodeL(*tempFile, ETempFile, iJournalFileName);

			CleanupStack::PopAndDestroy(tempFile);

			iLastEvent = ETempFile;

			break;

		case EAddedFile:

			VerifyIsEmptyOrFileEventL(iLastEvent);

			addedFile = HBufC::NewLC(aJournalStream, KMaxFileName);

			// make the file is located on the same drive as the journal

			if(CJournalFile::CheckFileNameL(iFs, *addedFile) != aDrive)

				{

				User::Leave(KErrCorrupt);

				}

			iTreeRoot->AddNodeL(*addedFile, EAddedFile, iJournalFileName);

			CleanupStack::PopAndDestroy(addedFile);

			iLastEvent = EAddedFile;

			break;

		case ECommitted:

			VerifyIsFileEventL(iLastEvent);

			iLastEvent = ECommitted;

			break;

		case EBackupFilesRemoved:

			if(iLastEvent != ECommitted)

				{

				User::Leave(KErrCorrupt);

				}

			iLastEvent = EBackupFilesRemoved;

			break;

		case EAddedFilesRemoved:

			if(iLastEvent != ECommitted)

				VerifyIsFileEventL(iLastEvent); // The last event can be only a commit, or one of the file events

			iLastEvent = EAddedFilesRemoved;

			break;

		case ETempFilesRemoved:

			if(iLastEvent != EBackupFilesRemoved && iLastEvent != ERemovedFilesRestored)

				{

				User::Leave(KErrCorrupt);

				}

			iLastEvent = ETempFilesRemoved;

			break;

		case ERemovedFilesRestored:

			if(iLastEvent != EAddedFilesRemoved)

				{

				User::Leave(KErrCorrupt);

				}

			iLastEvent = ERemovedFilesRestored;

			break;

		default:

			User::Leave(KErrCorrupt);

			break;

   		}

	}

void CJournalFile::PrepareToWriteL()

	{

	DEBUG_PRINTF2(_L("CJournalFile::PrepareToWriteL() iJournalFileName %S"), &iJournalFileName);							

	RFile file;

	CleanupClosePushL(file);

	// try opening the journal if it already exists

	TEntry entry;

	TBool journalFileExists = (iFs.Entry(iJournalFileName, entry) == KErrNone);

	if (journalFileExists)

		{

		User::LeaveIfError(file.Open(iFs, iJournalFileName, EFileWrite | EFileShareAny));

		}

	else

		{

		// journal does not exist, try creating one

		User::LeaveIfError(file.Create(iFs, iJournalFileName, EFileWrite | EFileShareAny));

		}

	TInt fileSize;

	User::LeaveIfError(file.Size(fileSize));

	// attach to end of file for writing

	iWriteStream.Attach(file, fileSize);

	CleanupStack::Pop(&file); // file ownership transfered to stream

	}

void CJournalFile::EventL(TIntegrityServicesEvent aEvent, TBool aSerializeEventToJournal /* = ETrue*/ )

	{

	DEBUG_PRINTF2(_L("CJournalFile::EventL() - aEvent %d"), aEvent);							

	if (aSerializeEventToJournal)

		{

		iWriteStream.WriteInt32L(static_cast<TInt> (aEvent));

		iWriteStream.CommitL();

		}

	iLastEvent = aEvent;

	}

void CJournalFile::AddL(const TDesC& aFileName)

	{

	DEBUG_PRINTF2(_L("CJournalFile::AddL() - aFileName %S"), &aFileName);							

	iTreeRoot->AddNodeL(aFileName, EAddedFile, iJournalFileName);

	// write filename to journal

	iWriteStream.WriteInt32L(static_cast<TInt> (EAddedFile));

	iWriteStream << aFileName;

	iWriteStream.CommitL();

	iLastEvent = EAddedFile;

	}

void CJournalFile::RemoveL(const TDesC& aFileName, TDes& aBackupFileName)

	{

	DEBUG_PRINTF2(_L("CJournalFile::RemoveL() - aFileName %S"), &aFileName);							

	// Only journal removals if the file hasn't been added in the same

	// journalfile.

	TInt err = iTreeRoot->FindNode(aFileName, EAddedFile);

	if (err == KErrNotFound)

		{

		CIntegrityTreeLeaf* removalNode = iTreeRoot->AddNodeL(aFileName, ERemovedFile, iJournalFileName);

		// generate the next backup filename for this journal

		NextBackupFileNameL(aBackupFileName);

		CIntegrityTreeLeaf* backupNode = iTreeRoot->AddNodeL(aBackupFileName, EBackupFile, iJournalFileName);

		// set peers on both nodes

		removalNode->SetPeer(backupNode);

		backupNode->SetPeer(removalNode);

		// write filenames to journal

		iWriteStream.WriteInt32L(static_cast<TInt> (ERemovedFile));

		iWriteStream << aFileName;

		iWriteStream.WriteInt32L(static_cast<TInt> (EBackupFile));

		iWriteStream << aBackupFileName;

		iWriteStream.CommitL();

		iLastEvent = ERemovedFile;

		}

	else

		{

		User::LeaveIfError(err);

		}

	}

void CJournalFile::TemporaryL(const TDesC& aFileName)

	{

	DEBUG_PRINTF2(_L("CJournalFile::TemporaryL() - aFileName %S"), &aFileName);							

	iTreeRoot->AddNodeL(aFileName, ETempFile, iJournalFileName);

	// write filename to journal

	iWriteStream.WriteInt32L(static_cast<TInt> (ETempFile));

	iWriteStream << aFileName;

	iWriteStream.CommitL();

	iLastEvent = ETempFile;

	}

void CJournalFile::JournalOperationL(TTreeWalkFunctionL aFunc, TIntegrityServicesEvent aTypeFilter,

	CIntegrityServices::TFailType aFailType)

	{

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

	CleanupStack::PushL(fileman);

	iTreeRoot->WalkTreeL(aFunc, aTypeFilter, iFs, iLoader, *fileman, aFailType);

	CleanupStack::PopAndDestroy(fileman);

	}

void CJournalFile::NextBackupFileNameL(TDes& aBackupFileName)

	{

	TParsePtrC fileNamePtr(iJournalFileName);

	aBackupFileName = fileNamePtr.DriveAndPath();

	aBackupFileName.Append(fileNamePtr.Name());

	aBackupFileName.Append(KPathDelimiter);

	aBackupFileName.AppendNumUC(iBackupFilesCount, EHex);

	aBackupFileName.Append(KExtDelimiter);

	aBackupFileName.Append(KBackupExt);

	iBackupFilesCount++;

	}

TIntegrityServicesEvent CJournalFile::LastEvent() const

	{

	return iLastEvent;

	}

TInt CJournalFile::Drive()

	{

	return iDrive;

	}

void CJournalFile::Close()

	{

	iWriteStream.Close();

	}

/*static*/ TInt CJournalFile::CheckFileNameL(RFs&, const TDesC& aFileName)

	{

	TParse parse;

	User::LeaveIfError(parse.Set(aFileName, NULL, NULL));

	if (!parse.DrivePresent())

		User::Leave(KErrArgument);

	if (!parse.PathPresent())

		User::Leave(KErrArgument);	

	TDriveUnit drive(parse.Drive());

	return drive;

	}

}//End of namespace Usif