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

	{

	TRepositoryBackupStreamIndexElement newIndexElement;

	newIndexElement.Set(aUid,aSettingStreamId, aDeletedSettingsStreamId) ;

	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)

	{

	TInt error = KErrNone ;

	if (iIndex < iStreamIndex.Count())

		{

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

		}

	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(*iNotifier) ;

		delete(iRepository);

		}

	if (iNotifier)

		delete(iNotifier) ;

	if (iActiveBackupClient)

		delete(iActiveBackupClient) ;	

	}

// 

// DoCancel - mandatory for active objects.

//	

void CRepositoryBackupClient::DoCancel()

	{

	iBackupRestoreProperty.Cancel() ;

	}

//

// RunError

//

TInt CRepositoryBackupClient::RunError(TInt aError)

	{

	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 ;

	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?

				iBackupStatus = ENoBackupActivty ;

				// Back to normal, so enable cache

				TServerResources::iCacheManager->EnableCache();				

				// delete the CActiveBackupClient

				if (iActiveBackupClient)

					{

					delete iActiveBackupClient ;

					iActiveBackupClient = NULL ;

					}

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

		iFs.Delete(backupFilePath.FullName()) ;

		}

	}

//

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

		iFs.Delete(restoreFilePath.FullName()) ;

		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 ;

	TStreamId deletedSettingsStreamId ;

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

		{

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

		iRepository->FailAllTransactions();

		iRepository->RestoreRepositoryContentsL(*store, settingsStreamId, deletedSettingsStreamId);

		iRepository->CommitChangesL();

		iRepository->Close(*iNotifier) ;

		}

	CleanupStack::PopAndDestroy(restoreStreamIndex) ;

	CleanupStack::PopAndDestroy(&indexStream);

	CleanupStack::PopAndDestroy(store);

	iFs.Delete(restoreFilePath.FullName()) ;

	}

//

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

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

					break ;

				case EScanInstall :

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

					break ;

				case EScanPersist :

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

					break ;				

			}

		CDir* directory;

		User::LeaveIfError(iFs.GetDir(directoryName, KEntryAttNormal, ESortNone, directory));		

		CleanupStack::PushL(directory);

		const TInt directoryFileCount = directory->Count();

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

			{

			// Attempt to extract a repository UID from directory entry

			TUid uid;	

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

    			{

    			repositoryList.InsertInUnsignedKeyOrder(uid.iUid) ;

    			}

			}

		CleanupStack::PopAndDestroy(directory);

		}

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

				}

			}

		}

	CleanupStack::PopAndDestroy() ; // repositoryList	

	}

// CRepositoryBackupClient::InitialiseGetProxyBackupDataL