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

// 

//

/**

 @file

*/

#include <e32std.h>

#include <e32base.h>

#include <connect/abclientserver.h>

#include "abserver.h"

#include "absession.h"

#include "absessionmap.h"

#include "sbedataownermanager.h"

#include "sbepanic.h"

#include "OstTraceDefinitions.h"

#include "sbtrace.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "abserverTraces.h"

#endif

namespace conn

	{

	/** Active Backup security request ranges

	This is a breakdown of the active backup requests into ranges

	for security checking purposes.

	@internalComponent

	*/

	const TInt myABRanges[] = {0,11};

	/** Active Backup range count

	The number of different security ranges for active backup request numbers

	@internalComponent

	*/

	const TUint myABRangeCount = sizeof(myABRanges)/sizeof(myABRanges[0]);

	/** Active Backup security action array

	An array with a one-to-one mapping with the range array

	specifiying what security action to take for each server request.

	@internalComponent

	*/

	const TUint8 myABElementsIndex[myABRangeCount] =

		{

		CPolicyServer::EAlwaysPass,

		CPolicyServer::ENotSupported

		};

	/**

	@internalComponent

	*/

	const CPolicyServer::TPolicyElement myABElements[] =

		{_INIT_SECURITY_POLICY_PASS};

	/**

	@internalComponent

	*/

	const CPolicyServer::TPolicy myABPolicy =

		{

		CPolicyServer::EAlwaysPass,

		myABRangeCount,

		myABRanges,

		myABElementsIndex,

		myABElements,

		};

	CABServer::CABServer(CDataOwnerManager* aDOM)

		: CPolicyServer(EPriorityNormal,myABPolicy), iDOM(aDOM)

    /** 

    Class constructor

    */

		{

		OstTraceFunctionEntry0( CABSERVER_CABSERVER_CONS_ENTRY );

		__ASSERT_DEBUG(iDOM, Panic(KErrArgument));

		OstTraceFunctionExit0( CABSERVER_CABSERVER_CONS_EXIT );

		}

	CABServer::~CABServer()

    /**

    Class destructor

    */

		{

		OstTraceFunctionEntry0( CABSERVER_CABSERVER_DES_ENTRY );

		delete iSessionMap;

		OstTraceFunctionExit0( CABSERVER_CABSERVER_DES_EXIT );

		}

	CABServer* CABServer::NewLC(CDataOwnerManager* aDOM)

	/**

	Constructs a new instance of the CABServer, calls ConstructL, 

	and returns it to the caller leaving it on the cleanup stack.

	@return The new instance of CABServer.

	*/

		{

		OstTraceFunctionEntry0( CABSERVER_NEWLC_ENTRY );

		CABServer* pSelf = new (ELeave) CABServer(aDOM);

		CleanupStack::PushL(pSelf);

		pSelf->ConstructL();

		OstTraceFunctionExit0( CABSERVER_NEWLC_EXIT );

		return pSelf;

		}

	void CABServer::ConstructL()

	/**

	Construct this instance of CABServer.

	*/

		{

		OstTraceFunctionEntry0( CABSERVER_CONSTRUCTL_ENTRY );

		iSessionMap = CABSessionMap::NewL();

		//

		// Start the server 

		StartL(KABServerName);

		OstTraceFunctionExit0( CABSERVER_CONSTRUCTL_EXIT );

		}

	void CABServer::AddSession()

	/** Increments the server session count.

	The server will shutdown when its 

	session count drops to zero.

	*/

		{

		++iSessionCount;

		}

	void CABServer::DropSession()

	/** Decrements the server session count.  

	The server will shutdown when its 

	session count drops to zero.

	*/

		{		

		--iSessionCount;

		}

	void CABServer::RemoveElement(TSecureId aSecureId)

	/**

	Remove the element with key aSecureId from the session map

	@param aSecureId The key of the element to be removed

	*/

		{

		OstTraceFunctionEntry0( CABSERVER_REMOVEELEMENT_ENTRY );

		iSessionMap->Delete(aSecureId);

		OstTraceFunctionExit0( CABSERVER_REMOVEELEMENT_EXIT );

		}

	void CABServer::SupplyDataL(TSecureId aSID, TDriveNumber aDriveNumber, TTransferDataType aTransferType, 

		TDesC8& aBuffer, TBool aLastSection, TBool aSuppressInitDataOwner, TSecureId aProxySID)

	/**

	Supply data to the data owner

	@param aSID The secure ID of the data owner to signal

	@param aDriveNumber The drive number that the data corresponds to

	@param aTransferType The type of operation to perform on the data

	@param aBuffer The buffer containing data for the operation

	@param aLastSection Flag to indicate whether this is the last operation in a multi-part transfer

	@param aSuppressInitDataOwner Suppress the initialisation of Data Owner

	@param aProxySID The secure ID of the proxy

	*/

		{

		OstTraceFunctionEntry0( CABSERVER_SUPPLYDATAL_ENTRY );

		CABSession& session = iSessionMap->SessionL(aSID);

		session.SupplyDataL(aDriveNumber, aTransferType, aBuffer, aLastSection, aSuppressInitDataOwner, aProxySID);

		OstTraceFunctionExit0( CABSERVER_SUPPLYDATAL_EXIT );

		}

	void CABServer::RequestDataL(TSecureId aSID, TDriveNumber aDriveNumber, TTransferDataType aTransferType, 

		TPtr8& aBuffer, TBool& aLastSection, TBool aSuppressInitDataOwner, TSecureId aProxySID)

	/**

	Request data from the data owner

	@param aSID The secure ID of the data owner to signal

	@param aDriveNumber The drive number that the data corresponds to

	@param aTransferType The type of operation to perform on the data

	@param aBuffer The buffer containing data for the operation

	@param aLastSection Flag to indicate whether this is the last operation in a multi-part transfer

	@param aSuppressInitDataOwner Suppress the initialisation of Data Owner

	@param aProxySID The secure ID of the proxy

	*/

		{

		OstTraceFunctionEntry0( CABSERVER_REQUESTDATAL_ENTRY );

		CABSession& session = iSessionMap->SessionL(aSID);

		session.RequestDataL(aDriveNumber, aTransferType, aBuffer, aLastSection, aSuppressInitDataOwner, aProxySID);

		OstTraceFunctionExit0( CABSERVER_REQUESTDATAL_EXIT );

		}

	void CABServer::GetExpectedDataSizeL(TSecureId aSID, TDriveNumber aDriveNumber, TUint& aSize)

	/**

	Get the expected size of the data that will be returned

	@param aSID The secure ID of the data owner to signal

	@param aDriveNumber The drive number that the data corresponds to

	@param aSize The size of the data owner's data

	*/

		{

		OstTraceFunctionEntry0( CABSERVER_GETEXPECTEDDATASIZEL_ENTRY );

		CABSession& session = iSessionMap->SessionL(aSID);

		session.GetExpectedDataSizeL(aDriveNumber, aSize);

		OstTraceFunctionExit0( CABSERVER_GETEXPECTEDDATASIZEL_EXIT );

		}

	void CABServer::AllSnapshotsSuppliedL(TSecureId aSID)

	/** Lets the client know that all its snapshots have been supplied

	@param aSID The secure ID of the data owner to signal

	*/

		{

		OstTraceFunctionEntry0( CABSERVER_ALLSNAPSHOTSSUPPLIEDL_ENTRY );

		CABSession& session = iSessionMap->SessionL(aSID);

		session.AllSnapshotsSuppliedL();

		OstTraceFunctionExit0( CABSERVER_ALLSNAPSHOTSSUPPLIEDL_EXIT );

		}

	void CABServer::InvalidateABSessions()

	/** Set each CABSession currently hold for each active backup

	 * client as invalid, since there maybe some delay for the

	 * arrival of disconnect request from client. Within this time,

	 * this session can not be used for another backup/restore.

	 */

		{

		OstTraceFunctionEntry0( CABSERVER_INVALIDATEABSESSIONS_ENTRY );

		iSessionMap->InvalidateABSessions();

		OstTraceFunctionExit0( CABSERVER_INVALIDATEABSESSIONS_EXIT );

		}

	TDataOwnerStatus CABServer::SessionReadyStateL(TSecureId aSID)

	/**

	Returns the status of the active backup client

	@param aSID The SecureId of the session to query for

	@return Data owner status of the session

	*/

		{

		OstTraceFunctionEntry0( CABSERVER_SESSIONREADYSTATEL_ENTRY );

		CABSession& session = iSessionMap->SessionL(aSID);

		TDataOwnerStatus doStatus = EDataOwnerNotConnected;

		if (session.Invalidated())

			{

			OstTrace1(TRACE_NORMAL, CABSERVER_SESSIONREADYSTATEL, "session for 0x%08x has been invalidated, return NotConnected",

                    aSID.iId);

			OstTraceFunctionExit0( CABSERVER_SESSIONREADYSTATEL_EXIT );

			return doStatus;	

			}

		if (session.CallbackInterfaceAvailable())

			{

			OstTraceExt2(TRACE_NORMAL, DUP1_CABSERVER_SESSIONREADYSTATEL, "session for 0x%08x already have interface, confirmed:%d ",

                    aSID.iId, static_cast<TInt32>(session.ConfirmedReadyForBUR()));

			doStatus = EDataOwnerNotReady;

			if (session.ConfirmedReadyForBUR())

				{

				doStatus = EDataOwnerReady;

				}

			}

		else 

			{

			OstTraceExt2(TRACE_NORMAL, DUP2_CABSERVER_SESSIONREADYSTATEL, "session for 0x%08x does not have interface, confimed:%d",

                    aSID.iId, static_cast<TInt32>(session.ConfirmedReadyForBUR()));

			doStatus = EDataOwnerNotReady;

			if (session.ConfirmedReadyForBUR())

				{

				doStatus = EDataOwnerReadyNoImpl;

				}				

			}

		OstTraceFunctionExit0( DUP1_CABSERVER_SESSIONREADYSTATEL_EXIT );

		return doStatus;

		}

	void CABServer::RestoreCompleteL(TSecureId aSID, TDriveNumber aDrive)

	/**

	Called to indicate to the active backup client that a restore has completed

	@param aSID The secure Id of the active client for which the restore has completed

	@param aDrive The drive number for which the restore has completed

	*/

		{

		OstTraceFunctionEntry0( CABSERVER_RESTORECOMPLETEL_ENTRY );

		CABSession& session = iSessionMap->SessionL(aSID);

		session.RestoreCompleteL(aDrive);

		OstTraceFunctionExit0( CABSERVER_RESTORECOMPLETEL_EXIT );

		}

	CSession2* CABServer::NewSessionL(const TVersion& aVersion,

		const RMessage2& aMessage) const

	/** Constructs a new AB session.

	Querys the supplied version infomation from the client

	with that of this server, and leaves if they are incompatable.

	@param aVersion The clients version information

	@param aMessage Is ignored

	@return A new instance of CABSession

	@leave KErrNotSupported if the version passed in aVersion is not the same as this one

	*/

		{

		OstTraceFunctionEntry0( CABSERVER_NEWSESSIONL_ENTRY );

		TVersion thisVersion(KABMajorVersionNumber, 

								KABMinorVersionNumber,

								KABBuildVersionNumber);

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

			{

	        OstTrace0(TRACE_ERROR, CABSERVER_NEWSESSIONL, "Leave: KErrNotSupported");

			User::Leave(KErrNotSupported);

			}

		TSecureId sid = aMessage.SecureId();

		// The map creates the session and a map entry, then session ownership is passed to the server

		CSession2* newSession = &(iSessionMap->CreateL(sid));

		OstTraceFunctionExit0( CABSERVER_NEWSESSIONL_EXIT );

		return newSession;

		}

	TInt CABServer::RunError(TInt aError)

	/** Called when this active objects RunL leaves. 

	May be due to a bad client or the server itself.  In either 

	case, complete the last outstanding message with the error 

	code and continue handling client requests.

    @param aError  Standard Symbian OS error code

	@return The error code to be passed back to the active scheduler framework.

	*/

		{

		OstTraceFunctionEntry0( CABSERVER_RUNERROR_ENTRY );

		//

		// A Bad descriptor is a bad client - panic it.

		if(aError == KErrBadDescriptor)

			{

			PanicClient(KErrBadDescriptor);

			}

		//

		// Complete the message and continue handling requests.

		Message().Complete(aError);

		ReStart();

		OstTraceFunctionExit0( CABSERVER_RUNERROR_EXIT );

		return KErrNone;

		}

	void CABServer::PanicClient(TInt aPanic) const

	/** Panic a client.

	@param aPanic The panic code.

	*/

		{

		OstTraceFunctionEntry0( CABSERVER_PANICCLIENT_ENTRY );

		__DEBUGGER()

		_LIT(KPanicCategory,"AB Server");

		RThread client;

		Message().Client(client);

		client.Panic(KPanicCategory, aPanic);

		OstTraceFunctionExit0( CABSERVER_PANICCLIENT_EXIT );

		}

	} // end namespace