// Copyright (c) 1997-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 <baksrv.h>

#include "Baksrvs.h"

#include <babackup.h>

#include <bafl/backup_std.h>

#include <basched.h>

#include <bsul/clientmessage.h>

#include "patchdata.h"

extern const BSUL::TClientMessageServerData KServerData;

const TInt KBakServMaxOperationTimerLoops = 3; // Number of iterations for base operation timer

_LIT(KPanic,"BackupServer");

//

// RMessage::Panic() also completes the message. This is:

// (a) important for efficient cleanup within the kernel

// (b) a problem if the message is completed a second time

//

void PanicClient(const RMessagePtr2& aMessage, TInt aPanic)

	{

	aMessage.Panic(KPanic,aPanic);

	}

//

// class CShutdownServer

//

NONSHARABLE_CLASS(CShutdownServer) : public CTimer

	{

	enum {KMyShutdownDelay=0x2000000};	// approx 2s

public:

	inline CShutdownServer();

	inline void ConstructL();

	inline void Start();

private:

	void RunL();

	};

inline CShutdownServer::CShutdownServer()

	:CTimer(-1)

	{

	CActiveScheduler::Add(this);

	}

inline void CShutdownServer::ConstructL()

	{

	CTimer::ConstructL();

	}

inline void CShutdownServer::Start()

	{

	After(KMyShutdownDelay);

	}

//

// Initiate server exit when the timer expires

//

void CShutdownServer::RunL()

	{

	CActiveScheduler::Stop();

	}

//

// class CBaServBackupScheduler

//

EXPORT_C CBaServBackupScheduler::CBaServBackupScheduler()

{

}

EXPORT_C CBaServBackupScheduler::~CBaServBackupScheduler()

{

}

/**

 *

 * Set the error handler to aErrorHandler to the current scheduler.

 *

 * @param     "CBaServBackupSession* aErrorHandler"

 *            The handler session.

 */

EXPORT_C void CBaServBackupScheduler::SetErrorHandler(CBaServBackupSession* aErrorHandler)

	{

	iErrorHandler=aErrorHandler;

	}

/**

 *

 * Handles the error aError.

 *

 * @param     "TInt aError"

 *            The error.

 */

EXPORT_C void CBaServBackupScheduler::Error(TInt aError) const

	{

	if (iErrorHandler)

		{

		iErrorHandler->HandleError(aError);

		}

	else if (aError!=KLeaveWithoutAlert)

		{

		// Handling the in this way implies that ServiceL should not leave.

		CActiveScheduler::Error(aError);

		}

	}

/**

Class CBaServBackupSession::CReRegistrationTimer

*/

NONSHARABLE_CLASS(CBaServBackupSession::CReRegistrationTimer) : public CPeriodic

{

	public:

		static CReRegistrationTimer* NewL(TInt aPriority);

		static TInt ReRegistrationTimerCallBack(TAny* aPtr);

	protected:

		TInt RunError(TInt aError);

	private:

		CReRegistrationTimer(TInt aPriority);

		void HandleReRegistrationTimerCallBack();

    public:

		CBaBackupServer* iBackupServer;

};

/**

Class CBaBackupServer::CBaServCloseAllOperationTimer

*/

NONSHARABLE_CLASS(CBaBackupServer::CBaServCloseAllOperationTimer): public CPeriodic

{

	public:

	    static CBaServCloseAllOperationTimer* NewL(CBaBackupServer* aBackupServer);

	   void ConstructL(CBaBackupServer* aBackupServer);

	   ~CBaServCloseAllOperationTimer();

	   void SetMessage(const RMessagePtr2& aPtr);

	   RMessagePtr2 Message();

	   TInt GetOperationCount();

	   void SetOperationCount(TInt aCount);

	   static TInt OperationTimerCallBack(TAny* aPtr);

	protected:

	   TInt RunError(TInt aError);

	private:

	   void HandleOperationTimerCallBack();

	   CBaServCloseAllOperationTimer();

	private:

	   RMessagePtr2 iCloseAllFilesMessage;

	   TInt16 iOperationCount;

	   CBaBackupServer* iBackupServer;

};

//

// class CBaBackupServer

//

/**

 *

 * Returns a pointer to <code>CBaBackupServer</code> object.

 *

 * @return   "CBaBackupServer"

 *            A newly-constructed backup server object.

 */

EXPORT_C CBaBackupServer* CBaBackupServer::NewL()

	{ // static

	CBaBackupServer* self=new(ELeave) CBaBackupServer(CActive::EPriorityStandard);

	return self;

	}

/**

 *

 * Constructor.

 *

 * @param     "TInt aPriority"

 *            The active object priority.

 */

EXPORT_C CBaBackupServer::CBaBackupServer(TInt aPriority)

	: CServer2(aPriority)

	{}

/**

 *

 * Destructor.

 *

 */

EXPORT_C CBaBackupServer::~CBaBackupServer()

	{

	TDblQueIter<CSession2> iter(iSessionIter);

	iter.SetToFirst();

	for (CSession2* session=iter++; session!=NULL; session=iter++)

		{

		delete session;

		}

	delete iShutdown;

	delete iExtension;

	delete iCloseAllFilesOperationTimer;

	}

/**

 *

 * Completes the server construction by adding the server to the active scheduler and creating

 * a <code>CShutdownServer</code> object.

 *

 */

EXPORT_C void CBaBackupServer::ConstructL()

	{

	StartL(__BACKUP_SERVER_NAME_V2);

	iExtension = new(ELeave) CBaBackupServerExt();

	iShutdown = new (ELeave) CShutdownServer;

	iShutdown->ConstructL();

	// ensure that the server still exits even if the 1st client fails to connect

	iShutdown->Start();

	iRegisteredFilesCount = 0;

	iCloseAllFilesOperationTimer = CBaBackupServer::CBaServCloseAllOperationTimer::NewL(this);

	iCloseAllOperationRunning = EFalse;

	//initialise the client message framework

	BSUL::CClientMessage::InitialiseFrameworkL(KServerData);

	}

/**

 *

 * Sets the server to be busy with the aUniqueClientId client.

 *

 * @param     "TUint32 aUniqueClientId"

 *            A unique client identifier.

 */

EXPORT_C void CBaBackupServer::SetBusy(TUint32 aUniqueClientId)

	{

	iExtension->iUniqueBusyClientId=aUniqueClientId;

	}

/**

 *

 * Returns <code>ETrue</code> if the client using the server is not the one identified by aUniqueClientId

 * oterwise <code>EFalse</code>

 *

 * @param     "TUint32 aUniqueClientId"

 *            A unique client identifier.

 */

EXPORT_C TBool CBaBackupServer::IsOtherClientBusy(TUint32 aUniqueClientId) const

	{

	return (iExtension->iUniqueBusyClientId!=0 && iExtension->iUniqueBusyClientId!=aUniqueClientId);

	}

/**

 *

 * Returns <code>ETrue</code> if the client using the server corresponds has aUniqueClientId as unique id

 * oterwise <code>EFalse</code>

 *

 * @param     "TUint32 aUniqueClientId"

 *            A unique client identifier id.

 */

EXPORT_C TBool CBaBackupServer::IsClientBusy(TUint32 aUniqueClientId) const

	{

	return ((iExtension->iUniqueBusyClientId==aUniqueClientId) || 

			((iExtension->iCachedBusyClientId != 0) && (iExtension->iCachedBusyClientId == aUniqueClientId))); 

	}

/**

 *

 * Handles the closing of all files by signaling the new file lock flag, aFlag, to all client.

 *

 * @param     "MBackupObserver::TFileLockFlags aFlag"

 *            A file lock flag.

 */

EXPORT_C void CBaBackupServer::CloseAllFilesL(MBackupObserver::TFileLockFlags aFlag)

	{

	// Set the close all operation flag and the reregistration counter to zero

	iCloseAllOperationRunning = ETrue;

	iSessionLockReRegistrationCount = 0;

	// cleanup that calls RestartAll if required

	TDblQueIter<CSession2> iter(iSessionIter);

	iter.SetToFirst();

	for (CSession2* session=iter++; session!=NULL; session=iter++)

		{

		static_cast<CBaServBackupSession*>(session)->SignalReleaseAllFileLocksL(aFlag);

		}

	}

/**

 *

 * Signals to all clients of getting the lock of their respective files.

 *

 */

EXPORT_C void CBaBackupServer::RestartAll()

	{

	TDblQueIter<CSession2> iter(iSessionIter);

	iter.SetToFirst();

	for (CSession2* session=iter++; session!=NULL; session=iter++)

		{

		static_cast<CBaServBackupSession*>(session)->SignalRetakeAllFileLocks();

		}

	}

/**

 *

 * Allows any subclass of <code>CBaBackupServer</code> of completing the closing of files.

 * The server will lose the ownership of aClosedFiles object, which implies it is up to this virtual

 * function to deal with it in order to avoid a memory leak.

 *

 * @param     "CArrayFix<CBaServBackupSession::TClosedFile>* aClosedFiles"

 *            An array of closed files.

 */

EXPORT_C void CBaBackupServer::CompleteClosingFiles(CArrayFix<CBaServBackupSession::TClosedFile>* aClosedFiles)

	{

	delete aClosedFiles;

	}

/**

 *

 * Allows application framework backup code to check if all registerd files have beem updated

 *

 */

EXPORT_C TBool CBaBackupServer::HaveAllCloseAllFilesClientsReRegistered()

	{

	return((iRegisteredFilesCount == iSessionLockReRegistrationCount) ? ETrue : EFalse);

	}

void CBaBackupServer::CloseFileL(MBackupObserver::TFileLockFlags aFlag,const TDesC& aFileName)

	{

	TDblQueIter<CSession2> iter(iSessionIter);

	iter.SetToFirst();

	for (CSession2* session=iter++; session!=NULL; session=iter++)

		{

		static_cast<CBaServBackupSession*>(session)->SignalReleaseFileLockL(aFlag,aFileName);

		}

	}

void CBaBackupServer::RestartFile(const TDesC& aFileName)

	{

	TDblQueIter<CSession2> iter(iSessionIter);

	iter.SetToFirst();

	for (CSession2* session=iter++; session!=NULL; session=iter++)

		{

		static_cast<CBaServBackupSession*>(session)->SignalRetakeFileLocks(aFileName);

		}

	}

/**

 *

 * Creates a server-side client <code>CBaServBackupSession</code> session object by checking first if

 * the version of the server is compatible with the client.

 *

 * @param     "const TVersion &aVersion"

 *            Version information supplied by the client.

 */

EXPORT_C CSession2* CBaBackupServer::NewSessionL(const TVersion &aVersion, const RMessage2& /*aMessage*/) const

	{

	TVersion ver(KBakServMajorVN,KBakServMinorVN,KBakServBuildVN);

	if (!User::QueryVersionSupported(ver,aVersion))

		User::Leave(KErrNotSupported);

//

	return CBaServBackupSession::NewL();

	}

/**

 *

 * Signals to all clients the aBackupOperationAttributes.

 *

 * @param     "const TBackupOperationAttributes& aBackupOperationAttributes"

 *            Backup operation attributes.

 */

EXPORT_C void CBaBackupServer::SignalBackupOperation(const TBackupOperationAttributes& aBackupOperationAttributes)

	{

	TDblQueIter<CSession2> iter(iSessionIter);

	iter.SetToFirst();

	for (CSession2* session=iter++; session!=NULL; session=iter++)

		{

		static_cast<CBaServBackupSession*>(session)->SignalBackupOperation(aBackupOperationAttributes);

		}

	// Cache session id if starting backup

	if (aBackupOperationAttributes.iOperation == MBackupOperationObserver::EStart)

			iExtension->iCachedBusyClientId = iExtension->iUniqueBusyClientId;

	}

void CBaBackupServer::AddSession()

	{

	iShutdown->Cancel();

	++iSessionCount;

	}

void CBaBackupServer::DropSession()

	{

	if (--iSessionCount==0)

		{

		iShutdown->Start();

		}

	}

/*

 * Check to see if a CloseAll opertation is in progress

 * 

 */

TBool CBaBackupServer::IsCloseAllOperationRunning()

	{

	return iCloseAllOperationRunning;

	}

/*

 * Set value of IsCloseAllOperationRunning

 * 

 */

EXPORT_C void CBaBackupServer::SetCloseAllOperationRunningState(TBool aRunning)

	{

	iCloseAllOperationRunning = aRunning;

	}

/**

 *

 * This timer will only be created in cases of no derived backup server

 *

 */

void CBaBackupServer::StartCloseAllFilesOperationTimer(const RMessagePtr2& aPtr)

	{

	// Store the CloseAll message in case we need to Complete on a timeout

	iCloseAllFilesOperationTimer->SetMessage(aPtr);

	// If hardware use patchable constant if not default to 3 seconds

	iCloseAllFilesOperationTimer->Start(KBaBackupCloseallFilesTimeout, KBaBackupCloseallFilesTimeout, TCallBack(CBaBackupServer::CBaServCloseAllOperationTimer::OperationTimerCallBack, iCloseAllFilesOperationTimer));

	}

/**

 * Handle an error from CBaServBackupSession::ServiceL()

 * A bad descriptor error implies a badly programmed client, so panic it;

 * otherwise report the error to the client

 *

 * @param     "TInt aError"

 *            The error.

 */

EXPORT_C TInt CBaBackupServer::RunError(TInt aError)

	{

	if (aError==KErrBadDescriptor)

		{

		PanicClient(Message(), EBufferOverflow);

		}

	else

		{

		Message().Complete(aError);

		}

	//

	// The leave will result in an early return from CServer::RunL(), skipping

	// the call to request another message. So do that now in order to keep the

	// server running.

	ReStart();

	return KErrNone;	// handled the error fully

	}

//

// class CBaBackupServer::CBaServCloseAllOperationTimer

//

/**

@internalComponent

*/

CBaBackupServer::CBaServCloseAllOperationTimer* CBaBackupServer::CBaServCloseAllOperationTimer::NewL(CBaBackupServer* aBackupServer)

	{ // static

	CBaBackupServer::CBaServCloseAllOperationTimer* self=new(ELeave) CBaBackupServer::CBaServCloseAllOperationTimer();

	CleanupStack::PushL(self);

	self->ConstructL(aBackupServer);

	CleanupStack::Pop(); // self

	CActiveScheduler::Add(self);

	return self;

	}

/**

@internalComponent

*/

void CBaBackupServer::CBaServCloseAllOperationTimer::ConstructL(CBaBackupServer* aBackupServer)

	{

	CTimer::ConstructL();

	iBackupServer = aBackupServer;

	iOperationCount = 0;

	}

/**

@internalComponent

*/

TInt CBaBackupServer::CBaServCloseAllOperationTimer::GetOperationCount()

{

	return iOperationCount;	

}

/**

@internalComponent

*/

void CBaBackupServer::CBaServCloseAllOperationTimer::SetOperationCount(TInt aCount)

{

	iOperationCount = aCount;

}

/**

@internalComponent

*/

TInt CBaBackupServer::CBaServCloseAllOperationTimer::RunError(TInt aError)

	{

	if (aError==KLeaveWithoutAlert)

		{

		return KErrNone;

		}

	return aError;

	}