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

	*/

		{

		User::LeaveIfError(iSWIRestore.Connect());

		User::LeaveIfError(iSWIBackup.Connect());

		User::LeaveIfError(iFs.Connect());

		User::LeaveIfError(iFs.ShareProtected());

		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

	*/

		{

		__LOG("CPackageDataTransfer::BuildPackageFileListL() - START");

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

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

		#ifdef SBE_LOGGING_ENABLED

			const TUint fNameCount = iFiles.Count();

	        if  (fNameCount)

	            {

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

	                {

	                const TDesC& file = *iFiles[k];

	                __LOG2("CPackageDataTransfer::BuildPackageFileListL() - Files Added - file entry[%03d] %S", k, &file);

	                }

	            }

		#endif

		__LOG("CPackageDataTransfer::BuildPackageFileListL() - END");		

		}

	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

	*/

		{

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

			    __LOG("CPackageDataTransfer::GetExpectedDataSizeL - GetMetaDataL - KErrNotSupported");

			    return;

			    }

			else if(KErrNone != err)

			    {

			    __LOG1("CPackageDataTransfer::GetExpectedDataSizeL - GetMetaDataL leave with %d", err);

			    User::Leave(err);

			    }

			iMetaDataSize = iMetaData->Size();

			BuildPackageFileList();

			}

		__LOG("CPackageDataTransfer::GetExpectedDataSizeL - End getmetadata");

		if (!IsDataOnDrive(aDriveNumber))

			{

			// no data on drive

			aSize = 0;

			return;

			}

		aSize = iMetaData->Size();

		TUint count = iFiles.Count();

		switch (aTransferType)

			{

			case ESystemSnapshotData:

				{

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

				// Find all files

				aSize = (count * sizeof(TSnapshot));

				__LOG1("CPackageDataTransfer::GetExpectedDataSizeL() - passive snapshot count: %d", count);

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

					{

					const TDesC& fileName = *iFiles[x];

                	const TInt fileSize = fileName.Length();;

                	__LOG2("CPackageDataTransfer::GetExpectedDataSizeL() - passive snapshot file: %S, size: %d", &fileName, fileSize);

					aSize += fileSize;

					} // for x

				break;

				}

			case ESystemData:

				{

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

				aSize += sizeof(TInt);

				TEntry entry;

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

					__LOG2("CPackageDataTransfer::GetExpectedDataSizeL() - passive file: %S, size: %d", &fileName, fileSize);

					switch(err)

						{

					case KErrNone:

						aSize += fileSize;

						break;

					case KErrNotFound:

					case KErrPathNotFound:

					case KErrBadName:

						__LOG2("CPackageDataTransfer::GetExpectedDataSizeL() - error getting passive file: %S, error: %d", &fileName, err);

						break;

					default:

						User::Leave(err);

						}

					}

				break;

				}

			default:

				{

				__LOG2("CPackageDataTransfer::GetExpectedDataSizeL() - No case for TransferType: %d, data owner 0x%08x", aTransferType, iPackageID.iUid);

				User::Leave(KErrNotSupported);

				}

			} // switch

		__LOG2("CPackageDataTransfer::GetExpectedDataSizeL() - END - size is: %d, data owner 0x%08x", aSize, iPackageID.iUid);

		}

	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.

		*/

		{

		__LOG6("CPackageDataTransfer::RequestDataL() - START - aDrive: %c, aTransferType: %d, iSecureId: 0x%08x, iState.iState: %d, iState.iTransferType: %d, aBuffer.Length(): %d", aDriveNumber + 'A', aTransferType, iPackageID.iUid, iState.iState, iState.iTransferType, aBuffer.Length());

        //__LOGDATA("CPackageDataTransfer::RequestDataL() - %S", aBuffer.Ptr(), 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;

                Cleanup();

                return;

                }

            else if(KErrNone != err)

                {

                iState.iState = ENone;

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

			{

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

			__LOG1("CPackageDataTransfer::RequestDataL() - Left with error: %d", err);

			User::Leave(err);

			} // if

		__LOG("CPackageDataTransfer::RequestDataL() - END");

		}

	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

	*/

		{

		__LOG1("CPackageDataTransfer::SupplyFileDataL() - START - 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)

					{

					__LOG("CPackageDataTransfer::SupplyFileDataL() - ReadFromBufferF() returned False so breaking!");

					break;

					} // if

				__LOG1("CPackageDataTransfer::SupplyFileDataL() - fixed header - iFileNameLength:  %d", iFixedHeader.iFileNameLength);

                __LOG1("CPackageDataTransfer::SupplyFileDataL() - fixed header - iFileSize:        %d", iFixedHeader.iFileSize);

                __LOG1("CPackageDataTransfer::SupplyFileDataL() - fixed header - iAttributes:      %d", iFixedHeader.iAttributes);

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

					{

					__LOG1("CBufferFileReader::SupplyFileDataL() - Leaving - 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();

					__LOG1("CPackageDataTransfer::SupplyFileDataL() - ReadFromBufferV() returned False - Filename bytes read: %d", iBytesRead);

					break;

					} // if

				if (iFixedHeader.iFileNameLength > KMaxFileName)

					{

					__LOG("CBufferFileReader::SupplyFileDataL() - Leave with KErrOverflow");

					User::Leave(KErrOverflow);

					}

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

				iFileNameRead = ETrue;

				__LOG1("CPackageDataTransfer::SupplyFileDataL() - FileName: %S", iFileName);

				}

				if (!iFileOpen)

					{

					TFileName tempPath;

					// 0 is first character which will reperesent a drive

					tempPath.Append((*iFileName)[0]);

					tempPath.Append(KTempPath);

					// Create file on the drive

					TInt tempErr = iFs.MkDirAll(tempPath);

					if (tempErr == KErrNone || tempErr == KErrAlreadyExists)

						{

						TFileName tempFile;

						tempErr = iFileHandle.Temp(iFs, tempPath, tempFile, EFileWrite);

						if (iTempFileName)

							{

							delete iTempFileName;

							}

						iTempFileName = tempFile.AllocL();

						}

					if (tempErr != KErrNone)

						{

						__LOG2("CPackageDataTransfer::SupplyFileDataL() - Left creating temp file in: %S , with %d", &tempPath, tempErr);

						User::Leave(tempErr);

						}

					iFileOpen = ETrue;

					}

			// Write to the file

			TInt filesize;

			iFileHandle.Size(filesize);

			if ((end - current) >= (iFixedHeader.iFileSize - filesize))

				{

				TPtr8 ptr(current, iFixedHeader.iFileSize - filesize, iFixedHeader.iFileSize - filesize);

				User::LeaveIfError(iFileHandle.Write(ptr));

				// Write the attributes & modified time

				User::LeaveIfError(iFileHandle.Set(iFixedHeader.iModified, iFixedHeader.iAttributes, KEntryAttNormal));

				TInt err = KErrNone;

				if (((*iFileName).FindC(KPrimaryBackupRegistrationFile) >= 0) ||