// 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:
// eintsockimpl.h
// 
//

/**
 @file
 @internalTechnology 
*/

#ifndef __EINTSOCKIMPL_H__
#define __EINTSOCKIMPL_H__

#include <e32std.h>
#include <es_prot.h>
#include <ss_std.h>
#include <es_mbuf.h>
#include "ss_eintsock_msgs.h"

#include <comms-infras/ss_intsock.h>

class CInternalServiceResolver;	// not implemented as no-one wants it at the moment
class CInternalConnection;		// not implemented, as too dodgy to bypass multiplexing in esock without some serious thought

class RInternalSocket;
class TSockXferLength;
class TTransportUserStorage;

using namespace ESock;

// This is not really a C type class. 
NONSHARABLE_CLASS(CIntSocketMessage) : public CBase, public AMessage
	{
	public:
		virtual void AcquireMessage ( AMessage* aMessage );
		inline void SetMessage ( TEIntSockOpMsgWrapper& aMessage );
		
	private:
		virtual TInt ReadDes(TInt aSrcParamIndex,TDes8 &aDes,TInt anOffset=0 );
		virtual TInt ReadInt(TInt aSrcParamIndex);
		virtual TInt ReadMBuf(TInt aSrcParamIndex, RMBufChain& aBufChain);
		virtual void InitMBuf(TInt aParamIndex);
		virtual TInt WriteDes(TInt aDstParamIndex,const TDesC8& aDes,TInt anOffset=0);    
		virtual TInt WriteMBuf(TInt aDstParamIndex,RMBufChain& aBufChain);    

		virtual void CompleteMessage(TInt anError);
		virtual TBool IsNull (TInt aParamIndex);
		
		inline TEIntSockOpMsgWrapper& Message ();

	private:
		TEIntSockOpMsgWrapper iMessage;
	};


// A simple default security checker
class TDefaultSecurityChecker : public MProvdSecurityChecker
	{
	public:
		TInt CheckPolicy (const TSecurityPolicy& /*aPolicy*/, const char * /*aDiagnostic*/)
	      {
	      return KErrNone;
	      }
	};

// This class is needed for synchronous open
NONSHARABLE_CLASS(CAsyncWaiter) : public CActive
	{
	public:
		static CAsyncWaiter* New ();
		~CAsyncWaiter ();
		
		TInt StartAndWait ();
		
	protected:
		CAsyncWaiter ();
		
		// CActive
		void RunL ();
		void DoCancel ();		
	};


NONSHARABLE_CLASS(CInternalSockSubSession) : public CBase, public MProvdSecurityChecker
	{
public:
	class TParameters
		{
	public:
		TParameters(CommsFW::TWorkerId aClientWorkerId, CommsFW::MCommsTransportSender* aSender, TTransportUserStorage& aStorage, const Messages::TNodeId& aServerCookie, TRequestWrapper* aRequest /*TWorkerId aClientWorkerId, CommsFW::TWorkerId aServerWorkerId*/);
	public:
		TTransportUserStorage& iStorage;
		CommsFW::TWorkerId iClientWorkerId;
		Messages::TNodeId iServerCookie;

        // Used by the client for subsequent calls. Presumes client remains in same thread as when opened
        // RInternalSocket must be Transfer()'d if client thread changes
        CommsFW::MCommsTransportSender* iSender;
        TRequestWrapper* 			iRequest;
		};

	IMPORT_C static void ProcessMessage(const Den::TWorkerTransportMsg& aMsg, TRequestWrapper& aRequest, TTransportUserStorage& aStorage, CommsFW::TWorkerId aPeerWorkerId);
	IMPORT_C static void OnPeerDeath(CommsFW::TWorkerId aPeer, TTransportUserStorage& aStorage);
	IMPORT_C static void Shutdown(TBool aAlreadyDead, TTransportUserStorage& aStorage);

	inline CommsFW::TWorkerId ClientWorkerId() const;
	inline CommsFW::TWorkerId ServerWorkerId() const;
	CommsFW::MCommsTransportSender* Sender() const;
	void SetSender(CommsFW::MCommsTransportSender* aSender);

	inline TInt SendReceiveMsg(Den::TWorkerTransportMsg& aMsg);
	inline void SendMsg(Den::TWorkerTransportMsg& aMsg);
	static TInt SendReceiveMsg(Den::TWorkerTransportMsg& aMsg, CommsFW::MCommsTransportSender* aSender, const Messages::TNodeId& aServerCookie);
	static void SendMsg(Den::TWorkerTransportMsg& aMsg, CommsFW::MCommsTransportSender* aSender, const Messages::TNodeId& aServerCookie);
	static TInt SendReceiveMsgAsync( Den::TWorkerTransportMsg& aMsg, CommsFW::MCommsTransportSender* aSender, const Messages::TNodeId& aServerCookie );
	
	virtual void FinalCompleteAllBlockedMessages(TInt aResult) = 0;

	virtual TInt CheckPolicy(const TSecurityPolicy& /*aPolicy*/, const char* /*aDiagnostic*/);
	static TInt LinkOffset();
protected:
	typedef TDblQue<CInternalSockSubSession> TSubSessions;
	class TGlobals
		{
	public:
		TGlobals();
		TSubSessions iSubSessions;
		};

	CInternalSockSubSession(const TParameters& aParams);
	void ConstructL(const TParameters& aParams);

	static TGlobals* Globals(TTransportUserStorage& aStorage);

	static TSubSessions& SubSessions(TTransportUserStorage& aStorage);
	static void AddSubsession(TTransportUserStorage& aStorage, CInternalSockSubSession* aSubSession);
	static void ProcessMessageL(const Den::TWorkerTransportMsg& aMsg, TRequestWrapper& aRequest, TTransportUserStorage& aStorage, CommsFW::TWorkerId aPeerWorkerId);
	static TInt PerformOperationL(const TEIntSockMsg& aMsg, TRequestWrapper& aRequest);
	
private:
	TInt iAccessCount;
	CommsFW::TWorkerId iClientWorkerId;
//	TWorkerId iServerWorkerId;
	Messages::TNodeId iServerCookie;
	CommsFW::MCommsTransportSender* iSender;	// presumes client remains in same thread as when opened - safe for now
protected:
	TDblQueLink iLink;
	CWorkerThread* iOwnerThread;
	};


NONSHARABLE_CLASS(CInternalSocketImpl) : public CInternalSockSubSession, public ASocket
/**
Implementation of RInternalSocket
*/
	{
	typedef CInternalSockSubSession inherited;
	friend class CInternalSockSubSession;
	friend class ProtocolManager;
private:
	// Various bits to create a new internal socket in different ways	
	static CInternalSocketImpl* NewL ( const CInternalSockSubSession::TParameters& aParams );
	static CInternalSocketImpl* NewL ( const CInternalSockSubSession::TParameters& aParams, TServerProtocolDesc* aServiceInfo, CProtocolBase* aProt );
	~CInternalSocketImpl();

	virtual void FinalCompleteAllBlockedMessages(TInt aResult);
	
	void SetImpl ( CInternalSocketImpl*& aImpl );

	virtual TDes8* BorrowTemporaryBuffer(TInt aSize);
    virtual TDes8* BorrowTemporaryBufferL(TInt aSize);
private:
	CInternalSocketImpl(const CInternalSockSubSession::TParameters& aParams, TUint aSockType);
	void ConstructL(const TParameters& aParams, TServerProtocolDesc* aServiceInfo, CProtocolBase* aProt);
	void InitUserMessageL ( TSocketMessage aMessage );
	
	void SendL ( TSockMess aWriteFunction, TEIntSockOpMsgWrapper& aMsg );
	void RecvL ( TSockMess aReadFunction, TEIntSockOpMsgWrapper& aMsg );	
	void CancelOpen ();
	
	// From ASocket
	// ----------------
	virtual void SetClosing();
	virtual TBool IsClosing();

	virtual void DontCompleteCurrentRequest();
	
	virtual ASocket* InitiateAcceptingSocket();
    virtual ASocket* GetAcceptingSocket();
    
	virtual void SetReturn(TInt aReturnValue) const;

	virtual void GetOwnerInfo(TProcessId& aProcId, TSoOwnerInfo& aInfo, TThreadId& aThreadId);
    virtual TInt SecurityCheck();
	
    virtual void CompleteFlowRequestMessage(TInt aErr);
    
    virtual void InitiateDestruction();
    virtual TBool CloseSocket();
    virtual void PanicSocketClient(TESockPanic aPanic);
	// --------------
	
	TEIntSockOpMsgWrapper& GetMessage (TSocketMessage aMessage);
	TBool ShouldCompleteCurrentRequest () const;
	inline TInt Return () const;
	void AdoptFlowRequest ( TRequestWrapper& aRequest );
	void SetCurrentMessage ( TEIntSockOpMsgWrapper& aIntSockMsg );	
	void CompleteCurrentRequest ( TBool aValue );
	
private:
	TBool 				iComplete:1;
	TBool				iClosing:1;
	mutable TInt		iReturn;
	
	TRequestWrapper		iFlowRequest;
	CInternalSocketImpl** iImpl; // This will hold the reference to the pointer that RInternalSocket holds.
								 // It will be set when the the internal socket is actuall created. in case of
								 // an error it will be NULL and socket will do a self deletion. 
	CProtocolBase* iProtocol;
	};

#include "ss_eintsockimpl.inl"

#endif // __EINTSOCKIMPL_H__