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

// Implementation of CDataOwner

// 

//

/**

 @file

*/

#include <d32dbms.h>

#include "sbedataowner.h"

#include "abserver.h"

#include "sbtypes.h"

#include "sbeparserdefs.h"

#include "sbepanic.h"

#include "OstTraceDefinitions.h"

#include "sbtrace.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "sbedataownerTraces.h"

#endif

namespace conn

	{	

	_LIT(KDrive, "?:");

	_LIT(KDriveAndSlash, "?:\\");

	_LIT(KPrivateMatch, "?:\\private\\*");

	_LIT(KPrivateSidMatch, "?:\\private\\");

	_LIT(KSys, "?:\\sys\\*");

	_LIT(KSystem, "?:\\system\\*");

	_LIT(KResource, "?:\\resource\\*");

	_LIT(KOther, "*\\..\\*");

	_LIT(KPad, "00000000"); // Used for padding if required

	_LIT(KQuestionMark, "?");

	_LIT8(KVersion, "1.0");

	_LIT( KExclamationAsDrive, "!"); // Used to generic drives for public data as in .SIS file package

	_LIT( KPrivateNoBackup, "?:\\private\\????????\\NoBackup\\*"); // Used to exclude the file if it is in "NoBackup" folder.

	void CleanupRPointerArray(TAny* aPtr)

		{

		OstTraceFunctionEntry0( _CONN_CLEANUPRPOINTERARRAY_ENTRY );

		RPointerArray<CBase>* array = static_cast<RPointerArray<CBase>*>(aPtr);

		array->ResetAndDestroy();

		delete array;

		OstTraceFunctionExit0( _CONN_CLEANUPRPOINTERARRAY_EXIT );

		}

	// CSelection //

	/**

	Symbian 2nd phase construction creates a Selection

	@param aType - Selection Type

	@param aSelection - Selection Nmae

	@return CSelection a pointer to a new object 

	*/

	CSelection* CSelection::NewLC(TSelectionType aType, const TDesC& aSelection)

		{

		OstTraceFunctionEntry0( CSELECTION_NEWLC_ENTRY );

		CSelection* self = new (ELeave) CSelection(aType);

		CleanupStack::PushL(self);

		self->ConstructL(aSelection);

		OstTraceFunctionExit0( CSELECTION_NEWLC_EXIT );

		return self;

		}

	/**

	Standard C++ destructor

	*/

	CSelection::~CSelection()

		{

		OstTraceFunctionEntry0( CSELECTION_CSELECTION_DES_ENTRY );

		delete iSelection;

		OstTraceFunctionExit0( CSELECTION_CSELECTION_DES_EXIT );

		}

	/**

	Standard C++ constructor

	*/

	CSelection::CSelection(TSelectionType aType) : iType(aType)

		{

		OstTraceFunctionEntry0( CSELECTION_CSELECTION_CONS_ENTRY );

		OstTraceFunctionExit0( CSELECTION_CSELECTION_CONS_EXIT );

		}

	/**

	Symbian 2nd phase constructor

	*/

	void CSelection::ConstructL(const TDesC& aSelection)

		{

		OstTraceFunctionEntry0( CSELECTION_CONSTRUCTL_ENTRY );

		iSelection = aSelection.AllocL();

		OstTraceFunctionExit0( CSELECTION_CONSTRUCTL_EXIT );

		}

	/**

	Selection Type

	@return TSelectionType Type

	*/

	TSelectionType CSelection::SelectionType() const

		{

		return iType;

		}

	/**

	Selection Name

	@return const TDesC& Name

	*/

	const TDesC& CSelection::SelectionName() const

		{

		return *iSelection;

		}

	// CSelection End //

	CDataOwner* CDataOwner::NewL(TSecureId aSID, CDataOwnerManager* apDataOwnerManager)

	/** Symbian OS static constructor

	@param aSID secure id of data owner

	@param apDataOwnerManager data owner manager to access resources

	@return a CDataOwner object

	*/

		{

		OstTraceFunctionEntry0( CDATAOWNER_NEWL_ENTRY );

		CDataOwner* self = CDataOwner::NewLC(aSID, apDataOwnerManager);

		CleanupStack::Pop(self);

		OstTraceFunctionExit0( CDATAOWNER_NEWL_EXIT );

		return self;

		}

	CDataOwner* CDataOwner::NewLC(TSecureId aSID, CDataOwnerManager* apDataOwnerManager)

	/** Symbian OS static constructor

	@param aSID secure id of data owner

	@param apDataOwnerManager data owner manager to access resources

	@return a CDataOwner object

	*/

		{

		OstTraceFunctionEntry0( CDATAOWNER_NEWLC_ENTRY );

		CDataOwner* self = new(ELeave) CDataOwner(aSID, apDataOwnerManager);

		CleanupStack::PushL(self);

		self->ConstructL();

		OstTraceFunctionExit0( CDATAOWNER_NEWLC_EXIT );

		return self;

		}

	CDataOwner::CDataOwner(TSecureId aSID, CDataOwnerManager* apDataOwnerManager) :

	    iStatus(EUnset), iFilesParsed(EFalse), iPrimaryFile(EFalse), /*iBackupAsPartial(EFalse), */

	    iSecureId(aSID),

	    iBufferFileWriter(NULL), iBufferFileReader(NULL), iBufferSnapshotWriter(NULL), 

	    iTempSnapshotHolder(NULL), ipDataOwnerManager(apDataOwnerManager)

	/** Standard C++ constructor

	@param aSID secure id of data owner

	@param apDataOwnerManager data owner manager to access resources

	*/

		{

		OstTraceFunctionEntry0( CDATAOWNER_CDATAOWNER_CONS_ENTRY );

		OstTraceFunctionExit0( CDATAOWNER_CDATAOWNER_CONS_EXIT );

		}

	void CDataOwner::ConstructL()

	/** Symbian 2nd stage constructor */

		{

		OstTraceFunctionEntry0( CDATAOWNER_CONSTRUCTL_ENTRY );

		iRegistrationFiles = new (ELeave) CDesCArrayFlat(KDesCArrayGranularity);

		iPrivatePath = HBufC::NewL(0);

		iProxyInformationArray.Reset();

		iPublicDirStack.Reset();

		iPublicDirNameStack.Reset();

		iPublicExcludes.Reset();

		OstTraceFunctionExit0( CDATAOWNER_CONSTRUCTL_EXIT );

		}

	CDataOwner::~CDataOwner()

	/** Standard C++ destructor

	*/

		{

		OstTraceFunctionEntry0( CDATAOWNER_CDATAOWNER_DES_ENTRY );

		// Close the RArrays

		iProxyInformationArray.Close();

		iStateByDrive.Close();

		iProxyStateByDrive.Close();

		iDBMSSelections.Close();

		iPublicSelections.ResetAndDestroy();

		iPassiveSelections.ResetAndDestroy();

		iSnapshots.ResetAndDestroy();

		for (TInt x = iPublicDirStack.Count(); x > 0; --x)

			{

			iPublicDirStack[x-1].Close();

			delete iPublicDirNameStack[x-1];

			}

		iPublicDirStack.Close();

		iPublicDirNameStack.Close();

		iPublicExcludes.Close();

		delete iPrivatePath;

		delete iBufferFileWriter;

		delete iBufferFileReader;

		delete iBufferSnapshotWriter;

		delete iBufferSnapshotReader;

		delete iTempSnapshotHolder;

		delete iRegistrationFiles;

		OstTraceFunctionExit0( CDATAOWNER_CDATAOWNER_DES_EXIT );

		}

	void CDataOwner::AddRegistrationFilesL(const TDesC& aFileName)

	/** Adds a registration file

	Adds a registration file to the list of registration files for this data owner

	@param aFileName the filename of the 

	*/

		{

		OstTraceFunctionEntry0( CDATAOWNER_ADDREGISTRATIONFILESL_ENTRY );

		iRegistrationFiles->AppendL(aFileName);

		OstTraceFunctionExit0( CDATAOWNER_ADDREGISTRATIONFILESL_EXIT );

		}

	void CDataOwner::StartProcessIfNecessaryL()

	/**

	Start the active process

	*/

		{

		OstTraceFunctionEntry0( CDATAOWNER_STARTPROCESSIFNECESSARYL_ENTRY );

		// Do we need to check that the process is started?

		if (iActiveInformation.iSupported && iActiveInformation.iActiveDataOwner)

			{

			// Get the list of currently running processes

			TBool processFound = EFalse;

			TFullName processName;

			TFindProcess findProcess;

			while (!processFound && (findProcess.Next(processName) == KErrNone))

				{

				RProcess process;

				CleanupClosePushL(process);

				if (process.Open(processName) == KErrNone) // Should we leave on any errors?

					{

					if (process.SecureId() == iSecureId)

						{

						// Process already exists - see if it's previuosly connected and has a current session

					    OstTraceExt1(TRACE_NORMAL, CDATAOWNER_STARTPROCESSIFNECESSARYL, "Process %S already exists - not starting", processName);

						TRAPD(err, iStatus = ipDataOwnerManager->ABServer().SessionReadyStateL(iSecureId));

						if (err == KErrNone)

							{

						    OstTraceExt2(TRACE_NORMAL, DUP1_CDATAOWNER_STARTPROCESSIFNECESSARYL, "Existing session for process %S has status %d", processName, iStatus);

							} // if

						else

							{

						    OstTraceExt1(TRACE_NORMAL, DUP2_CDATAOWNER_STARTPROCESSIFNECESSARYL, "Existing process %S hasn't yet connected to a session", processName);

							iStatus = EDataOwnerNotConnected;//ReadyState only check session state when this status not equal to 'EDataOwnerReadyNoImpl' and 'EDataOwnerReady' 

							} // else

						processFound = ETrue;

						} // if

					} // if

					CleanupStack::PopAndDestroy(&process);

				} // while

			// If the process is not started then we need to start it

			if (!processFound)

				{

				// Create the process

				TUidType uidType(KNullUid, KNullUid, iSecureId);

				RProcess process;

				CleanupClosePushL(process);

				TInt createErr = process.Create(iActiveInformation.iProcessName, KNullDesC, uidType);

				if (createErr != KErrNone)

					{

				    OstTraceExt2(TRACE_NORMAL, DUP3_CDATAOWNER_STARTPROCESSIFNECESSARYL, "Process %S failed to start(%d)", iActiveInformation.iProcessName, createErr);

					iStatus = EDataOwnerFailed;

					} // if

				else

					{

				    OstTraceExt1(TRACE_NORMAL, DUP4_CDATAOWNER_STARTPROCESSIFNECESSARYL, "Process %S started.", iActiveInformation.iProcessName);

					process.Resume();

					} // else

				CleanupStack::PopAndDestroy(&process);

				} // if

			} // if

		OstTraceFunctionExit0( CDATAOWNER_STARTPROCESSIFNECESSARYL_EXIT );

		}

	void CDataOwner::ParseFilesL()

	/** Parse the registration files

	@leave KErrGeneral data owner has no primary registration file

	*/

		{

		OstTraceFunctionEntry0( CDATAOWNER_PARSEFILESL_ENTRY );

		if (!iFilesParsed)

			{

			TUint count = iRegistrationFiles->Count();

			TBool foundPrimaryFile = EFalse;

			while(count--)

				{

				const TDesC& fileName = (*iRegistrationFiles)[count];

			  // Determine if this is the primary file

				iPrimaryFile = (fileName.FindF(KPrimaryBackupRegistrationFile) != KErrNotFound);

				if (iPrimaryFile)

					{

					foundPrimaryFile = ETrue;

					}

				// Parse file

				OstTraceExt2(TRACE_NORMAL, CDATAOWNER_PARSEFILESL, "[0x%08x] - parsing reg file: %S...", iSecureId.iId, fileName);

				TRAPD(err, ParseFileL(fileName));

				if	(err == KErrNone)

					{

				    OstTrace1(TRACE_NORMAL, DUP1_CDATAOWNER_PARSEFILESL, "[0x%08x] - ...file parsed okay", iSecureId.iId);

					}

				else

					{

				    OstTraceExt2(TRACE_ERROR, DUP2_CDATAOWNER_PARSEFILESL, "[0x%08x] - ...*** PARSING FAILED *** - error: %d", iSecureId.iId, static_cast<TInt32>(err));

					User::Leave(err);

					}

				// Add the registration file to the exclude list

				CSelection* selection = CSelection::NewLC(EExclude, fileName);

				iPassiveSelections.AppendL(selection);

				CleanupStack::Pop(selection);

				}

			// Check that a primary file was found, as there must be one	

			if (!foundPrimaryFile)

				{

			    OstTrace0(TRACE_ERROR, DUP3_CDATAOWNER_PARSEFILESL, "Leave: KErrGeneral");

				User::Leave(KErrGeneral);

				} // if

			iFilesParsed = ETrue;

			} // if

		if (!iActiveInformation.iSupported && (iPassiveInformation.iSupported || iSystemInformation.iSupported))

			{

			iStatus = EDataOwnerReady;

			}

 		OstTraceFunctionExit0( CDATAOWNER_PARSEFILESL_EXIT );

 		}

	void CDataOwner::GetExpectedDataSizeL(TTransferDataType aTransferType,

										  TDriveNumber aDriveNumber, TUint& aSize)

	/** Gets the expected data size of the backkup.

	@param aTransferType the type of the transfer

	@param aDriveNumber the drive to check for files

	@param aSize on return the total size in bytes of the backup

	@leave KErrNotReady the snapshot has not been set

	*/

		{

		OstTraceFunctionEntry0( CDATAOWNER_GETEXPECTEDDATASIZEL_ENTRY );

		aSize = 0;

		switch (aTransferType)

			{

		case EPassiveSnapshotData:

			{

			OstTraceExt1(TRACE_NORMAL, CDATAOWNER_GETEXPECTEDDATASIZEL, "EPassiveSnapshotData - aDriveNumber: %c", aDriveNumber + 'A');

            CDesCArray* files = new(ELeave) CDesC16ArrayFlat(KDesCArrayGranularity);

            CleanupStack::PushL(files);

			BuildFileListL(iPassiveSelections, aDriveNumber, aTransferType, EFalse, NULL, NULL, files);

			// DBMS file?

			AddDBMSFilesL(aDriveNumber, files, NULL);

			TUint count = files->Count();

			aSize = count * sizeof(TSnapshot);

			OstTraceExt2(TRACE_NORMAL, DUP1_CDATAOWNER_GETEXPECTEDDATASIZEL, "passive snapshot count: %d, expected size: %d", count, aSize);

			CleanupStack::PopAndDestroy(files);

			break;

			}

		case EPassiveBaseData:

		case EPassiveIncrementalData:

			{

			OstTraceExt1(TRACE_NORMAL, DUP2_CDATAOWNER_GETEXPECTEDDATASIZEL, "EPassiveBaseData/EPassiveIncrementalData - aDriveNumber: %c", aDriveNumber + 'A');

            RFileArray files;

			CleanupClosePushL(files);

			// Find all the files

			if (aTransferType == EPassiveBaseData)

				{

			    OstTrace0(TRACE_NORMAL, DUP3_CDATAOWNER_GETEXPECTEDDATASIZEL, "EPassiveBaseData");

				BuildFileListL(iPassiveSelections, aDriveNumber, aTransferType, EFalse, NULL, &files, NULL);

				// Do we need to add the DBMS file?

				AddDBMSFilesL(aDriveNumber, NULL, &files);

				} // if

			else

				{

			    OstTrace0(TRACE_NORMAL, DUP4_CDATAOWNER_GETEXPECTEDDATASIZEL, "EPassiveIncrementalData");

				// Do we have a snapshot?

				const TUint count = iSnapshots.Count();

				RSnapshots* pSnapshot = NULL;

				for (TInt x = 0; !pSnapshot && (x < count); x++)

					{

					if (iSnapshots[x]->iDriveNumber == aDriveNumber)

						{

						pSnapshot = &(iSnapshots[x]->iSnapshots);

						} // if

					} // for x

				BuildFileListL(iPassiveSelections, aDriveNumber, aTransferType, EFalse, pSnapshot, &files, NULL);

				// Do we need to add the DBMS file?

				AddDBMSFilesL(aDriveNumber, NULL, &files);

				} // else

			// Calculate the expected data size

			const TUint count = files.Count();

			OstTrace1(TRACE_NORMAL, DUP5_CDATAOWNER_GETEXPECTEDDATASIZEL, "passive file count: %d", count);

			aSize = (count * sizeof(TFileFixedHeader));

			for (TInt x = 0; x < count; x++)

				{

                const TEntry& fileEntry = files[x];

                const TInt fileSize = fileEntry.iSize;

                OstTraceExt2(TRACE_NORMAL, DUP6_CDATAOWNER_GETEXPECTEDDATASIZEL, "passive file: %S, size: %d", fileEntry.iName, fileSize);

				aSize += fileEntry.iName.Length();

				aSize += fileSize;

				}

			CleanupStack::PopAndDestroy(&files);

			break;

			}

		case EActiveBaseData:

		case EActiveIncrementalData:

			{

			OstTraceExt1(TRACE_NORMAL, DUP7_CDATAOWNER_GETEXPECTEDDATASIZEL, "EActiveBaseData/EActiveIncrementalData - aDriveNumber: %c", aDriveNumber + 'A');

			// Only request expected data size if it's for this data owner, not the proxies

			if (iActiveInformation.iSupported && iActiveInformation.iActiveDataOwner && (iActiveInformation.iActiveType != EProxyImpOnly))

				{

				ipDataOwnerManager->ABServer().GetExpectedDataSizeL(iSecureId, aDriveNumber, aSize);

				}

			else

				{

				aSize = 0;

				OstTrace1(TRACE_NORMAL, DUP8_CDATAOWNER_GETEXPECTEDDATASIZEL, "ACTIVE BASE - DO 0x%08x is PROXY, so setting size to 0!", iSecureId.iId);

				}

			} break;

		case EActiveSnapshotData:

			{

			OstTraceExt1(TRACE_NORMAL, DUP9_CDATAOWNER_GETEXPECTEDDATASIZEL, "EActiveSnapshotData - aDriveNumber: %c", aDriveNumber + 'A');

			aSize = 0;		// ABClient M class doesn't provide retrieval of snapshot data size

			} break;

		default:

		    OstTraceExt1(TRACE_ERROR, DUP10_CDATAOWNER_GETEXPECTEDDATASIZEL, "ERROR - UNSUPPORTED TYPE! => KErrNotSupported - aDriveNumber: %c", aDriveNumber + 'A');

			User::Leave(KErrNotSupported);

			} // switch

		OstTraceExt2(TRACE_NORMAL, DUP11_CDATAOWNER_GETEXPECTEDDATASIZEL, "size is: %d, data owner 0x%08x", static_cast<TUint32>(aSize), iSecureId.iId);

		OstTraceFunctionExit0( CDATAOWNER_GETEXPECTEDDATASIZEL_EXIT );

		}

	void CDataOwner::GetPublicFileListL(TDriveNumber aDriveNumber, RFileArray& aFiles)

	/** Gets the public file list

	Gets the public file list for the given drive

	@param aDriveNumber the drive to retrieve the public files for

	@param aFiles on return a list of public files

	*/

		{

		OstTraceFunctionEntry0( CDATAOWNER_GETPUBLICFILELISTL_ENTRY );

		BuildFileListL(iPublicSelections, aDriveNumber, EPassiveBaseData, ETrue, NULL, &aFiles, NULL);

		OstTraceFunctionExit0( CDATAOWNER_GETPUBLICFILELISTL_EXIT );

		}

	void CDataOwner::GetRawPublicFileListL(TDriveNumber aDriveNumber, 

										   RRestoreFileFilterArray& aRestoreFileFilter)

	/** Gets the raw public file list 

	@param aDriveNumber the drive to return the list for

	@param aRestoreFileFilter on return the file filter

	*/

		{

		OstTraceFunctionEntry0( CDATAOWNER_GETRAWPUBLICFILELISTL_ENTRY );

		// Convert drive number to letter

		TChar drive;

		TInt err = ipDataOwnerManager->GetRFs().DriveToChar(aDriveNumber, drive);

		LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, CDATAOWNER_GETRAWPUBLICFILELISTL, "Leave: %d", err));

		const TUint count = iPublicSelections.Count();

		for (TInt x = 0; x < count; x++)

			{

			TBool include = (iPublicSelections[x]->SelectionType() == EInclude);

			TFileName filename;