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

 //

 #ifndef __SQLBUR_H__

 #define __SQLBUR_H__

 #include <e32base.h>

 #include <f32file.h>

 #include <f32file64.h>

 #include <e32property.h>

 #include <connect/abclient.h> // MactiveBackupDataClient

 #include "SqlSrvBurInterface.h"

 //Forward declarations

 class CSqlBurCallback;

 #ifdef SQL_BUR_PROPERTY_MONITOR_TEST

 const TInt32 KSqlBurPropertyCategory = 0x10281e17;//the SQL server secure id (the bur tests have the same id, 

                                                   //in order to be able to operate with the property)

 const TUint KSqlBurBackupRestoreKeyValue = 0x1234DDD1;

 extern TInt TestModeSqlBurError;

 #define SQL_BUR_TEST_SET_ERROR(err) TestModeSqlBurError = err 

 //This macro is called at the end of CSqlBurEventMonitor::RunL()and CSqlBurEventMonitor::RunError() 

 //CActiveScheduler::Stop() is called here to return the execution control back to the test code.

 #define SQL_BUR_TEST_STOP() CActiveScheduler::Stop() 

 #else

 const TInt32 KSqlBurPropertyCategory = KUidSystemCategoryValue;

 const TUint KSqlBurBackupRestoreKeyValue = conn::KUidBackupRestoreKey;

 #define SQL_BUR_TEST_SET_ERROR(err) (void)0 

 #define SQL_BUR_TEST_STOP() (void)0 

 #endif

 /**

 The system category of the backup and restore property, that is used for notifying active backup clients

 regarding beginning or the end of backup or restore process.

 Different value is used in SQL tests, because only the secure backup server can set or get the value of

 the  {KUidSystemCategoryValue, conn::KUidBackupRestoreKey} property. 

 @internalComponent

 */

 const TUid KSqlBurPropertyCategoryUid = {KSqlBurPropertyCategory};

 /**

 The backup and restore property key, that is used for notifying active backup clients

 regarding beginning or the end of backup or restore process. 

 Different value is used in SQL tests, because only the secure backup server can set or get the value of

 the  {KUidSystemCategoryValue, conn::KUidBackupRestoreKey} property. 

 @internalComponent

 */

 const TUint KSqlBurBackupRestoreKey = KSqlBurBackupRestoreKeyValue;

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

 //////////////                     Backup database file header format                           ///////////////////

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

 ////// No version (Version 0)

 //  8 chars          8 chars          8 chars             up to 256 characters (512 bytes)

 // <32-bit checksum><32-bit filesize><32-bit filenamelen><filename - UTF16 encoded>

 //////             Version 2

 //  8 chars          8 chars   4 chars     16 chars         8 chars             up to 256 characters (512 bytes)

 // <32-bit checksum><FFFFAA55><Version N#><64-bit filesize><32-bit filenamelen><filename - UTF16 encoded>

 const TInt KSqlBurHeaderVersion = 2;             //Current backup database file header version

 const TUint32 KSqlBurMagicNum = 0xFFFFAA55;      //Magic number. If the "old database file size" field in the header

                                                  //has this value, then the header version is 2+

 const TInt KSqlBurMaxHeaderSize = 256 + KMaxFileName; //The size of the buffer used for the operations on the header

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

 /**

 An object of this class is created to monitor the backup & restore property

 {KUidSystemCategory, KUidBackupRestoreKey}.

 If the property gets set, the CSqlBurEventMonitor object will create a CSqlBurClient

 instance to handle the backup or restore.  

 @internalComponent

 */

 class CSqlBurEventMonitor : public CActive

 	{

 public:

 	static CSqlBurEventMonitor* NewL(MSqlSrvBurInterface& aBufInterface);

 	virtual ~CSqlBurEventMonitor();

 #ifdef SQL_BUR_PROPERTY_MONITOR_TEST

 	inline conn::CActiveBackupClient* ActiveBackupClient();

 	inline CSqlBurCallback* SqlBurCallback();

 #endif

 private:

 	CSqlBurEventMonitor(MSqlSrvBurInterface& aInterface);

 	void ConstructL();

 	virtual void RunL();

 	virtual void DoCancel();

 	virtual TInt RunError(TInt aError);

 	void CreateContentL();

 	void DestroyContent();

 private:

 	RProperty 					iBurProperty;//B&R property published by the B&R server. SQL server subscribes for notifications

 	MSqlSrvBurInterface& 		iBurInterface;//Provided by the SQL server

 	conn::CActiveBackupClient*	iActiveBackupClient;//The connection with the B&R server

 	CSqlBurCallback*			iSqlBurCallback;//A "Database file list" interface provided by the SQL server

 	};

 #ifdef SQL_BUR_PROPERTY_MONITOR_TEST

 inline conn::CActiveBackupClient* CSqlBurEventMonitor::ActiveBackupClient()

 	{

 	return iActiveBackupClient;

 	}

 inline CSqlBurCallback* CSqlBurEventMonitor::SqlBurCallback()

 	{

 	return iSqlBurCallback;

 	}

 #endif

 /**

 This class is called by the Backup and Restore Framework

 when a backup or restore is requested by the user

 It implements the active proxy backup and restore as

 defined in the MActiveBackupDataClient interface.

 @internalComponent

 */

 class CSqlBurCallback : public CBase, public conn::MActiveBackupDataClient

 	{

 public:

 	static CSqlBurCallback* NewL(MSqlSrvBurInterface& aBufInterface);

 	virtual ~CSqlBurCallback();

 	//Implementations of virtuals from MActiveBackupDataClient - full backup

 	virtual void InitialiseGetProxyBackupDataL(TSecureId aSid, TDriveNumber aDrive);

 	virtual TUint GetExpectedDataSize(TDriveNumber aDrive);

 	virtual void GetBackupDataSectionL(TPtr8& aBuffer, TBool& aFinished);

 	//Implementations of virtuals from MActiveBackupDataClient - full restore

 	virtual void InitialiseRestoreProxyBaseDataL(TSecureId aSid, TDriveNumber aDrive);

 	virtual void RestoreComplete(TDriveNumber aDrive);

 	virtual void RestoreBaseDataSectionL(TDesC8& aBuffer, TBool aFinished);

 	virtual void TerminateMultiStageOperation();

 	virtual TUint GetDataChecksum(TDriveNumber aDrive);	

 	//Implementations of virtuals from MActiveBackupDataClient - incremental backup & restore - not supported

 	virtual void AllSnapshotsSuppliedL();

 	virtual void ReceiveSnapshotDataL(TDriveNumber aDrive, TDesC8& aBuffer, TBool aLastSection);

 	virtual void GetSnapshotDataL(TDriveNumber aDrive, TPtr8& aBuffer, TBool& aFinished);

 	virtual void InitialiseGetBackupDataL(TDriveNumber aDrive);

 	virtual void InitialiseRestoreBaseDataL(TDriveNumber aDrive);

 	virtual void InitialiseRestoreIncrementDataL(TDriveNumber aDrive);

 	virtual void RestoreIncrementDataSectionL(TDesC8& aBuffer, TBool aFinished);

 	// to validate successful BUR

 	TInt CheckSum(const RFile64 &aOpenFile, TUint64& aCheckSum) const;

 private:

 	CSqlBurCallback(MSqlSrvBurInterface& aInterface);

 	void CopyBufData(const TDesC8& aInBuf, TInt& aInBufReadPos, TDes& aOutBuf, TInt aDataLen);

 	void BackupCleanup();

 	TInt RestoreCleanup();

 	void SetBackupError(TInt aError);

 private:

 	// state machine for backup

 	enum

 		{

 		EBackupNoFileOpen=0, // not currently processing a file

 		EBackupOpenNothingSent, // file open and ready, but nothing sent yet

 		EBackupOpenPartHeaderSent, // part of the header is sent, but more remains

 		EBackupOpenAllHeaderSent, // all of the header is sent, ready to send the data

 		EBackupEndOfFile // all done, tidy up after backup

 		};

 	// state machine for restore

 	// this is more complicated because we are driven by the backup engine

 	// and have incomplete information most of the time

 	enum

 		{

 		ERestoreExpectChecksum=0, 		// checksum marks the start of the next file

 		ERestoreExpectOldFileSize, 		// the size of the file - backup file header version 0

 		ERestoreExpectVersion, 			// backup header version

 		ERestoreExpectFileSize, 		// the size of the file, backup file header version 2+

 		ERestoreExpectFileNameSize, 	// the size of the file name

 		ERestoreExpectFileName, 		// the name of the file to restore

 		ERestoreExpectData, 			// now for the data

 		ERestoreComplete 				// tidy up after restore

 		};

 	MSqlSrvBurInterface& iInterface;	//A "Database file list" interface provided by the SQL server

 	RArray<HBufC*> iFileList; 			//An array with database file names for backup, provided by the SQL server 

 	RFile64 iFile;						//A handle to file being backup/restored.

 	TInt iFileIndex;					//The index of the file name in iFileList being processed at the moment 

 	TUint iState;						//Backup or restore state machine - current state

 	TBuf<KSqlBurMaxHeaderSize> iBuffer; //Used for the header data

 	TInt iHeaderSent; 					//How many header bytes sent so far

 	TUint32 iChecksum; 					//Database archive checksum - used by the restore.

 	TInt64 iFileSize; 					//Restored database file size - used by the restore.

 	TUint32 iFileNameSize; 				//Restored database file name size - used by the restore.

 	TDriveNumber iRestoreDrive;			//The drive where the data is currently restored to.

 	TSecureId iRestoreId;				//The secure id of the client which data is being restored at the moment

 	TInt iBackupError;					//An error occured during the backup processing

 	TFileName iRestoreDir;				//The directory where temporary files will be created during restore.

 	TParse iParse;

 	};

 #endif // __SQLBUR_H__