// 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 "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 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 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);

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

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

		{

		LEAVEIFERRORL(KErrNotSupported);

		}

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

	CRemConSession* sess = NULL;

	ASSERT_DEBUG(iBearerManager);

		{

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

		// we need to shut down again.

		LEAVEIFERRORL(err);

		}

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

	return sess;

	}

	{

	LOG_FUNC;

		{

		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"));

			}

		}

	}

TInt CRemConServer::TimerFired(TAny* aThis)

	{

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

	{

	// 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()

	{

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

	}

	{

	LOG_FUNC;

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