// 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 CABSession class.

// 

//

/**

 @file

*/

#include <e32base.h>

#include "abserver.h"

#include "absession.h"

#include <connect/abclientserver.h>

#include "sbedataownermanager.h"

#include "sbedataowner.h"

#include <connect/sbtypes.h>

#include "sbepanic.h"

#include "sblog.h"

namespace conn

	{

	CABSession* CABSession::NewL(TSecureId aSecureId)

	/**

	Symbian first phase constructor

	@param aSecureId The SID of the client that's connecting to this session

	*/

		{

		CABSession* self = new (ELeave) CABSession(aSecureId);

		CleanupStack::PushL(self);

		self->ConstructL();

		CleanupStack::Pop(self);

		return self;

		}

	void CABSession::ConstructL()

	/**

	Symbian second phase constructor. Initialise some more of the data members

	*/

		{

		iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait;

		__LOG1("CABSession::ConstructL() [0x%08x]", iClientSID.iId);

		}

	CABSession::CABSession(TSecureId aSecureId) : iClientSID(aSecureId), 

		iCallbackWatchdog(NULL), iActiveSchedulerWait(NULL), iABClientLeaveCode(KErrNone), 

		iReceiveFromClientFinished(ETrue), iSendToClientBuffer(NULL, 0), 

		iWatchdogHandler(ABSessionStaticWatchdogCaller, static_cast<TAny*>(this)), iMisbehavingClient(EFalse),

		iInvalid(EFalse)

    /**

    Class Constructor

	@param aSecureId The SID of the client that's connecting to this session

    */

		{

		}

	CDataOwner& CABSession::DataOwnerL() const

	/**

	Return the active data owner

	@return A reference to the active data owner

	*/

		{

		return Server().DataOwnerManager().DataOwnerL(iClientSID);

		}

	TInt CABSession::ABSessionStaticWatchdogCaller(TAny* aWatchdoggingObject)

	/**

	CPeriodic only accepts a TCallBack style function pointer which must be a pointer to a static or

	non-member function. As we need to have watchdogs per session object instead of per class, we 

	must make the call to the particular object from within this static method.

	@param aWatchdoggingObject CABSession* to the object that watchdogged

	@return Any error code - enforced return, not necessarily used by this function

	@see TCallBack

	*/

		{

		return (static_cast<CABSession*>(aWatchdoggingObject))->WatchdogExpired();

		}

	TInt CABSession::WatchdogExpired()

	/**

	Called by ABSessionStaticWatchdogCaller to indicate that the watchdog has expired on this particular 

	session as a result of the callback not being returned from by the client

	@return An error code

	*/

		{

		__LOG1("CABSession::WatchdogExpired() - [0x%08x] Watchdog expired on session", iClientSID.iId);

		iMisbehavingClient = ETrue;			// Flag the client as having not responded

		// Inform the Data Owner of the new status

		TRAP_IGNORE(DataOwnerL().SetReadyState(EDataOwnerFailed));

		if (iActiveSchedulerWait->IsStarted())

			{

			iABClientLeaveCode = KErrTimedOut;

			ReturnFromCallback();

			}

		else

			{

			// We should never get here - only a callback call should time out

			Panic(KErrTimedOut);

			}

		return KErrTimedOut;

		}

	TBool CABSession::ConfirmedReadyForBUR() const

	/** Accessor to get the state from an already existing connection

	@return ETrue if the active client has previously confirmed that it's ready for a backup or restore

	*/

		{

		return iConfirmedReadyForBUR;

		}

	TBool CABSession::CallbackInterfaceAvailable() const

	/** Accessor to indicate whether or not the client has enabled the callback interface or not

	@return ETrue if the callback interface is available

	*/

		{

		return !iMessage.IsNull();

		}

	CABSession::~CABSession()

    /**

    Class destructor

    */

		{

		__LOG1("~CABSession for sid:0x%08x", iClientSID.iId);

		delete iCallbackWatchdog;

		iCallbackWatchdog = NULL;

		// Remove this session from the server's session map

		// Clear up any outstanding message

		HandleIPCClosingDownCallback();

		delete iActiveSchedulerWait;

		//

		// If the client has detached properly, they should

		// have done this - but just in case.

		//DoCancelWaitForCallback();

		}

	void CABSession::CreateL()

	/**

	Creates a connection between active backup server and the active backup session.

	Increments the server's session count

	*/

		{

		//

		// Increase the servers session count.

		Server().AddSession();

		}

	void CABSession::RestoreCompleteL(TDriveNumber aDriveNumber)

	/**

	Signal the client that the restore operation is complete

	@param aDriveNumber The drive that has finished being backed up

	*/

		{

		MakeCallbackRestoreCompleteL(aDriveNumber);

		}

	void CABSession::AllSnapshotsSuppliedL()

	/**

	Lets the session know that all snapshots have been supplied.

	*/

		{

		MakeCallbackAllSnapshotsSuppliedL();

		}

	void CABSession::GetExpectedDataSizeL(TDriveNumber aDriveNumber, TUint& aSize)

	/**

	Get the expected data size from the active backup client

	@param aDriveNumber The drive number of the data

	@param aSize Upon exit, this parameter will indicate the expected data size

	*/

		{

		aSize = MakeCallbackGetExpectedDataSizeL(aDriveNumber);

		}

	void CABSession::SupplyDataL(TDriveNumber aDriveNumber, TTransferDataType aTransferType, TDesC8& aBuffer,

			TBool aLastSection, TBool aSuppressInitDataOwner, TSecureId aProxySID)

	/**

	Supply data to the active backup client

	@param aDriveNumber The drive number of the data

	@param aTransferType Specifies the type of data to get the expected data size of

	@param aBuffer The data to send to the Active Backup Client

	@param aLastSection Specifies whether or not additional SupplyDataL calls will be made (multi-part)

	@param aSuppressInitDataOwner Suppress the initialisation of Data Owner

	@param aProxySID The secure ID of the proxy

	*/

		{

		TInt dataSizeTransferred = 0;

		TInt remainingBlockSize = 0;

		TBool lastSection;

		TPtrC8 transferBlock;

		// Repeat the data transfer until all data has been sent

		while (dataSizeTransferred < aBuffer.Size())

			{

			remainingBlockSize = aBuffer.Size() - dataSizeTransferred;

			if (remainingBlockSize > KIPCMessageSize)

				{

				remainingBlockSize = KIPCMessageSize;

				lastSection = EFalse;

				}

			else

				{

				lastSection = aLastSection;

				}

			// Create a temporary descriptor representing the next block to send

			transferBlock.Set(aBuffer.Mid(dataSizeTransferred, remainingBlockSize));

			dataSizeTransferred += transferBlock.Size();

			// If we're sending

			if ((transferBlock.Size() <= KIPCMessageSize) && (dataSizeTransferred != aBuffer.Size()))

				{

				lastSection = EFalse;

				}

			else

				{

				lastSection = aLastSection;

				}

			__LOG2("CABSession::SupplyDataL() - [0x%08x] Supplying data to ABClient, %d bytes transferred", iClientSID.iId, dataSizeTransferred);

			switch(aTransferType)

				{

				case EActiveSnapshotData:

					{

					MakeCallbackReceiveSnapshotDataL(aDriveNumber, transferBlock, lastSection);

					} break;

				case EActiveBaseData:

					{

					if (!aSuppressInitDataOwner)

						{

						if (aProxySID != KNullABSid)

							{

							MakeCallbackInitialiseRestoreProxyBaseDataL(aProxySID, aDriveNumber);

							}

						else

							{

							MakeCallbackInitialiseRestoreBaseDataL(aDriveNumber);

							}

						}

					MakeCallbackRestoreBaseDataSectionL(transferBlock, lastSection);

					} break;

				case EActiveIncrementalData:

					{

					if (!aSuppressInitDataOwner)

						{

						MakeCallbackInitialiseRestoreIncrementDataL(aDriveNumber);

						}

					MakeCallbackRestoreIncrementDataSectionL(transferBlock, lastSection);

					} break;

				default:

					{

					User::Leave(KErrNotSupported);

					}

				}

			// Even if we were supposed to suppress it first time round, for a multipart supply, it 

			// shouldn't be sent again

			aSuppressInitDataOwner = ETrue;

			}

		}

	void CABSession::RequestDataL(TDriveNumber aDriveNumber, TTransferDataType aTransferType, TPtr8& aBuffer,

			TBool& aLastSection, TBool aSuppressInitDataOwner, TSecureId aProxySID)

	/**

	Request data from the active backup client

	@param aDriveNumber The drive number of the data 

	@param aTransferType Specifies the type of data to get the expected data size of

	@param aBuffer This buffer will be filled by the Active Backup Client upon return

	@param aLastSection Upon return indicates whether or not additional RequestDataL calls will be made (multi-part)

	@param aSuppressInitDataOwner Suppress the initialisation of Data Owner

	@param aProxySID The secure ID of the proxy

	*/

		{

        __LOG5("CABSession::RequestDataL() - START - aDrive: %c, aTType: %d, aBuffer.Ptr(): 0x%08x, aBuffer.Length(): %d, aProxySID: 0x%08x", 

            aDriveNumber + 'A', aTransferType, aBuffer.Ptr(), aBuffer.Length(), aProxySID.iId );

        TInt dataSizeTransferred = 0;

		TInt remainingBlockSize = 0;

		TBool lastSection = EFalse;

		TPtr8 transferBlock(NULL, 0);

		// While there is space left in aBuffer and the client hasn't finished, keep requesting data

		do

			{

			// Set max for the MidTPtr call to work. Length of this buffer is reset after each data transfer

			aBuffer.SetMax();

			remainingBlockSize = aBuffer.MaxSize() - dataSizeTransferred;

			__LOG2("CABSession::RequestDataL() - dataSizeTransferred: %d, remainingBlockSize: %d", dataSizeTransferred, remainingBlockSize);

			if (remainingBlockSize > KIPCMessageSize)

				{

				remainingBlockSize = KIPCMessageSize;

				}

			transferBlock.Set(aBuffer.MidTPtr(dataSizeTransferred, remainingBlockSize));

			__LOG2("CABSession::RequestDataL() - transferBlock: 0x%08x (%d)", transferBlock.Ptr(), transferBlock.Length());

			switch(aTransferType)

				{

				case EActiveSnapshotData:

					{

					MakeCallbackGetSnapshotDataL(aDriveNumber, transferBlock, lastSection);

					} break;

				case EActiveBaseData:

				case EActiveIncrementalData:

					{

					if (!aSuppressInitDataOwner)

						{

						if (aProxySID != KNullABSid)

							{

							MakeCallbackInitialiseGetProxyBackupDataL(aProxySID, aDriveNumber);

							}

						else

							{

							MakeCallbackInitialiseGetBackupDataL(aDriveNumber);

							}

						}

					MakeCallbackGetBackupDataSectionL(transferBlock, lastSection);

					} break;

				default:

					{

					User::Leave(KErrNotSupported);

					}

				}

			// Even if we were supposed to suppress it first time round, for a multipart get, it 

			// shouldn't be sent again

			aSuppressInitDataOwner = ETrue;

			// update our count to reflect the new data supplied by the client

			dataSizeTransferred += transferBlock.Size();

            __LOG2("CABSession::RequestDataL() - received data so far: %d, buffer start address: 0x%08x", dataSizeTransferred, aBuffer.Ptr());

            //__LOGDATA("CABSession::RequestDataL() - total received data - %S", aBuffer.Ptr(), dataSizeTransferred);

			__LOG2("CABSession::RequestDataL() - [0x%08x] Requesting data from ABClient %d bytes so far)", iClientSID.iId, dataSizeTransferred);

			aBuffer.SetLength(dataSizeTransferred);

			} while (!lastSection && (dataSizeTransferred < aBuffer.MaxSize()));

		aLastSection = lastSection;

		}

	void CABSession::TerminateMultiStageOperationL()

	/**

	Instruct the client that copying of data has been aborted and it should clean up

	*/

		{

		MakeCallbackTerminateMultiStageOperationL();

		}

	TUint CABSession::GetDataChecksumL(TDriveNumber aDrive)

	/**

	Test method for validating data

	@param aDrive The drive from which the data is backed up from

	@return The checksum

	*/

		{

		return MakeCallbackGetDataChecksumL(aDrive);

		}

	void CABSession::CleanupClientSendState()

	/**

	Delete the client sending buffer and reset multipart flag

	*/

		{

		iReceiveFromClientFinished = ETrue;

		}

	void CABSession::MadeCallback()

	/**

	Start the CActiveSchedulerWait() object. The ABServer will stop this wait object when it's callback 

	has returned, this way the thread's AS still processes ABServer ServiceL's etc. but it appears as 

	though the request to the ABClient is synchronous. This method will be called from the ABServer inside 

	the call from the Data Owner requesting an operation

	@see CDataOwner::ReturnFromActiveCall()

	*/

		{

		// Reset the leave flag

		iABClientLeaveCode = KErrNone;

		#ifndef _DEBUG

		// Start the callback timer only in release builds

		delete iCallbackWatchdog;

		iCallbackWatchdog = NULL;

		iCallbackWatchdog = CPeriodic::NewL(EPriorityHigh);

		TTimeIntervalMicroSeconds32 KWatchdogIntervalNone = 0;

		iCallbackWatchdog->Start(DataOwnerL().ActiveInformation().iCallbackDelayTime, KWatchdogIntervalNone, iWatchdogHandler);

		#endif

		// Send the message back to the callback handler

		iMessage.Complete(KErrNone);

		__LOG1("CABSession::MadeCallback() - [0x%08x] Calling ABClient to process callback", iClientSID.iId);

		// Set the timeout for the callback

		iActiveSchedulerWait->Start();

		}

	void CABSession::ReturnFromCallback()

	/**

	This method is called by the ABServer once it's completed it's request from the Active Backup Client 

	so that the Data Owner appears to have made a synchronous call into the ABServer

	*/

		{

		if (iCallbackWatchdog)

			{

			if (iCallbackWatchdog->IsActive())

				{

				iCallbackWatchdog->Cancel();

				delete iCallbackWatchdog;

				iCallbackWatchdog = NULL;

				}

			}

		if (iActiveSchedulerWait->IsStarted())

			{

			__LOG1("CABSession::MadeCallback() - [0x%08x] has returned from callback - CASW::AsyncStop()", iClientSID.iId);

			iActiveSchedulerWait->AsyncStop();

			}

		}

	void CABSession::TakeOwnershipOfIPCMessage(const RMessage2& aMessage)

	/**

	Take ownership of the IPC message so that we're able to signal the Active Backup Callback Handler

	@param aMessage The IPC message that we're going to take ownership of

	*/

		{

		iMessage = aMessage;

		}

	void CABSession::HandleIPCBURModeInfoL(const RMessage2& aMessage)

	/**

	Return information about the backup and restore mode to the active backup client

	@param aMessage The IPC message

	*/

		{

		__LOG1("CABSession::HandleIPCBURModeInfoL() - [0x%08x] Received IPC IPCBURModeInfo", iClientSID.iId);

		TPckgC<TBURPartType> partType(Server().DataOwnerManager().BURType());

		TPckgC<TBackupIncType> incType(Server().DataOwnerManager().IncType());

		// Return the backup and restore settings to the client

		aMessage.WriteL(0, Server().DataOwnerManager().DriveList());

		aMessage.WriteL(1, partType);

		aMessage.WriteL(2, incType);

		}

	void CABSession::HandleIPCDoesPartialBURAffectMeL(const RMessage2& aMessage)

	/**

	Return information about the backup and restore mode to the active backup client

	@param aMessage The IPC message

	*/

		{

		__LOG1("CABSession::HandleIPCDoesPartialBURAffectMeL() - [0x%08x] Received IPC DoesPartialBURAffectMe", iClientSID.iId);

		TPckgC<TBool> resultPkg(Server().DataOwnerManager().IsSetForPartialL(iClientSID));

		aMessage.WriteL(0, resultPkg);

		}

	void CABSession::HandleIPCConfirmReadyForBURL(const RMessage2& aMessage)

	/**

	Respond to an event from abclient informing us that it's prepared it's data and is ready for backup

	@param aMessage The IPC message

	*/

		{

		TInt errorCode = aMessage.Int0();

		__LOG2("CABSession::HandleIPCConfirmReadyForBURL() - [0x%08x] Received IPC ConfirmReadyForBUR, errorCode: %d", iClientSID.iId, errorCode);

		// Set our internal state to indicate that the client has confirmed ready for BUR

		iConfirmedReadyForBUR = ETrue;

		TDataOwnerStatus status;

		if (errorCode == KErrNone)

			{

			if (CallbackInterfaceAvailable())

				{

				status = EDataOwnerReady;

				}

			else