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

	{

	}

void CRepositoryBackupClient::RestoreRepositoryAndListL(TUid repositoryUid, CDirectFileStore* store, TStreamId settingsStreamId, TStreamId deletedSettingsStreamId, TInt& repIndex)

    {

    // 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.

    repIndex = AddRestoredRepositoryL(repositoryUid);

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

    iRepository->CommitChangesL();

    }

//

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

		TInt repIndex;

		TRAPD(err, RestoreRepositoryAndListL(repositoryUid, store, settingsStreamId, deletedSettingsStreamId, repIndex));

		iRepository->Close();

	    User::LeaveIfError(err);

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

						{

						directoryName.Set(TServerResources::iRomDirectory->Des()) ;						

						}

					else

						{

						// if ROM directory doesn't exist or there are no files, skip scanning

						continue;

						}

					break ;

				case EScanInstall :

					directoryName.Set(TServerResources::iInstallDirectory->Des()) ;

					break ;

				case EScanPersist :

					directoryName.Set(TServerResources::iDataDirectory->Des()) ;

					break ;				

			}

		RDir dir;

	    CleanupClosePushL(dir);

		User::LeaveIfError(dir.Open(iFs, directoryName, KEntryAttNormal));

	    TEntryArray dirEntries;

	    TInt readError = KErrNone;

		while (readError != KErrEof)  

			{

		    readError = dir.Read(dirEntries);

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

		    	{

		    	User::Leave(readError);

		    	}

		    else

		    	{

		    	const TInt dirCount = dirEntries.Count();   

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

		    		{

		    		// Attempt to extract a repository UID from directory entry

		    		TUid uid;

					TInt insertionError;

		    		if (KErrNone == TServerResources::GetUid(const_cast<TEntry&>(dirEntries[i]), uid))

		    			{

		    			insertionError=repositoryList.InsertInUnsignedKeyOrder(uid.iUid) ;

						// Should leave in all cases other than KErrNone or KErrAlreadyExists						

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

							{

							User::Leave(insertionError);

							}						

		    			}

		    		}

		    	}

			}

		CleanupStack::PopAndDestroy(&dir);

		}

	// Open all repositories in turn. Save repository UID and owner ID

	// in lookup table.

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

		{

		// Look to see if this repository already has an entry in the owner ID lookup table

		if ( TServerResources::FindOwnerIdLookupMapping(repositoryList[i]) == KErrNotFound)

			{

			// Need to TRAP here as otherwise if ANY repository fails to open

			// (e.g. due to corruption) it would cause the entire backup to

			// fail

			TRAPD(err, iRepository->OpenL(TUid::Uid(repositoryList[i]), *iNotifier));

			if (err == KErrNoMemory)

				{

				User::Leave(err) ;

				}

			else if (err == KErrNone)

				{

				// The act of opening a repository will cause it to add itself to the

				// Repository/Owner UID mapping table so we don't need to do anything

				// and can close it immediately!

				iRepository->Close();

				}

			}

		}

	CleanupStack::PopAndDestroy() ; // repositoryList	

	}

// CRepositoryBackupClient::InitialiseGetProxyBackupDataL

//

// Prepare data to be backed up. We get the Sid/Uid of the entity whos data

// is to be backed up. What we do is to open each repository in turn (identified

// by directory listing), check its owner, and if it matches the Sid/Uid we've

// been given by secure backup externalise it to a stream within a file store.

//

void CRepositoryBackupClient::InitialiseGetProxyBackupDataL(TSecureId aSID, TDriveNumber /* aDrive */) 

	{

	// Prepare data for backup.

	// Create file store

	TParse backupFilePath ;

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

	CDirectFileStore* store = CDirectFileStore::ReplaceLC(iFs, backupFilePath.FullName(),

	                                                      (EFileWrite | EFileShareExclusive));

	const TUid uid2  = KNullUid ;	                                                     

	store->SetTypeL(TUidType(KDirectFileStoreLayoutUid, uid2, KServerUid3)) ; 

	// Create a Backup Stream index

	CRepositoryBackupStreamIndex* backupStreamIndex = CRepositoryBackupStreamIndex::NewLC();	

	// Find the reps owned by aSID

	for(TInt i = 0; i < TServerResources::iOwnerIdLookUpTable.Count(); ++i)

		{

		const TOwnerIdMapping& lookupTableEntry = TServerResources::iOwnerIdLookUpTable[i];

		if ( lookupTableEntry.iOwner == aSID )

			{

			TStreamId settingStreamId(KNullStreamIdValue);

			TStreamId deletedSettingsStreamId(KNullStreamIdValue);

			TStreamId installedSettingStreamId(KNullStreamIdValue);

			// Found one match, open the repository and externalise content.

			TUid uid = TUid::Uid(lookupTableEntry.iRepUid);

			TRAPD(err,iRepository->OpenL(uid, *iNotifier));

			if (err == KErrNoMemory)

				{

				User::Leave(err) ;

				}

			else if (err == KErrNone)

				{			

				iRepository->FailAllTransactions();

				// externalise repository contents

				iRepository->StoreRepositoryContentsL(*store, settingStreamId, deletedSettingsStreamId);

				// Close repository.

				iRepository->Close();

				}

			TBool installExists=TServerResources::InstallFileExistsL(uid);

			if(installExists)

				{			

				// load existing repository from install directory (default values installed post-build by SWI)

				// and externalise installed repository contents				

				TRAPD(err, iRepository->BackupInstallRepositoryL(uid, *store, installedSettingStreamId));

				// We trap and discard most errors to be able to continue backing up other repositories in the list

				if (err == KErrNoMemory)

					{

					User::Leave(err) ;

					}

				else if (err != KErrNone)

					{

					// If for any reason we haven't been able to back up the install repository, 

					// we create an empty stream to preserve the format

					installedSettingStreamId = KNullStreamIdValue;

					}

				}

			// Add all to store index

			backupStreamIndex->AddL(uid, settingStreamId, deletedSettingsStreamId, installedSettingStreamId) ;

			}

		}

	// Write the stream index/dictionary as root stream within the store

	// so we can access it when we do a restore later on

	RStoreWriteStream indexStream ;

	TStreamId indexStreamId = indexStream.CreateLC(*store) ;

	backupStreamIndex->ExternalizeL(indexStream) ;

	indexStream.CommitL() ;

	CleanupStack::PopAndDestroy(&indexStream) ;

	CleanupStack::PopAndDestroy (backupStreamIndex) ;

	// Create the Header and write it as the root stream within the store

	// so we can access it when we do a restore later on

	TRepositoryBackupStreamHeader header (indexStreamId) ;

	RStoreWriteStream rootStream ;

	TStreamId rootStreamId = rootStream.CreateLC(*store) ;

	header.ExternalizeL(rootStream) ;

	rootStream.CommitL() ;

	CleanupStack::PopAndDestroy(&rootStream) ;

	store->SetRootL(rootStreamId);

	store->CommitL();

	CleanupStack::PopAndDestroy(store) ; 

	// Attempt to open file containing store ready to read back and send to

	// BUR engine as a stream of bytes.

	User::LeaveIfError(iFile.Open(iFs, backupFilePath.FullName(), (EFileRead | EFileShareExclusive))) ;

	}

//

// CRepositoryBackupClient::InitialiseRestoreProxyBaseDataL

//

// Called when secure backup is about to start sending restore data.

//

void CRepositoryBackupClient::InitialiseRestoreProxyBaseDataL(TSecureId aSID, TDriveNumber /* aDrive*/)

	{

	// prepare for restore - Don't think we need to do anything here except prepare

	// data structures to receive incoming data

	// Save SID so we can check that it corresponds with the owner information 

	// in the restored data.

	iSid = aSID ;

	// Open file to receive restored data

	TParse restoreFilePath ;

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

	User::LeaveIfError(iFile.Replace (iFs, restoreFilePath.FullName(), (EFileWrite | EFileShareExclusive)));

	}

//

// CRepositoryBackupClient::RestoreBaseDataSectionL

//

// Called when secure backup has a chunk of restore data for us. Last data

// segment identified by aFinished.

//

void CRepositoryBackupClient::RestoreBaseDataSectionL(TDesC8& aBuffer, TBool aFinished)

	{

	// Receive a chunk of restore data in aBuffer 

	User::LeaveIfError(iFile.Write (aBuffer)) ;

	if (aFinished)

		{

		iFile.Close() ;

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

		// backup store	

		RestoreCompleteL();	

		}

	}

void CRepositoryBackupClient::TerminateMultiStageOperation()

	{

	// Backup/Restore operation aborted!

	// Tidy up all temporary data.

	HBufC* burFileName = HBufC::New(KMaxFileName);

	if(burFileName==NULL)

		{

		return;

		}

	TPtr burFileNamePtr(burFileName->Des());

	iFile.FullName(burFileNamePtr); //get the full name of the temporary file

	iFile.Close(); // close the file

	// If a debug build - record error

	TInt fileDeleteErr=iFs.Delete(burFileNamePtr);

	#ifdef _DEBUG

		if (fileDeleteErr != KErrNone)

		{

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

		}

	#else

		UNUSED_VAR(fileDeleteErr);

	#endif

	delete burFileName;

	}

//

// CRepositoryBackupClient::GetDataChecksum

//

// Not required and we don't implement it.

//

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

	{

	return KArbitraryNumber;

	}

// 

// CRepositoryBackupClient::GetSnapshotDataL

//

// Only required for incremental backup (which we don't support

//

void CRepositoryBackupClient::GetSnapshotDataL(TDriveNumber /* aDrive */, TPtr8& /* aBuffer */, TBool& /* aFinished */) 

	{

	User::Leave(KErrNotSupported) ;

	}

// 

// CRepositoryBackupClient::InitialiseGetBackupDataL

//

// Used by "normal" active backup to prepare data - we use

// InitialiseRestoreProxyBaseDataL so this shouldn't be called!

//	

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

	{

	User::Leave(KErrNotSupported) ;

	}

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

	{

	// Check this! I Don't think this method should get called as we're a proxy

	// and so implement InitialiseGetProxyBackupDataL!! 

	User::Leave(KErrNotSupported) ;		

	}

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

	{

	// Check this! I Don't think this method should get called as we're a proxy

	// so don't do incremental backup!! 

	User::Leave(KErrNotSupported) ;			

	}

void CRepositoryBackupClient::RestoreIncrementDataSectionL(TDesC8& /* aBuffer */, TBool /* aFinished */)

	{

	// Check this! I Don't think this method should get called as we're a proxy

	// so don't do incremental backup!! 

	User::Leave(KErrNotSupported) ;		

	}

//

// Incremental backup isn't supported for the proxy data holder model so this

// method should never be called.

//

// Not acceptable to leave even though it's an ...L function which we don't implement

void CRepositoryBackupClient::AllSnapshotsSuppliedL() 

	{

	;

	}

//

// Incremental backup not supported

//	

void CRepositoryBackupClient::ReceiveSnapshotDataL(TDriveNumber /* aDrive */, TDesC8& /* aBuffer */, TBool /* aLastSection */) 

	{

	User::Leave(KErrNotSupported) ;

	}

/**

Adds a new entry to the restored repository list with the specified repository uid.

Creates an object of the CRestoredRepository and inserts it to the list.

If a repository of the specified uid is already on the list, the created object will 

be deleted and no repeated entry will be inserted to the list.

@param aUid The uid of the repository to be added to this array.

@return The index of the new or existing entry within the list.

*/

TInt CRepositoryBackupClient::AddRestoredRepositoryL(TUid aUid)

	{

	CRestoredRepository* rstRepos = new(ELeave) CRestoredRepository(aUid);

	CleanupStack::PushL(rstRepos);

	TInt err = iRestoredRepositoriesArray.InsertInOrder(rstRepos, TLinearOrder<CRestoredRepository>(CRestoredRepository::CompareUids));

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

		User::Leave(err);

	TInt index = iRestoredRepositoriesArray.FindInOrderL(rstRepos, TLinearOrder<CRestoredRepository>(CRestoredRepository::CompareUids));

	CleanupStack::Pop();

	if(err == KErrAlreadyExists)

		{

		delete rstRepos;

		}

	return index;

	}