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

//

/**

 @file

 @internalComponent

*/

#include "sd_log.h"

#include "sd_std.h"

#include "sd_roles.h"

#include "sd_errors.h"

#include "sd_msgs.h"

#include "sd_apiextensionrouting.h"

#include "sd_apiextensionipc.h"

#include <elements/nm_common.h>

#include <elements/cfmacro.h>

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ElemSvrDenWrkrSC, "ElemSvrDenWrkrSC");

#endif

using namespace Den;

using namespace Messages;

using namespace Elements;

using namespace CommsFW;

class RNullableMessage : public RMessage2

	{

public:

	void NullHandle() const

		{

		// Although this casting away of const looks awful it's in keeping with the ability to Complete() const

		// messages - perhaps iHandle should have been mutable?

		const_cast<RNullableMessage&>(*this).iHandle = 0;

		}

	};

//

// CSubSessionIx

//

void CSubSessionIx::InitialiseL()

	{

	User::LeaveIfError(iLock.CreateLocal());

	}

EXPORT_C CSubSessionIx::~CSubSessionIx()

	{

	User::Free(iIx);

	}

EXPORT_C TInt CSubSessionIx::Find(CWorkerSubSession* aSubSession, TSubSessionHandle& aHandle) const

	{

	iLock.AssertLockHeld();

	for(TInt ix = 0; ix < iSize; ++ix)

		{

		TEntry& e = iIx[ix];

		if(e.iType != TSubSessInfo::ENull && e.iObject == aSubSession)

			{

			aHandle = MakeHandle(ix, e.iMagic, e.iType);

			return KErrNone;

			}

		}

	return KErrNotFound;

	}

TInt CSubSessionIx::Add(CWorkerSubSession* aSubSession, TSubSessionHandle& aHandle)

	{

	iLock.AssertLockHeld();

	if(TUint(iFreeListHead) >= TUint(iSize))

		{

		TInt err = ExpandArray();

		if(err != KErrNone)

			{

			return err;

			}

		}

	TInt ix = iFreeListHead;

	TEntry& e = iIx[ix];

	__ASSERT_DEBUG(e.iType == TSubSessInfo::ENull, User::Panic(KSpecAssert_ElemSvrDenWrkrSC, 1));

	iFreeListHead = e.iNextFree;

	__ASSERT_DEBUG(TUint(iFreeListHead) <= TUint(iSize), User::Panic(KSpecAssert_ElemSvrDenWrkrSC, 2));

	e.iObject = aSubSession;

	e.iType = aSubSession->Type().iType;

	TInt magic = (e.iMagic + 1) & KMagicMask;

	e.iMagic = TUint16(magic);

	aHandle = MakeHandle(ix, magic, e.iType);

	++iActiveCount;

	return KErrNone;

	}

EXPORT_C CWorkerSubSession* CSubSessionIx::Replace(TSubSessionHandle aHandle, CWorkerSubSession* aSubSession)

	{

	iLock.AssertLockHeld();

	__ASSERT_DEBUG(TUint(iFreeListHead) <= TUint(iSize), User::Panic(KSpecAssert_ElemSvrDenWrkrSC, 3));

	TEntry* e = At(aHandle);

	__ASSERT_DEBUG(e, User::Panic(KSpecAssert_ElemSvrDenWrkrSC, 4));

	CWorkerSubSession* origSubSession = e->iObject;

	e->iObject = aSubSession;

	return origSubSession;

	}

EXPORT_C CWorkerSubSession* CSubSessionIx::Remove(TSubSessionHandle aHandle)

	{

	iLock.AssertLockHeld();

	__ASSERT_DEBUG(TUint(iFreeListHead) <= TUint(iSize), User::Panic(KSpecAssert_ElemSvrDenWrkrSC, 5));

	TEntry* e = At(aHandle);

	__ASSERT_DEBUG(e, User::Panic(KSpecAssert_ElemSvrDenWrkrSC, 6));

	CWorkerSubSession* subSess = e->iObject;

	e->iType = TUint8(TSubSessInfo::ENull);

	e->iNextFree = iFreeListHead;

	iFreeListHead = e - &iIx[0];

	__ASSERT_DEBUG(TUint(iFreeListHead) < TUint(iSize), User::Panic(KSpecAssert_ElemSvrDenWrkrSC, 7));

	--iActiveCount;

	return subSess;

	}

EXPORT_C CWorkerSubSession* CSubSessionIx::At(TInt aHandle, TSubSessInfo aType) const

	{

	iLock.AssertLockHeld();

	TEntry* e = At(aHandle);

	if(e &&

		(e->iType == aType.iType || aType.iType == TSubSessInfo::EAny))

		{

		return e->iObject;

		}

	return NULL;

	}

EXPORT_C CSubSessionIx::TEntry* CSubSessionIx::At(TSubSessionHandle aHandle) const

	{

	TEntry* e = 0;

	TInt ix = IndexFromHandle(aHandle);

	if(TUint(ix) < TUint(iSize))

		{

		e = &iIx[ix];

		if(MakeHandle(ix, e->iMagic, e->iType) != aHandle)

			{

			e = 0;

			}

		}

	return e;

	}

TInt CSubSessionIx::ExpandArray()

	{

	__ASSERT_DEBUG(TUint(iFreeListHead) <= TUint(iSize), User::Panic(KSpecAssert_ElemSvrDenWrkrSC, 8));

	TInt size = iSize + EIndexGranularity;

	if(size > KIndexLimit)

		{

		return KErrNoMemory;

		}

	TEntry* ix = reinterpret_cast<TEntry*>(User::ReAlloc(iIx, size * sizeof(TEntry)));

	if(!ix)

		{

		return KErrNoMemory;

		}

	iIx = ix;

	iSize = size;

	for(TInt ii = iFreeListHead; ii < size;)

		{

		TEntry& e = ix[ii];

		e.iNextFree = ++ii;

		e.iType = TUint8(TSubSessInfo::ENull);

		}

	return KErrNone;

	}

CSubSessionIx::TIter::TIter(CSubSessionIx& aContainer)

: iContainer(aContainer)

	{

	SetToFirst();

	}

void CSubSessionIx::TIter::SetToFirst()

	{

	iPos = 0;

	}

CWorkerSubSession* CSubSessionIx::TIter::operator++(TInt)

	{

	TSubSessionHandle dummyHandle;

	return Next(dummyHandle);

	}

CWorkerSubSession* CSubSessionIx::TIter::Next(TSubSessionHandle& aHandle)

	{

	iContainer.iLock.AssertLockHeld();

	TEntry* e = &iContainer.iIx[iPos];

	while(iPos < iContainer.iSize)

		{

		TInt oldPos = iPos++;

		if(e->iType != TSubSessInfo::ENull)

			{

			aHandle = iContainer.MakeHandle(oldPos, e->iMagic, e->iType);

			return e->iObject;

			}

		++e;

		}

	return NULL;

	}

void CWorkerSubSession::CleanupDeadWorker(TWorkerId aWorkerId)

	{

	CCommonSessionProxy* sessProxy = SessionProxy();

	if(sessProxy && sessProxy->Player().WorkerId() == aWorkerId)

		{

		delete this;

		}

	}

// API extension support

EXPORT_C TIpcExtensionRoutingMessageFromSubSession* CWorkerSubSession::IsSubSessionIpcExtensionSupported(TInt aInterfaceId, TDes8& aBuff)

	{

	TIpcExtensionRoutingMessageFromSubSession* routinMsg = DoIsSubSessionIpcExtensionSupported(aInterfaceId, aBuff);

	if (routinMsg!=NULL)

		{

		__ASSERT_ALWAYS(routinMsg->IsTypeOf(TIpcExtensionRoutingMessageFromSubSession::TypeId()), User::Panic(KDenFaultPanic, ECommonBadState));

		}

	return routinMsg;

	}

EXPORT_C void CWorkerSubSession::OpenSubSessionIpcExtensionL(const RSafeMessage& aMessage, const TApiExtIdentification& aExtIdentification)

	{

	iApiExtRegister.RegisterOpenInterfaceLC(aExtIdentification); //Fails with KErrAlreadyExists if already opened

	TBuf8<TSignalBase::KMaxInlineMessageSize+TSignalBase::KMaxUnstoredOverhead> msgDst;

	TIpcExtensionRoutingMessageFromSubSession* routingMsg = IsSubSessionIpcExtensionSupported(aExtIdentification.InterfaceId(), msgDst);

	if (routingMsg==NULL)

		{

		User::Leave(KErrNotSupported);

		}

	routingMsg->KickOffL(aMessage, *this, aExtIdentification);

	CleanupStack::Pop(); //RegisterInterfaceLC

	DontCompleteCurrentRequest();

	}

EXPORT_C void CWorkerSubSession::SendReceiveSubSessionIpcExtensionL(const RSafeMessage& aMessage, const TApiExtIdentification& aExtIdentification)

	{

	if (!iApiExtRegister.IsOpened(aExtIdentification))

		{

		//Out of band message..

		PanicClient(ECommonBadState);

		return;

		}

	TBuf8<TSignalBase::KMaxInlineMessageSize+TSignalBase::KMaxUnstoredOverhead> msgDst;

	TIpcExtensionRoutingMessageFromSubSession* routingMsg = IsSubSessionIpcExtensionSupported(aExtIdentification.InterfaceId(), msgDst);

	//routingMsg must be there now, otherwise the interface would not be opened!

	__ASSERT_ALWAYS(routingMsg, User::Panic(KDenFaultPanic, ECommonBadState));

	routingMsg->KickOffL(aMessage, *this, aExtIdentification);

	DontCompleteCurrentRequest();

	}

EXPORT_C void CWorkerSubSession::CloseSubSessionIpcExtension(const RSafeMessage& aMessage, const TApiExtIdentification& aExtIdentification)

	{

	if (iApiExtRegister.IsOpened(aExtIdentification))

		{

		TBuf8<TSignalBase::KMaxInlineMessageSize+TSignalBase::KMaxUnstoredOverhead> msgDst;

		TIpcExtensionRoutingMessageFromSubSession* routingMsg = IsSubSessionIpcExtensionSupported(aExtIdentification.InterfaceId(), msgDst);

		//routingMsg must be there, otherwise the interface would not be opened!

		__ASSERT_ALWAYS(routingMsg, User::Panic(KDenFaultPanic, ECommonBadState));

		routingMsg->KickOffL(aMessage, *this, aExtIdentification);

		iApiExtRegister.DeregisterClosedInterface(aExtIdentification);

		DontCompleteCurrentRequest();

		}

	}

EXPORT_C void CWorkerSubSession::CloseAllSubSessionIpcExtensions()

	{

	//This funtion does not expect not causes the SafeMessage() to be completed.

	//It is called from the session's destructor.

	TBuf8<TSignalBase::KMaxInlineMessageSize+TSignalBase::KMaxUnstoredOverhead> msgDst;

	for (TInt i = iApiExtRegister.InterfaceCount() - 1; i >= 0; --i)

		{

		const TApiExtIdentification& entry = iApiExtRegister[i];

		TBuf8<TSignalBase::KMaxInlineMessageSize+TSignalBase::KMaxUnstoredOverhead> msgDst;

		TIpcExtensionRoutingMessageFromSubSession* routingMsg = IsSubSessionIpcExtensionSupported(entry.InterfaceId(), msgDst);

		//routingMsg must be there now, otherwise the interface would not be opened!

		__ASSERT_ALWAYS(routingMsg, User::Panic(KDenFaultPanic, ECommonBadState));

		RSettableParameterMessage message(EIpcSubSessionApiExtIfaceClose);

		routingMsg->KickOffL(message, *this, entry);

		iApiExtRegister.DeregisterClosedInterface(entry);

		}

	}

#ifdef SYMBIAN_TRACE_ENABLE

TInt CWorkerSession::DisconnectPlayers()

	{

	return iDisconnectPlayers;

	}

#endif

EXPORT_C CWorkerSession::CWorkerSession(TUidType aUid, TSessionUniqueId aSessionUniqueId)

:	iUidType(aUid),

	iSessionUniqueId(aSessionUniqueId)

	{

	}

EXPORT_C void CWorkerSession::ConstructL(TProcessId aProcessId)

	{

	User::LeaveIfError(iProcess.Open(aProcessId));

	iSubSessions.InitialiseL();

	}

/** Sends SessionClosed to all non-resident players. Add self to Dealers list of disconnecting sessions.

*/

void CWorkerSession::Disconnect()

	{

	#ifdef SYMBIAN_TRACE_ENABLE

		TBuf8<KMaxProcessName> processName;

		processName.Copy(iProcess.Name().Left(KMaxProcessName));

	 	COMMONLOG((WorkerId(), KECommonSessDetailTag, _L8("CWorkerSession(%08x):\tDisconnect(), \"%S\""), this, &processName));

	 #endif

 		{

 		SubSessions().Lock();

		// Remove all subsessions from the session, i.e., just as if the client had closed them all individually

		ProcessSubSessions(TWorkerThreadPublicInfo::ENullWorkerId, ForgetSubSession, NULL);

		SubSessions().Unlock();

		}

	CCommonWorkerThread& owner=WorkerThread();

	TWorkerId self = owner.WorkerId();

	for(TWorkerId player = TWorkerThreadPublicInfo::EFirstPlayerThread; player <= TWorkerThreadPublicInfo::EMaxWorkerThreadId; ++player)

		{

		if(IsPlayerInDisconnectList(player))

			{

			if(owner.PeerReachable(player))

				{

				/* Sending closed session message to involved player, dont care if it times out. After this we just wait

				anyway for a while and then obliterate it.*/

				COMMONLOG((WorkerId(),KECommonSessDetailTag, _L8("CWorkerSession(%08x):\tDisconnect() Sending SessionClose to W%d"), this, player));

				TPlayerSessionCloseMsg msg(this);

				owner.PostMessage(player, reinterpret_cast<TCFCommsMessage&>(msg));

				}

			else

				{

				__ASSERT_DEBUG(0, User::Panic(KSpecAssert_ElemSvrDenWrkrSC, 9)); 	// Ouch! - binding gone & we need to talk to them. Maybe they crashed & there's a bug in the cleanup of that

				}

			}

		}

	}

EXPORT_C void CWorkerSession::Disconnect(const RMessage2& aMessage)

	{

	COMMONLOG((WorkerId(),KECommonSessDetailTag, _L8("CWorkerSession(%08x):\tDisconnect(const RMessage2& = %08x)"), this, aMessage.Handle()));

	iDisconnectMessage = aMessage;

	Disconnect();

	// If co-resident Player was only one then complete immediately

	if(IsDisconnectListEmpty())

		{

		COMMONLOG((WorkerId(),KECommonSessDetailTag, _L8("CWorkerSession(%08x):\tDisconnect(const RMessage2&) inherited disconnect"), this));

		CSession2::Disconnect(aMessage);

		}

	}

void CWorkerSession::AddPlayerToDisconnectList(TWorkerId aPlayerId)

	{

	__ASSERT_COMPILE(TWorkerThreadPublicInfo::EMaxWorkerThreadId < 32);	// Using a TUint32 as a flag container

	__ASSERT_DEBUG(aPlayerId >= TWorkerThreadPublicInfo::EFirstPlayerThread && aPlayerId <= TWorkerThreadPublicInfo::EMaxWorkerThreadId, User::Panic(KSpecAssert_ElemSvrDenWrkrSC, 10));

#ifdef SYMBIAN_TRACE_ENABLE

		if(!IsPlayerInDisconnectList(aPlayerId))

			{

			COMMONLOG((WorkerId(),KECommonSessDetailTag, _L8("CWorkerSession(%08x):\tAddPlayerToDisconnectList(%d)"), this, aPlayerId));

			}

#endif

	iDisconnectPlayers |= (1 << aPlayerId);

	}

void CWorkerSession::RemovePlayerFromDisconnectList(TWorkerId aPlayerId)

	{

	__ASSERT_DEBUG(aPlayerId >= TWorkerThreadPublicInfo::EFirstPlayerThread && aPlayerId <= TWorkerThreadPublicInfo::EMaxWorkerThreadId, User::Panic(KSpecAssert_ElemSvrDenWrkrSC, 11));

#ifdef SYMBIAN_TRACE_ENABLE

		if(IsPlayerInDisconnectList(aPlayerId))

			{

			COMMONLOG((WorkerId(),KECommonSessDetailTag, _L8("CWorkerSession(%08x):\tRemovePlayerFromDisconnectList(%d)"), this, aPlayerId));

			}

#endif

	iDisconnectPlayers &= ~(1 << aPlayerId);

	}

EXPORT_C TBool CWorkerSession::IsDisconnectListEmpty() const

	{

	return iDisconnectPlayers == 0;

	}

TBool CWorkerSession::IsPlayerInDisconnectList(TWorkerId aPlayerId) const

	{

	// A potential optimisation for the future would be to actively check whether the player still has subsessions here, rather

	// than blinding sending the session close message

	__ASSERT_DEBUG(aPlayerId >= TWorkerThreadPublicInfo::EFirstPlayerThread && aPlayerId <= TWorkerThreadPublicInfo::EMaxWorkerThreadId, User::Panic(KSpecAssert_ElemSvrDenWrkrSC, 12));

	return iDisconnectPlayers & (1 << aPlayerId);

	}

void CWorkerSession::CleanupDeadWorker(TWorkerId aPeerId)

	{

	// Forget all subsessions belonging to that Player and no longer a need to notify Player of session closure

		{

		SubSessions().Lock();

		ProcessSubSessions(aPeerId, ForgetSubSession, NULL);

		SubSessions().Unlock();

		}

	RemovePlayerFromDisconnectList(aPeerId);

	}

void CWorkerSession::ForgetSubSession(CWorkerSession* aSelf, CWorkerSubSession* aSubSession, TInt aSubSessionHandle, TAny*)

	{

	(void) aSubSession;	// suppress UREL warnings

	VERIFY_RESULT(aSelf->iSubSessions.Remove(aSubSessionHandle), aSubSession);

	}

void CWorkerSession::CountSubSessions(CWorkerSession*, CWorkerSubSession*, TInt, TAny* aArg)

	{

	TInt* counter = reinterpret_cast<TInt*>(aArg);

	++*counter;

	}

#ifdef SYMBIAN_TRACE_ENABLE

EXPORT_C void CWorkerSession::LogSubSession(CWorkerSession*, CWorkerSubSession* aSubSession, TInt, TAny*)

#else

EXPORT_C void CWorkerSession::LogSubSession(CWorkerSession*, CWorkerSubSession*, TInt, TAny*)

#endif

	{

	COMMONLOG((KInvalidWorkerId, KECommonSessDetailTag, _L8("CSockSession(%08x):\tLogSubSession --subsess: %08x"), aSubSession));

	}

/**

Destroy

*/

EXPORT_C CWorkerSession::~CWorkerSession()

	{

	//All interfaces muxt be closed by now (by the derived session's destructor the latest)

	__ASSERT_DEBUG(iApiExtRegister.InterfaceCount() == 0, User::Panic(KSpecAssert_ElemSvrDenWrkrSC, 13));

	// On the normal pathway all subsessions are removed by Disconnect() before session destruction can proceed. The only time we just delete a session

	// without being instructed by the client is during an immediate shutdown

	__ASSERT_DEBUG((iSubSessions.ActiveCount() == 0 || PitBoss().TestImmediateShutdownPresent()), User::Panic(KSpecAssert_ElemSvrDenWrkrSC, 18));

	iProcess.Close();

	const CCommonServer* s = static_cast<const CCommonServer*>(Server());

	if (s)     // guard against leave during construction (e.g. a leave from CWorkerSession::ConstructL()).

	    {

        __ASSERT_DEBUG(s->iNumSessions>0, User::Panic(KDenFaultPanic, ECommonNegativeSessionCount));

        s->iNumSessions--;

        COMMONLOG((WorkerId(), KECommonSessDetailTag, _L8("CWorkerSession(%08x):\t~CWorkerSession() iNumSessions=%d (remaining)"), this, s->iNumSessions));

        CCommonWorkerThread& selfWorker = WorkerThread();

        if (selfWorker.ShuttingDown())

            {

            COMMONLOG((WorkerId(), KECommonSessDetailTag, _L8("Shutdown requested: %d sessions"), s->iNumSessions));

            if (s->iNumSessions <= 0)

                {

                if(selfWorker.IsMainThread())

                    {

                    selfWorker.PitBoss().SessionShutdownComplete();

                    }

                else

                    {

                    selfWorker.MaybeTriggerThreadShutdownCallback();

                    }

                }

            }

	    }

	}

EXPORT_C void CWorkerSession::ProcessSubSessions(TWorkerId aPeerId, TSubSessionProcessor aSubSessionProcessor, TAny* aArg)

	{

	TInt count = iSubSessions.ActiveCount();

	if(count != 0)

		{

		COMMONLOG((WorkerId(), KECommonSessDetailTag, _L8("CSockSession(%08x):\tProcessSubSessions - Processing %d subsessions for W%d:"), this, count, aPeerId));

		CSubSessionIx::TIter iter(iSubSessions);

		CWorkerSubSession* ss;

		TInt ssHandle;

		while((ss = iter.Next(ssHandle)) != NULL)

			{

			COMMONLOG((WorkerId(), KECommonSessDetailTag, _L8("CSockSession(%08x):\tProcessSubSessions - Processing subsession %08X"), this, ss));

			if(aPeerId == TWorkerThreadPublicInfo::ENullWorkerId || aPeerId == ss->Player().WorkerId())

				{

				aSubSessionProcessor(this, ss, ssHandle, aArg);

				}

			}

		}

	}

/** Determine WorkedId for a subsession and deal with the message.

@param aMessage IPC message received from client.

@param aSubSess Subsession that needs to deal with this message.

*/

EXPORT_C void CWorkerSession::ForwardMessageL(const RMessage2 &aMessage, CWorkerSubSession& aSubSess)

	{

	ForwardMessageL(aMessage, &aSubSess, aSubSess.Player().WorkerId());

	}

/** Determine whether to deal with message directly or