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

//

#define SYMBIAN_NETWORKING_UPS

#include <es_prot.h>

#include <comms-infras/ss_roles.h>

#include <comms-infras/ss_log.h>

#include "es_mbufif.h"

#include <ss_glob.h>

#include <ss_protprov.h>

#include <comms-infras/ss_sapshim.h>

#include <comms-infras/ss_intsock.h>

#include <in_sock.h>

#include "ss_flowrequest.h"

#include "ss_sapfactshim.h"

#include <comms-infras/ss_nodemessages_dataclient.h>

#include <comms-infras/cfmacro.h>

#include <comms-infras/ss_msgintercept.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <es_sock_internal.h>

#endif

#ifdef SYMBIAN_NETWORKING_UPS

#include <comms-infras/ss_platsec_apiext.h>		// MPlatSecApiExt

#endif //SYMBIAN_NETWORKING_UPS

#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_ESockSSocksntsck, "ESockSSocksntsck");

#endif

using namespace ESock;

using namespace Messages;

using namespace Factories;

using namespace Den;

/**

 @internalComponent

 */

const TUint KAllSelectFlags = (KSockSelectRead | KSockSelectWrite | KSockSelectExcept);

#define MSG_PRM(prmIndex)		(prmIndex)

ASocket::ASocket(TInt aSocketType)

	: iSocketType(aSocketType),

	  iIsFlowRequestPending(EFalse)

/**

 Constructor - set up default options.

 */

	{

	}

const RNodeInterface* ASocket::ServiceProvider() const

	{

	return iServiceProvider.IsOpen()? &iServiceProvider : NULL;

	}

TBool ASocket::GetFlowAndSCPR(Messages::TNodeId& aFlow, Messages::TNodeId& aSCPR) const

    {

    if (iFlowBinder)

        {

    	aFlow = iFlowBinder->Flow()->Id();

    	aSCPR = iFlowBinder->Flow()->ControlProvider().RecipientId();

    	return ETrue;

        }

    return EFalse;

    }

void ASocket::ReceivedL(const TRuntimeCtxId& aSender, const TNodeId& aRecipient, TSignatureBase& aMessage)

    {

    (void) aRecipient;

	ESOCK_DEBUG_MESSAGE_INTERCEPT(aSender, aMessage, aRecipient);

	if (aMessage.IsMessage<TEBase::TError>())

    	{

 		// The first error would be from the flow request, any other error iIsFlowRequestPending must be false anyway

		if (FlowRequestPending())

			{

			TEBase::TError& errorMsg(static_cast<TEBase::TError&>(aMessage));

			CompleteFlowRequestMessage(errorMsg.iValue);

			SetFlowRequestPending(EFalse);

			}

 		//We are no longer needed and the client has been completed too, tear us down.

		InitiateDestruction();

		}

    else if (aMessage.IsMessage<TCFDataClient::TBindTo>())

		{

		TCFDataClient::TBindTo& bindToMsg(static_cast<TCFDataClient::TBindTo&>(aMessage));

		TInt err;

		if (IsClosing())

			{

			err = KErrAbort;

			}

		else

			{

			TRAP(err,BindToL(bindToMsg));

			}

		if(err == KErrNone)

		    {

		    RClientInterface::OpenPostMessageClose(Id(), aSender, TCFDataClient::TBindToComplete().CRef());

		    }

		else

		    {

		    RClientInterface::OpenPostMessageClose(Id(), aSender, TEBase::TError(aMessage.MessageId(), err).CRef());

		    }

		CompleteFlowRequestMessage(err);

		SetFlowRequestPending(EFalse);

		if ( IsClosing () )

			InitiateDestruction ();

		}

    else

        {

   		__ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockSSocksntsck, 1));

    	}

    }

void ASocket::BindToL(const TCFDataClient::TBindTo& aBindTo)

    {

    __ASSERT_DEBUG(iSSP==NULL, User::Panic(KSpecAssert_ESockSSocksntsck, 2));

#ifdef SYMBIAN_NETWORKING_UPS

	LOG(ESockLog::Printf(_L8("CSocket %08x:\tBindToL(%08x)"), this, &aBindTo.iNodeId.Node()) );

	LOG(ESockLogExternal::Printf(KCFNodeTag, KESockFlowTag, _L8("CSocket %08x:\tSynchronous call: Sender=%08x, Recipient=%08x, Function=BindToL"), this, static_cast<Messages::ANode*>(this), &aBindTo.iNodeId.Node()) );

#endif

#if defined(__GCCXML__)

	CSubConnectionFlowBase* flow = reinterpret_cast<CSubConnectionFlowBase*>(

		reinterpret_cast<Messages::ANode*>(

			aBindTo.iNodeId.Ptr()

			)

		);

#else

	CSubConnectionFlowBase* flow = mcfnode_cast<CSubConnectionFlowBase>(

		reinterpret_cast<Messages::ANode*>(

			aBindTo.iNodeId.Ptr()

			)

		);

#endif

    if (flow==NULL)

        {

	    NM_LOG((KESockServerTag, _L8("CSocket %08x:\tSynchronous call: From=%08x To=%08x Func=BindToL Error flow is null"),

				this, static_cast<Messages::ANode*>(this), &aBindTo.iNodeId.Node()) )

        User::Leave(KErrArgument);

        }

    NM_LOG((KESockServerTag, _L8("CSocket %08x:\tSynchronous call: From=%08x To=%08x Func=BindToL"),

			this, static_cast<Messages::ANode*>(this), &aBindTo.iNodeId.Node()) )

	// Perform the binding to the flow below

	iFlowBinder = flow->GetBinderControlL();

	iServiceProvider.Open(iFlowBinder->Flow()->Id());

	iSSP = iFlowBinder->GetControlL(iProtocolInfo->iSockType, *this);

	iSSPData = iFlowBinder->BindL(*this);

	if(RequiresOwnerInfo())

		{

		CommunicateOwner();

		}

	// ask the socket provider to perform security policy checking

	TInt ret = SecurityCheck();

    NM_LOG((KESockServerTag, _L8("CSocket %08x:\tSynchronous call: From=%08x To=%08x Func=SecurityCheck Result Error Code=%d"),

			this, static_cast<Messages::ANode*>(this), &aBindTo.iNodeId.Node(), ret) )

	User::LeaveIfError(ret);

	iSSP->Start();

    }

void ASocket::AcceptSetupL(const ASocket& aParentSocket, CSubConnectionFlowBase& aFlow)

/**

Copy constructor type thing for Accept

Takes all the useful info from a parent socket, sets up the supplied SSP and

Other default values.

*/

	{

	iOptions = aParentSocket.iOptions;

	iProtocolInfo = aParentSocket.iProtocolInfo;

    __ASSERT_DEBUG(iFlowBinder==NULL, User::Panic(KSpecAssert_ESockSSocksntsck, 3));

	iFlowBinder = aFlow.GetBinderControlL();

	iSSP = iFlowBinder->GetControlL(iProtocolInfo->iSockType, *this);

	iSSPData = iFlowBinder->BindL(*this);

	iIsBound=ETrue;

	iRecBufSize=aParentSocket.iRecBufSize;

	iSendBufSize=aParentSocket.iSendBufSize;

	}

void ASocket::Create(TServerProtocolDesc *aServiceInfo)

/**

Create for all sockets.

*/

	{

	/** We create non connection orinted sockets "Open" and sockets without an ssp "NULL" */

	if (!aServiceInfo)

		{

		SetState(ESStateNull);

		UnregisterSelf();	// Null sockets need no cookie (and subsequently trying to deregister from a different Accept()ing Player is problematic and adds no benefit

		}

	else

		{

		iProtocolInfo=aServiceInfo;

		if (!IsConnectionOriented())

			{

			SetState(ESStateOpen);

			}

		}

	iOptions=KESocketDefaultOptions;

	iIsBound=EFalse;

#ifdef ESOCK_GULP

    // allocate extra memory for experimental gulp implementation

    iRecBufSize=KSocketDefaultBufferSize * 4;

#else

    iRecBufSize=KSocketDefaultBufferSize;

#endif

	iSendBufSize=KSocketDefaultBufferSize;

	}

ASocket::~ASocket()

/**

Socket destructor. Will ensure that the SSP (and any accept queue) is shutdown before destroying it.

Automatically completes all outstanding requests.

*/

	{

	iServiceProvider.Close();

	delete iDisconnectData;

	iDatagramTail.Free();	// we should normally have done this in closing

	iSendData.Free();		// we should normally have done this in closing

	if (iAcceptQ)

		{

		while (iAcceptQ->Count())

			{

			TAcceptQEntry a;

			iAcceptQ->Remove(&a);

			// the SSPs on an accept queue shouldn't have been Start()ed so we don't need to shut them down.

			// a.iSSP->DeleteMeNow();	// destruction no longer synchronous & vertical

			CTransportFlowShim* shimFlow = factoryobject_cast<CTransportFlowShim>(a.iSSP);

		 	// The SAP is no longer owned by the listener socket.

			shimFlow->iListenerControlNotify = NULL;

			shimFlow->InitDestroy();

			delete a.iConnectData;

			}

		delete iAcceptQ;

		}

	delete iNextAcceptQ;

	delete iAllocAsync;

	delete iCurrentMsg;

	delete iReadMsg;

	delete iWriteMsg;

	delete iBlockedCloseMsg;

	delete iBlockedConnectMsg;

	delete iBlockedIoctlMsg;

	delete iBlockedSetLocalNameMsg;

	}

void ASocket::InitiateDestruction()

    {

    SetClosing();

    if (iSSP)

		{

		if ((State()==ESStateOpeningActive || State()==ESStateOpeningPassive

			|| State()==ESStateOpen || State()==ESStateConnected

||  State()==ESStateBinding

			))

		    {

		    iSSP->Shutdown(MSessionControl::EImmediate);

		    }

		__ASSERT_DEBUG(iFlowBinder, User::Panic(KSpecAssert_ESockSSocksntsck, 4));

		iFlowBinder->Unbind();

		}

    /*

		CSubConnectionFlowBase* flow = iFlowBinder->Flow();

		if(!flow->HasControlPlane())

			{

			CNetworkFlow* netFlow = static_cast<CNetworkFlow*>(flow);

			delete netFlow;

			iSSP = NULL;

			delete this;

			}

		}

	else

		{

		// Either stillborn with OOM or after Shutdown() has detached

		delete this;

		}

     */

    }

void ASocket::ShutdownL(RSocket::TShutdown aType, TBool aDisconnectData)

/**

Terminate the protocol

*/

	{

	if (State()==ESStateShuttingDown)

		{

		PanicSocketClient(EShutDownTwice);

		return;

		}

	if (!CheckRunningAndSetReturn())

		{

		return;

		}

	MSessionControl::TCloseType h=MSessionControl::ENormal;

	if (SupportsGracefulClose())

		{

		switch (aType)

			{

		case RSocket::ENormal:

			CompleteWrite(KErrCancel);

			CompleteRead(KErrCancel);

			h=MSessionControl::ENormal;

			iBlockedOperations|=(EReadStopped|EWriteStopped);

			break;

		case RSocket::EStopInput:

			CompleteRead(KErrCancel);

			h=MSessionControl::EStopInput;

			iBlockedOperations|=EReadStopped;

			iDatagramTail.Free();

			break;

		case RSocket::EStopOutput:

			h=MSessionControl::EStopOutput;

			iBlockedOperations|=EWriteStopped;

			CompleteWrite(KErrCancel);

			break;

		case RSocket::EImmediate:

			h=MSessionControl::EImmediate;

			CompleteWrite(KErrCancel);

			CompleteRead(KErrCancel);

			iDatagramTail.Free();

			break;

			}

		}

	else

		{

		CompleteWrite(KErrCancel);

		CompleteRead(KErrCancel);

		h=MSessionControl::EImmediate;

		}

	CompleteConnect(KErrCancel);

	CompleteSetLocalName(KErrCancel);

	SetState(ESStateShuttingDown);

	if(h!=MSessionControl::EImmediate)

	    {

	    SetBlockedClose();

	    DontCompleteCurrentRequest();

	    }

	if (CanSendDisconnectData() && h!=MSessionControl::EImmediate && aDisconnectData)

		{

        TDes8& sendBuf = *BorrowTemporaryBufferL(iSendBufSize);

		ReadParamL(ESocketCurrentMessage,MSG_PRM(1),sendBuf);

		iSSP->Shutdown(h,sendBuf);

		}

	else

		{

		iSSP->Shutdown(h);

		}

	if (iErrorOperationMask & MSessionControlNotify::EErrorClose)

		{

		SetReturn(iError);

		ClearErrorIfNotFatal(); //Sets iError = 0;

		iErrorOperationMask = 0;

		}

	// OK to access socket because a CanClose would set the socket state to dead

	else if (h==MSessionControl::EImmediate)

		{

		// Set state to dead - let close delete the socket

		SetState(ESStateDead);

		}

	else

		{

		if (!(iOptions & KOptBlocking) && IsBlockedClose())

			{

			CompleteClose(KErrWouldBlock);

			}

		}

	}

TBool ASocket::CloseSocket()

/**

A Client has closed our RSocket - or we're being closed by the session because our client has exited

*/

	{

	SetClosing();

	TBool immediateClose = EFalse;

	switch (State())

		{

	case ESStateNull:

	case ESStateAccepting:

	case ESStateCreated:

	case ESStateError:

	case ESStateDead:

	case ESStateDisconnected:

		immediateClose = ETrue;

		break;

	case ESStateShuttingDown:

        CompleteClose(KErrCancel);

		SetReturn(KErrAlreadyExists);

		SetState(ESStateClosing);

		immediateClose = ETrue;

		break;

	case ESStateOpeningActive:

	case ESStateOpeningPassive:

	case ESStateOpen:

	case ESStateConnected:

	case ESStateBinding:

        {

		SetState(ESStateClosing);

        TBool graceful = SupportsGracefulClose() && iSSP;

		// CanClose will be called irrespective of whether the socket

		// supports graceful close or not.

		// ASocket can take care of the ownership of deletion via InitiateDestruction.

		// Also, CanClose will call InitiateDestruction if we are in ESStateClosing.

		// We already set to ESStateClosing.

	    SetBlockedClose();

	    DontCompleteCurrentRequest(); // Block closes regardless of NonBlocking mode state

        if (graceful)

           	{

	        iSSP->Shutdown(MSessionControl::ENormal);

	        }

        else

           	{

           	if (iSSP)

               	{

               	iSSP->Shutdown(MSessionControl::EImmediate);

               	}

            CanClose(MSessionControlNotify::EDelete);

            }

        }

        break;

	case ESStateClosing:

		PanicSocketClient(ECloseTwice);

		break;

		}

	return immediateClose;

	}

void ASocket::BindL()

/**

Set local address from a client request.

*/

	{

	if (!CheckRunningAndSetReturn())

		{

		return;

		}

	if (IsConnectionOriented() && iIsBound)

		{

		SetReturn(KErrAlreadyExists);

		}

	else

if (State() == ESStateBinding)

		{

		SetReturn(KErrInUse);

		}

		else

		{

		TSockAddr a;

		ReadParamL(ESocketCurrentMessage,MSG_PRM(0),a);

		// Set to blocked before call to SetLocalName. This allows for immediate callback,

		// as some conditions may not require asynchronous processing.

		SetBlockedSetLocalName();

		DontCompleteCurrentRequest();

		// Save off the state for transition later.

		iNextState = State();

		SetState(ESStateBinding);

		iSSP->SetLocalName(a);

		}

	}

void ASocket::AutoBind()

	{

	iSSP->AutoBind();