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

// 

//

/**

 @file

 @internalComponent

*/

#include "e32base.h"

#include <bluetooth/logger.h>

#include <remcon/remconbearerinterface.h>

#include <remcon/remconifdetails.h>

#include <s32mem.h>

#include "utils.h"

#include "server.h"

#include "bearermanager.h"

#include "remconmessage.h"

#include "connections.h"

#include "activehelper.h"

#include "session.h"

#include "messagequeue.h"

#include "remconserver.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_REMCON_SERVER);

#endif

#ifdef _DEBUG

PANICCATEGORY("session");

#endif

CRemConSession* CRemConSession::NewL(CRemConServer& aServer,

		CBearerManager& aBearerManager,

		const RMessage2& aMessage,

		TUint aId)

	{

	LOG_STATIC_FUNC

	CRemConSession* self = new(ELeave) CRemConSession(aServer, aBearerManager, aId);

	CleanupStack::PushL(self);

	self->ConstructL(aMessage);

	CLEANUPSTACK_POP1(self);

	return self;

	}

CRemConSession::CRemConSession(CRemConServer& aServer,

		CBearerManager& aBearerManager,

		TUint aId)

 :	iServer(aServer),

	iBearerManager(aBearerManager),

	iId(aId)

	{

	LOG_FUNC

	}

void CRemConSession::ConstructL(const RMessage2& aMessage)

	{

	LOG_FUNC;

	// Get the client's process ID.

	RThread thread;

	LEAVEIFERRORL(aMessage.Client(thread));

	CleanupClosePushL(thread);

	RProcess process;

	LEAVEIFERRORL(thread.Process(process));

	iClientInfo.ProcessId() = process.Id();

	process.Close();

	iClientInfo.SecureId() = thread.SecureId();

	CleanupStack::PopAndDestroy(&thread);

	iSendQueue = CMessageQueue::NewL();

	TCallBack cb(SendNextCb, this);

	iSendNextCallBack = new(ELeave) CAsyncCallBack(cb, CActive::EPriorityStandard);

	// Tell the server about us.

	LEAVEIFERRORL(iServer.ClientOpened(*this));

	// Set our pointer into the connection history at the current/'Last' item.

	iServer.SetConnectionHistoryPointer(Id());

	iPendingMsgProcessor = new (ELeave) CActiveHelper(*this);

	}

CRemConSession::~CRemConSession()

	{

	LOG(KNullDesC8);

	LOG_FUNC;

	delete iPendingMsgProcessor;

	delete iSendNextCallBack;

	delete iSendQueue;

	// we will need to tell the server which bearer this used to be connected to

	// this enables the server to not inform a bearer that is already connected

	// that its been connected

	// Tell the server we've gone away- it may start its shutdown timer.

	iServer.ClientClosed(*this, iRemoteAddress.BearerUid());

	delete iInterestedAPIs;

	iPlayerName.Close();

	}

void CRemConSession::ServiceL(const RMessage2& aMessage)

	{

	LOG(KNullDesC8);

	LOG_FUNC;

	LOG1(_L("\taMessage.Function() = %d"), aMessage.Function());

	// Switch on the IPC number and call a 'message handler'. Message handlers 

	// complete aMessage (either with Complete or Panic), or make a note of 

	// the message for later asynchronous completion.

	// Message handlers should not leave- the server does not have an Error 

	// function. 

	switch ( aMessage.Function() )

		{

	// Heap failure testing APIs.

	case ERemConDbgMarkHeap:

#ifdef _DEBUG

		LOG(_L("\tmark heap"));

		__UHEAP_MARK;

#endif // _DEBUG

		CompleteClient(aMessage, KErrNone);

		break;

	case ERemConDbgCheckHeap:

#ifdef _DEBUG

		LOG1(_L("\tcheck heap (expecting %d cells)"), aMessage.Int0());

		__UHEAP_CHECK(aMessage.Int0());

#endif // _DEBUG

		CompleteClient(aMessage, KErrNone);

		break;

	case ERemConDbgMarkEnd:

#ifdef _DEBUG

		LOG1(_L("\tmark end (expecting %d cells)"), aMessage.Int0());

		__UHEAP_MARKENDC(aMessage.Int0());

#endif // _DEBUG

		CompleteClient(aMessage, KErrNone);

		break;

	case ERemConDbgFailNext:

#ifdef _DEBUG

		{

		LOG1(_L("\tfail next (simulating failure after %d allocation(s))"), aMessage.Int0());

		if ( aMessage.Int0() == 0 )

			{

			__UHEAP_RESET;

			}

		else

			{

			__UHEAP_FAILNEXT(aMessage.Int0());

			}

		}

#endif // _DEBUG

		CompleteClient(aMessage, KErrNone);

		break;

	case ERemConSetClientType:

		SetClientType(aMessage);

		// This is a sync API- check that the message has been completed.

		// (NB We don't check the converse for async APIs because the message 

		// may have been panicked synchronously.)

		ASSERT_DEBUG(aMessage.IsNull());

		break;

	case ERemConGoConnectionOriented:

		GoConnectionOriented(aMessage);

		ASSERT_DEBUG(aMessage.IsNull());

		break;

	case ERemConGoConnectionless:

		GoConnectionless(aMessage);

		ASSERT_DEBUG(aMessage.IsNull());

		break;

	case ERemConConnectBearer:

		ConnectBearer(aMessage);

		break;

	case ERemConConnectBearerCancel:

		ConnectBearerCancel(aMessage);

		ASSERT_DEBUG(aMessage.IsNull());

		break;

	case ERemConDisconnectBearer:

		DisconnectBearer(aMessage);

		break;

	case ERemConDisconnectBearerCancel:

		DisconnectBearerCancel(aMessage);

		ASSERT_DEBUG(aMessage.IsNull());

		break;

	case ERemConSend:

		Send(aMessage);

		break;

	case ERemConSendNotify:

		SendNotify(aMessage);

		break;

	case ERemConSendUnreliable:

		SendUnreliable(aMessage);

		break;

	case ERemConSendCancel:

		SendCancel(aMessage);

		ASSERT_DEBUG(aMessage.IsNull());

		break;

	case ERemConReceive:

		Receive(aMessage);

		break;

	case ERemConReceiveCancel:

		ReceiveCancel(aMessage);

		ASSERT_DEBUG(aMessage.IsNull());

		break;

	case ERemConGetConnectionCount:

		GetConnectionCount(aMessage);

		ASSERT_DEBUG(aMessage.IsNull());

		break;

	case ERemConGetConnections:

		GetConnections(aMessage);

		ASSERT_DEBUG(aMessage.IsNull());

		break;

	case ERemConNotifyConnectionsChange:

		NotifyConnectionsChange(aMessage);

		break;

	case ERemConNotifyConnectionsChangeCancel:

		NotifyConnectionsChangeCancel(aMessage);

		ASSERT_DEBUG(aMessage.IsNull());

		break;

	case ERemConRegisterInterestedAPIs:

		RegisterInterestedAPIs(aMessage);

		ASSERT_DEBUG(aMessage.IsNull());

		break;

	default:

		// Unknown message

		PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicIllegalIpc);

		break;

		}

	}

void CRemConSession::CompleteClient(const RMessage2& aMessage, TInt aError)

	{

	LOG1(_L("\tcompleting client message with %d"), aError);

	TBool cleanClientInfoMessage = (iClientInfo.Message().Handle() == aMessage.Handle());

	aMessage.Complete(aError);

	if(cleanClientInfoMessage)

		{

		iClientInfo.Message() = RMessage2();

		}

	}

void CRemConSession::SetClientType(const RMessage2& aMessage)

	{

	LOG_FUNC;

	if ( iType != ERemConClientTypeUndefined )

		{

		PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicClientTypeAlreadySet);

		return;

		}

	const TRemConClientType type = static_cast<TRemConClientType>(aMessage.Int0());

	LOG1(_L("\trequested (TRemConClientType) type = %d"), type);

	TInt err = aMessage.GetDesLength(1);

	if(err >= 0)

		{

		TRAP(err, DoSetClientTypeL(aMessage));

		if(err == KErrBadDescriptor)

			{

			PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicBadDescriptor);

			return;

			}

		}

	else if(err == KErrBadDescriptor)

		{

		// The additional parameters are optional (i.e. old or controller clients won't provide them).

		err = KErrNone;

		}

	if(err != KErrNone)

		{

		CompleteClient(aMessage, err);

		}

	else

		{

		switch ( type )

			{

		case ERemConClientTypeController:

			iType = type;

			CompleteClient(aMessage, KErrNone);

			break;

		case ERemConClientTypeTarget:

			// Check that there aren't already any target clients with the

			// same process ID.

			if ( !iServer.TargetClientWithSameProcessId(iClientInfo.ProcessId()) )

				{

				iType = type;

				CompleteClient(aMessage, KErrNone);

				}

			else

				{

				CompleteClient(aMessage, KErrInUse);

				}

			break;

		default:

			PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicBadType);

			break;

			}

		}

	if ( iType != ERemConClientTypeUndefined )

		{

		// The type got set, so tell the server, so it can tell the bearers if 

		// necessary. 

		iServer.ClientTypeSet(*this);

		}

	}

void CRemConSession::DoSetClientTypeL(const RMessage2& aMessage)

	{

	// Retrieve the client type information 

	RBuf8 typeBuf;

	typeBuf.CreateL(sizeof(TPlayerTypeInformation));

	CleanupClosePushL(typeBuf);

	aMessage.ReadL(1, typeBuf);

	const TPlayerTypeInformation* Ptr = reinterpret_cast<const TPlayerTypeInformation*> (typeBuf.Ptr());

	iPlayerType.iPlayerType = (*Ptr).iPlayerType;

	iPlayerType.iPlayerSubType = (*Ptr).iPlayerSubType;

	// Retrieve the client player name inforamtion

	iPlayerName.CreateL(aMessage.Int2());

	CleanupClosePushL(iPlayerName);

	aMessage.ReadL(3, iPlayerName);	

	CleanupStack::Pop(&iPlayerName);

	CleanupStack::PopAndDestroy(&typeBuf); 

	}

void CRemConSession::GoConnectionOriented(const RMessage2& aMessage)

	{

	LOG_FUNC;

	// Check we've had our type set...

	if ( iType != ERemConClientTypeController )

		{

		PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicBadType);

		return;

		}

	if ( !iRemoteAddress.IsNull() )

		{

		PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicAlreadyConnectionOriented);

		return;

		}

	if ( iConnectBearerMsg.Handle() || iDisconnectBearerMsg.Handle() || iSendMsg.Handle())

		{

		PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicBearerControlOutstanding);

		return;

		}

	if (iSending != ENotSending)

		{

		DoSendCancel();

		}

	EmptySendQueue();

	// Get the desired address from the message and check it.

	const TUid uid = TUid::Uid(aMessage.Int0());

	LOG1(_L("\tuid = 0x%08x"), uid);

	// Check the requested bearer exists.

	TBool bearerExists = iBearerManager.BearerExists(uid);

	if ( !bearerExists)

		{

		PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicBearerPluginIncorrectInterface);

		return;

		}

	// Check the bearer-specific part of the address.

	TBuf8<TRemConAddress::KMaxAddrSize> buf;

	TInt err = aMessage.Read(1, buf);

	if ( err != KErrNone )

		{

		PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicBadDescriptor);

		return;

		}

	// Do security check- if this client won't be allowed to use the bearer 

	// then fail the request. 

	// NB This security check (repeated in debug at ConnectBearer and 

	// DisconnectBearer time) is all that stands between a connection-oriented 

	// client and the bearer, and is all the caps checking that RemCon does!

	err = KErrPermissionDenied;

	if ( iBearerManager.CheckPolicy(uid, aMessage) )

		{

		err = KErrNone;

		}

	// if alls well and we're connection oriented then set up as such

	if (KErrNone == err)

		{

		// The client has passed all our checks- set our data member.

		iRemoteAddress.BearerUid() = uid;

		iRemoteAddress.Addr() = buf;

		// tell the server

		iServer.ClientGoConnectionOriented(*this,uid);

		}

	CompleteClient(aMessage, err);

	}

void CRemConSession::GoConnectionless(const RMessage2& aMessage)

	{

	LOG_FUNC;

	// Check we've had our type set...

	if ( iType != ERemConClientTypeController )

		{

		PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicBadType);

		return;

		}

	if ( iRemoteAddress.IsNull() )

		{

		PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicNotConnectionOriented);

		return;

		}

	if ( iConnectBearerMsg.Handle() || iDisconnectBearerMsg.Handle() || iSendMsg.Handle())

		{

		PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicBearerControlOutstanding);

		return;

		}

	if (iSending != ENotSending)

		{

		DoSendCancel();

		}

	EmptySendQueue();

	// we will need to tell the server which bearer this used to be connected to

	// this enables the server to not inform a bearer that is already connected

	// that its been connected

	TUid oldUid = iRemoteAddress.BearerUid();

	iRemoteAddress.BearerUid() = KNullUid;	

	// tell the server

	iServer.ClientGoConnectionless(*this, oldUid);

	CompleteClient(aMessage, KErrNone);

	}

void CRemConSession::ConnectBearer(const RMessage2& aMessage)

	{

	LOG_FUNC;

	if ( iType != ERemConClientTypeController )

		{

		PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicBadType);

		return;

		}

	if ( iConnectBearerMsg.Handle() || iDisconnectBearerMsg.Handle() )

		{

		PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicBearerControlOutstanding);

		return;

		}

	if ( iRemoteAddress.IsNull() )

		{

		PANIC_MSG(aMessage, KRemConClientPanicCat, ERemConClientPanicNotConnectionOriented);

		return;

		}

	// Check the requested bearer exists.

	TBool bearerExists = iBearerManager.BearerExists(iRemoteAddress.BearerUid());

	// This check was done at GoConnectionOriented time.

	ASSERT_DEBUG(bearerExists);

	// So was this one.

	ASSERT_DEBUG(iBearerManager.CheckPolicy(iRemoteAddress.BearerUid(), aMessage));

	// Check the state of our given connection at the bearer level. If it is: 

	// -) disconnected request the connection to come up,

	// -) connecting or disconnecting, add message to the queue of pending 

	//		messages, and process it once connecting/disconnecting has been completed

	// -) connected, complete the client's message,

	TConnectionState conState;

	conState = iServer.ConnectionState(iRemoteAddress);

	if ( conState == EDisconnected )

		{

		// The bearer may indicate connection synchronously, so set this 

		// message _before_ we ask them

		iConnectBearerMsg = aMessage;

		TInt err = iBearerManager.Connect(iRemoteAddress);

		if ( err != KErrNone )

			{

			CompleteClient(iConnectBearerMsg, err);

			}

		}

	else if ( conState == EDisconnecting ||  conState == EConnecting )