// 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 "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 <e32def.h>

#include <e32property.h>

#include <s32file.h>

#include <connect/sbdefs.h>

#include "srvres.h"

#include "cachemgr.h"

#include "srvparams.h"

#include "shrepos.h"

#include "sessnotf.h"

#include "backup.h"

#define UNUSED_VAR(a) a = a

_LIT (KBackupFileName, "BACKUP") ;

_LIT (KRestoreFileName, "RESTORE") ;

_LIT(KBackupFileExt, ".bak");

_LIT(KRestoreFileExt, ".rst");

TRepositoryBackupState CRepositoryBackupClient::iBackupStatus ;

//

// Backup stream index class - Used to hold association between a UID (in

// our case the UID of a repository) and a stream ID - Can't use CStreamDictionary

// because that only lets you retrieve stream IDs by a (previously known) UID rather

// than iterate through its contentsretrieving UID/StreamID pairs...

// 

//

// CRepositoryBackupStreamIndex::AddL

//

// Add a new repository UID and stream ID pair to the index

void CRepositoryBackupStreamIndex::AddL(TUid aUid, TStreamId aSettingStreamId, TStreamId aDeletedSettingsStreamId, TStreamId aInstalledSettingsStreamId) 

	{

	TRepositoryBackupStreamIndexElement newIndexElement;

	newIndexElement.Set(aUid,aSettingStreamId, aDeletedSettingsStreamId, aInstalledSettingsStreamId) ;

	iStreamIndex.AppendL(newIndexElement);

	}

// 

// CRepositoryBackupStreamIndex::GetNext

//

// Iterate through the index retrieving the next Reposirory UID and Stream ID

// pair.

//

TInt CRepositoryBackupStreamIndex::GetNext(TUid& aUid, TStreamId& aSettingsStreamId, TStreamId& aDeletedSettingsStreamId, TStreamId& aInstalledSettingsStreamId)

	{

	TInt error = KErrNone ;

	if (iIndex < iStreamIndex.Count())

		{

		iStreamIndex[iIndex++].Get(aUid, aSettingsStreamId, aDeletedSettingsStreamId, aInstalledSettingsStreamId) ;

		}

	else

		{

		error = KErrNotFound ;

		}

	return error ;

	}

//

// Backup client class.

//

// Has Active object functionality to monitor the state of the publish and subscribe 

// flags associated with backup and restore and also implements MActiveBackupDataClient

// to perform active backup according to the "proxy data holder" model.

//

//

// Usual 2 phase construction factory NewL NewLC classes

//	

CRepositoryBackupClient* CRepositoryBackupClient::NewLC(RFs& aFs) 

	{

	CRepositoryBackupClient* me = new(ELeave)CRepositoryBackupClient(aFs);

	CleanupStack::PushL(me) ;

	me->ConstructL() ;

	return me ;

	}

CRepositoryBackupClient* CRepositoryBackupClient::NewL(RFs& aFs) 

	{

	CRepositoryBackupClient* me = CRepositoryBackupClient::NewLC(aFs) ;

	CleanupStack::Pop(me) ;

	return me ;

	}

// 

// Constructor - doesn't really do anything!

//

CRepositoryBackupClient::CRepositoryBackupClient(RFs& aFs) : CActive(EPriorityStandard), iFs(aFs), iRomScanDone(EFalse)

	{

	}

// 

// Phase 2 constructor

//	

void CRepositoryBackupClient::ConstructL()

	{

	// Create repository object

	iRepository = new(ELeave) CServerRepository;

	// Notifier needed to open repositories.		

	iNotifier = new(ELeave)CSessionNotifier ;

	// Attach to Backup/Restore Pub/Sub property.	

	User::LeaveIfError(iBackupRestoreProperty.Attach(KUidSystemCategory, KUidBackupRestoreKey)) ;

	// Add ourself to the active scheduler

	CActiveScheduler::Add(this) ;

	// Initialise backup/restore status

	iBackupStatus = ENoBackupActivty ;

	// Set active and request notification of changes to backup/restore

	// Pub/Sub property.

	StartL() ;

	}

//

// Destructor

//

CRepositoryBackupClient::~CRepositoryBackupClient()

	{

	Cancel();

	iBackupRestoreProperty.Close() ;

	if (iRepository)

		{

		iRepository->Close();

		delete(iRepository);

		}

	if (iNotifier)

		delete(iNotifier) ;

	if (iActiveBackupClient)

		delete(iActiveBackupClient) ;	

	iRestoredRepositoriesArray.ResetAndDestroy();

	iRestoredRepositoriesArray.Close();

	iFile.Close();

	}

// 

// DoCancel - mandatory for active objects.

//	

void CRepositoryBackupClient::DoCancel()

	{

	iBackupRestoreProperty.Cancel() ;

	}

//

// RunError

//

TInt CRepositoryBackupClient::RunError(TInt aError)

	{

	iRestoredRepositoriesArray.ResetAndDestroy();

	UNUSED_VAR(aError);

	return KErrNone;

	}

//

// Test BUR Pub/Sub property set status, and notify BUR that we're

// ready to go as appropriate. 

//

void CRepositoryBackupClient::TestBURstatusL(void)

	{

	TInt BURstatus ;

	TRepositoryBackupState lastBackupStatus = ENoBackupActivty;

	if (iBackupRestoreProperty.Get(BURstatus) != KErrNotFound)

		{

		BURstatus &= KBURPartTypeMask ;

		switch (BURstatus)

			{

			case EBURUnset:	// State not yet set. Treat as no backup/restore in progress.

			case EBURNormal:

				// No backup or restore in progress. Probably

				// means we've just completed an operation?

				lastBackupStatus = iBackupStatus;

				iBackupStatus = ENoBackupActivty ;

				// Back to normal, so enable cache

				TServerResources::iCacheManager->EnableCache();				

				// delete the CActiveBackupClient

				if (iActiveBackupClient)

					{

					delete iActiveBackupClient ;

					iActiveBackupClient = NULL ;

					}

				// Notify the changed keys if a restoration was just completed

				if((lastBackupStatus == ERestoreInProgress)) 

			    	{

				    for(TInt i = 0; i < iRestoredRepositoriesArray.Count(); i++)

				    	{

						iRepository->OpenL(iRestoredRepositoriesArray[i]->Uid(), *iNotifier, EFalse);

						iRepository->RestoreNotify(*iRestoredRepositoriesArray[i]);

						iRepository->Close();

						}

					iRestoredRepositoriesArray.ResetAndDestroy();

					}

				break ;

			case EBURBackupFull :

			case EBURBackupPartial :

				// We don't distinguish between full and partial backups

				// as the Backup engine will give us UIDs for all the

				// repository data owners that want their stuff backed up

				// anyway.

				// We don't want cache activity during backup

				TServerResources::iCacheManager->DisableCache();

				// Any (and all!) repositories which have been opened in the

				// course of system boot and normal operation will have been

				// added to TServerResources::iOwnerIdLookUpTable as they were

				// opened but there may well be repositories which need backing

				// up and haven't yet been opened so we need to make sure that

				// the lookup table is complete.

				CompleteOwnerIdLookupTableL();

				// Register with BUR engine

				if (!iActiveBackupClient)

					{

					iActiveBackupClient = CActiveBackupClient::NewL(this) ;

					}	

				iActiveBackupClient->ConfirmReadyForBURL(KErrNone);

				iBackupStatus = EBackupInProgress ;

				break ;

			case EBURRestoreFull :

			case EBURRestorePartial :

				// We don't distinguish between full and partial restore

				// either!

				// We don't want cache activity during restore either!

				TServerResources::iCacheManager->DisableCache();

				// Register with BUR engine

				if (!iActiveBackupClient)

					{

					iActiveBackupClient = CActiveBackupClient::NewL(this) ;

					}

				iActiveBackupClient->ConfirmReadyForBURL(KErrNone);

				iBackupStatus = ERestoreInProgress ;

				break ;

			}

		}

	}

//

// Request notification of changes in BUR Pub/Sub status

//

void CRepositoryBackupClient::StartL()

	{

	if (!IsActive())

		{

		TestBURstatusL();	

		NotifyChange();

		}

	}

//

// Request notification of changes in BUR Pub/Sub status

//

void CRepositoryBackupClient::NotifyChange()

	{

	// Watch for changes in the property state. 

	iBackupRestoreProperty.Subscribe(iStatus) ;

	SetActive();

	}

//

// Handle changes of backup state through publish/subscribe

//

void CRepositoryBackupClient::RunL()

	{	

	NotifyChange() ;

	TestBURstatusL();

	}

//

// We can't estimate data size without A) having the SID of the data owner who's data

// is to be backed up and B) going through the whole process of preparing the backup.

//

// The only sensible thing we can do is return an arbitrary value!

//

TUint CRepositoryBackupClient::GetExpectedDataSize(TDriveNumber /* aDrive */)

	{

	return KArbitraryNumber ;

	}	

//

// Called by BUR engine to request a chunk of backup data.

//	

void CRepositoryBackupClient::GetBackupDataSectionL(TPtr8& aBuffer, TBool& aFinished)

	{

	const TInt chunkSize = aBuffer.MaxSize() ;

	aFinished = EFalse ;

	// Pass a chunk of our prepared backup data in aBuffer

	User::LeaveIfError(iFile.Read(aBuffer, chunkSize)) ;

	TInt bytesRead = aBuffer.Length() ;

	// Check to see if this was the last chunk of data.

	if (bytesRead < chunkSize)

		{

		// Set "finished" flag so that BUR knows we're through...

		aFinished = ETrue ;

		// ...and then tidy up by closing and deleting the backup file.

		iFile.Close() ;

		TParse backupFilePath ;

		User::LeaveIfError(backupFilePath.Set(KBackupFileName, TServerResources::iBURDirectory, &KBackupFileExt));

		TInt fileDeleteErr=iFs.Delete(backupFilePath.FullName()) ;

		#ifdef _DEBUG

			if (fileDeleteErr != KErrNone)

			{

				RDebug::Print(_L("CRepositoryBackupClient::GetBackupDataSectionL - Failed to delete file. Error = %d"), fileDeleteErr);

			}

		#else

			UNUSED_VAR(fileDeleteErr);

		#endif

		}

	}

//

// CRepositoryBackupClient::RestoreComplete

//

// Called when a Complete set of backup data has been received and written

// to a file. We now need to open the file as a stream store, get the

// index (list of repository UID and corresponding stream ID pairs, and then

// reconstruct and save each repository in turn.

// 

void CRepositoryBackupClient::RestoreComplete(TDriveNumber /* aDrive */)

	{

	}

//

// CRepositoryBackupClient::RestoreCompleteL

//

// Does the actual work of reconstructing repositories from backup data

//

//

void CRepositoryBackupClient::RestoreCompleteL()

	{

	// All restore data recived so we can now recreate the repositories from the

	// backup store

	// Attempt to open the restore file as a CDirectFileStore

	TParse restoreFilePath ;

	User::LeaveIfError(restoreFilePath.Set(KRestoreFileName, TServerResources::iBURDirectory, &KRestoreFileExt));

	CDirectFileStore* store = CDirectFileStore::OpenLC (iFs,restoreFilePath.FullName(), EFileRead|EFileShareReadersOnly);

	if (store->Type()[0] != KDirectFileStoreLayoutUid)

		{

		// store wasn't quite what we were expecting - can't return an error, can't leave

		// so all we can do is close the file, tidy up as best we can, and bail out!!!! 

		CleanupStack::PopAndDestroy(store);

		// If a debug build - record error

		TInt fileDeleteErr=iFs.Delete(restoreFilePath.FullName()) ;

		#ifdef _DEBUG

			if (fileDeleteErr != KErrNone)

			{

				RDebug::Print(_L("CRepositoryBackupClient::RestoreCompleteL - Failed to delete file. Error = %d"), fileDeleteErr);

			}

		#else

			UNUSED_VAR(fileDeleteErr);

		#endif

		User::Leave(KErrCorrupt);

		}		

	// Get the root stream and attempt to read a backup file header from it

	TStreamId rootStreamId = store->Root() ;

	RStoreReadStream rootStream ;

	RStoreReadStream indexStream ;

	rootStream.OpenLC(*store, rootStreamId);

	TRepositoryBackupStreamHeader header ;

	TRAPD(err, header.InternalizeL(rootStream)) ;

	// Check for a valid header by checking that the UID matches the UID

	// of Central Repository and that the version number is sane.

	if (err == KErrNotSupported)

	    {

   		// Not a valid header - assume it's an old style backup stream,

		// set extensions supported to none, set index stream to be

		// root stream and reset read pointer to beginning.

		iBackupExtensionsSupported = ENoBackupExtensions ;

		CleanupStack::PopAndDestroy(&rootStream) ;

		CleanupStack::PopAndDestroy(store) ;

		// Try re-opening as old-style backup stream with index

		// as root stream.		

		CDirectFileStore* store = CDirectFileStore::OpenLC (iFs,restoreFilePath.FullName(), EFileRead|EFileShareReadersOnly);

		indexStream.OpenLC(*store, rootStreamId) ;

	    }

	else

		{

	    // Got a valid header. Check for extensions supported by this

	    // stream and get stream to read index from

	    CleanupStack::PopAndDestroy(&rootStream) ;

	    iBackupExtensionsSupported = header.getBackupExtensionsSupported();	

	    TStreamId indexStreamId = header.getIndexStreamId() ;

	    indexStream.OpenLC (*store, indexStreamId) ; 		

		}

	CRepositoryBackupStreamIndex *restoreStreamIndex = CRepositoryBackupStreamIndex::NewLC();	

	restoreStreamIndex->InternalizeL(indexStream, iBackupExtensionsSupported);

	// Iterate through index and attempt restore of each repository stream

	// we find in it.

	restoreStreamIndex->Reset() ;	

	TUid repositoryUid ;

	TStreamId settingsStreamId(KNullStreamIdValue);

	TStreamId deletedSettingsStreamId(KNullStreamIdValue);

	TStreamId installedSettingsStreamId(KNullStreamIdValue);

	while (restoreStreamIndex->GetNext(repositoryUid, settingsStreamId, deletedSettingsStreamId, installedSettingsStreamId) == KErrNone)

		{

		iRepository->OpenL(repositoryUid, *iNotifier, EFalse);

		iRepository->FailAllTransactions();

		// Add the restored repository to the restored repositories list.

		// Pass its changed-keys list to further restoring functions to add entries for post-restoration notification.

		TInt repIndex = AddRestoredRepositoryL(repositoryUid);

		iRepository->RestoreRepositoryContentsL(*store, settingsStreamId, deletedSettingsStreamId, *iRestoredRepositoriesArray[repIndex]);

		iRepository->CommitChangesL();

		iRepository->Close();

		// If the backup contains an installed repository containing default values for the settings, read them in

		if (installedSettingsStreamId != KNullStreamId)

			{

			// create an empty repository in install directory, and restore the data from backup file

			iRepository->RestoreInstallRepositoryL(repositoryUid, *store, installedSettingsStreamId, *iRestoredRepositoriesArray[repIndex]);

			// remove the .ini install file (if exists) because it will clash with the restored file

			TServerResources::DeleteCentrepFileL(repositoryUid, EInstall, EIni);

			}

		}

	CleanupStack::PopAndDestroy(restoreStreamIndex) ;

	CleanupStack::PopAndDestroy(&indexStream);

	CleanupStack::PopAndDestroy(store);

	// If a debug build - record error

	TInt fileDeleteErr=iFs.Delete(restoreFilePath.FullName());

	#ifdef _DEBUG

		if (fileDeleteErr != KErrNone)

		{

			RDebug::Print(_L("CRepositoryBackupClient::RestoreCompleteL (2nd) - Failed to delete file. Error = %d"), fileDeleteErr);

		}

	#else

		UNUSED_VAR(fileDeleteErr);

	#endif

	}

//

// CRepositoryBackupClient::CompleteOwnerIdLookupTableL

//

// Open each repository in TServerResources::iDataDirectory.

// Save the Rep UID and Owner Id of the rep to be used by

// InitialiseGetProxyBackupDataL.

void CRepositoryBackupClient::CompleteOwnerIdLookupTableL()

	{

	// Read contents of persist, install, and ROM directories and

	// use them to build a list of repository candidates.

	RArray <TUint32> repositoryList ;

	CleanupClosePushL(repositoryList) ;

	for (TBackupDirectoryScan scanDir = EScanRom; scanDir <= EScanPersist; scanDir = (TBackupDirectoryScan)(scanDir+1))

		{

		TPtrC directoryName ;

		switch (scanDir)

			{

				case EScanRom :

					if (TServerResources::iRomDirectory)