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

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

	*/

		{

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

		CleanupStack::Pop(self);

		return self;

		}

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

	/** Standard Symbian Constructor

	@param aPid Package Id

	@return a CPackageDataTransfer object

	*/

		{

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

		CleanupStack::PushL(self);

		self->ConstructL();

		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)

	  	{

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

		}

	void CPackageDataTransfer::ConstructL()

	/** Standard Symbian second phase constructor

	*/

		{

		iRegistrationFile = HBufC::NewL(0);

		iFileName = HBufC::NewL(KMaxFileName);

		iTempFileName = HBufC::NewL(KMaxFileName);

		}

	CPackageDataTransfer::~CPackageDataTransfer()

	/** Standard C++ Destructor

	*/

	  	{

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

		}

	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

	*/										 

		{

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

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

			{

			aBuffer.Append(pos[i]);

			}

		}

	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

	*/

		{

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

		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

		}

	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

	*/

		{

		if (iMetaData == NULL)

			{

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

			if(KErrNotSupported == err)

			    {//Non-Removable package, nothing to backup

			    aSize = 0;

			    return;

			    }

			else if(KErrNone != err)

			    {

			    User::Leave(err);

			    }

			iMetaDataSize = iMetaData->Size();

			BuildPackageFileList();

			}

		if (!IsDataOnDrive(aDriveNumber))

			{

			// no data on drive

			aSize = 0;

			return;

			}

		aSize = iMetaData->Size();

		TUint count = iFiles.Count();

		switch (aTransferType)

			{

			case ESystemSnapshotData:

				{

				// Find all files

				aSize = (count * sizeof(TSnapshot));

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

					{

					const TDesC& fileName = *iFiles[x];

                	const TInt fileSize = fileName.Length();;

					aSize += fileSize;

					} // for x

				break;

				}

			case ESystemData:

				{

				aSize += sizeof(TInt);

				TEntry entry;

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

					{

					const TDesC& fileName = *iFiles[x];

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

					TUint fileSize = entry.iSize;

					switch(err)

						{

					case KErrNone:

						aSize += fileSize;

						break;

					case KErrNotFound:

					case KErrPathNotFound:

					case KErrBadName:

						break;

					default:

						User::Leave(err);

						}

					}

				break;

				}

			default:

				{

				User::Leave(KErrNotSupported);

				}

			} // switch

		}

	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.

		*/

		{

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

                return;

                }

            else if(KErrNone != err)

                {

                iState.iState = ENone;

                aLastSection = ETrue;

                Cleanup();

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

			{

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

			User::Leave(err);

			} // if

		}

	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

	*/

		{

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

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

			{

			pos[i] = aBuffer[i];

			}

		}

	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

	*/

		{

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

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

		while (current < end)

			{

			if (!iFixedHeaderRead)

				{

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

					{

					break;

					} // if

                if ((iFixedHeader.iFileNameLength > KMaxFileName) || (!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();

					break;

					} // if

				if (iFixedHeader.iFileNameLength > KMaxFileName)

					{

					User::Leave(KErrOverflow);

					}

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

				iFileNameRead = ETrue;

				}

				if (!iFileOpen)