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

//

#include <ss_std.h>

#include <comms-infras/sockmes.h>

#include <ss_glob.h>

#include "ss_msgs.h"

#include <nifman.h>

#include <comms-infras/ss_log.h>

#include <comms-infras/ss_roles.h>

#include "ss_subconn.h"

#include <ss_sock.h>

#include "SS_rslv.H"

#include "SS_conn.H"

#include "ss_connectionsession.h"

#include <comms-infras/ss_api_ext.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <es_sock_internal.h>

#endif

#include "ss_apiext_messages.h"

#include <comms-infras/ss_tiermanagerutils.h>

#include <comms-infras/ss_nodemessages_internal_esock.h>

#include <comms-infras/esockdebugmessages.h>

#ifdef SYMBIAN_ZERO_COPY_NETWORKING

#include <comms-infras/commsbufpondop.h>

#include <comms-infras/commsbufponddbg.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_SES, "ESockSSockS_SES.");

#endif

#define MSG_PRM(prmIndex)		(prmIndex)

using namespace NetInterfaces;

using namespace ESock;

//using namespace Elements;

using namespace Messages;

using namespace Den;

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;

		}

	};

/**

Constructor

*/

CSockSession::CSockSession(TUidType aUid, TSessionUniqueId aSessionUniqueId)

:	CWorkerSession(aUid, aSessionUniqueId)

	{

	LOG(ESockLog::Printf(KESockSessDetailTag, _L8("CSockSession(%08x):\tConstructor"), this) );

	SocketServer::NewSession();

	}

/*static*/ CSockSession* CSockSession::NewL(TProcessId aProcessId, TUidType aUid, TSessionUniqueId aSessionUniqueId)

	{

	CSockSession* self = new (ELeave) CSockSession(aUid, aSessionUniqueId);

	CleanupStack::PushL(self);

	self->ConstructL(aProcessId);

	CleanupStack::Pop(self);

	return self;

	}

void CSockSession::ConstructL(TProcessId aProcessId)

	{

#ifdef SYMBIAN_TRACE_ENABLE

	// Document the owner of the session

	TLogTextBuf buf;

	buf.Format(_L8("CSockSession %08x:\tConstructL()"), this);

	RProcess cliProc;

	if (cliProc.Open(aProcessId) == KErrNone)

		{

		TName cliName = cliProc.Name();

		TInt index = cliName.LocateReverse('[');

		if (index >= 1)

			{

			cliName.SetLength(index);

			}

		TUint processId = cliProc.Id();

		iProcessName.Copy(cliName);

		buf.AppendFormatIgnoreOverflow(_L8(" pid=%x \"%S\""), processId, &iProcessName);

		// Remove the "...[nnn]nnn" clutter from the name stored in the session

		// (unless the name happens to begin with "[").

		cliProc.Close();

		}

	LOG(ESockLog::Printf(KESockServerTag, buf) );

#endif

	CWorkerSession::ConstructL(aProcessId);

	}

/**

Destroy

*/

CSockSession::~CSockSession()

	{

	LOG( ESockLog::Printf(KESockServerTag, _L8("~CSockSession(%08x):\t\"%S\""), this, &iProcessName) );

	if(iOptimalDealer)

		{

		iOptimalDealer->RemoveEligiblePid(iProcess.Id());

		}

	SocketServer::SessionClosing();

	}

CSockManData* CSockSession::SockManGlobals() const

    {

    return WorkerThread().SockManGlobals();

    }

TInt CSockSession::CheckPolicy(const TSecurityPolicy& aPolicy, const char *aDiagnostic)

/**

Check the security policy of a process.

Called from a socket or resolver provider to check whether the process conforms to the security policy passed as

argument.

@see MProvdSecurityChecker

*/

	{

	return aPolicy.CheckPolicy(iProcess, aDiagnostic) ? KErrNone : KErrPermissionDenied;

	}

/**

 Handle messages for this server. In a few cases the messages will be dealt with accordingly,

 but in most cases they will be 1) forwarded to seperate player or 2) be handled by ProcessMessageL

 if the Player is co-resident in this thread.

 @param aMessage Standard IPC request from client side

*/

void CSockSession::ServiceL(const RMessage2& aMessage)

	{

	LOG(

		TBuf8<64> messName;

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

		ESockLog::Printf(KESockServerTag, _L8("CSockSession(%08x):\tServiceL, Message(%08x) [%S] \"%S\" int3=%08x"),

				this, aMessage.Handle(), &messName, &iProcessName, SubSessionFromHandle(aMessage.Int3(), TCFSubSessInfo(TCFSubSessInfo::EAny)));

		);

	const CWorkerThread& owner=WorkerThread();

	const CPitBoss& pitBoss = owner.PitBoss();

	if(pitBoss.TestImmediateShutdownPresent())

		{

		User::Leave(KErrServerTerminated);

		}

	iComplete=ETrue; 		// Whether to complete RMessage2 immediately

	iReturn=KErrNone;		// Default return value if completing RMessage2 here

    iOurMessage = &aMessage;

	CWorkerSubSession* ss = NULL;

	TWorkerId worker=TWorkerThreadPublicInfo::ENullWorkerId;

	const TInt function = aMessage.Function();

#if defined(_DEBUG_SOCKET_FUNCTIONS)

	if(function != ESSDbgControl && iDebugParking.iNumOutstanding > 0)

		{

		// Weakness here; if it's a session request then the 4th arg may be random stack junk. Major mitigation is that almost certainly they're in UDEB which gives near-certainty

		// of it being the stack fill pattern (eg 0xCCCCCCCC) so a collision is very unlikely to be seen (and only in the few cases where debug parking is employed). To improve this

		// need to test whether it's a sub-session operation; reorganising the IPC list will help this

		if(iDebugParking.iSubSessHandle == 0 || iDebugParking.iSubSessHandle == aMessage.Int3())

			{

			User::LeaveIfError(Dealer()->ParkRequest(this, aMessage, CCommonDealer::EDebugParking));

			--iDebugParking.iNumOutstanding;

			DontCompleteCurrentRequest();

			return;

			}

		}

#endif

	switch(function)

        {

    /* Cases handled without a player */

    case ESSRequestOptimalDealer:

     	RequestOptimalDealerL();

    	break;

	case ESSInstallExtension:

		LOG(ESockLog::Printf(_L8("WARNING: unsupported function ESSInstallExtension called, CSockSession(%08x)"), this));

		SetReturn(KErrNotSupported);

		break;

    case ESSExclusiveMode:

		LOG(ESockLog::Printf(_L8("WARNING: unsupported function ESSExclusiveMode called, CSockSession(%08x)"), this));

		SetReturn(KErrNone);

        break;

    case ESSClearExclusiveMode:

		LOG(ESockLog::Printf(_L8("WARNING: unsupported function ESSClearExclusiveMode called, CSockSession(%08x)"), this));

		SetReturn(KErrNone);

        break;

 	case ESSNumProtocols:

		NumProtocolsL();

		break;

	case ESSProtocolInfo:

		ProtocolInfoL();

		break;

	case ESSProtocolInfoByName:

		ProtocolInfoByNameL();

		break;

    /* Cases for a Player to deal with, protocol level */

	case ESSProtocolStart:

	case ESSProtocolStop:

	case ESoCreate:

	case ESRCreate:

		if(pitBoss.GetWorkerForProtocol(aMessage.Int0(),aMessage.Int1(),aMessage.Int2(), worker))

			{

			ForwardMessageL(aMessage, TPlayerForwardRequestMsg::NormalCreationFlag(), worker);

			}

		else

			{

			ParkIfIndeterminateRequest(aMessage, KErrBadName);

			}

		break;

	case ESoCreateWithConnection:

		{

		TPckgBuf<TSockOpen> argPkg;

		SafeMessage().ReadL(MSG_PRM(0),argPkg);

		ss = CConnectionFromHandle(argPkg().iHandle);

		if(!ss)

		    {

		    PanicClient(ESockBadHandle);

		    }

		else

			{

			// Forward the message to the connection's (control) thread. It's best placed to decide which of its data threads it really belongs in

			ForwardMessageL(aMessage, TPlayerForwardRequestMsg::NormalCreationFlag(), ss->Player().WorkerId());

			}

		}

		break;

	case ESoCreateWithSubConnection:

		{

	    TPckgBuf<TSockOpen> argPkg;

	    SafeMessage().ReadL(MSG_PRM(0),argPkg);

	    ss = CSubConnectionFromHandle(argPkg().iHandle);

	    if (!ss)

		    {

		    PanicClient(ESockBadHandle);

		    }

		else

			{

			// Forward the message to the subconnection's (control) thread. It's best placed to decide which of its data threads it really belongs in

			ForwardMessageL(aMessage, TPlayerForwardRequestMsg::NormalCreationFlag(), ss->Player().WorkerId());

			}

		break;

		}

	case EHRCreateWithConnection:

	case EHRCreate:

	case ENDCreate:

		if(pitBoss.GetWorkerForProtocol(aMessage.Int0(), KUndefinedSockType, aMessage.Int1(), worker))

			{

			ForwardMessageL(aMessage, TPlayerForwardRequestMsg::NormalCreationFlag(), worker);

			}

		else

			{

			ParkIfIndeterminateRequest(aMessage, KErrBadName);

			}

		break;

	case ESoCreateNull:

		// Attempt to pass to co-resident player

		if(owner.Player())

			{

			worker = WorkerId();

			}

		else

			{ // No co-resident player, pass to NullSocket handling player known to PitBoss

			VERIFY(pitBoss.GetWorkerForNullSocket(worker));

			}

		ForwardMessageL(aMessage, TPlayerForwardRequestMsg::NormalCreationFlag(), worker);

		break;

	case ECNCreate:

        ForwardTierRequestL(aMessage);

		break;

	// Connection Messages

	case ECNCreateWithName:

		{

		// The cloned connection must be created on the same [control] Player that owns the original

		TName name;

		aMessage.ReadL(0, name);

		User::LeaveIfError(CSockSubSession::FetchSubSessionFromName(name, TCFSubSessInfo(TCFSubSessInfo::EConnection), owner, ss));

		ForwardMessageL(aMessage, *ss);	// can't be indeterminate request; already created the clone source

		break;

		}

    /* All else (cases for a Player to deal with, subsession level) */

// socket messages

	case ESoClose:

		CloseSubSessionL(aMessage, TCFSubSessInfo(TCFSubSessInfo::ESocket));

		break;

	case ESoConnect:

	case ESoShutdown:

	case ESoSendToNoLength:

	case ESoSendNoLength:

	case ESoSendTo:

	case ESoSend:

	case ESoWrite:

	case ESoRecvFromNoLength:

	case ESoRecvNoLength:

	case ESoRecvOneOrMore:

    case ESoRecvOneOrMoreNoLength:

	case ESoRecvFrom:

	case ESoRecv:

	case ESoRead:

	case ESoBind:

	case ESoAccept:

	case ESoListen:

	case ESoSetOpt:

	case ESoGetOpt:

	case ESoIoctl:

	case ESoGetDiscData:

	case ESoGetLocalName:

	case ESoGetRemoteName:

	case ESoReference:

		ss=CSocketFromHandle(aMessage.Int3());

		if (ss)

			{

			ForwardMessageL(aMessage, *ss);

			}

		else

			{

			PanicClient(ESockBadHandle);

			}

		break;

	case ESoCancelRecv:

	case ESoCancelSend:

	case ESoCancelIoctl:

	case ESoCancelConnect:

	case ESoCancelAccept:

	case ESoCancelAll:

		ss=CSocketFromHandle(aMessage.Int3());

		if(ss)

			{

			ForwardMessageL(aMessage, *ss);

			}

		else

			{

			LOG(ESockLog::Printf(_L8("CSockSession::ServiceL: BAD ESoCancelAll")));

			}

		break;

	case ESoSocketInfo:

		ss=CSocketFromHandle(aMessage.Int3());

		if (ss)

			{

			ForwardMessageL(aMessage, *ss);

			}

		else

			{

			SetReturn(KErrBadHandle);

			}

		break;

	case ESoTransfer:

		TransferSocketL();

		break;

// Host resolver message types

	case EHRClose:

		CloseSubSessionL(aMessage, TCFSubSessInfo(TCFSubSessInfo::EHostResolver));

		break;

	case EHRCancel:

		ss=CHostResolverFromHandle(aMessage.Int3());

		if (ss)

			{

			ForwardMessageL(aMessage, *ss);

			}

		else

			{

			LOG( ESockLog::Printf(_L8("CSockSession::ServiceL: BAD EHRCancel")) );

			}

		break;

    case EHRGetByName:

	case EHRNext:

	case EHRGetByAddress:

	case EHRGetHostName:

	case EHRSetHostName:

	case EHrQuery:

	case EHrQueryNext:

	case EHRSetOpt:

		ss=CHostResolverFromHandle(aMessage.Int3());

		if (ss)

			{

			ForwardMessageL(aMessage, *ss);

			}

		else

			{

			PanicClient(ESockBadHandle);

			}

		break;

// Service resolver message types

	case ESRClose:

		CloseSubSessionL(aMessage, TCFSubSessInfo(TCFSubSessInfo::EServiceResolver));

		break;

	case ESRGetByName:

	case ESRGetByNumber:

	case ESRRegisterService:

	case ESRRemoveService:

		ss=CServiceResolverFromHandle(aMessage.Int3());

		if (ss)

			{

			ForwardMessageL(aMessage, *ss);

			}

		else

			{

			PanicClient(ESockBadHandle);

			}

		break;

	case ESRCancel:

		ss=CServiceResolverFromHandle(aMessage.Int3());

		if (ss)

			{

			ForwardMessageL(aMessage, *ss);

			}

		else

			{

			LOG( ESockLog::Printf(_L8("CSockSession::ServiceL: BAD ESRCancel")) );

			}

		break;

// Net database message types

	case ENDClose:

		CloseSubSessionL(aMessage, TCFSubSessInfo(TCFSubSessInfo::ENetDatabase));

		break;

	case ENDQuery:

	case ENDAdd:

	case ENDRemove:

		ss=CNetDatabaseFromHandle(aMessage.Int3());

		if (ss)

			{

			ForwardMessageL(aMessage, *ss);

			}

		else

			{

			PanicClient(ESockBadHandle);

			}

		break;

	case ENDCancel:

		ss=CNetDatabaseFromHandle(aMessage.Int3());

		if (ss)

			{

			ForwardMessageL(aMessage, *ss);

			}

		else

			{

			LOG( ESockLog::Printf(_L8("CSockSession::ServiceL: BAD ENDCancel")) );

			}

		break;

    case ECNClose:

		CloseSubSessionL(aMessage, TCFSubSessInfo(TCFSubSessInfo::EConnection));

		break;

	case ECNStart:

	case ECNSetStartPrefs:

	case ECNStop:

	case ECNReference:

	case ECNProgress:

	case ECNProgressNotification:

	case ECNCancelProgressNotification:

	case ECNLastProgressError:

	case ECNServiceChangeNotification:

	case ECNCancelServiceChangeNotification:

	case ECNGetIntSetting:

	case ECNGetBoolSetting:

	case ECNGetDes8Setting:

	case ECNGetDes16Setting:

	case ECNGetLongDesSetting:

	case ECNEnumerateConnections:

	case ECNGetConnectionInfo:

	case ECNIoctl:

	case ECNCancelIoctl:

	case ECNControl:

	case ECNAttach:

	case ECNAllInterfaceNotification:

	case ECNCancelAllInterfaceNotification:

	case ECNCancelAllSubConnectionNotification:

	case ECNEnumerateSubConnections:

	case ECNAllSubConnectionNotification:

	case ECNWaitForIncoming:

	case ECNCancelWaitForIncoming:

	case ESCPSStop:

	case ESCPSProgressNotification:

	case ESCPSCancelProgressNotification:

	case ESCPSDataTransferred: