// Copyright (c) 2005-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 "ss_roles.h"

#include <e32base.h>

#include <ss_glob.h>

#include <comms-infras/ss_log.h>

#include <es_ini.h>

#include <cfthread.h>

#include <rsshared.h>	// logging tags

#include "ss_subconn.h"

#include <comms-infras/ss_tiermanagerutils.h>

#include <ss_sock.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <es_sock_internal.h>

#endif

#include "SS_rslv.H"

#include "SS_conn.H"

#include <comms-infras/ss_subconnprov.h>

#include <comms-infras/ss_connprov.h>

#include <comms-infras/ss_sapshim.h>

#include <comms-infras/idquerynetmsg.h>

#include <comms-infras/nifprvar.h> //for KNifEntireConnectionSubConnectionId

#include <elements/responsemsg.h> //CResponseMsg

#include "ss_connectionsession.h"

#include "ss_flowrequest.h"

#include "ss_msgs.h"

#include <ecom/ecom.h>

#include <ecom/implementationproxy.h>

#include "ss_connectionserver.h"

#include "ss_tierthreadmap.h"

#include <comms-infras/ss_nodemessages_internal_esock.h>

#ifdef SYMBIAN_ZERO_COPY_NETWORKING

#include <comms-infras/commsbufpondop.h>

#else

#include <es_mbman.h>

#endif // SYMBIAN_ZERO_COPY_NETWORKING

#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_ESockSSocks_rls, "ESockSSocks_rls.");

#endif

using ESock::MProviderSelector;

using ESock::ISelectionNotify;

#define MSG_PRM(prmIndex)		(prmIndex)

using namespace NetInterfaces;

using namespace NetInterfaces;

using namespace ESock;

using namespace Messages;

using namespace Den;

using namespace CommsFW;

#include <cs_subconparams.h>

//

// CPlayer

//

CPlayer* CPlayer::NewL(CWorkerThread* aOwnerThread, TPlayerRole aPlayerRole)

	{

	CPlayer* self = new(ELeave) CPlayer(aOwnerThread, aPlayerRole);

	return self;

	}

/**

The Player destructor doesn't have much to do as a lot of the cleanup is done during the

normal shutdown routines. Here the Player merely deletes all sub-sessions it owns.

*/

CPlayer::~CPlayer()

	{

	// The object container is stored as a packed array, so working backwards through it avoids invalidating

	// the iterator when removing entries (and as a bonus is more efficient)

	LOG(ESockLog::Printf(KESockBootingTag, _L8("CPlayer::~CPlayer()")));

    iTransferBuffer.Close();

	}

CPlayer::CPlayer(CWorkerThread* aOwnerThread, TPlayerRole aPlayerRole)

:	CCommonPlayer(aOwnerThread, aPlayerRole)

	{

	LOG(ESockLog::Printf(KESockBootingTag, _L8("CPlayer::CPlayer()")));

	}

CSockSubSession* CPlayer::SubSession(const Den::TSubSessionUniqueId& aSubSessionUniqueId) const

	{

	return static_cast<CSockSubSession*>(CCommonPlayer::SubSession(aSubSessionUniqueId));

	}

CSockSession* CPlayer::CurrentSession() const

	{

	return static_cast<CSockSession*>(CCommonPlayer::Session());

	}

CWorkerThread& CPlayer::WorkerThread() const

	{

	return static_cast<CWorkerThread&>(CCommonPlayer::WorkerThread());

	}

/**

Check whether the Player is ready to shut down and if so, tells the owning Worker Thread

*/

TBool CPlayer::IsPlayerShutdownComplete()

	{

	CSockManData* globals = SockManGlobals::Get();

	// Basic reason: we have no subsessions or protocol families remaining open

	TBool shutdownComplete = globals->iNumFamilies == 0;

	LOG_STMT(TBool dataThreadShutdownPending = EFalse;)

	if(shutdownComplete)

		{

		// But it could be that we're providing management services and have a data thread still bound; if so we hold-off from shutdown

		// until the data thread completes its own shutdown. Being relatively dumb it certainly can't survive without us.

		if(!HasDataPlane() && !SockManGlobals::Get()->GetPlaneFC(TCFPlayerRole(TCFPlayerRole::EDataPlane)).IsNull())

			{

			shutdownComplete = EFalse;

			LOG_STMT(dataThreadShutdownPending = ETrue;)

			}

		}

		shutdownComplete, SubSessions().Count(), globals->iNumFamilies, dataThreadShutdownPending) );

	if(globals->iNumFamilies)

		{

		// Help them figure out what (might be) blocking shutdown

#ifdef __FLOG_ACTIVE

		TProtocolManagerLogger::LogLoadedInfo();

#endif

		}

	return shutdownComplete;

	}

/**

Called directly by the PitBoss to get protocol information.

@note Index is 1-based for legacy reasons.

*/

TInt CPlayer::ProtocolInfo(TUint aIndex, TProtocolDesc& aProtocol)

	{

	// This could be optimised, eg to remember the last found position in case caller is iterating from 1..n protocols (since the

	// code here also iterates that gives O2 complexity). However, it is likely that this is a seldom-used function

	if((aIndex > SockManGlobals()->iNumProtocols) || aIndex<1)

		{

		return KErrNotSupported;

		}

	// Simply iterate along the queue aIndex times

	TSglQueIter<CProtocolRef> i(*SockManGlobals()->iProtocols);

	while(--aIndex)

		{

		i++;

		}

	aProtocol=((CProtocolRef*)i)->Info();

	return KErrNone;

	}

/**

Write a handle back to Ptr3 of the current message

*/

TInt CPlayer::WriteSubSessionHandle(TInt aHandle)

	{

	TPckgC<TInt> pH(aHandle);

	return SafeMessage().Write(MSG_PRM(3),pH);

	}

void CPlayer::CommsApiExtBindIfaceL(const RMessage2& aMessage, CSockSubSession& aSubSession)

	{

	aSubSession.CommsApiExtBindIfaceL(aMessage);

	}

void CPlayer::CommsApiExtIfaceSendReceiveL(const RMessage2& aMessage, CSockSubSession& aSubSession)

	{

	aSubSession.CommsApiExtIfaceSendReceiveL(aMessage);

	}

void CPlayer::CloseExtensionInterface(const RMessage2& aMessage, CSockSubSession& aSubSession)

	{

	aSubSession.CloseExtensionInterface(aMessage);

	}

/**

Called from a socket to delete it

Removing a socket has the side effect of Close()ing it.

*/

void CPlayer::DeleteSocket(CSocket& aSocket)

	{

	aSocket.InitiateDestruction();

	}

MShimControlClient* CPlayer::CSubConnectionProviderFromHandleL(ESock::CConnection& /*aConnection*/, TSubConnectionUniqueId /*aSubConnectionUniqueId*/)

	{//this is a very link shim specific function to send a message to the shim connection provider factory

	LOG( ESockLog::Printf(_L("CPlayer %08x:\tCSubConnectionProviderFromHandleL() KErrNotReady"), this) );

	User::Leave(KErrNotReady);

	return NULL;

	}

/**

	Process the client message forwarded from the Dealer. For subsession-Close commands

	the Dealer provides the subsession pointer explicitly as it has already been removed from

	the index.

*/

void CPlayer::DoProcessMessageL(const RSafeMessage& aMessage, Den::CWorkerSubSession* aSubSession)

	{

	LOG(

		TBuf8<64> messBuf;

		ESockLog::IPCMessName((TSockMess) aMessage.Function(), messBuf);

		ESockLog::Printf(KESockSessDetailTag, _L8("CPlayer:\tProcessMessageL: session=%08x, subsess=%08x, Message(%08x) [%S]"), Session(), aSubSession, aMessage.Handle(), &messBuf);

	);

	switch (aMessage.Function())

		{

	case ESoCreateNull:

		{

		TInt dummyHandle;

		NewSocketL(ETrue, dummyHandle);

		break;

		}

//	case ESSNumProtocols:

//		NumProtocols();

//		break;

	case ESSProtocolInfo:

		ProtocolInfo();

		break;

	case ESSProtocolInfoByName:

		ProtocolInfoByName();

		break;

	case ESSProtocolStart:

		LoadProtocolL(aMessage.Int0(),aMessage.Int1(),aMessage.Int2());

		break;

	case ESSProtocolStop:

		UnLoadProtocolL(aMessage.Int0(),aMessage.Int1(),aMessage.Int2());

		break;

// socket messages

	case ESoCreate:

		NewSocketDefaultL();

		break;

	case ESoCreateWithConnection:

		NewSocketWithConnectionL();

		break;

	case ESoCreateWithSubConnection:

		NewSocketWithSubConnectionL();

		break;

	case ESoTransfer:

		__ASSERT_DEBUG(aSubSession->Type().iType == TCFSubSessInfo::ESocket, User::Panic(KSpecAssert_ESockSSocks_rls, 2));	// Dealer does all of the validation for us

		TransferSocketL(static_cast<CSocket*>(aSubSession));

		break;

// Host resolver message types

	case EHRCreate:

		NewHostResolverDefaultL(aMessage.Int0(),aMessage.Int1());

		break;

	case EHRCreateWithConnection:

		NewHostResolverWithConnectionL(aMessage.Int0(),aMessage.Int1(), aMessage.Int2());

		break;

// Service resolver message types

	case ESRCreate:

		NewServiceResolverL(aMessage.Int0(),aMessage.Int1(),aMessage.Int2());

		break;

// Net database message types

	case ENDCreate:

		NewNetDatabaseL(aMessage.Int0(),aMessage.Int1());

		break;

	// Connection Messages

	case ECNCreate:

		{

		NewConnectionL();

		break;

		}

	case ECNCreateWithName:

		{

		NewConnectionWithNameL(static_cast<CSockSubSession*>(aSubSession));

		break;

		}

/*

	case ESCPSStop:

	case ESCPSProgressNotification:

	case ESCPSCancelProgressNotification:

	case ESCPSDataTransferred:

	case ESCPSDataTransferredCancel:

	case ESCPSDataSentNotificationRequest:

	case ESCPSDataSentNotificationCancel:

	case ESCPSDataReceivedNotificationRequest:

	case ESCPSDataReceivedNotificationCancel:

	case ESCPSIsSubConnectionActiveRequest:

	case ESCPSIsSubConnectionActiveCancel:

	case ESCPSGetSubConnectionInfo:

		{

		__ASSERT_DEBUG(aSubSession, User::Panic(KSpecAssert_ESockSSocks_rls, 3));

		ESock::CConnection* cn = static_cast<ESock::CConnection*>(aSubSession);

		TSubConnectionUniqueId subConnectionUniqueId = aMessage.Function() != ESCPSGetSubConnectionInfo ? static_cast<TSubConnectionUniqueId>(aMessage.Int0()) : KNifEntireConnectionSubConnectionId;

		MShimControlClient* sc = CSubConnectionProviderFromHandleL(*cn, subConnectionUniqueId);

		if (!sc)

			{

			LOG( ESockLog::Printf(_L("CPlayer %08x:\tProcessMessageL() ESCPS...... KErrNotReady"), this) );

			User::Leave(KErrNotReady);

			}

		__ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockSSocks_rls, 4));

		//@TODO service RConnection sub-connection oriented calls

		//iComplete = CSubConnection::ServiceL(*sc,aMessage);

		break;

		}

*/

	case ESCCreate:

		{

		LOG( ESockLog::Printf(KESockSubConnectionTag, _L8("CSubConnection %08x\tESCCreate aMessage %08x"), this, &SafeMessage()) );

		ESock::CSubConnection* sc = NewSubConnectionWithConnectionL();

    	__ASSERT_DEBUG(sc, User::Panic(KSpecAssert_ESockSSocks_rls, 5));

    	//If successful, the ownership of the RMessage2 is taken by the activity, otherwise completed on leave

    	//The activity also takes ownership of the CSubConnection for the duration of the activity for cleanup purposes

    	sc->CMMSockSubSession::ReceivedL(ESCCreate, ESock::TCFInternalEsock::TSubSess(ESCCreate,SafeMessage()).CRef());

		break;

		}

	case ECommsApiExtBindIface:

		__ASSERT_DEBUG(aSubSession, User::Panic(KSpecAssert_ESockSSocks_rls, 6));

		CommsApiExtBindIfaceL(aMessage, static_cast<CSockSubSession&>(*aSubSession));

		break;

	case ECommsApiExtIfaceSend:

	case ECommsApiExtIfaceSendReceive:

		__ASSERT_DEBUG(aSubSession, User::Panic(KSpecAssert_ESockSSocks_rls, 7));

		CommsApiExtIfaceSendReceiveL(aMessage, static_cast<CSockSubSession&>(*aSubSession));

		break;

	case ECommsApiExtIfaceClose:

		{

		CloseExtensionInterface(aMessage, static_cast<CSockSubSession&>(*aSubSession));

		break;

		}

	default:

		__ASSERT_DEBUG(aSubSession, User::Panic(KSpecAssert_ESockSSocks_rls, 8));

		aSubSession->ProcessMessageL();

		break;

		}

	// Message handlers can change the state of the iMessage if they want to hold onto the message.

	// They can also write a return value to iReturn.

	if (iComplete)

		{

		LOG(ESockLog::Printf(KESockServerTag, _L8("CPlayer:\tProcessMessageL, session=%08x, RMessage2::Complete (%08x) with %d."), Session(), aMessage.Handle(), iReturn) );

		aMessage.Complete(Return());

		}

	//This is a normal return so we do no longer need the reference

	SetSession(NULL);

	}

/**

Get info for a protocol by index.

*/

void CPlayer::ProtocolInfo()

	{

	TProtocolDesc prot;

	TInt ret=0;

	TInt localIndex = static_cast<CPitBoss&>(PitBoss()).GetLocalProtocolIndex(SafeMessage().Int1());

	if((ret=ProtocolInfo(localIndex,prot))==KErrNone)

		{

		TPckgC<TProtocolDesc> p(prot);

		ret = SafeMessage().Write(MSG_PRM(0),p);

		}

	SetReturn(ret);

	}

/**

Get protocol info by name.

*/

void CPlayer::ProtocolInfoByName()

	{

	TProtocolName name;

	TServerProtocolDesc prot;

	TInt ret=0;

	ret = SafeMessage().Read(MSG_PRM(1),name);

	if((ret=ProtocolInfo(name, prot))==KErrNone)

		{

		TPckgC<TProtocolDesc> p(prot);

		ret = SafeMessage().Write(MSG_PRM(0),p);

		}

	SetReturn(ret);

	}

/**

Find a protocol by name - no wildcard support.

*/

TInt CPlayer::ProtocolInfo(const TDesC &aName, TServerProtocolDesc &aProtocol)

	{

	TSglQueIter<CProtocolRef> i(*SockManGlobals::Get()->iProtocols);

	// Run the queue looking for a match.

	do

		{

		if(((CProtocolRef *)i)->Info().iName.CompareF(aName)==0)

			{

			aProtocol=((CProtocolRef*)i)->Info();

			return KErrNone;

			}

		i++;

		}

	while((CProtocolRef *)i);

	return KErrNotFound;

	}

/**

The socket reference is the object name preceded by the Worker's id and a space. This is

intended as an opaque cookie for use with socket transfer.

*/

void CPlayer::TransferSocketL(CSocket* aSocket)

	{

	__ASSERT_DEBUG(&aSocket->Player() == this, User::Panic(KSpecAssert_ESockSSocks_rls, 9));

	TInt id;

	TInt ret;

		{

		ProtocolManager::TransferSocketL(aSocket, this);

		aSocket->CancelAll();

		CurrentSession()->SubSessions().Lock();

		ret = PitBoss().AddSubSession(aSocket, CurrentSession(), id);

		aSocket->SetUniqueId(PitBoss().NextSubSessionUniqueId());

		CurrentSession()->SubSessions().Unlock();

		}

	if(ret == KErrNone)

		{

			{

			aSocket->Session()->SubSessions().Lock();

			// Remove from original session

			CSubSessionIx& srcSubSessions = aSocket->Session()->SubSessions();

			TInt oldIndex;

			VERIFY_RESULT(srcSubSessions.Find(aSocket, oldIndex), KErrNone);

			PitBoss().RemoveSubSession(oldIndex, static_cast<CSockSession*>(aSocket->Session()));

			aSocket->Session()->SubSessions().Unlock();

			}

		aSocket->SetSessionProxy(NULL);

		aSocket->SetSession(CurrentSession());

		aSocket->SetSessionProxy(CurrentSessionProxyL());

		ret = WriteSubSessionHandle(id);

		if (ret != KErrNone)

			{

			aSocket->InitiateDestruction();	// this should leave socket (almost) dead; we're not trying to reverse the transfer

			}

		if(ret == KErrNone && aSocket->RequiresOwnerInfo())

			{

			// store information about the client that created this socket

			aSocket->StoreOwnerInfo();

			aSocket->CommunicateOwner();

			}

		}

	if(ret != KErrNone)

		{

		User::Leave(ret);

		}

	}

/**

Create a new empty socket to be used for accept.

We need to make empty sockets just to get a valid handle to accept into.

*/

CSocket* CPlayer::NewSocketL(TBool aCompleteClientRequest, TInt& aHandle)

	{

	LOG(ESockLog::Printf(KESockSessDetailTag, _L8("CPlayer::NewSocketL(null sock)")) );

	CSocket *sp = NULL;

	TInt ret;

		{

		// Create a new socket and add it our list of subsessions

		sp = CSocket::NewLC(

			NULL,

			CurrentSession(),

			this,