// Copyright (c) 2005-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:

//

#include "SqlBur.h"

#include "SqlAssert.h"

#include "SqlPanic.h"

//Extracts and returns 32-bit integer from aNumBuf buffer.

static TUint32 GetNumUint32L(const TDesC& aNumBuf)

	{

	TLex lex(aNumBuf);

	lex.SkipSpace();

	TUint32 num = 0xFFFFFFFF;

	__SQLLEAVE_IF_ERROR(lex.Val(num, EHex));

	return num;

	}

//Extracts and returns 64-bit integer from aNumBuf buffer.

static TInt64 GetNumInt64L(const TDesC& aNumBuf)

	{

	TLex lex(aNumBuf);

	lex.SkipSpace();

	TInt64 num = -1;

	__SQLLEAVE_IF_ERROR(lex.Val(num, EHex));

	return num;

	}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// string consts

_LIT(KRestoreFilter,"*.rst"); // the filter for restore files

_LIT(KBackupFilter,"*.bak");// the filter for backup files

_LIT(KRestoreSuffix,".bak.rst"); // the suffix for restore files (a shortcut by using double suffix :)

const TUint K8to16bitShift = 1;

/** Standard two phase construction

	@return an instance of the backup client

	@param a pointer to the SQL server which must have implemented the

			TSqlSrvBurInterface interface

	@leave if no memory

*/

CSqlBackupClient* CSqlBackupClient::NewLC(MSqlSrvBurInterface *aInterface)

	{

	CSqlBackupClient *self=(CSqlBackupClient *)new(ELeave) CSqlBackupClient(aInterface);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

/** Standard two phase construction

	@return an instance of the backup client

	@param a pointer to the SQL server which must have implemented the

			TSqlSrvBurInterface interface

	@leave if no memory

*/

CSqlBackupClient* CSqlBackupClient::NewL(MSqlSrvBurInterface *aInterface)

	{

	CSqlBackupClient *self=(CSqlBackupClient *) NewLC(aInterface);

	CleanupStack::Pop();

	return self;

	}

/** Standard two phase construction

	@param a pointer to the SQL server which must have implemented the

			TSqlSrvBurInterface interface

*/		

CSqlBackupClient::CSqlBackupClient(MSqlSrvBurInterface *aInterface)

: CActive(EPriorityStandard), iInterface(aInterface)

	{

	}

/** Usual tidy up

*/

CSqlBackupClient::~CSqlBackupClient()

	{

	// cancel outstanding requests

	Cancel();

	// release the pub/sub property

	iProperty.Close();

	// make sure the file list is released

	iFileList.Reset();

	// the file list array

	iFileList.Close();

	// close the file

	iFile.Close();

	// nuke the active backup client

	}

/** Standard two phase construction

	@leave if non memory or StartL leaves

*/	

void CSqlBackupClient::ConstructL()

	{

	// attach to backup/restore publish/subscribe property

	__SQLLEAVE_IF_ERROR(iProperty.Attach(KUidSystemCategory,KUidBackupRestoreKey));

	// add us to the scheduler

	CActiveScheduler::Add(this);

	// set active and request notification of changes to backup

	// and restore publish/subscribe property

	StartL();	

	}

/** Nuke outstanding requests

*/

void CSqlBackupClient::DoCancel()

	{

	// lose any oustanding reqs

	iProperty.Cancel();

	}

/** Not implemented

	@return a flag indicating whether we actioned the error

	@param the error unused

*/

TInt CSqlBackupClient::RunError(TInt /* aError */)

	{

	// just satisfy it that we did something!

	return KErrNone;

	}

/**	Kick off the BUR client

	@leave if TestBurStatusL leaves

*/

void CSqlBackupClient::StartL()

	{

	}

/** Resubscribe and wait for events

*/	

void CSqlBackupClient::NotifyChange()

	{

	iProperty.Subscribe(iStatus);

	SetActive();

	}

/** Something happened. Find out what.

	Create an instance of BUR client if required

	Delete it if no longer required

	This is for performance reasons

	@leave if ConfirmReadyForBURL leaves

*/

void CSqlBackupClient::TestBurStatusL()

	{

	TInt status;

	if(iProperty.Get(status)!=KErrNotFound)

		{

		status&=KBURPartTypeMask;

		switch(status)

			{

			case EBURNormal:

				break;

			case EBURBackupFull:

			case EBURBackupPartial:

				if(!iActiveBackupClient)

					{

					iActiveBackupClient=CActiveBackupClient::NewL(this);

					}

				iActiveBackupClient->ConfirmReadyForBURL(KErrNone);

				break;

			default:

				return;

			}

		}

	}

/** Called when BUE notifies a BUR event

	@leave if TestBurStatusL leaves

*/

void CSqlBackupClient::RunL()

	{

	NotifyChange();

	TestBurStatusL();

	}

/** This is supposed to allow the BUE to know in advance how much

	data is coming - but unfortunately there is no way to know this

	at this stage since we don't even know yet what SID is being processed

	So we just answer some number to make the BUE happy. It doesn't

	actually rely on this number so there is no risk - the aFinishedFlag

	indicates the end of data, not the value returned here. It is

	supposed to allow the BUE to optimise its behaviour by know up front

	the data volume.

	@return an arbitrary number

	@param TDrive unused

*/

TUint CSqlBackupClient::GetExpectedDataSize(TDriveNumber /* aDrive */)

	{

	// we have no idea at this point - we even don't know who is to be backed up yet

	const TUint KArbitraryNumber = 1024;

	return KArbitraryNumber;

	}

/** This is the backup state machine

	Because the data has to be sent back in sections and the various

	components of the dataflow may straddle chunks, we have to keep

	track of where we are between each transfer - a state machine is

	the simplest and most understandable implementation

	@param TPtr this is where the data will be put to be passed back

	@param TBool set to true when all data has been submitted for backup

	@leave

*/

void CSqlBackupClient::GetBackupDataSectionL(TPtr8& aBuffer, TBool& aFinishedFlag)

	{

	// don't assume they set it to false

	aFinishedFlag=EFalse;

	// any files to backup

	if(iFileList.Count()==0)

		{

		// nothing to backup - just return the finished flag

		aFinishedFlag=ETrue;

		// clear down the list

		iFileList.Reset();

		// iFileList closed in dtor

		return;

		}

	// run the state machine

	for(TInt bufFreeSpace=aBuffer.MaxSize()-aBuffer.Size(); bufFreeSpace>0; bufFreeSpace=aBuffer.MaxSize()-aBuffer.Size())

		{

		switch(iState)

			{

			case EBackupNoFileOpen: // open a file for processing

				{

				if(iFileIndex>=iFileList.Count())

					{

					// all files have been processed - send the finished flag

					aFinishedFlag=ETrue;

					// clear down the filelist

					iFileList.Reset();

					return;

					}

				// open the database file to send

				TInt rc=iFile.Open(	iInterface->Fs(), iFileList[iFileIndex].FullName(), EFileRead | EFileShareExclusive);

				if(KErrNone!=rc)

					{

					// there's nothing we can do if we can't open the file so we just skip it

					++iFileIndex;

					break;

					}

				iState=EBackupOpenNothingSent;

				break;

				}

			case EBackupOpenNothingSent: // nothing sent (so far) for this file - send the header info

				{

				TInt64 fileSize;

				if(KErrNone!=iFile.Size(fileSize) || fileSize==0) // short circuit eval

					{

					// empty or unreadable - skip this file

					iState=EBackupEndOfFile;

					break;

					}

				// get the checksum - only grab last 4 bytes - enough to be satisfied that

				// the backup and restore worked ok

				const TDesC& fileName = iFileList[iFileIndex].FullName();

					checksum,					// %8x

					KMagicNum,					// %8x

					KBackupHeaderVersion,		// %4x

					fileSize,					// %16lx

					fileName.Length(),			// %8x

					&fileName);					// %S

				// we need it to look like an 8bit buffer

				TInt len = Min(hdrPtr8.Size(), bufFreeSpace);

				// append the header to the buffer (only till it's full)

				aBuffer.Append(hdrPtr8.Ptr(), len);

				// decide what needs to happen next

				// if complete then we need data, otherwise we need to put

				// the rest of the header in the next chunk

				if(hdrPtr8.Size() <= bufFreeSpace)

					{

					iState = EBackupOpenAllHeaderSent;

					}

				else

					{

					// we need to keep track of how much of the header has

					// been sent so that we only send the reminder on the next

					// iteration

					iHeaderSent = len;

					iState = EBackupOpenPartHeaderSent;

					}

				break;

				}

			case EBackupOpenPartHeaderSent: // need to send the rest of the header

				{

				// get back the header - this is already loaded with the necessary info

				// we need it to look like an 8bit buffer

				// how many bytes have we yet to send?

				TInt len = Min(bytesRemaining, bufFreeSpace);

				aBuffer.Append(hdrPtr8.Ptr() + iHeaderSent, len);

				if(bytesRemaining <= bufFreeSpace)

					{

					iHeaderSent = 0; // ready for next header

					iState = EBackupOpenAllHeaderSent;

					}

				else

					{

					iHeaderSent += len; // ready to do round again

					//iState=EBackupOpenPartHeaderSent; same state as now!

					}

				break;

				}

			case EBackupOpenAllHeaderSent: // need to send some data

				{

				TPtr8 ptr((TUint8*)aBuffer.Ptr() + aBuffer.Size(), 0, bufFreeSpace);

				__SQLLEAVE_IF_ERROR(iFile.Read(ptr));

				TInt bytesRead = ptr.Size();

				aBuffer.SetLength(aBuffer.Size() + bytesRead);

				// EOF

				if(bytesRead == 0)

					{

					iState = EBackupEndOfFile;

					break;

					}

				break;

				}

			case EBackupEndOfFile:

				{

				iFile.Close();

				++iFileIndex; // move on to next file

				iState = EBackupNoFileOpen; // go round again

				break;

				}

			default:

				{

				break;

				}

			}//end of the "switch" statement

		}//end of the "for" statement

	}

/** This is called by BUE when the restore has completed

	Nothing to do here except tell the server

	@param TDrive the drive that is being restored (unused)

*/

void CSqlBackupClient::RestoreComplete(TDriveNumber /* aDrive */)

	{

	}

/** This is called to let us know that the given SID is to be backed up

	We ask the SQL server for a list of databases that want to be backed

	up - this is because the backup flag is an internal metadata object

	in the database, and to decouple we don't want to have to know how

	this data is stored.

	@param TSecureSid the UID of the application to backup

	@param TDriveNumber the drive to be backed up (unused)

	@leave

*/

void CSqlBackupClient::InitialiseGetProxyBackupDataL(TSecureId aSid, TDriveNumber /*aDrive*/)

	{

	// get the list of database files to back up - this is provided by the SQL server

	GetBackupListL(aSid);

	// this is the index of the file being processed - point to the beginning

	iFileIndex=0;

	// the first state of the backup state machine

	iState=EBackupNoFileOpen;

	// save the sid for notifying the server when the backup is complete

	iSid=aSid;

	}

/** Called when the BUE wants to start sending data to us

	@param TSecureId the UID of the application that is to be restored

	@param TDriveNumber the drive to restore (unused)

	@leave

*/

void CSqlBackupClient::InitialiseRestoreProxyBaseDataL(TSecureId aSid, TDriveNumber /* aDrive */)

	{

	// this is the first state of the restore state machine

	iState=ERestoreExpectChecksum;

	iAnyData=EFalse; // to keep track in the state machine whether any data was actually sent

	// save the sid for notifying the server when the restore is done

	iSid=aSid;

	}

/** This is repeatedly called by the BUE to send us chunks of restore data (for the current SID)

    Becuase the data is spread over chunks we need to manage the state across mutiple calls

    to this method so we use a state machine

    @leave KErrCorrupt if the data is incomplete or the checksum fails

    @param TDesc8 the data to be restored

    @param TBool set when there is not more data to restore

Attention!!! This function won't work properly if aInBuffer parameter contains odd number of bytes!!!

(a legacy problem, if it is a problem at all, because the B&R engine probably sends the data in chunks with even size)

*/

void CSqlBackupClient::RestoreBaseDataSectionL(TDesC8& aInBuffer, TBool aFinishedFlag)

	{

	// used to walk the buffer

	// got a new buffer - because each time this method is called, we have a

	// fresh chunk of data

	TInt inBufferPos = 0;

	// to mark when the state machine is through

	TBool done = EFalse;

	// check whether this is an empty restore

	if(aFinishedFlag && !iAnyData)

		{

		// we have to do this and not rely on aFinishedFlag alone, becuase

		// if aFinished is used, we'll process the last state of the machine

		// which does tidyup, except that if there was no data, no tidyup should

		// be done

		return;

		}

	// run the machine

	do

		{

		// how many bytes are there available in the buffer for processing?

		TInt bytesAvailable = aInBuffer.Size() - inBufferPos;

		// the reason why we are testing finishedFlag is because we must

		// make sure we re-enter the machine to do the tidyup

		if(bytesAvailable <= 0 && !aFinishedFlag)

			{

			// ran out of data in the chunk

			// so we return and wait for more data to arrive

			return;

			}

		if(aFinishedFlag && iState != ERestoreComplete && iState != ERestoreExpectData)

			{

			// ran out of data early

			// will be ERestoreComplete if data not aligned on 128

			// will be ERestoreExpectData if data aligned on 128

			__SQLLEAVE(KErrCorrupt);

			}

		// yep there was some data in the chunk if we got here

		if(bytesAvailable > 0)

			{

			iAnyData = ETrue;

			}

		switch(iState)

			{

			case ERestoreExpectChecksum: // 16 bytes (the header is UTF16 encoded, 8 unicode characters for the checksum)

				{

				const TInt KCheckSumStrLen = 8;

					{

					iState = ERestoreExpectOldFileSize;

					}

				break;

				}

			case ERestoreExpectOldFileSize: // 16 bytes (the header is UTF16 encoded, 8 unicode characters for 32-bit old file size)

				{

				const TInt KOldFileSizeStrLen = 8;

					{

					if(oldFileSize == KMagicNum)

						{

						iState = ERestoreExpectVersion;

						}

					else

						{

						iFileSize = oldFileSize;	

						iState = ERestoreExpectFileNameSize;

						}

					}

				break;

				}	

			case ERestoreExpectVersion:

				{

				const TInt KVersionStrLen = 4;

					{

					//At this stage we know that the version is 2+

					iState = ERestoreExpectFileSize;

					}

				break;

				}

			case ERestoreExpectFileSize:

				{