// 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:

// Remote Control server implementation.

// 

//

/**

 @file

 @internalComponent

*/

#include <bluetooth/logger.h>

#include <remcon/remcontargetselectorplugin.h>

#include <remcon/remcontargetselectorplugininterface.h>

#include <remcon/remconbearerinterface.h>

#include <remcon/remconbearerbulkinterface.h>

#include "server.h"

#include "session.h"

#include "serversecuritypolicy.h"

#include "utils.h"

#include "bearermanager.h"

#include "messagequeue.h"

#include "convertermanager.h"

#include "remconmessage.h"

#include "connections.h"

#include "connectionhistory.h"

#include "messagerecipients.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_REMCON_SERVER);

#endif

PANICCATEGORY("server");

#ifdef __FLOG_ACTIVE

#define LOGSESSIONS							LogSessions()

#define LOGREMOTES							LogRemotes()

#define LOGCONNECTIONHISTORYANDINTEREST		LogConnectionHistoryAndInterest()

#define LOGOUTGOINGCMDPENDINGTSP			LogOutgoingCmdPendingTsp()

#define LOGOUTGOINGNOTIFYCMDPENDINGTSP		LogOutgoingNotifyCmdPendingTsp()

#define LOGOUTGOINGRSPPENDINGTSP			LogOutgoingRspPendingTsp()

#define LOGOUTGOINGPENDINGSEND				LogOutgoingPendingSend()

#define LOGOUTGOINGSENT						LogOutgoingSent()

#define LOGINCOMINGCMDPENDINGADDRESS			LogIncomingCmdPendingAddress()

#define LOGINCOMINGNOTIFYCMDPENDINGADDRESS		LogIncomingNotifyCmdPendingAddress()

#define LOGINCOMINGNOTIFYCMDPENDINGREADDRESS	LogIncomingNotifyCmdPendingReAddress()

#define LOGINCOMINGPENDINGDELIVERY			LogIncomingPendingDelivery()

#define LOGINCOMINGDELIVERED				LogIncomingDelivered()

#else

#define LOGSESSIONS

#define LOGREMOTES

#define LOGCONNECTIONHISTORYANDINTEREST

#define LOGOUTGOINGCMDPENDINGTSP

#define LOGOUTGOINGNOTIFYCMDPENDINGTSP

#define LOGOUTGOINGRSPPENDINGTSP

#define LOGOUTGOINGPENDINGSEND

#define LOGOUTGOINGSENT

#define LOGINCOMINGCMDPENDINGADDRESS

#define LOGINCOMINGNOTIFYCMDPENDINGADDRESS

#define LOGINCOMINGNOTIFYCMDPENDINGREADDRESS

#define LOGINCOMINGPENDINGDELIVERY

#define LOGINCOMINGDELIVERED

#endif // __FLOG_ACTIVE

TInt BulkMain(TAny* aParam);

CRemConServer* CRemConServer::NewLC()

	{

	LOG_STATIC_FUNC;

	CRemConServer* self = new(ELeave) CRemConServer();

	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(KRemConServerName);

	self->ConstructL();

	return self;

	}

CRemConServer::~CRemConServer()

	{

	LOG_FUNC;

	delete iBearerManager;

	delete iShutdownTimer;

	// There should be no watcher as there should be no bulk thread running

	ASSERT_DEBUG(!iBulkThreadWatcher);

	iSessionsLock.Wait();

	iSessions.Close();

	iSessionsLock.Close();

	// Destroy TSP before iIncomingPendingAddress in case the TSP is 

	// addressing a message on it at the time.

	// The TSP should not be handling outgoing commands or responses as all the sessions 

	// have gone, and they clean up their outgoing messages when they close.

	ASSERT_DEBUG(!iTspHandlingOutgoingCommand);

	ASSERT_DEBUG(!iTspHandlingOutgoingResponse);

	ASSERT_DEBUG(!iTspHandlingOutgoingNotifyCommand);	

	// We can't assert anything about iTspAddressingIncomingCommand- it isn't 

	// interesting.

	delete iTsp;

	delete iOutgoingCmdPendingTsp;

	delete iOutgoingNotifyCmdPendingTsp;

	delete iOutgoingRspPendingTsp;

	delete iOutgoingRspPendingSend;

	delete iOutgoingPendingSend;

	delete iOutgoingSent;

	delete iIncomingCmdPendingAddress;

	delete iIncomingNotifyCmdPendingAddress;

	delete iIncomingNotifyCmdPendingReAddress;

	delete iIncomingPendingDelivery;

	delete iIncomingDelivered;

	delete iMessageRecipientsList;

	iTspConnections.Reset();

	iTspIncomingCmdClients.Reset();

	iTspIncomingNotifyCmdClients.Reset();

	delete iConverterManager;

	// Clean up the connection information (must be done after the bearer 

	// manager is destroyed).

	LOGREMOTES;

	LOGCONNECTIONHISTORYANDINTEREST;

	delete iConnectionHistory;

	iSession2ConnHistory.Close();

	// This is the odd ECOM code for cleaning our session. NB This must be 

	// done AFTER destroying all the other things in this thread which use 

	// ECOM!

	if ( iEcom )

		{

		iEcom->Close();

		}

	REComSession::FinalClose();

	}

CRemConServer::CRemConServer()

 :	CPolicyServer(CActive::EPriorityHigh, KRemConServerPolicy),

 	iTspConnections(_FOFF(TRemConAddress, iLink)),

	iTspIncomingCmdClients(_FOFF(TClientInfo, iLink)),

	iTspIncomingNotifyCmdClients(_FOFF(TClientInfo, iLink2)),

	iTspIf4Stub(*this)

	{

	LOG_FUNC;

	// NB CRemConServer uses CActive::EPriorityHigh to help it get priority 

	// over other AOs in its thread. (The fact that it's added to the AS 

	// before anything else helps too.) This is so that client requests are 

	// not blocked by other AOs in the thread being very busy. This relies of 

	// course on the cooperation of the other AOs running in RemCon's thread 

	// over which we have no control (e.g. those in externally-supplied 

	// bearers or the Target Selector Plugin). In Symbian OS, it's the best we 

	// can do.

	// This is needed for BC reasons, as the TUint32 padding in TClientInfo is now replaced with

	// a second TSglQueLink. Therefore in order to maintain BC we need these two classes

	// to be the same size.

	__ASSERT_COMPILE(sizeof(TUint32) == sizeof(TSglQueLink));

	}

void CRemConServer::ConstructL()

	{

	LOG_FUNC;

	// Open ECOM session.

	iEcom = &(REComSession::OpenL());

	LEAVEIFERRORL(iSessionsLock.CreateLocal());

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

	// Make the connection history holder before creating the bearer manager, 

	// as some bearers might call the bearer manager back synchronously with a 

	// new connection, and we need iConnectionHistory to be able to handle 

	// that.

	iConnectionHistory = CConnectionHistory::NewL();

	// Make the queues before making the bearer manager because otherwise a 

	// 'connection up' which is indicated synchronously with 

	// CBearerManager::NewL will blow us up (we address some of the queues 

	// when that happens).

	iOutgoingCmdPendingTsp = CMessageQueue::NewL();

	iOutgoingNotifyCmdPendingTsp = CMessageQueue::NewL();

	iOutgoingRspPendingTsp = CMessageQueue::NewL();

	iOutgoingRspPendingSend = CMessageQueue::NewL();

	iOutgoingPendingSend = CMessageQueue::NewL();

	iOutgoingSent = CMessageQueue::NewL();

	iIncomingCmdPendingAddress = CMessageQueue::NewL();

	iIncomingNotifyCmdPendingAddress = CMessageQueue::NewL();

	iIncomingNotifyCmdPendingReAddress = CMessageQueue::NewL();

	iIncomingPendingDelivery = CMessageQueue::NewL();

	iIncomingDelivered = CMessageQueue::NewL();

	iMessageRecipientsList = CMessageRecipientsList::NewL();

	// Make bearer manager. This makes the bearers, and connects them up to 

	// the event handler.

	iBearerManager = CBearerManager::NewL(*this);

	// We must load the bearers before the TSP as the TSP loader checks

	// whether there are any bearers with interface V2	

	ASSERT_ALWAYS(!iTspIf);

	iConverterManager = CConverterManager::NewL();

	LoadTspL();

	LOGREMOTES;

	LOGCONNECTIONHISTORYANDINTEREST;

	}

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

	const RMessage2& aMessage) const

	{

	LOG(KNullDesC8);

	LOG_FUNC;

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

	// Version number check...

	TVersion v(KRemConSrvMajorVersionNumber,

		KRemConSrvMinorVersionNumber,

		KRemConSrvBuildNumber);

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

		{

		LEAVEIFERRORL(KErrNotSupported);

		}

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

	CRemConSession* sess = NULL;

	ASSERT_DEBUG(iBearerManager);

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

				*iBearerManager, 

				aMessage, 

				(ncThis->iSessionId)++)

			);

	if ( err != KErrNone )

		{

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

		// we need to shut down again.

		const_cast<CRemConServer*>(this)->StartShutdownTimerIfNoSessionsOrBulkThread();

		LEAVEIFERRORL(err);

		}

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

	return sess;

	}

void CRemConServer::StartShutdownTimerIfNoSessionsOrBulkThread()

	{

	LOG_FUNC;

	iSessionsLock.Wait();

	if ( iSessions.Count() == 0 && !iBulkThreadOpen)

		{

		LOG(_L("\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(CRemConServer::TimerFired, this)

				);

			}

		else

			{

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

			}

		}

	iSessionsLock.Signal();

	}

TInt CRemConServer::TimerFired(TAny* aThis)

	{

	LOG_STATIC_FUNC

	static_cast<void>(aThis);

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

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

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

	ASSERT_DEBUG(self);

	LOG1(_L8("\tauto shutdown- terminating the 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;

	}

void CRemConServer::InitialiseBulkServerThreadL()

	{

	LOG_FUNC

	// Set up the configuration of the thread

	iBulkServerThread.SetPriority(EPriorityLess);

	iBulkThreadWatcher = new(ELeave) CBulkThreadWatcher(*this);

	CleanupDeleteAndNullPushL(iBulkThreadWatcher);

	// Create the communication between the servers.

	LEAVEIFERRORL(iBulkServerMsgQueue.CreateLocal(2)); // only ever two outstanding messages

	CleanupClosePushL(iBulkServerMsgQueue); // member variable, but closing again should be fine.

	// Load the server pointer (for TClientInfo info)

	TBulkServerMsg ctrlMsg;

	ctrlMsg.iType = EControlServer;

	ctrlMsg.iData = this;

	iBulkServerMsgQueue.SendBlocking(ctrlMsg); // this should not block as there is enough room in queue.

	// Load the bearer manager pointer

	TBulkServerMsg manMsg;

	manMsg.iType = EBearerManager;

	manMsg.iData = iBearerManager;

	iBulkServerMsgQueue.SendBlocking(manMsg); // this should not block as there is enough room in queue.

	TRequestStatus stat;

	iBulkServerThread.Rendezvous(stat);

	// Mark bulk server thread ready to run

	iBulkServerThread.Resume();

	User::WaitForRequest(stat); 	// wait for start or death

	// we can't use the 'exit reason' if the server panicked as this

	// is the panic 'reason' and may be '0' which cannot be distinguished

	// from KErrNone

	TInt err = (iBulkServerThread.ExitType() == EExitPanic) ? KErrServerTerminated : stat.Int();

	LEAVEIFERRORL(err);

	// Everything appears to be running...so watch the thread until it dies...

	iBulkThreadWatcher->StartL();

	CleanupStack::Pop(2, &iBulkThreadWatcher); // iBulkServerMsgQueue, iBulkThreadWatcher

	}

TInt CRemConServer::BulkServerRequired()

	{

	LOG_FUNC

	// If the bulk server is required then try to create it

	TThreadFunction bulkServerThreadFunction(BulkMain);

	_LIT(KBulkServerThreadName, "RemConBulkServerThread");

	const TInt KMaxBulkServerThreadHeapSize = 0x100000;

	TInt err = KErrNone;

	if(!iBulkThreadOpen)

		{

		err = iBulkServerThread.Create(KBulkServerThreadName, bulkServerThreadFunction, KDefaultStackSize, KMinHeapSize, KMaxBulkServerThreadHeapSize, &iBulkServerMsgQueue, EOwnerThread);

		if(err == KErrNone)

			{

			TRAP(err, InitialiseBulkServerThreadL());

			if(err == KErrNone)

				{

				iBulkThreadOpen = ETrue;

				}

			}

		}

	return err;

	}

TInt CRemConServer::ClientOpened(CRemConSession& aSession)

	{

	LOG_FUNC;

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

	LOGSESSIONS;

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

	iSessionsLock.Wait();

	TInt ret = iSessions.Append(&aSession);

	if ( ret == KErrNone )

		{

		TSessionPointerToConnectionHistory item;

		item.iSessionId = aSession.Id();

		item.iIndex = 0; // there is always at least one item in the connection history

		ret = iSession2ConnHistory.Append(item);

		if ( ret != KErrNone )

			{

			iSessions.Remove(iSessions.Count() - 1);

			}

		}

	iSessionsLock.Signal();

	if ( ret == KErrNone )

		{

		// Should have been created during our construction.

		ASSERT_DEBUG(iShutdownTimer);

		iShutdownTimer->Cancel();

		}

	LOGSESSIONS;

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

	return ret;

	}

// this function is called by the session when the session type is set

void CRemConServer::ClientTypeSet(CRemConSession& aSession)

	{

	LOG_FUNC;

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

	LOGSESSIONS;

	/* When a client (session) has its type set (controller or target) then 

	   it will still have a bearer uid of NullUid. In this case we want to 

	   update any bearers which now have a controller or target count moving 

	   (from 0) to 1. */

	/* tell the bearer manager that someones set a client type

	   The bearer manager maintains controller and target counts for all bearers

	   and will tell bearers when they need to know things have changed */

	ASSERT_DEBUG(iBearerManager);

	iBearerManager->ClientTypeSet(aSession.Type() == ERemConClientTypeController);

	LOGSESSIONS;

	}

// this function is called by the session when the client has registered its features

void CRemConServer::TargetClientAvailable(CRemConSession& aSession)

	{

	LOG_FUNC;

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

	LOGSESSIONS;

	ASSERT_DEBUG(iBearerManager);

	iBearerManager->TargetClientAvailable(aSession.Id(), aSession.PlayerType(), aSession.PlayerSubType(), aSession.Name());

	LOGSESSIONS;

	}

// this function is called by the session when the client has registered its features

void CRemConServer::ControllerClientAvailable()

	{

	LOG_FUNC;

	LOGSESSIONS;

	ASSERT_DEBUG(iBearerManager);

	iBearerManager->ControllerClientAvailable();

	LOGSESSIONS;

	}

// this function is called by the session when it goes connection oriented

void CRemConServer::ClientGoConnectionOriented(CRemConSession& aSession, TUid aUid)

	{

	LOG_FUNC;

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

	LOGSESSIONS;

	(void)&aSession; // get rid of unused warning.

	ASSERT_DEBUG(aSession.Type() == ERemConClientTypeController);

	/* now tell the bearer manager that someones went connection oriented

	   The bearer manager maintains controller and target counts for all bearers

	   and will tell bearers when they need to know things have changed */

	ASSERT_DEBUG(iBearerManager);

	iBearerManager->ClientConnectionOriented(aUid);

	LOGSESSIONS;

	}

// this is called by the session when the client goes connectionless

void CRemConServer::ClientGoConnectionless(CRemConSession& aSession, TUid aUid)

	{

	LOG_FUNC;

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

	LOGSESSIONS;

	(void)&aSession; // get rid of unused warning.

	ASSERT_DEBUG(aSession.Type() == ERemConClientTypeController);

	/* now tell the bearer manager that someones went connection less

	   The bearer manager maintains controller and target counts for all bearers

	   and will tell bearers when they need to know things have changed */

	ASSERT_DEBUG(iBearerManager);

	iBearerManager->ClientConnectionless(aUid);

	LOGSESSIONS;

	}

// called by session when session is closed.

void CRemConServer::ClientClosed(CRemConSession& aSession, TUid aUid)

	{

	LOG_FUNC;

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

	LOGSESSIONS;

	iSessionsLock.Wait();

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

	const TUint sessCount = iSessions.Count();

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

		{

		if ( iSessions[ii] == &aSession )

			{

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

			// 1. Remove the session from our array.

			iSessions.Remove(ii);

			// 2. Tell the bearers about the session going away, if it was the 

			// last controller or last target.

			// If the session hasn't already set its type, then it doesn't