_LIT(KSqlBurBackupExt,  ".bak");

_LIT(KSqlBurRestoreDir, "temprestore");

_LIT(KSqlBurAllFiles,   "*");

const TUint K8to16bitShift = 1;

///////////////////////////////   CSqlBurEventMonitor    //////////////////////////////////////////////////////////

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

/** 

Standard two phase construction. Creates a CSqlBurEventMonitor instance.

@param aInterface A reference to an interface that is used for retrieving list of databases to be sent for backup.

@return An instance of the backup notifier

@leave  KErrNoMemory, an out of memory condition has occurred;

                      Note that the function may also leave with some other system-wide error codes.

CSqlBurEventMonitor* CSqlBurEventMonitor::NewL(MSqlSrvBurInterface& aInterface)

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

	CleanupStack::Pop(self);

	SQL_TRACE_BUR(OstTrace1(TRACE_INTERNALS, CSQLBACKUPNOTIFIER_NEWL, "0x%X;CSqlBurEventMonitor::NewL", (TUint)self));

/**

Releases the allocated resources.

*/

CSqlBurEventMonitor::~CSqlBurEventMonitor()

	{

	SQL_TRACE_BUR(OstTrace1(TRACE_INTERNALS, CSQLBACKUPNOTIFIER_CSQLBACKUPNOTIFIER2, "0x%X;CSqlBurEventMonitor::~CSqlBurEventMonitor", (TUint)this));

	Cancel();

	iBurProperty.Close();

	DestroyContent();

	}

/**

Initializes data members with their default values. 

@param aInterface A reference to an interface that is used for retrieving list of databases to be sent for backup.

CSqlBurEventMonitor::CSqlBurEventMonitor(MSqlSrvBurInterface& aInterface) :

	CActive(EPriorityStandard), 

	iBurInterface(aInterface)

/**

Initializes the created CSqlBurEventMonitor object.  

@leave  KErrNoMemory, an out of memory condition has occurred;

                      Note that the function may also leave with some other system-wide error codes.

*/	

void CSqlBurEventMonitor::ConstructL()

	__SQLLEAVE_IF_ERROR(iBurProperty.Attach(KSqlBurPropertyCategoryUid, KSqlBurBackupRestoreKey));

	iBurProperty.Subscribe(iStatus);

	SetActive();

RunL() is called when the value of the {KUidSystemCategory, KUidBackupRestoreKey} gets changed.

That indicates: a backup or a restore is about to begin.

How the function works:

 - When a backup or restore notification is received, the function will subscribe again for notifications from

   the backup and restore property and will read the property status;

 - If the property status is conn::EBURUnset or conn::EBURNormal, the function will destroy iSqlBurCallback

   and iActiveBackupClient interfaces. No more callbacks will be reseived from the backup and restore server.

   This is the end of the backup or restore processing;

 - If the property status is conn::EBURBackupFull, conn::EBURBackupPartial, conn::EBURRestoreFull or 

   conn::EBURRestorePartial, the function will create iSqlBurCallback and iActiveBackupClient interface

   (iActiveBackupClient's NewL() receives iSqlBurCallback as an input parameter, registering this way the callback

   in the backup and restore server to be called later, when sending or retrieving data to/from the server).

   If the property read and the interface creation operations have been successful, the function will call 

   ConfirmReadyForBURL(KErrNone) to notify the backup and restore server that the SQL server is ready to send/retrieve 

   backup/restore data.

   If the current notification is that a backup is about to begin, after the confirmation the backup and restore server will

   call CSqlBurCallback::InitialiseGetProxyBackupDataL() once per {client secure id, drive} 

   followed by CSqlBurCallback::GetBackupDataSectionL() calls to retrieve the backup data. 

   If the current notification is that a restore is about to begin, after the confirmation the backup and restore server will

   call CSqlBurCallback::InitialiseRestoreProxyBaseDataL() once per {client secure id, drive} 

   followed by CSqlBurCallback::RestoreBaseDataSectionL() calls to send the restore data.

The current implementation has one design flaw. If a backup or restore notification is received, there are at lest 3

places before the ConfirmReadyForBURL() call, where the code may leave: 

 - the "property get" operation;

 - the iSqlBurCallback creation;

 - the iActiveBackupClient creation;

If a leave occurs at some of the mentioned places, that leave will be trapped by the current CActiveScheduler object

and CSqlBurEventMonitor::RunError() will be called with the leaved error code.

Problem #1: CSqlBurEventMonitor::RunError() won't do anything with the error (apart from printing a trace in the OST builds).

            The error is silently suppressed. The backup or restore won't start. But the client won't see any notification

            for that problem.

Problem #2: ConfirmReadyForBURL() won't be called. According to the backup and restore documentation, if

            ConfirmReadyForBURL() is called with KErrNone parameter, that's a confirmation for the backup and restore

            server to start the processing. If ConfirmReadyForBURL() is called with an error different than KErrNone,

            that's a confirmation for the backup and restore server that the client is not ready. No backup or restore

            will be started. The remote backup client will be notified about the problem.

After an investigation it was found that the same problems do exist in all active backup clients, none of them has 

solved the problems. Then, the code here will be kept as it is, it might be too dangerous to do a change right now.

@see CSqlBurEventMonitor::RunError()

@see CSqlBurCallback

@see CActiveBackupClient

@see CSqlBurCallback::InitialiseGetProxyBackupDataL()

@see CSqlBurCallback::GetBackupDataSectionL()

@see CSqlBurCallback::InitialiseRestoreProxyBaseDataL()

@see CSqlBurCallback::RestoreBaseDataSectionL()

@leave  KErrNoMemory, an out of memory condition has occurred;

                      Note that the function may also leave with some other system-wide error codes.

void CSqlBurEventMonitor::RunL()

	{

	SQL_TRACE_BUR(OstTrace1(TRACE_INTERNALS, CSQLBACKUPNOTIFIER_RUNL_ENTRY, "Entry;0x%X;CSqlBurEventMonitor::RunL", (TUint)this));

	iBurProperty.Subscribe(iStatus);

	SetActive();

	TInt status;

	__SQLLEAVE_IF_ERROR(iBurProperty.Get(status));

	status &= conn::KBURPartTypeMask;

#ifdef _SQL_RDEBUG_PRINT

	SQL_TRACE_BUR(OstTraceExt2(TRACE_INTERNALS, CSQLBACKUPNOTIFIER_RUNL1, "0x%X;CSqlBurEventMonitor::RunL;status=%d", (TUint)this, status));

#else

	SQL_TRACE_BUR(OstTraceExt2(TRACE_INTERNALS, CSQLBACKUPNOTIFIER_RUNL2, "0x%X;CSqlBurEventMonitor::RunL;status=%{TBURPartType}", (TUint)this, status));

#endif	    

	switch(status)

		{

		case conn::EBURBackupFull:

		case conn::EBURBackupPartial:

		case conn::EBURRestoreFull:

		case conn::EBURRestorePartial:

			{

			// we only do full backups and full restores

			if(!(iSqlBurCallback && iActiveBackupClient))

				{

				DestroyContent();

				TRAPD(err, CreateContentL());

				if(err != KErrNone)

					{

					DestroyContent();

					__SQLLEAVE(err);

					}

				}

			iActiveBackupClient->ConfirmReadyForBURL(KErrNone);

			}

			break;

		//case conn::EBURUnset:

		//case conn::EBURNormal:

		default:

			DestroyContent();

			break;

		}

	SQL_TRACE_BUR(OstTrace1(TRACE_INTERNALS, CSQLBACKUPNOTIFIER_EXIT, "Exit;0x%X;CSqlBurEventMonitor::RunL", (TUint)this));

	SQL_BUR_TEST_STOP();

	}

/** 

Cancels the subscribtion for {KUidSystemCategory, KUidBackupRestoreKey} property changes.

*/

void CSqlBurEventMonitor::DoCancel()

/**

No-op. The method does nothing with the reported from CSqlBurEventMonitor::RunL() error  

(apart from logging a trace in OST builds).

Actually, the right action is to return KErrNone (as it is implemented), otherwise the default implementation of 

CActiveScheduler::Error() will panic the current thread.

@see CActiveScheduler::Error()

@see CSqlBurEventMonitor::RunL()

@return The RunL() error, if the RunL() call leaves.

@param The RunL() error

TInt CSqlBurEventMonitor::RunError(TInt aError)

	SQL_TRACE_BUR(OstTraceExt2(TRACE_INTERNALS, CSQLBACKUPCLIENT_RUNERROR, "0x%X;CSqlBurEventMonitor::RunError;aError=%d", (TUint)this, aError));

	SQL_BUR_TEST_SET_ERROR(aError); 

	SQL_BUR_TEST_STOP();

/**

Creates iActiveBackupClient and iSqlBurCallback objects.

void CSqlBurEventMonitor::CreateContentL()

	iSqlBurCallback = CSqlBurCallback::NewL(iBurInterface);

	iActiveBackupClient = conn::CActiveBackupClient::NewL(iSqlBurCallback);

	}

/**

Destroys iActiveBackupClient and iSqlBurCallback objects.

*/

void CSqlBurEventMonitor::DestroyContent()

	{

	delete iActiveBackupClient;

	iActiveBackupClient = NULL;

	delete iSqlBurCallback;

	iSqlBurCallback = NULL;

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

///////////////////////////////   CSqlBackupClient    /////////////////////////////////////////////////////////////

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

/** 

Creates new CSqlBurCallback instance.

The CSqlBurEventMonitor object monitors the state of the {KUidSystemCategory, KUidBackupRestoreKey} 

property. When a backup or a restore is about to begin, the CSqlBurEventMonitor object creates a

CSqlBurCallback instance, establishes a connection with the B&R server and passes a pointer to

the CSqlBurCallback callback to the BYR conenction.

The CSqlBurCallback methods will be called during the backup/restore for sending/retrieving data.

@param aInterface A reference to an interface that is used for retrieving list of databases to be sent for backup.

@return A pointer to the created CSqlBurCallback instance

@leave  KErrNoMemory, an out of memory condition has occurred;

                      Note that the function may also leave with some other system-wide error codes.

*/

CSqlBurCallback* CSqlBurCallback::NewL(MSqlSrvBurInterface& aInterface)

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

	SQL_TRACE_BUR(OstTrace1(TRACE_INTERNALS, CSQLBACKUPCLIENT_NEWLC, "0x%X;CSqlBurCallback::NewL", (TUint)self));

	return self;

	}

/**

Initializes CSqlBurCallback data members with their default values. 

@param aInterface A reference to an interface that is used for retrieving list of databases to be sent for backup.

*/		

CSqlBurCallback::CSqlBurCallback(MSqlSrvBurInterface& aInterface) :

	iInterface(aInterface)

	{

/** 

Releases the allocated resources.

CSqlBurCallback::~CSqlBurCallback()

	SQL_TRACE_BUR(OstTraceExt2(TRACE_INTERNALS, CSQLBACKUPCLIENT_CSQLBACKUPCLIENT2, "0x%X;CSqlBurCallback::~CSqlBurCallback;iFile.SubSessionHandle()=0x%X", (TUint)this, (TUint)iFile.SubSessionHandle()));

	BackupCleanup();

	(void)RestoreCleanup();

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

/////////////////////////////////////       Full backup   //////////////////////////////////////////////////////////

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

/** 

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

We ask the SQL server (using iInterface, see MSqlSrvBurInterface for more details) 

for a list of databases that want to be backed up.

The backup is initiated by a notification received in CSqlBurEventMonitor::RunL() method.

InitialiseGetProxyBackupDataL() is called once per {client secure id, drive} and each 

InitialiseGetProxyBackupDataL() call is followed after that by a set of CSqlBurCallback::GetBackupDataSectionL() calls,

made from the backup and restore client dll.

During GetBackupDataSectionL() calls the CSqlBurCallback object will read the content of the databases from the list,

retrieved from the MSqlSrvBurInterface::GetBackUpListL() call and send the content to the backup and restore server.     

@see MSqlSrvBurInterface

@see CSqlBurEventMonitor::RunL()

@see CSqlBurCallback::GetBackupDataSectionL()

@see CSqlServer::GetBackUpListL() 

@param aSid the UID of the application to backup

@param aDrive the drive to be backed up

@leave  KErrNoMemory, an out of memory condition has occurred;

                      Note that the function may also leave with some other system-wide error codes.

void CSqlBurCallback::InitialiseGetProxyBackupDataL(TSecureId aSid, TDriveNumber aDrive)

	SQL_TRACE_BUR(OstTraceExt3(TRACE_INTERNALS, CSQLBACKUPCLIENT_INITIALIZEGETPROXYBACKUPDATAL, "0x%X;CSqlBurCallback::InitialiseGetProxyBackupDataL;aSid=0x%X;aDrive=%d", (TUint)this, (TUint)aSid.iId, (TInt)aDrive));

	BackupCleanup();

	iInterface.GetBackUpListL(aSid, aDrive, iFileList);

	iFileIndex = 0;

	iState = EBackupNoFileOpen;

	iBackupError = KErrNone;

/** 

This is supposed to allow the B&R framework 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.

@see CSqlBurEventMonitor::RunL()

@see CSqlBurCallback::InitialiseGetProxyBackupDataL()

@param aDrive Unused parameter (the drive number is logged in OST builds).

@return an arbitrary number (1024 at the moment)

TUint CSqlBurCallback::GetExpectedDataSize(TDriveNumber aDrive)

	SQL_TRACE_BUR(OstTraceExt3(TRACE_INTERNALS, CSQLBACKUPCLIENT_GETEXPECTEDDATASIZE, "0x%X;CSqlBurCallback::GetExpectedDataSize;aDrive=%d;rc=%u", (TUint)this, (TInt)aDrive, 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.

Please note how the function processes the errors occuring during the backup.

If an error occurs, the error is not propagated back to the B&R server immediatelly.

The error is stored in iBurError data member and is reported at the end of the backup process.

The reason for such unusual error reporting poicy is: the SQL server performs full backup of possibly more

than one database file. If an error occurs during the backup of the first file for example, the backup

process should not stop at that point. All files will be processed and then at the end, the error will be reproted.

In details, the function runs a state machine, where:

 - every file in the list retrieved in InitialiseGetProxyBackupDataL() is opened;

 - the file is read and 32-bit checksum over the file data - calculated;

 - a file backup header is prepared, including there the file size, file name, file name length, protocol verison number

   and the checksum. The header is sent to the backup restore server;

 - the file data is read and sent to the backup and restore server;

 - during the described above sequence no leave ever occurs. The error that occurs during the file processing,

   is stored into a data member of CSqlBurCallback class. At the end, after the last file in the list is processed,

   the backup and restore server will get a notification (via a User::Leave() call) regarding the error;

   The used error reporting policy allows all files to be process without interrupting the backup process.

   For example, if there are 5 files to be sent to the backup and restore server, an error that occurs during the 

   processing of file #3, won't prevent files #4 and #5 from being sent for backup.       

@see CSqlBurEventMonitor::RunL()

@see CSqlBurCallback::InitialiseGetProxyBackupDataL()

@param aBuffer Output parameter, the buffer where the data will be put to be passed back

@param aFinishedFlag Set to true when all data has been submitted for backup

@leave  KErrNoMemory, an out of memory condition has occurred;

                      Note that the function may also leave with some other system-wide error codes.

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

		// nothing to backup

		SQL_TRACE_BUR(OstTrace1(TRACE_INTERNALS, CSQLBACKUPCLIENT_GETBACKUPDATASECTIONL1, "0x%X;CSqlBurCallback::GetBackupDataSectionL;file count is 0", (TUint)this));

		aFinishedFlag = ETrue;

		BackupCleanup();

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

					SQL_TRACE_BUR(OstTraceExt2(TRACE_INTERNALS, CSQLBACKUPCLIENT_GETBACKUPDATASECTIONL2, "0x%X;CSqlBurCallback::GetBackupDataSectionL;all files processed;iBackupError=%d", (TUint)this, iBackupError));

					aFinishedFlag = ETrue;

					BackupCleanup();

					__SQLLEAVE_IF_ERROR(iBackupError);

				TPtrC fname = iFileList[iFileIndex]->Des();

				TInt err = iFile.Open(iInterface.Fs(), fname, EFileRead | EFileShareExclusive);

				SQL_TRACE_BUR(OstTraceExt5(TRACE_INTERNALS, CSQLBACKUPCLIENT_GETBACKUPDATASECTIONL3, "0x%X;CSqlBurCallback::GetBackupDataSectionL;BEGIN;fname=%S;iFileIndex=%d;iFile.SubSessionHandle()=0x%X;err=%d", (TUint)this, __SQLPRNSTR(fname), iFileIndex, (TUint)iFile.SubSessionHandle(), err));

				if(KErrNone != err)

					SetBackupError(err);

				TInt err = iFile.Size(fileSize);

				if(KErrNone != err)

					SetBackupError(err);

					iState = EBackupEndOfFile;

				TUint64 checksum64 = 0;

				err = CheckSum(iFile, checksum64);

				SQL_TRACE_BUR(OstTraceExt3(TRACE_INTERNALS, CSQLBACKUPCLIENT_GETBACKUPDATASECTIONL4, "0x%X;CSqlBurCallback::GetBackupDataSectionL;CheckSum();iFileIndex=%d;err=%d", (TUint)this, iFileIndex, err));

				if(err != KErrNone)

					{

					//An error occured while reading the file (or there was not enough memory for the read buffer)

					SetBackupError(err);

					iState = EBackupEndOfFile;

					break;

					}

				// Only grab last 4 bytes of the checksum - enough to be satisfied that the backup and restore worked ok

				TUint32 checksum32 = checksum64 & KMaxTUint32;

				TPtrC fname = iFileList[iFileIndex]->Des();

					checksum32,					// %8x

					KSqlBurMagicNum,			// %8x

					KSqlBurHeaderVersion,		// %4x

					fname.Length(),				// %8x

					&fname);					// %S

				SQL_TRACE_BUR(OstTraceExt4(TRACE_INTERNALS, CSQLBACKUPCLIENT_GETBACKUPDATASECTIONL5, "0x%X;CSqlBackupClient::GetBackupDataSectionL;fileName=%S;hdrPtr=|%S|;fileSize=%lld", (TUint)this, __SQLPRNSTR(fname), __SQLPRNSTR(iBuffer), fileSize));