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

// 

//

/**

 @file

*/

#include "sbedataowner.h"

#include "sbebufferhandler.h"

#include "sbpackagedatatransfer.h"

#include <babackup.h>

#include <swi/backuprestore.h>

#include <swi/sisregistryentry.h>

#include <swi/sisregistrypackage.h>

#include "sbeparserdefs.h"

#include "OstTraceDefinitions.h"

#include "sbtrace.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "sbpackagedatatransferTraces.h"

#endif

namespace conn

	{

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

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

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

	_LIT(KImport, "*\\import\\*");

	_LIT(KTempPath, ":\\system\\temp\\");

	CPackageDataTransfer* CPackageDataTransfer::NewL(TUid aPid, CDataOwnerManager* aDOM)

	/** Standard Symbian Constructor

	@param aPid Package Id

	@return a CPackageDataTransfer object

	*/

		{

		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_NEWL_ENTRY );

		CPackageDataTransfer* self = CPackageDataTransfer::NewLC(aPid, aDOM);

		CleanupStack::Pop(self);

		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_NEWL_EXIT );

		return self;

		}

	CPackageDataTransfer* CPackageDataTransfer::NewLC(TUid aPid, CDataOwnerManager* aDOM)

	/** Standard Symbian Constructor

	@param aPid Package Id

	@return a CPackageDataTransfer object

	*/

		{

		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_NEWLC_ENTRY );

		CPackageDataTransfer *self = new(ELeave) CPackageDataTransfer(aPid, aDOM);

		CleanupStack::PushL(self);

		self->ConstructL();

		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_NEWLC_EXIT );

		return self;

		}

	CPackageDataTransfer::CPackageDataTransfer(TUid aPid, CDataOwnerManager* aDOM) : 

	/** Standard C++ Constructor

	@param aPid Package Id

	*/

		iBufferSnapshotReader(NULL), 

		iBufferFileWriter(NULL), iBufferSnapshotWriter(NULL), 

		iPackageID(aPid), iSnapshot(NULL), iMetaData(NULL), ipDataOwnerManager(aDOM), iRestored(EFalse)

	  	{

	  	OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_CPACKAGEDATATRANSFER_CONS_ENTRY );

	  	// needed for intiliazion

	  	iDriveList.SetLength(KMaxDrives);

	  	iDriveList.FillZ();

	  	// needed for hashes in registry on drive C (i.e. MMC card app's hash)

	  	iDriveList[EDriveC] = ETrue;

		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_CPACKAGEDATATRANSFER_CONS_EXIT );

		}

	void CPackageDataTransfer::ConstructL()

	/** Standard Symbian second phase constructor

	*/

		{

		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_CONSTRUCTL_ENTRY );

		TInt err = iSWIRestore.Connect();

		LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, CPACKAGEDATATRANSFER_CONSTRUCTL, "error = %d", err));

		err = iSWIBackup.Connect();

		LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, DUP1_CPACKAGEDATATRANSFER_CONSTRUCTL, "error = %d", err));

		err = iFs.Connect();

		LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, DUP2_CPACKAGEDATATRANSFER_CONSTRUCTL, "error = %d", err));

		err = iFs.ShareProtected();

		LEAVEIFERROR(err, OstTrace1(TRACE_ERROR, DUP3_CPACKAGEDATATRANSFER_CONSTRUCTL, "error = %d", err));

		iRegistrationFile = HBufC::NewL(0);

		iFileName = HBufC::NewL(KMaxFileName);

		iTempFileName = HBufC::NewL(KMaxFileName);

		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_CONSTRUCTL_EXIT );

		}

	CPackageDataTransfer::~CPackageDataTransfer()

	/** Standard C++ Destructor

	*/

	  	{

		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_CPACKAGEDATATRANSFER_DES_ENTRY );

		iSWIRestore.Close();

		iSWIBackup.Close();

		iFileHandle.Close();

		iFiles.ResetAndDestroy();

		iPublicSelections.ResetAndDestroy();

		delete iRegistrationFile;

		delete iBufferFileWriter;

		delete iBufferSnapshotReader;

		delete iBufferSnapshotWriter;

		delete iSnapshot;

		delete iMetaData;

		delete iFileName;

		delete iTempFileName;

		iFs.Close();

		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_CPACKAGEDATATRANSFER_DES_EXIT );

		}

	void CPackageDataTransfer::WriteData(TAny* aItem, TPtr8& aBuffer, 

										 TInt aSize)

	/** Used to write data to a buffer

	@param aItem Item to write

	@param aBuffer Buffer to write aItem to

	@param aSize Size of the aItem

	*/										 

		{

		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_WRITEDATA_ENTRY );

		TUint8 *pos = reinterpret_cast<TUint8*>(aItem);

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

			{

			aBuffer.Append(pos[i]);

			}

		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_WRITEDATA_EXIT );

		}

	TUid CPackageDataTransfer::PackageId() const

	/** Returns the package Id

	@return the package Id

	*/

		{

		return iPackageID;

		}

	void CPackageDataTransfer::BuildPackageFileList()

	/** Builds the file list of all files in the package on the given drive

	@param aDriveNumber drive the files must be on to be included in the list

	@param apSnapshot (OPTIONAL)A file will only be included if the file is not 

					  in the snapshot is newer than the file in the snapshot

	@param aFileNames on return the list of files

	*/

		{

		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_BUILDPACKAGEFILELIST_ENTRY );		

		// Establish a connection to the registry and read the list of

		// filenames into array.

		// 

		iDriveList.SetLength(KMaxDrives);

		iDriveList.FillZ();

		// also set EDriveC to True for hashesh of the registry

		iDriveList[EDriveC] = ETrue;

		TUint count = iFiles.Count();

		OstTrace1(TRACE_NORMAL, CPACKAGEDATATRANSFER_BUILDPACKAGEFILELIST, "No of files: %d", count);

		while (count > 0)

			{

			count--;

			TBool remove = EFalse;

			TFileName fileName (*iFiles[count]);

			if ((fileName.FindC(KPrimaryBackupRegistrationFile) < 0) &&

				(fileName.MatchC(KSys) < 0) &&

				(fileName.MatchC(KResource) < 0) && 

  				(fileName.MatchC(KImport) < 0 ))

				{

				remove = ETrue;	

				}

			// check read only media

			if (!remove && (NULL != iFs.IsFileInRom(fileName)))

				{

				remove = ETrue;

				}

			// check if real entry

			if (!remove)

				{

				TEntry entry;

				TInt err = iFs.Entry(fileName, entry);

				if (err != KErrNone)

					{

					remove = ETrue;

					}

				}

			// remove?

			if (remove)

				{

				delete iFiles[count];

				iFiles[count] = NULL;

				iFiles.Remove(count);

				}

			else

				{

				// append to drive list

				TInt num;

				TChar ch = fileName[0];

				TInt err = iFs.CharToDrive(ch, num);

				if (err == KErrNone)

					{

					iDriveList[num] = ETrue;

					}

				}

			} // for

        const TUint fNameCount = iFiles.Count();

        if  (fNameCount)

            {

            for(TUint k=0; k<fNameCount; k++)

                {

                const TDesC& file = *iFiles[k];

                OstTraceExt2(TRACE_NORMAL, DUP1_CPACKAGEDATATRANSFER_BUILDPACKAGEFILELIST, "Files Added - file entry[%03d] %S", static_cast<TInt32>(k), file);

                }

            }

		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_BUILDPACKAGEFILELIST_EXIT );

		}

	void CPackageDataTransfer::GetExpectedDataSizeL(TPackageDataType aTransferType, TDriveNumber aDriveNumber, TUint& aSize)

	/** Get the expected data size of a request for data

	@param aTransferType the type of data to check the size of

	@param aDriveNumber the drive to check

	@param aSize on return the size of the data

	*/

		{

		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL_ENTRY );

		OstTrace0(TRACE_NORMAL, CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "Begin getmetadata");

		if (iMetaData == NULL)

			{

			TRAPD(err, iMetaData = iSWIBackup.GetMetaDataL(iPackageID, iFiles));

			if(KErrNotSupported == err)

			    {//Non-Removable package, nothing to backup

			    aSize = 0;

			    OstTrace0(TRACE_NORMAL, DUP1_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "GetMetaDataL - KErrNotSupported");

			    OstTraceFunctionExit0( CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL_EXIT );

			    return;

			    }

			else if(KErrNone != err)

			    {

			    OstTrace1(TRACE_ERROR, DUP2_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "GetMetaDataL leave with %d", err);

			    User::Leave(err);

			    }

			iMetaDataSize = iMetaData->Size();

			BuildPackageFileList();

			}

		OstTrace0(TRACE_NORMAL, DUP3_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "End getmetadata");

		if (!IsDataOnDrive(aDriveNumber))

			{

			// no data on drive

			aSize = 0;

			OstTraceFunctionExit0( DUP1_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL_EXIT );

			return;

			}

		aSize = iMetaData->Size();

		TUint count = iFiles.Count();

		switch (aTransferType)

			{

			case ESystemSnapshotData:

				{

				OstTraceExt1(TRACE_NORMAL, DUP4_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "ESystemSnapshotData - aDriveNumber: %c", aDriveNumber + 'A');

				// Find all files

				aSize = (count * sizeof(TSnapshot));

				OstTrace1(TRACE_NORMAL, DUP5_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "passive snapshot count: %d", count);

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

					{

					const TDesC& fileName = *iFiles[x];

                	const TInt fileSize = fileName.Length();;

                	OstTraceExt2(TRACE_NORMAL, DUP6_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "passive snapshot file: %S, size: %d", fileName, fileSize);

					aSize += fileSize;

					} // for x

				break;

				}

			case ESystemData:

				{

				OstTraceExt1(TRACE_NORMAL, DUP7_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "ESystemData - aDriveNumber: %c", aDriveNumber + 'A');

				aSize += sizeof(TInt);

				TEntry entry;

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

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

					{

					const TDesC& fileName = *iFiles[x];

					TInt err = iFs.Entry(fileName, entry);

					TUint fileSize = entry.iSize;

					OstTraceExt2(TRACE_NORMAL, DUP9_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "passive file: %S, size: %d", fileName, static_cast<TInt32>(fileSize));

					switch(err)

						{

					case KErrNone:

						aSize += fileSize;

						break;

					case KErrNotFound:

					case KErrPathNotFound:

					case KErrBadName:

					    OstTraceExt2(TRACE_NORMAL, DUP10_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "error getting passive file: %S, error: %d", fileName, err);

						break;

					default:

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

						User::Leave(err);

						}

					}

				break;

				}

			default:

				{

				OstTraceExt2(TRACE_ERROR, DUP11_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "No case for TransferType: %d, data owner 0x%08x", static_cast<TInt32>(aTransferType), iPackageID.iUid);

				User::Leave(KErrNotSupported);

				}

			} // switch

		OstTraceExt2(TRACE_NORMAL, DUP12_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL, "size is: %d, data owner 0x%08x", static_cast<TInt32>(aSize), iPackageID.iUid);

		OstTraceFunctionExit0( DUP2_CPACKAGEDATATRANSFER_GETEXPECTEDDATASIZEL_EXIT );

		}

	void CPackageDataTransfer::RequestDataL(TDriveNumber aDriveNumber, 

	    									TPackageDataType aTransferType, 

	    									TPtr8& aBuffer,

	    									TBool& aLastSection)

		/** Request data

		@param aDriveNumber the drive you want data from

		@param aTransferType the type of data you require

		@param aBuffer the buffer to write the data

		@param aLastSection has all the data been supplied. If all data is not

			   supplied a further calls to the function will return the extra

			   data.

		*/

		{

		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_REQUESTDATAL_ENTRY );

		OstTraceExt3(TRACE_NORMAL, CPACKAGEDATATRANSFER_REQUESTDATAL, "aDrive: %c, aTransferType: %d, iSecureId: 0x%08x", static_cast<TInt8>(aDriveNumber + 'A'), static_cast<TInt32>(aTransferType), static_cast<TUint32>(iPackageID.iUid));

		OstTraceExt3(TRACE_NORMAL, DUP4_CPACKAGEDATATRANSFER_REQUESTDATAL, "iState.iState: %d, iState.iTransferType: %d, aBuffer.Length(): %d", static_cast<TInt32>(iState.iState), static_cast<TInt32>(iState.iTransferType), static_cast<TInt32>(aBuffer.Length()));

		TInt err = KErrNone;

		if (iMetaData == NULL)

			{

			TRAPD(err, iMetaData = iSWIBackup.GetMetaDataL(iPackageID, iFiles));

            if(KErrNotSupported == err)

                {//Non-Removable package, nothing to backup

                iState.iState = ENone;

                aLastSection = ETrue;

                Cleanup();

                OstTraceFunctionExit0( CPACKAGEDATATRANSFER_REQUESTDATAL_EXIT );

                return;

                }

            else if(KErrNone != err)

                {

                iState.iState = ENone;

                aLastSection = ETrue;

                Cleanup();

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

                User::Leave(err);

                }

			iMetaDataSize = iMetaData->Size();

			BuildPackageFileList();

			}

		// Check our state

		if (!((iState.iState == ENone) || (iState.iState == EBuffer) ||

		     ((iState.iState == ERequest) && (iState.iDriveNumber == aDriveNumber) && 

		      (iState.iTransferType == aTransferType))))

			{

		    OstTrace0(TRACE_ERROR, DUP1_CPACKAGEDATATRANSFER_REQUESTDATAL, "bad state => ERROR => KErrNotReady");

			User::Leave(KErrNotReady);			

			}

		// Set the state?

		if (iState.iState == ENone)

			{

			iState.iDriveNumber = aDriveNumber;

			iState.iTransferType = aTransferType;

			}

		switch (aTransferType)

			{

			case ESystemSnapshotData:

				{

				TRAP(err, RequestSnapshotL(aDriveNumber, aBuffer, aLastSection));

				break;

				}

			case ESystemData:

				{

				TRAP(err, DoRequestDataL(aDriveNumber, aBuffer, aLastSection));

				break;

				}

			default:

				{

				err = KErrNotSupported;

				}

			} // switch

		if (err != KErrNone)

			{

			iState.iState = ENone;

			Cleanup();

			OstTrace1(TRACE_ERROR, DUP2_CPACKAGEDATATRANSFER_REQUESTDATAL, "Leave with error: %d", err);

			User::Leave(err);

			} // if

		OstTraceFunctionExit0( DUP1_CPACKAGEDATATRANSFER_REQUESTDATAL_EXIT );

		}

	void CPackageDataTransfer::ReadData(TAny* aDestinationAddress, const TDesC8& aBuffer, TInt aSize)

	/** Read data from the given buffer

	@param aItem the item to fill

	@param aBuffer the buffer to read the data from

	@param aSize the size of the item to fill

	*/

		{

        OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_READDATA_ENTRY );

        TUint8* pos = reinterpret_cast<TUint8*>(aDestinationAddress);

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

			{

			pos[i] = aBuffer[i];

			}

		OstTraceFunctionExit0( CPACKAGEDATATRANSFER_READDATA_EXIT );

		}

	void CPackageDataTransfer::SupplyFileDataL( const TDesC8& aBuffer, TBool aLastSection)

	/** Restores files from the buffer to the package.

	@param aBuffer the buffer to read data from

	@param aLastSection has all data been supplied

	*/

		{

		OstTraceFunctionEntry0( CPACKAGEDATATRANSFER_SUPPLYFILEDATAL_ENTRY );

		OstTrace1(TRACE_NORMAL, CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "aLastSection: %d", aLastSection);

		TUint8* current = const_cast<TUint8*>(aBuffer.Ptr());

		const TUint8* end = current + aBuffer.Size();

		while (current < end)

			{

			if (!iFixedHeaderRead)

				{

				if (ReadFromBufferF(iFixedHeader, current, end) == EFalse)

					{

				    OstTrace0(TRACE_NORMAL, DUP1_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "ReadFromBufferF() returned False so breaking!");

					break;

					} // if

				OstTrace1(TRACE_NORMAL, DUP2_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "fixed header - iFileNameLength:  %d", iFixedHeader.iFileNameLength);

				OstTrace1(TRACE_NORMAL, DUP3_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "fixed header - iFileSize:        %d", iFixedHeader.iFileSize);

				OstTrace1(TRACE_NORMAL, DUP4_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "fixed header - iAttributes:      %d", iFixedHeader.iAttributes);

                if ((iFixedHeader.iFileNameLength > KMaxFileName) || (!iFixedHeader.iFileNameLength))

					{

                    OstTrace1(TRACE_ERROR, DUP5_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "Leave with KErrOverflow - iFileNameLength: %d more then MaxLength", iFixedHeader.iFileNameLength);

					User::Leave(KErrOverflow);

					}

				iFixedHeaderRead = ETrue;

				} //if

			if (!iFileNameRead)

				{

				TPtr8 ptr(reinterpret_cast<TUint8*>(const_cast<TUint16*>(iFileName->Des().Ptr())), iBytesRead,iFixedHeader.iFileNameLength * KCharWidthInBytes);

				if (ReadFromBufferV(ptr, iFixedHeader.iFileNameLength * KCharWidthInBytes, current, end) == EFalse)

					{

					iBytesRead = ptr.Size();

					OstTrace1(TRACE_NORMAL, DUP6_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "ReadFromBufferV() returned False - Filename bytes read: %d", iBytesRead);

					break;

					} // if

				if (iFixedHeader.iFileNameLength > KMaxFileName)

					{

				    OstTrace0(TRACE_ERROR, DUP7_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "Leave with KErrOverflow");

					User::Leave(KErrOverflow);

					}

				iFileName->Des().SetLength(iFixedHeader.iFileNameLength);

				iFileNameRead = ETrue;

				OstTraceExt1(TRACE_NORMAL, DUP8_CPACKAGEDATATRANSFER_SUPPLYFILEDATAL, "FileName: %S", *iFileName);

				}

				if (!iFileOpen)