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

#include "sbeparserdefs.h"

#include "sbepanic.h"

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)

		{

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

		array->ResetAndDestroy();

		delete array;

		}

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

		{

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

		CleanupStack::PushL(self);

		self->ConstructL(aSelection);

		return self;

		}

	/**

	Standard C++ destructor

	*/

	CSelection::~CSelection()

		{

		delete iSelection;

		}

	/**

	Standard C++ constructor

	*/

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

		{

		}

	/**

	Symbian 2nd phase constructor

	*/

	void CSelection::ConstructL(const TDesC& aSelection)

		{

		iSelection = aSelection.AllocL();

		}

	/**

	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

	*/

		{

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

		CleanupStack::Pop(self);

		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

	*/

		{

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

		CleanupStack::PushL(self);

		self->ConstructL();

		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

	*/

		{

		}

	void CDataOwner::ConstructL()

	/** Symbian 2nd stage constructor */

		{

		iRegistrationFiles = new (ELeave) CDesCArrayFlat(KDesCArrayGranularity);

		iPrivatePath = HBufC::NewL(0);

		iProxyInformationArray.Reset();

		iPublicDirStack.Reset();

		iPublicDirNameStack.Reset();

		iPublicExcludes.Reset();

		}

	CDataOwner::~CDataOwner()

	/** Standard C++ destructor

	*/

		{

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

		}

	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 

	*/

		{

		iRegistrationFiles->AppendL(aFileName);

		}

	void CDataOwner::StartProcessIfNecessaryL()

	/**

	Start the active process

	*/

		{

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

						__LOG1("Process %S already exists - not starting", &processName);

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

						if (err == KErrNone)

							{

							__LOG2("Existing session for process %S has status %d", &processName, iStatus);

							} // if

						else

							{

							__LOG1("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)

					{

					__LOG2("Process %S failed to start(%d)", &iActiveInformation.iProcessName, createErr);

					iStatus = EDataOwnerFailed;

					} // if

				else

					{

					__LOG1("Process %S started.", &iActiveInformation.iProcessName);

					process.Resume();

					} // else

				CleanupStack::PopAndDestroy(&process);

				} // if

			} // if

		}

	void CDataOwner::ParseFilesL()

	/** Parse the registration files

	@leave KErrGeneral data owner has no primary registration file

	*/

		{

		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

				__LOG2("CDataOwner::ParseFilesL() - [0x%08x] - parsing reg file: %S...", iSecureId.iId, &fileName);

				TRAPD(err, ParseFileL(fileName));

				if	(err == KErrNone)

					{

					__LOG1("CDataOwner::ParseFilesL() - [0x%08x] - ...file parsed okay", iSecureId.iId);

					}

				else

					{

					__LOG2("CDataOwner::ParseFilesL() - [0x%08x] - ...*** PARSING FAILED *** - error: %d", iSecureId.iId, 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)

				{

				User::Leave(KErrGeneral);

				} // if

			iFilesParsed = ETrue;

			} // if

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

			{

			iStatus = EDataOwnerReady;

			}

 		}

	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

	*/

		{

		aSize = 0;

		switch (aTransferType)

			{

		case EPassiveSnapshotData:

			{

			__LOG1("CDataOwner::GetExpectedDataSizeL() - START - 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);

            __LOG2("CDataOwner::GetExpectedDataSizeL() - passive snapshot count: %d, expected size: %d", count, aSize);

			CleanupStack::PopAndDestroy(files);

			break;

			}

		case EPassiveBaseData:

		case EPassiveIncrementalData:

			{

			__LOG1("CDataOwner::GetExpectedDataSizeL() - START - EPassiveBaseData/EPassiveIncrementalData - aDriveNumber: %c", aDriveNumber + 'A');

            RFileArray files;

			CleanupClosePushL(files);

			// Find all the files

			if (aTransferType == EPassiveBaseData)

				{

	            __LOG("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

				{

	            __LOG("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();

	        __LOG1("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;

                __LOG2("CDataOwner::GetExpectedDataSizeL() - passive file: %S, size: %d", &fileEntry.iName, fileSize);

				aSize += fileEntry.iName.Length();

				aSize += fileSize;

				}

			CleanupStack::PopAndDestroy(&files);

			break;

			}

		case EActiveBaseData:

		case EActiveIncrementalData:

			{

			__LOG1("CDataOwner::GetExpectedDataSizeL() - START - 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;

                __LOG1("CDataOwner::GetExpectedDataSizeL() - ACTIVE BASE - DO 0x%08x is PROXY, so setting size to 0!", iSecureId.iId);

				}

			} break;

		case EActiveSnapshotData:

			{

			__LOG1("CDataOwner::GetExpectedDataSizeL() - START - EActiveSnapshotData - aDriveNumber: %c", aDriveNumber + 'A');

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

			} break;

		default:

			__LOG1("CDataOwner::GetExpectedDataSizeL() - START - ERROR - UNSUPPORTED TYPE! => KErrNotSupported - aDriveNumber: %c", aDriveNumber + 'A');

			User::Leave(KErrNotSupported);

			} // switch

		__LOG2("CDataOwner::GetExpectedDataSizeL() - END - size is: %d, data owner 0x%08x", aSize, iSecureId.iId);

		}

	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

	*/

		{

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

		}

	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

	*/

		{

		// Convert drive number to letter

		TChar drive;

		User::LeaveIfError(ipDataOwnerManager->GetRFs().DriveToChar(aDriveNumber, drive));

		const TUint count = iPublicSelections.Count();

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

			{

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

			TFileName filename;

			const TDesC& selectionName = iPublicSelections[x]->SelectionName();

			// Name

			TBool add = false;

			if ((selectionName.Length() > 1) && (selectionName[1] == KColon()[0]))

				{

				// It has a drive specified

				TInt drive;

				ipDataOwnerManager->GetRFs().CharToDrive(selectionName[0], drive);

				if (static_cast<TDriveNumber>(drive) == aDriveNumber)

					{

					add = true;

					filename.Append(selectionName);

					} // if

				} // if

			else if (selectionName[0] == KBackSlash()[0])

				{

					add = true;

					filename.Append(drive);

					filename.Append(KColon);

					filename.Append(selectionName);

				} // if

			else

				{

					filename.Append(drive);

					filename.Append(KColon);

					filename.Append(KBackSlash);

					filename.Append(selectionName);

				} // else

				if (add)

					{

					aRestoreFileFilter.AppendL(TRestoreFileFilter(include, filename));

					} // if

			} // for x

		}

	void CDataOwner::ProcessSupplyDataL(TDriveNumber aDriveNumber, TTransferDataType aTransferType, 

								 TDesC8& aBuffer, TBool aLastSection)

	/** Supply data to the data owner

	@param aDriveNumber the drive requesting data for

	@param aTransferType the type of transfer

	@param aBuffer the buffer containing the data

	@param aLastSection have we received all our information

	@leave KErrNotReady In the process of another call

	@leave KErrNotSupported Unsupported transfer type

	@leave KErrCorrupt If commands have been issued that violate the allowed sequence