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

 *

 * Implements CCommSession, CCommSubSession

 */

#include "CS_STD.H"

#include "C32LOG.H"

#include "cs_thread.h"

#include "cs_roles.h"

#include "cs_msgs.h"

#include "cs_glob.h"

#include <comms-infras/c32startcli.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <c32comm_internal.h>

#endif

class CCommSubSession;

void PanicClient(TInt aPanic, const RMessagePtr2& aMessage)

	{

	if(aMessage.Handle() != 0)

		{

		aMessage.Panic(KCommServerName(), aPanic);

		}

	}

TWorkerId CCommSession::WorkerId() const

	{

	return Dealer().WorkerId();

	}

/**

@param aMessage IPC message received from client.

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

*/

void CCommSession::ForwardMessageL(const RMessage2 &aMessage, CCommSubSession& aSubSess)

	{

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

	}

/** Determine whether to deal with message directly or to send it on a channel.

@param aMessage IPC message received from client.

@param aWorkerId Id of worker that can handle this message.

*/

void CCommSession::ForwardMessageL(const RMessage2& aMessage, CCommSubSession* aSS, TWorkerId aWorker)

	{

	ASSERT(aWorker <= TC32WorkerThreadPublicInfo::EMaxWorkerThreadId);

	CC32WorkerThread& owner = C32WorkerThread();

	/**

	While forwarding the message to player, Add player to disconnect list. While closing the session

	the disconnect list is used and session close message is forwarded to player. Only when session

	close response is received, the session is destroyed.

	*/

	// If the Player is co-resident in this worker thread

	if(owner.WorkerId()==aWorker)

		{

		AddPlayerToDisconnectList(aWorker);

		owner.Player()->ProcessMessageL(aMessage, aSS);

		DontCompleteCurrentRequest();

		}

	else if(owner.PeerReachable(aWorker))	// Forward to Player thread

		{

		AddPlayerToDisconnectList(aWorker);

		TC32PlayerForwardRequestMsg msg(aMessage, aSS);

		owner.PostMessage(aWorker, msg);

		DontCompleteCurrentRequest();

		const RNullableMessage& forwardedMsg = static_cast<const RNullableMessage&>(aMessage);

		forwardedMsg.NullHandle();

		}

	else

		{

		C32LOG1(KC32Warning, _L8("CCommSession::ForwardMessageL() Peer Thread Unreachable"));

		DontCompleteCurrentRequest();

		__ASSERT_DEBUG(0, User::Panic(KCFTransportPanic, ECFTransAbsentWorker));

		}

	}

void CCommSession::ServiceError(const RMessage2& aMessage, TInt aError)

	{

	if (aError==KErrBadDescriptor)

		{

		// this completes message as well so we have to handle it in ServiceL

		PanicClient(EBadDescriptor,aMessage);

		return;

		}

	C32LOG1(KC32Detail, _L8("CCommSession::ServiceError() ServiceL leave occured"));

	inherited::ServiceError(aMessage,aError);

	}

void CCommSession::ServiceL(const RMessage2& aMessage)

/**

 * Handle messages for this session.

 *

 * @param aMessage handle to the IPC message from the client

 */

	{

	C32LOG5(KC32Detail,_L8("CCommSession::ServiceL(), Session : 0x%x, IPC: %d (%S). Message: %08x"), this, aMessage.Function(), &TC32Log::C32RequestStr(aMessage.Function()),aMessage.Handle());

	iComplete = ETrue;

	const CC32WorkerThread& owner=C32WorkerThread();

	CC32Dealer& c32Dealer = owner.DealerByRef();

	if (c32Dealer.StartupFailed())

		{

		SafeComplete(aMessage, KErrNotReady);

		return;

		}

	// TestImmediateShutdownPresent is only set when EImmediate shutdown is present, which is

	// used only in testing phase.

	if(c32Dealer.TestImmediateShutdownPresent())

		{

		User::Leave(KErrServerTerminated);

		}

	if((aMessage.Function()==ECommOpen)

	   ||

	   (aMessage.Function()==ECommOpenWhenAvailable))

		{

		NewPortL(aMessage);

		return;

		}

#if defined (_DEBUG)

	switch (aMessage.Function())

		{

		case ECommDbgMarkHeap:

			__UHEAP_MARK;

			SafeComplete(aMessage, KErrNone);

			return;

		case ECommDbgCheckHeap:

			__UHEAP_CHECK(aMessage.Int0());

			SafeComplete(aMessage, KErrNone);

			return;

		case ECommDbgMarkEnd:

			__UHEAP_MARKENDC(aMessage.Int0());

			SafeComplete(aMessage, KErrNone);

			return;

		case ECommDbgFailNext:

  			// We set the fail point for all heaps, rather than just the current Dealer. This could lead to a failure not related

  			// directly to whatever the client test code is trying to exercise but it all helps find bugs

  			c32Dealer.SetFailNextForAllHeaps(aMessage.Int0());

			SafeComplete(aMessage, KErrNone);

			return;

		}

#endif

	switch ((aMessage.Function()))

		{

		case ECommLoadCommModule:

			{

			TFileName fullCSYFilename;

			TInt ret = Read(0,aMessage,fullCSYFilename);

			if (ret != KErrNone)

				{

				C32LOG2(KC32Warning, _L8("ServiceL: LoadCommModule  Read returned %d instead of KErrNone, cannot proceed"), ret);

				PanicClient(EBadDescriptor,aMessage);

				return;

				}

			ret = AddCSYExtension(fullCSYFilename,aMessage);

			if(ret != KErrNone)

				{

				C32LOG2(KC32Warning, _L8("ServiceL: LoadCommModule AddCSYExtension returned %d instead of KErrNone, cannot proceed"), ret);

				return;

				}

 		 	CommsFW::TWorkerId worker;

	 		TBuf8<KMaxFileName> fileName8;

			fileName8.Copy(fullCSYFilename);

 		    TBool found = iThreadManager->FindThreadByFileName(fileName8, worker);

	 		if(!found)

		 		{

		 		worker = iThreadManager->iDefaultThreadIndex;

		 		}

 		 	if(c32Dealer.WorkerExists(worker))

 		 		{

 		 		LoadCommModuleL(aMessage,worker,!found,fullCSYFilename);

 		 		}

 		 	else

 		 		{

				C32LOG2(KC32Dealer,_L8("ServiceL: LoadCommModule requires worker %d. This worker does not exist so starting"),worker);

 		 		ret = c32Dealer.LoadCPMOnLoadCommModule(worker);

 		 		if ((ret!=KErrNone) && (ret!=KErrInUse))

 		 			{

 		 			// only likely return codes here are KErrNoMemory or KErrNotFound if

 		 			// the RS server could not be found - which means system is probably in pretty bad state (ie, no memory)

 		 			// luckily at this point there isn't anything to clean up!

 		 			SafeComplete(aMessage,ret);

 		 			}

 		 		else

 		 			{

	 		 		ret = c32Dealer.ParkRequest(this, aMessage);

	 		 		if(ret != KErrNone)

	 		 			{

	 		 			SafeComplete(aMessage, ret);

	 		 			}

 		 			}

 		 		}

 		 	return;

 		 	}

		case ECommCloseCommModule:

			CloseCommModuleL(aMessage);

			return;

		case ECommPortInfoByName:

			{

			TPortName name;

			TInt ret = Read(1,aMessage,name);

			if (ret != KErrNone)

				{

				C32LOG2(KC32Warning, _L8("ServiceL: LoadCommModule  Read returned %d instead of KErrNone, cannot proceed"), ret);

				PanicClient(EBadDescriptor,aMessage);

				return;

				}

			PortInfoL(aMessage,name);

			return;

			}

		case ECommPortInfoByNumber:		// original msg is not forwarded as global as aMessage.Int2() is not valid in player, instead CSerial* is wrapped in TC32PlayerGetPortInfoMsg

			PortInfo(aMessage,aMessage.Int2());

			return;

		case ECommNumPorts:				// get information from ThreadManager in dealer

			NumPorts(aMessage);

			return;

		case ECommStartServerThread:	// KErrNotSupported

			C32LOG2(KC32Dealer, _L8("WARNING: deprecated function ECommStartServerThread called, CCommSession(%08x)"), this);

			SafeComplete(aMessage, KErrNotSupported);

			return;

		}

	// obtain subsession* from aMessage.Int3()

	CCommSubSession *p = SubSessionFromHandle(aMessage.Int3(), CCommSubSession::ECPort);

	if (aMessage.Function()==ECommClose)

		{

		if (p==NULL)	// not a valid aMessage.Int3()

			{

			SafeComplete(aMessage, KErrBadHandle);

			return;

			}

		else

			{

			CloseSubSessionL(aMessage, CCommSubSession::ECPort);

			return;

			}

		}

	if (p==NULL)	// not a valid aMessage.Int3()

		{

		PanicClient(EBadCommHandle, aMessage);

		return;

		}

	// Its OK to proceed with the dispatch of other requests

	switch (aMessage.Function())

        {

	    case ECommRead:

		case ECommReadCancel:

		case ECommQueryReceiveBuffer:

		case ECommResetBuffers:

		case ECommWrite:

		case ECommWriteCancel:

		case ECommBreak:

		case ECommBreakCancel:

		case ECommCancel:

		case ECommConfig:

		case ECommSetConfig:

		case ECommCaps:

		case ECommSetMode:

		case ECommGetMode:

		case ECommSignals:

		case ECommSetSignalsToMark:

		case ECommSetSignalsToSpace:

		case ECommReceiveBufferLength:

		case ECommSetReceiveBufferLength:

		case ECommSetAccess:

		case ECommOpenWhenAvailableCancel:

	#ifdef _DEBUG

		case ECommDebugState:

	#endif

		// Extensions to the CCommSession starts from here

		case ECommNotifySignals:

		case ECommNotifyFlowControl:

		case ECommNotifySignalsCancel:

		case ECommNotifyFlowControlCancel:

		case ECommGetFlowControl:

		case ECommNotifyConfigChange:

		case ECommNotifyConfigChangeCancel:

		case ECommNotifyBreak:

		case ECommNotifyBreakCancel:

		case ECommGetRole:

		case ECommNotifyDataAvailable:

		case ECommNotifyDataAvailableCancel:

		case ECommNotifyOutputEmpty:

		case ECommNotifyOutputEmptyCancel:

			ForwardMessageL(aMessage, *p);

			break;

		// Extensions to the CCommSession ends to here

		default:

			SafeComplete(aMessage, KErrNotSupported);

			break;

		}

	C32LOG(KC32Detail,_L8("CCommSession::ServiceL() end"));

	}

TInt CCommSession::DisconnectPlayers()

	{

	return iDisconnectPlayers;

	}

CCommSubSession* CCommSession::SubSessionFromHandle(TUint aHandle, CCommSubSession::TSubSessionType aType) const

    {

	iSubSessions.Lock();

	CCommSubSession* subSess = iSubSessions.At(aHandle, aType);

	iSubSessions.Unlock();

	return subSess;

	}

CCommSession::CC32SessionCloseTimer::CC32SessionCloseTimer(CCommSession* aSession)

: CTimer(EPriorityLow),

  iSession(aSession)

	{

	}

CCommSession::CC32SessionCloseTimer* CCommSession::CC32SessionCloseTimer::NewL(CCommSession* aSession)

	{

	CC32SessionCloseTimer* self = new (ELeave) CCommSession::CC32SessionCloseTimer(aSession);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CCommSession::CC32SessionCloseTimer::Start()

	{

	CActiveScheduler::Add(this);

	After(KC32SessionCloseDelay);

	}

void CCommSession::CC32SessionCloseTimer::RunL()

	{

	Deque();

	if(iStatus == KErrNone)

		{

		C32LOG3(KC32Detail, _L8("CCommSession::CC32SessionCloseTimer::RunL session = %08x, DisconnectList = %08x. Will panic in debug."), iSession,	iSession->DisconnectPlayers());

		// After sending a sessionclose message to the player the timeout is set and it is in the order

		// of seconds. IF the player doesn't respond (may be unloaded during shutdown, see below comment

		// about stackable csy) and we get to this place, it is a defect and we'd like to catch that in

		// debug mode.

		// NOTE FOR STACKABLE CSY WRITERS

		// The session from csy loading another csy was not closed properly and hence when shutdown was

		// commanded, player CPMs unload, while the session remains. When EDisconnect message is received

		// by the comms server from kernel, session close message is sent to player CPM which has already

		// been unloaded and thus this timer expires. Ensure that all sessions from within csy is closed

		// before shutdown is called

		ASSERT(0);

		CC32Dealer* dealer = const_cast<CC32Dealer*>(&iSession->Dealer());

		dealer->DeleteSession(iSession);

		}

	}

void CCommSession::AddPlayerToDisconnectList(TWorkerId aPlayerId)

	{

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

	ASSERT(aPlayerId <= TC32WorkerThreadPublicInfo::EMaxWorkerThreadId);

	__FLOG_STMT(

		if(!IsPlayerInDisconnectList(aPlayerId))

			{

			C32LOG3(KC32Detail, _L8("CCommSession(%08x):\tAddPlayerToDisconnectList(%d)"), this, aPlayerId );

			}

		)

	iDisconnectPlayers |= (1 << aPlayerId);

	}

void CCommSession::RemovePlayerFromDisconnectList(TWorkerId aPlayerId)

	{

	ASSERT(aPlayerId <= TC32WorkerThreadPublicInfo::EMaxWorkerThreadId);

	__FLOG_STMT(

		if(IsPlayerInDisconnectList(aPlayerId))

			{

			C32LOG3(KC32Detail, _L8("CCommSession(%08x):\tRemovePlayerFromDisconnectList(%d)"), this, aPlayerId );

			}

		)

	iDisconnectPlayers &= ~(1 << aPlayerId);

	}

TBool CCommSession::IsDisconnectListEmpty() const

	{

	C32LOG2(KC32Detail, _L8("CCommSession::IsDisconnectListEmpty %d "), iDisconnectPlayers );

	return iDisconnectPlayers == 0;

	}

TBool CCommSession::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(aPlayerId <= TC32WorkerThreadPublicInfo::EMaxWorkerThreadId);

	return iDisconnectPlayers & (1 << aPlayerId);

	}

void CCommSession::ForgetSubSession(CCommSession* aSelf, CCommSubSession* aSubSession, TInt aSubSessionHandle, TAny*)

	{

	(void) aSubSession;	// suppress UREL warnings

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

	}

void CCommSession::CountSubSessions(CCommSession*, CCommSubSession*, TInt, TAny* aArg)

	{

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

	++*counter;

	}

CCommSession::CCommSession(CC32ThreadManager* aThreadManager)

/**

 * C'Tor - must pass client to CSession

 *

 * @param aClient handle to the Clients thread

 * @param aPortManager pointer to th port manager

 */

	:CSession2(),

	iThreadManager(aThreadManager)

	{

	C32GlobalUtil::NewSession();		// increment iNumSessions

	C32LOG1(KC32Detail, _L8("CCommSession::CCommSession()"));

	}

CCommSession* CCommSession::NewL(CC32ThreadManager* aThreadManager)

	{

	CCommSession* self = new (ELeave) CCommSession(aThreadManager);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CCommSession::ConstructL()

	{

	iSessionCloseTimer = CCommSession::CC32SessionCloseTimer::NewL(this);

	iSubSessions.InitialiseL();			// initialise CC32SubSessionIx

	}

void CCommSession::CloseSubSessionL(const RMessage2& aMessage, CCommSubSession::TSubSessionType aType)

	{

	iSubSessions.Lock();

	CCommSubSession* subSess = iSubSessions.At(aMessage.Int3(), aType);

	C32LOG5(KC32Detail, _L8("CCommSession(%08x):\tCloseSubSession(%08x, %d) - subSess %08x"), this, aMessage.Int3(), aType, subSess);

	ASSERT(subSess);

	iSubSessions.Unlock();

	ForwardMessageL(aMessage, *subSess);

	}

TInt CCommSession::AddCSYToSessionL(const TDesC& aCSYFileName, TBool& aIsDuplicate)

	{

	aIsDuplicate=EFalse;

	TInt k = 0;

	while (k < iCsyCon.Count() && !aIsDuplicate)

		{

		if (aCSYFileName.CompareF(*iCsyCon[k])==0)

			{

			aIsDuplicate=ETrue;

			}

		k++;

		}

	HBufC* name = aCSYFileName.AllocL();

	return iCsyCon.Append(name);

	}

TInt CCommSession::RemoveCSYFromSession(const TDesC& aCSYFileName, TBool& aIsLast)

	{

	TBool aFound=EFalse;

	TInt k = 0;

	while (k < iCsyCon.Count())

		{

		if (iCsyCon[k]->CompareF(aCSYFileName)==0)

			{

            // coverity [dead_error_condition] aFound can be true on later iterations of the while loop

            if (aFound)

				{

				aIsLast=EFalse;

				}

			else

				{

				delete iCsyCon[k];

				iCsyCon.Remove(k);

				aIsLast=ETrue;

				aFound=ETrue;

				return KErrNone;

				}

			}

		k++;

		}

	return KErrNotFound;