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

// Remote Control bulk server implementation.

//

/**

 @file

 @internalComponent

*/

#include <bluetooth/logger.h>

#include "bulkbearerinterface.h"

#include "bulkserver.h"

#include "bulkserversecuritypolicy.h"

#include "bulksession.h"

#include "messagequeue.h"

#include "remconmessage.h"

#include "utils.h"

#include "server.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_REMCON_SERVER);

#endif

#ifdef _DEBUG

PANICCATEGORY("bulkserver");

#endif // _DEBUG

#ifdef __FLOG_ACTIVE

#define LOGSESSIONS							LogSessions()

#define LOGINCOMINGPENDINGDELIVERY			LogIncomingPendingDelivery()

#define LOGINCOMINGDELIVERED				LogIncomingDelivered()

#else

#define LOGSESSIONS

#define LOGINCOMINGPENDINGDELIVERY

#define LOGINCOMINGDELIVERED

#endif // __FLOG_ACTIVE

CRemConBulkServer* CRemConBulkServer::NewLC(RMsgQueue<TBulkServerMsg>& aMsgQueue)

	{

	LOG_STATIC_FUNC;

	CRemConBulkServer* self = new(ELeave) CRemConBulkServer(aMsgQueue);

	CleanupStack::PushL(self);

	// StartL is where the kernel checks that there isn't already an instance 

	// of the same server running, so do it before ConstructL.

	self->StartL(KRemConBulkServerName);

	self->ConstructL();

	return self;

	}

CRemConBulkServer::~CRemConBulkServer()

	{

	LOG_FUNC;

	delete iShutdownTimer;

	iSessions.Close();

	delete iIncomingPendingDelivery;

	delete iIncomingDelivered;

	delete iBulkBearerInterface;

	}

CRemConBulkServer::CRemConBulkServer(RMsgQueue<TBulkServerMsg>& aMsgQueue)

 :	CPolicyServer(CActive::EPriorityStandard, KRemConBulkServerPolicy, ESharableSessions),

 	iRemConMsgQueue(aMsgQueue)

	{

	LOG_FUNC;

	}

void CRemConBulkServer::ConstructL()

	{

	LOG_FUNC;

	iShutdownTimer = CPeriodic::NewL(CActive::EPriorityStandard);

	iIncomingPendingDelivery = CMessageQueue::NewL();

	iIncomingDelivered = CMessageQueue::NewL();

	// First message is the control server for client ID binding

	TBulkServerMsg ctrlMsg;

	iRemConMsgQueue.ReceiveBlocking(ctrlMsg);

	ASSERT_DEBUG(ctrlMsg.iType == EControlServer);

	ASSERT_DEBUG(ctrlMsg.iData);

	iControlServer = reinterpret_cast<CRemConServer*>(ctrlMsg.iData);

	// Second message is bearer manager information for interface loading.

	TBulkServerMsg msg;

	iRemConMsgQueue.ReceiveBlocking(msg);

	ASSERT_DEBUG(msg.iType == EBearerManager);

	ASSERT_DEBUG(msg.iData);

	CBearerManager* bearerManager = reinterpret_cast<CBearerManager*>(msg.iData);

	iBulkBearerInterface = CBulkBearerInterface::NewL(*this, *bearerManager);

	}

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

	const RMessage2& aMessage) const

	{

	LOG_FUNC;

	LOG3(_L8("\taVersion = (%d,%d,%d)"), aVersion.iMajor, aVersion.iMinor, aVersion.iBuild);

	// Version number check...

	TVersion v(KRemConBulkSrvMajorVersionNumber,

		KRemConBulkSrvMinorVersionNumber,

		KRemConBulkSrvBuildNumber);

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

		{

		LEAVEIFERRORL(KErrNotSupported);

		}

	CRemConBulkServer* ncThis = const_cast<CRemConBulkServer*>(this);

	CRemConBulkSession* sess = NULL;

	TRAPD(err, sess = CRemConBulkSession::NewL(*ncThis, 

				aMessage)

			);

	if ( err != KErrNone )

		{

		// Session creation might have failed- if it has we need to check if 

		// we need to shut down again.

		const_cast<CRemConBulkServer*>(this)->StartShutdownTimerIfNoSessions();

		LEAVEIFERRORL(err);

		}

	LOG1(_L8("\tsess = 0x%08x"), sess);

	return sess;

	}

void CRemConBulkServer::StartShutdownTimerIfNoSessions()

	{

	LOG_FUNC;

	if ( iSessions.Count() == 0 )

		{

		LOG(_L8("\tno remaining sessions- starting shutdown timer"));

		// Should have been created during our construction.

		ASSERT_DEBUG(iShutdownTimer);

		// Start the shutdown timer. It's actually a CPeriodic- the first 

		// event will be in KShutdownDelay microseconds' time.

		// NB The shutdown timer might already be active, in the following 

		// case: this function is being called by NewSessionL because there 

		// was a failure creating a new session, BUT this function had already 

		// been called by the session's destructor (i.e. the failure was in 

		// the session's ConstructL, NOT its new(ELeave)). To protect against 

		// KERN-EXEC 15 just check for if the timer is already active. 

		if ( !iShutdownTimer->IsActive() )

			{

			iShutdownTimer->Start(KShutdownDelay, 

				// Delay of subsequent firings (will not happen because we kill 

				// ourselves after the first).

				0, 

				TCallBack(CRemConBulkServer::TimerFired, this)

				);

			}

		else

			{

			LOG(_L8("\tshutdown timer was already active"));

			}

		}

	}

TInt CRemConBulkServer::TimerFired(TAny* aThis)

	{

	LOG_STATIC_FUNC

	static_cast<void>(aThis);

#if defined(__FLOG_ACTIVE) || defined(_DEBUG)

	CRemConBulkServer* self = static_cast<CRemConBulkServer*>(aThis);

	// We should have sent 'this' to this callback. 

	ASSERT_DEBUG(self);

	LOG1(_L8("\tauto shutdown- terminating the bulk server [0x%08x]"), self);

#endif // __FLOG_ACTIVE || _DEBUG

	// Stop our Active Scheduler. This returns the flow of execution to after 

	// the CActiveScheduler::Start call in the server startup code, and 

	// terminates the server.

	CActiveScheduler::Stop();

	return KErrNone;

	}

TInt CRemConBulkServer::ClientOpened(CRemConBulkSession& aSession, TProcessId aProcessId)

	{

	LOG_FUNC;

	LOG1(_L8("\t&aSession = 0x%08x"), &aSession);

	LOGSESSIONS;

	ASSERT_DEBUG(iControlServer);

	TRemConClientId id = iControlServer->ClientIdByProcessId(aProcessId);

	TInt ret = KErrNotFound; // If the control session has already been destroyed then fail...

	if(id != KNullClientId)

		{

		TRAP(ret, iControlServer->BulkInterfacesForClientL(id, aSession.InterestedAPIs()));

		if(ret == KErrNone)

			{

			aSession.SetId(id);

			// Register the session by appending it to our array, and also making an 

			// item for it in the record of which points in the connection history 

			// sessions are interested in.

			ret = iSessions.Append(&aSession);

			if ( ret == KErrNone )

				{

				ASSERT_DEBUG(iBulkBearerInterface);

				iBulkBearerInterface->BulkClientAvailable(id);

				// Should have been created during our construction.

				ASSERT_DEBUG(iShutdownTimer);

				iShutdownTimer->Cancel();

				}

			}

		}

	LOGSESSIONS;

	LOG1(_L8("\tret = %d"), ret);

	return ret;

	}

// called by session when session is closed.

void CRemConBulkServer::ClientClosed(CRemConBulkSession& aSession)

	{

	LOG_FUNC;

	LOG1(_L8("\t&aSession = 0x%08x"), &aSession);

	LOGSESSIONS;

	// Find this session in the array and remove it (if it's there).

	const TUint sessCount = iSessions.Count();

	for(TUint ix = 0; ix < sessCount; ++ix)

		{

		if(iSessions[ix] == &aSession)

			{

			// We've found the session in our array.

			ASSERT_DEBUG(aSession.Id() != KNullClientId);

			ASSERT_DEBUG(iBulkBearerInterface);

			iBulkBearerInterface->BulkClientRemoved(aSession.Id());

			// Remove the session from our array.

			iSessions.Remove(ix);

			break;

			}

		}

	StartShutdownTimerIfNoSessions();

	LOGSESSIONS;

	}

#ifdef __FLOG_ACTIVE

void CRemConBulkServer::LogSessions() const

	{

	const TUint count = iSessions.Count();

	LOG1(_L8("\tNumber of sessions = %d"), count);

	for ( TUint ii = 0 ; ii < count ; ++ii )

		{

		CRemConBulkSession* const session = iSessions[ii];

		ASSERT_DEBUG(session);

		LOG3(_L8("\t\tsession %d [0x%08x], Id = %d"), 

			ii, 

			session,

			session->Id()

			);

		}

	}

void CRemConBulkServer::LogIncomingPendingDelivery() const

	{

	LOG(_L8("Logging incoming pending delivery messages"));

	__FLOG_STMT(const_cast<CRemConBulkServer*>(this)->IncomingPendingDelivery().LogQueue();)

	}

void CRemConBulkServer::LogIncomingDelivered() const

	{

	LOG(_L8("Logging incoming delivered commands"));

	__FLOG_STMT(const_cast<CRemConBulkServer*>(this)->IncomingDelivered().LogQueue();)

	}

#endif // __FLOG_ACTIVE

void CRemConBulkServer::ReceiveRequest(CRemConBulkSession& aSession)

	{

	LOG_FUNC;

	LOGINCOMINGPENDINGDELIVERY;

	LOGINCOMINGDELIVERED;

	// Find the first message in IncomingPendingDelivery for this session.

	TSglQueIter<CRemConMessage>& iter = IncomingPendingDelivery().SetToFirst();

	CRemConMessage* msg;

	while ( ( msg = iter++ ) != NULL )

		{

		if ( msg->SessionId() == aSession.Id() )

			{

			TInt err = aSession.WriteMessageToClient(*msg);

			IncomingPendingDelivery().Remove(*msg);

			if (err == KErrNone )

				{

				// We'll need to remember it for the response coming back.

				IncomingDelivered().Append(*msg); 

				}

			else

				{

				// Tell bearer it won't be getting a response

				SendReject(msg->Addr(), msg->InterfaceUid(), msg->OperationId(), msg->TransactionId());

				// 'Take ownership' of it by destroying it- it's finished with.

				delete msg;

				}

			break;

			}

		}

	LOGINCOMINGPENDINGDELIVERY;

	LOGINCOMINGDELIVERED;

	}

void CRemConBulkServer::NewCommand(CRemConMessage& aMsg)

	{

	LOG_FUNC;

	CRemConBulkSession* const sess = Session(aMsg.Client());

	if(!sess)

		{

        // Tell bearer it won't be getting a response

        SendReject(aMsg.Addr(), aMsg.InterfaceUid(), aMsg.OperationId(), aMsg.TransactionId());

        // 'Take ownership' of it by destroying it- it's finished with.

        delete &aMsg;

		}

	else

		{

		DeliverCmdToClient(aMsg, *sess);

		}

	//now wait for the actual response to come from the client (success!)

	}

void CRemConBulkServer::DeliverCmdToClient(const CRemConMessage& aMsg, CRemConBulkSession& aSess)

	{

	LOG_FUNC;

	ASSERT_DEBUG(aMsg.MsgType() == ERemConCommand); 

	// Take a reference of the message and set the right session ID (important 

	// to set the selected session's ID because this is how we match up the 

	// client's response).

	CRemConMessage& msg = const_cast<CRemConMessage&>(aMsg);

	msg.SessionId() = aSess.Id();

	DeliverMessageToClient(msg, aSess);

	}

void CRemConBulkServer::DeliverMessageToClient(CRemConMessage& aMsg, CRemConBulkSession& aSess)

	{

	LOG_FUNC;

	TInt err = KErrNone;

	// See if the client can take the message now and put it on the right 

	// queue.

	if ( aSess.CurrentReceiveMessage().Handle() )

		{

		err = aSess.WriteMessageToClient(aMsg);

		// If the message was a command, and it was delivered with no error, 

		// then put it in the 'incoming delivered' log. Otherwise, delete it 

		// because it's finished with.

		if (err == KErrNone )

			{

			// We'll need to remember it for the response coming back.

			IncomingDelivered().Append(aMsg); 

			}

		else

			{

			// Tell bearer it won't be getting a response

			SendReject(aMsg.Addr(), aMsg.InterfaceUid(), aMsg.OperationId(), aMsg.TransactionId());

			// 'Take ownership' of it by destroying it- it's finished with.

			delete &aMsg;

			}

		}

	else

		{

		IncomingPendingDelivery().Append(aMsg);

		}

	LOGINCOMINGPENDINGDELIVERY;

	LOGINCOMINGDELIVERED;

	}

TInt CRemConBulkServer::SendResponse(CRemConMessage& aMsg, CRemConBulkSession& aSess)

	{

	LOG_FUNC;

	LOGINCOMINGDELIVERED;

	TInt ret = KErrNone;

	CRemConMessage* response = &aMsg;

	// Find the first command ('space badger') in the iIncomingDelivered queue with 

	// the same session ID, interface UID and operation ID as the response 

	// we're sending, and send the response to the same address that space badger came 

	// from.

	TSglQueIter<CRemConMessage>& iter = IncomingDelivered().SetToFirst();

	CRemConMessage* msg;

	TBool found = EFalse;

	while ( ( msg = iter++ ) != NULL )

		{

		if (	msg->SessionId() == aSess.Id()

			&&	msg->InterfaceUid() == response->InterfaceUid()

			&&	msg->OperationId() == response->OperationId())

			{

			LOG1(_L8("\tfound a matching item in the incoming delivered commands log: [0x%08x]"), msg);

			found = ETrue;

			// Set the right address and transaction id in the outgoing message

			response->Addr() = msg->Addr();

			response->TransactionId() = msg->TransactionId();

			// Remove the item from the 'incoming delivered' queue now we've 

			// addressed a response using it.

			IncomingDelivered().RemoveAndDestroy(*msg);

			ASSERT_DEBUG(iBulkBearerInterface);

			ret = iBulkBearerInterface->Send(aMsg);

			break;

			}

		}

	// If the command was not found, then the app has sent a response to a

	// non-existant command.  It may do this in good intention if the server 

	// has transparently died and been restarted between the app's reception

	// of the command and it sending its response, so we can't panic it.

	// Just drop the message.

	if ( !found )

		{

		// Complete the message with KErrNone.  We have done all we can with

		// it.  Any other error may encourage retries from the application,

		// which would be useless in this situation.

		ret = KErrNone;

		}

	// We've now finished with the response.

	delete response;

	LOGINCOMINGDELIVERED;

	return ret;

	}

void CRemConBulkServer::CommandExpired(TUint aTransactionId)

	{

	LOG_FUNC;

	CRemConMessage* msg;

	TSglQueIter<CRemConMessage> pendingDeliveryIter = IncomingPendingDelivery().SetToFirst();

	while ((msg = pendingDeliveryIter++) != NULL)

		{

		if (msg->TransactionId() == aTransactionId)

			{

			IncomingPendingDelivery().RemoveAndDestroy(*msg);

			}

		}

	TSglQueIter<CRemConMessage> deliveredIter = IncomingDelivered().SetToFirst();

	while ((msg = deliveredIter++) != NULL)

		{

		if (msg->TransactionId() == aTransactionId)

			{

			IncomingDelivered().RemoveAndDestroy(*msg);

			}

		}

	}

void CRemConBulkServer::SendReject(TRemConAddress aAddr, TUid aInterfaceUid, TUint aOperationId, TUint aTransactionId)

	{

	LOG_FUNC;

	CRemConMessage* rejectMsg = NULL;

	RBuf8 data;

	data = KNullDesC8;

	TRAPD(err, rejectMsg = CRemConMessage::NewL(aAddr, KNullClientId, ERemConReject, ERemConMessageDefault, aInterfaceUid, aOperationId, data, 0, aTransactionId));

	if ( err == KErrNone)

		{

		static_cast<void>(iBulkBearerInterface->Send(*rejectMsg));

		// We've now finished with the response.

		delete rejectMsg;

		}

	}

CMessageQueue& CRemConBulkServer::IncomingPendingDelivery()

	{

	ASSERT_DEBUG(iIncomingPendingDelivery);

	return *iIncomingPendingDelivery;

	}

CMessageQueue& CRemConBulkServer::IncomingDelivered()

	{

	ASSERT_DEBUG(iIncomingDelivered);

	return *iIncomingDelivered;

	}

CRemConBulkSession* CRemConBulkServer::Session(TUint aSessionId) const

	{

	CRemConBulkSession* sess = NULL;

	const TUint count = iSessions.Count();

	for ( TUint ii = 0 ; ii < count ; ++ii )

		{

		CRemConBulkSession* const temp = iSessions[ii];

		ASSERT_DEBUG(temp);

		if ( temp->Id() == aSessionId )

			{

			sess = temp;

			break;

			}

		}