/*
* 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: 
* CJournalFile implementation
*
*/


/**
 @file 
 @released
 @internalTechnology
*/

#include "journalfile.h"

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

using namespace Swi;

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)
	{
	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)
		{
		// if necessary create the path
		if(err == KErrPathNotFound)
			{
			err = iFs.MkDirAll(iJournalFileName);
			if(err != KErrNone && err != KErrAlreadyExists)
				{
				User::Leave(err);
				}
			}
		else if (err != KErrNotFound)
			{
			User::Leave(err);
			}
		}
	// now prepare for writing
	PrepareToWriteL();
	}

void CJournalFile::ReadL()
	{
	RFileReadStream journalStream;
	User::LeaveIfError(journalStream.Open(iFs, iJournalFileName, EFileWrite | 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)
			{
			User::Leave(err);
			}
		}
	CleanupStack::PopAndDestroy(&journalStream);
	}

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:
			{
			if(iLastEvent != ENone && iLastEvent != ERemovedFile &&
				iLastEvent != ETempFile && iLastEvent != EAddedFile)
				{
				User::Leave(KErrCorrupt);
				}

			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:
			if(iLastEvent != ENone && iLastEvent != ERemovedFile &&
				iLastEvent != ETempFile && iLastEvent != EAddedFile)
				{
				User::Leave(KErrCorrupt);
				}
			
			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:
			if(iLastEvent != ENone && iLastEvent != ERemovedFile &&
				iLastEvent != ETempFile && iLastEvent != EAddedFile)
				{
				User::Leave(KErrCorrupt);
				}
			
			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 EInstallComplete:
			if(iLastEvent != ERemovedFile && iLastEvent != ETempFile &&
				iLastEvent != EAddedFile)
				{
				User::Leave(KErrCorrupt);
				}
				
			iLastEvent = EInstallComplete;
			break;
			
		case EBackupFilesRemoved:
			if(iLastEvent != EInstallComplete)
				{
				User::Leave(KErrCorrupt);
				}
			iLastEvent = EBackupFilesRemoved;
			break;
			
		case EAddedFilesRemoved:
			if(iLastEvent != EInstallComplete && iLastEvent != ERemovedFile &&
				iLastEvent != ETempFile && iLastEvent != EAddedFile)
				{
				User::Leave(KErrCorrupt);
				}
			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()
	{
	RFile file;
	CleanupClosePushL(file);
	// try opening the journal if it already exists
	TInt err = file.Open(iFs, iJournalFileName, EFileWrite | EFileShareAny);
	if (err != KErrNone)
		{
		if (err == KErrNotFound)
			{
			// journal does not exist, try creating one
			User::LeaveIfError(file.Create(iFs, iJournalFileName, EFileWrite | EFileShareAny));
			}
		else
			{
			User::Leave(err);
			}
		}
	
	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
	
	// record the last known size.
	iLastSize = fileSize;
	}

void CJournalFile::EventL(TIntegrityServicesEvent aEvent)
	{
	iWriteStream.WriteInt32L(static_cast<TInt> (aEvent));
	iWriteStream.CommitL();
	
	iLastEvent = aEvent;
	iLastSize = iWriteStream.Sink()->SizeL();
	}

void CJournalFile::AddL(const TDesC& aFileName)
	{
	iTreeRoot->AddNodeL(aFileName, EAddedFile, iJournalFileName);

	// write filename to journal
	iWriteStream.WriteInt32L(static_cast<TInt> (EAddedFile));
	iWriteStream << aFileName;
	iWriteStream.CommitL();
	
	iLastEvent = EAddedFile;
	iLastSize = iWriteStream.Sink()->SizeL();
	}

void CJournalFile::RemoveL(const TDesC& aFileName, TDes& aBackupFileName)
	{
	// 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;
		iLastSize = iWriteStream.Sink()->SizeL();
		}
	else
		{
		User::LeaveIfError(err);
		}
	}
	
void CJournalFile::TemporaryL(const TDesC& aFileName)
	{
	iTreeRoot->AddNodeL(aFileName, ETempFile, iJournalFileName);
	
	// write filename to journal
	iWriteStream.WriteInt32L(static_cast<TInt> (ETempFile));
	iWriteStream << aFileName;
	iWriteStream.CommitL();
	
	iLastEvent = ETempFile;
	iLastSize = iWriteStream.Sink()->SizeL();
	}
	
void CJournalFile::SynchL()
	{
	// check if the journal is in synch with the underlying media
	iWriteStream.Sink()->SynchL();
	TInt size = iWriteStream.Sink()->SizeL();
	if (size != iLastSize)
		{
		// it isn't in synch! read from the underlying media.
		delete iTreeRoot;
		iTreeRoot = NULL;
		iWriteStream.Close();
		iBackupFilesCount = 0;
		
		TChar drive;
		User::LeaveIfError(iFs.DriveToChar(iDrive, drive));
		
		TBuf<2> driveSpec;
		driveSpec.Append(drive);
		driveSpec.Append(KDriveDelimiter);
		iTreeRoot = CIntegrityTreeNode::NewL(driveSpec);
		
		ReadL();
		PrepareToWriteL();
		}
	}	
	
void CJournalFile::JournalOperationL(TTreeWalkFunctionL aFunc, TIntegrityServicesEvent aTypeFilter,
	CIntegrityServices& aIntegrityServices, CIntegrityServices::TFailType aFailType)
	{
	CFileMan* fileman = CFileMan::NewL(iFs);
	CleanupStack::PushL(fileman);
	iTreeRoot->WalkTreeL(aFunc, aTypeFilter, iFs, iLoader, *fileman, aIntegrityServices, 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;
	// We allow wildcards because this is also used to generate the
	// uninstall log which may contain FN entries using wildcards.
	User::LeaveIfError(parse.Set(aFileName, NULL, NULL));
	User::LeaveIfError(parse.DrivePresent());
	User::LeaveIfError(parse.PathPresent());
	
	TDriveUnit drive(parse.Drive());
	return drive;
	}