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

//

#if !defined(__SS_INTSOCK_H__)

#define __SS_INTSOCK_H__

#define SYMBIAN_NETWORKING_UPS

#include <es_enum.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <es_enum_internal.h>

#endif

#include <e32base.h>

#include <comms-infras/ss_flowbinders.h>

#include <comms-infras/ss_nodeinterfaces.h>

#include <comms-infras/ss_nodemessages_dataclient.h>

#include "ss_flowrequest.h"

#include <es_mbufif.h>

#ifdef SYMBIAN_NETWORKING_UPS

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

#endif //SYMBIAN_NETWORKING_UPS

class CWaitForMBufs;

class CProtocolBase;

class ProtocolManager;

class CInternalSocketImpl;

namespace ESock

{

class AMessage

{

public:

	virtual void AcquireMessage ( AMessage* aMessage ) =0;

    virtual TInt ReadDes(TInt aSrcParamIndex,TDes8 &aDes,TInt anOffset=0) = 0;

	virtual TInt ReadInt(TInt aSrcParamIndex) = 0;

	virtual TInt ReadMBuf(TInt aSrcParamIndex, RMBufChain& aBufChain) =0;

	virtual void InitMBuf(TInt aParamIndex) =0;

    virtual TInt WriteDes(TInt aDstParamIndex,const TDesC8& aDes,TInt anOffset=0) = 0;

    virtual TInt WriteMBuf(TInt aDstParamIndex,RMBufChain& aBufChain) = 0;

	virtual void CompleteMessage(TInt anError) = 0;

	virtual TBool IsNull (TInt aParamIndex) =0;

#ifdef SYMBIAN_NETWORKING_UPS

    virtual TInt GetProcessAndThreadId(TProcessId& /*aProcessId*/, TThreadId& /*aThreadId*/) const;

#endif	

	virtual ~AMessage() {}

};

NONSHARABLE_CLASS(ASocket) : public Messages::ASimpleNodeIdBase,

                             public MSessionControlNotify, public MSessionDataNotify,

                             public AIPCFlowRequester

#ifdef SYMBIAN_NETWORKING_UPS

                             , private ASockSubSessionPlatsecApiExt

#endif

/**

Represents binder-facing part of socket.

Implements ESOCK client socket binder and flow specific handling.

It's meant to be agregated with the apropriet client-facing part to implement

full socket functionality

@see CSocket

@internalTechnology

*/

	{

	friend class ::ProtocolManager;

protected:

	enum TSocketState

		{

		ESStateNull=-1,

		ESStateCreated=0,

		ESStateOpeningActive,

		ESStateOpeningPassive,

		ESStateOpen,

		ESStateConnected,

		ESStateDisconnected,

		ESStateClosing,

		ESStateShuttingDown,

		ESStateDead,

		ESStateError,

		ESStateAccepting,

		ESStateBinding

		};

protected:

    //Messages::ANode

	virtual void ReceivedL(

		const Messages::TRuntimeCtxId& aSender,

		const Messages::TNodeId& aRecipient,

		Messages::TSignatureBase& aMessage

		);

	//messages

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

public:

	virtual ~ASocket();

	virtual const Messages::RNodeInterface* ServiceProvider() const;

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

	TInt GetConnectionSocketInfo(TConnectionSocketInfo& aInfo) const;

	// Request service routines.

	void ConnectL(TBool aConnectData);

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

	virtual TBool CloseSocket();

	void ListenL(TInt aQlen, TBool aConnectionData);

	void Accept();

	void AutoBind();

	void BindL();

	void RemoteNameL();

	void LocalNameL();

	void SetLocalName();

	void SetSockOptionL(TInt aOptionName, TInt aOptionLength, TInt aOptionLevel);

	void GetSockOptionL(TInt aOptionName, TInt aOptionLength, TInt aOptionLevel, TInt aWriteBack);

	void IoctlL(TInt aOptionName, TInt aOptionLength, TInt aOptionLevel, TBool aReadOption);

	void GetDisconnectDataL( ) const;

//

	void SendL(TInt aXferLenArg, TInt aAddrArg, TInt aSendByteCount, TInt aSendFlags, TBool aUseMBufs);

	void RecvL(TInt aXferLenArg, TInt aAddrArg, TInt aReadByteCount, TInt aReadFlags, TBool aUseMBufs, TInt aRecvOneOrMore);

//

	inline void CancelSend();

	inline void CancelRecv();

	void CancelConnect();

	void CancelAccept();

	void CancelIoctl();

	void CancelAll();

	void GetInfoL();

	void CommunicateOwner();

	TPtr8 IoctlBuffer();

	//	SSP Upcalls - from MSessionControlNotify

	void NewData(TUint aCount);

    void CanSend();

    void ConnectComplete();

	void ConnectComplete(const TDesC8& aConnectData);

    void ConnectComplete(CSubConnectionFlowBase& anSSP);

	void ConnectComplete(CSubConnectionFlowBase& anSSP,const TDesC8& aConnectData);

	void CanClose(MSessionControlNotify::TDelete aDelete=MSessionControlNotify::EDelete);

    void CanClose(const TDesC8& aDisconnectData,MSessionControlNotify::TDelete aDelete=MSessionControlNotify::EDelete);

	TInt Error(TInt anError,TUint anOperationMask);

	void Disconnect( );

	void Disconnect(TDesC8& aDisconnectData);

	void IoctlComplete(TDesC8* aBuf);

    void SetLocalNameComplete();

	void DisconnectFromListener(CSubConnectionFlowBase& aSSP);

	// Utitlity functions for testing state and capabilities

	inline TUint IsConnectionOriented() const;

	inline TUint IsConnectionLess()const;

	inline TUint IsDataGram() const;

	inline TUint IsStream() const;

	inline TUint IsPseudoStream() const;

	inline TUint IsReliable() const;

	inline TUint DeliversInOrder() const;

	inline TUint IsMessageBased() const;

	inline TUint CanSendUrgentData() const;

	inline TUint CanSendConnectData() const;

	inline TUint CanSendDisconnectData() const;

	inline TUint CanBroadcast() const;

	inline TUint SupportsMultiPoint() const;

	inline TUint SupportsQOS() const;

	inline TUint IsWriteOnly() const;

	inline TUint IsReadOnly() const;

	inline TUint SupportsGracefulClose() const;

	inline TUint CanReconnect() const;

	inline TUint SupportsPeek() const;

	inline TUint RequiresOwnerInfo() const;

	inline TUint StateCanProcessData() const;

	virtual void InitiateDestruction();

	inline void SetFlowRequestPending(TBool aPending);

	enum 

        { 

        KNoXferLen = -1, 

        KNoAddrArg = -1, 

        KWriteNoAddrArg = -2    // for legacy compatibility reasons we tolerate ESoWrite on a non-connected datagram socket  

        };

protected:

   	explicit ASocket(TInt aSocketType);

	void Create(TServerProtocolDesc* aServiceInfo);

	TBool CheckRunningAndSetReturn();

	// Utility functions for handling blocked messages.

	enum EBlockingFlags

	 {EBlockedClose=0x01,

	 EBlockedConnect=0x02,

	 EBlockedIoctl=0x04,

	 EBlockedRead=0x08, 

	 EBlockedWrite=0x10,

	 EWriteFlowedOff=0x20,

	EReadStopped=0x40,

	 EWriteStopped=0x80

	, EBlockedSetLocalName=0x100

						 };

	inline void SetBlockedReadFlag();

	inline void SetBlockedWriteFlag();

	inline void SetBlockedCloseFlag();

	inline void SetBlockedIoctlFlag();

	inline void SetBlockedConnectFlag();

	inline void SetBlockedRead();

	inline void SetBlockedWrite();

	inline void SetBlockedClose();

	inline void SetBlockedIoctl();

	inline void SetBlockedConnect();

	inline void SetBlockedSetLocalName();

	inline TBool IsBlockedSetLocalName() const;

	void CompleteSetLocalName(TInt anErr);

	virtual void SetClosing() =0;

	inline TBool IsBlockedRead() const;

	inline TBool IsBlockedWrite() const;

	inline TBool IsBlockedConnect() const;

	inline TBool IsBlockedClose() const;

	inline TBool IsBlockedIoctl() const;

	virtual TBool IsClosing() =0;

	TBool CompleteRead(TInt anError);

	TBool CompleteWrite(TInt anError);

	void CompleteConnect(TInt anErr);

	TBool CompleteClose(TInt anErr);

	void CompleteIoctl(TInt anErr);

	virtual void DontCompleteCurrentRequest() = 0;

	virtual ASocket* InitiateAcceptingSocket() = 0;

	virtual ASocket* GetAcceptingSocket() = 0;

	virtual void DoCompleteAccept();

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

	virtual void PanicSocketClient(TESockPanic aPanic) =0;

	virtual void SetReturn(TInt aReturnValue) const = 0;

	inline TSocketState State() const;

	inline void SetState(TSocketState aState);

	virtual TDes8* BorrowTemporaryBuffer(TInt aSize) = 0;

    virtual TDes8* BorrowTemporaryBufferL(TInt aSize) = 0;

	TInt DrainStreamProtocol(AMessage* aMsg);

	void DoRecv(TBool aInitialRequest);

	TInt FillStreamProtocol(AMessage* aMsg);

	void DoSend(TBool aInitialRequest);

    TUint SelectConditionsReady();

	TBool CheckReadStopped();

	void TryToCompleteSelectIoctl();

	void DoError(TInt aError, TUint aOperationMask, TBool aDeleteInterface = ETrue);

    inline void ClearErrorIfNotFatal();

	TInt RequestAsyncMBufAllocation(TInt aSignalType, TUint aSize);

	enum TSocketMessage

		{

		ESocketCurrentMessage,

		ESocketReadMessage,

		ESocketWriteMessage,

		ESocketCloseMessage,

		ESocketIoCtlMessage,

		ESocketConnectMessage

		,ESocketSetLocalNameMessage

		};

    void ReadParamL(TSocketMessage aMessage, TInt aSrcParamIndex,TDes8 &aDes,TInt anOffset=0);

    void ReadParamL(TSocketMessage aMessage, TInt aSrcParamIndex, RMBufChain& aBufChain);

	void WriteParamL(TSocketMessage aMessage, TInt aDstParamIndex,const TDesC8& aDes,TInt anOffset=0);

	void WriteParamL(TSocketMessage aMessage, TInt aDstParamIndex, RMBufChain& aBufChain);

	AMessage* GetUserMessage( TSocketMessage aMessage ) const;

	void SetUserMessage ( TSocketMessage aMessageType, AMessage* aMessage );

	virtual void GetOwnerInfo(TProcessId& aProcId, TSoOwnerInfo& aInfo, TThreadId& aThreadId) = 0;

    virtual TInt SecurityCheck() = 0;

	virtual void CompleteFlowRequestMessage(TInt err) =0;

	inline TBool FlowRequestPending();

#ifdef SYMBIAN_NETWORKING_UPS

	TInt GetProcessAndThreadId(TProcessId& aProcessId, TThreadId& aThreadId) const;

#endif

protected:

	MSessionControl* iSSP; // NULL-ness well controlled

	AMessage*  iCurrentMsg;

	TSockXfrLength iXferLength;		// used to write transfer lengths back to client; kept in scope with socket to avoid repeated construction cost

private:

	MSessionData* iSSPData;

	MFlowBinderControl* iFlowBinder;

	Messages::RNodeInterface iServiceProvider;

	TProtocolDesc* iProtocolInfo;

    TInt        iSocketType;

	TSocketState iState;

	TInt iDataAvailable;

	TInt iSendOffset;

	TInt iRecOffset;

	TInt iSendByteCount;

	TInt iRecByteCount;

	TInt iSendFlags;

	TInt iRecvFlags;

	TSockAddr iRecvFromAddr;

//

	TUint iBlockedOperations;

	TInt iError;

    TUint iErrorOperationMask;     // stored aOperationMask from last MSessionControlNotify::Error() call

	TUint iOptions;

	enum { KMaxStreamChunk = 32 * 1024 };

//

	TInt iRecBufSize;

	TInt iSendBufSize;

	RMBufChain iSendData;

	HBufC8* iDisconnectData;

	TInt iDisconnectDataError;

	RMBufChain iDatagramTail;

//

	CWaitForMBufs* iAllocAsync;

//

	CCirBuf<TAcceptQEntry>* iAcceptQ;	//lint -esym(613, ASocket::iAcceptQ)	// NULL-ness well controlled

	CCirBuf<TAcceptQEntry>* iNextAcceptQ;	//lint -esym(613, CSocket::iAcceptQ)	// NULL-ness well controlled

	TInt        iSelectFlags;

	TSecurityPolicy iTransferSecPolicy;     // used for security check during ProtocolManager::TransferSocketL()

	TBool iIsBound:1;

	TBool iRecvOneOrMore:1;

    TBool iSecTransferEnabled:1;  // flag, indicating that iTransferSecPolicy is initialized and socket transfer is enabled

	TBool iIsFlowRequestPending:1;

	TBool iSendUseMBufs:1;

	TBool iRecvUseMBufs:1;

	TInt8 iSendXferLenIdx;

	TInt8 iRecvXferLenIdx;

	TInt8 iSendToAddrIdx;

	TInt8 iRecvFromAddrIdx;

    TInt8 iBlockOnPeekReadCnt; // recursion level counter for NewData().

	AMessage* iReadMsg;

	AMessage* iWriteMsg;

	AMessage* iBlockedCloseMsg;

	AMessage* iBlockedConnectMsg;

	AMessage* iBlockedIoctlMsg;

	AMessage* iBlockedSetLocalNameMsg;

	TSocketState iNextState; // Next state to enter after binding state exits.

	TBool        iConnectData; // Used to indicate if connect data is present.

	RMBufAllocator iAllocator; // To speed up the RMBufChain allocation

	};

inline TUint ASocket::IsConnectionOriented()  const

	{

	return !(iProtocolInfo->iServiceInfo & KSIConnectionLess);

	}

inline TUint ASocket::IsConnectionLess() const

	{

	return (iProtocolInfo->iServiceInfo & KSIConnectionLess);

	}

inline TUint ASocket::IsDataGram() const

	{

	return (iProtocolInfo->iServiceInfo & KSIDatagram);

	}

inline TUint ASocket::IsStream() const

	{

	return (iProtocolInfo->iServiceInfo & KSIStreamBased);

	}

inline TUint ASocket::IsPseudoStream() const

	{

	return (iProtocolInfo->iServiceInfo & KSIPseudoStream);

	}

inline TUint ASocket::IsReliable() const

	{

	return (iProtocolInfo->iServiceInfo & KSIReliable);

	}

inline TUint ASocket::CanReconnect() const

	{

	return (iProtocolInfo->iServiceInfo & KSICanReconnect);

	}

inline TUint ASocket::SupportsPeek() const

	{

	return (iProtocolInfo->iServiceInfo & KSIPeekData);

	}

inline TUint ASocket::DeliversInOrder() const

	{

	return (iProtocolInfo->iServiceInfo & KSIInOrder);

	}

inline TUint ASocket::IsMessageBased() const

	{

	return (iProtocolInfo->iServiceInfo & KSIMessageBased);

	}

inline TUint ASocket::CanSendUrgentData() const

	{

	return (iProtocolInfo->iServiceInfo & KSIUrgentData);

	}

inline TUint ASocket::CanSendConnectData() const

	{

	return (iProtocolInfo->iServiceInfo & KSIConnectData);

	}

inline TUint ASocket::CanSendDisconnectData() const

	{

	return (iProtocolInfo->iServiceInfo & KSIDisconnectData);

	}

inline TUint ASocket::CanBroadcast() const

	{

	return (iProtocolInfo->iServiceInfo & KSIBroadcast);

	}

inline TUint ASocket::SupportsMultiPoint() const

	{

	return (iProtocolInfo->iServiceInfo & KSIMultiPoint);

	}

inline TUint ASocket::SupportsQOS() const

	{

	return (iProtocolInfo->iServiceInfo & KSIQOS);

	}

inline TUint ASocket::IsWriteOnly() const

	{

	return (iProtocolInfo->iServiceInfo & KSIWriteOnly);

	}

inline TUint ASocket::IsReadOnly() const

	{

	return (iProtocolInfo->iServiceInfo & KSIReadOnly);

	}

inline TUint ASocket::SupportsGracefulClose() const

	{

	return (iProtocolInfo->iServiceInfo & KSIGracefulClose);

	}

inline TUint ASocket::RequiresOwnerInfo() const

	{

	return (iProtocolInfo->iServiceInfo & KSIRequiresOwnerInfo);

	}

inline void ASocket::SetBlockedReadFlag()

	{

	__ASSERT_DEBUG(!IsBlockedRead(),Fault(ETwoReads));

	iBlockedOperations|=EBlockedRead;

	}

inline void ASocket::SetBlockedWriteFlag()

	{

	__ASSERT_DEBUG(!IsBlockedWrite(),Fault(ETwoWrites));

	iBlockedOperations|=EBlockedWrite;

	}

inline void ASocket::SetBlockedConnectFlag()

	{

	__ASSERT_DEBUG(!IsBlockedConnect(),Fault(ETwoConnects));

	iBlockedOperations|=EBlockedConnect;

	}

inline void ASocket::SetBlockedCloseFlag()

	{

	__ASSERT_DEBUG(!IsBlockedClose(),Fault(ETwoClose));

	iBlockedOperations|=EBlockedClose;

	}

inline void ASocket::SetBlockedIoctlFlag()

	{

	__ASSERT_DEBUG(!IsBlockedIoctl(),Fault(ETwoIoctl));

	iBlockedOperations|=EBlockedIoctl;

	}

inline void ASocket::SetBlockedSetLocalName()

    {

    iBlockedOperations |= EBlockedSetLocalName;

    iBlockedSetLocalNameMsg->AcquireMessage( iCurrentMsg );

    }

 inline TBool ASocket::IsBlockedSetLocalName() const

	{

	return iBlockedOperations & EBlockedSetLocalName;

	}

inline void ASocket::SetBlockedRead()