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

//

#if !defined(__SS_SOCK_H__)

#define __SS_SOCK_H__

#include <comms-infras/ss_intsock.h>

#define SYMBIAN_NETWORKING_UPS

#ifdef SYMBIAN_NETWORKING_UPS

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

#endif //SYMBIAN_NETWORKING_UPS

//#include <es_prot.h>

#include <es_enum.h>

#include <e32base.h>

#include <comms-infras/ss_flowbinders.h>

#include <comms-infras/ss_nodeinterfaces.h>

#include "ss_flowrequest.h"

class CWaitForMBufs;

class CProtocolBase;

class ProtocolManager;

class CInternalSocketImpl;

namespace ESock

{

NONSHARABLE_CLASS(CSocketMessage) : public CBase, public AMessage 

	{

	public:

	virtual void AcquireMessage ( AMessage* aMessage );

	inline void SetMessage ( Den::RSafeMessage& aMessage );

	inline void ProcessedMessage ();

	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);

#ifdef SYMBIAN_NETWORKING_UPS

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

	inline const Den::RSafeMessage& Message() const;

#endif	

	inline Den::RSafeMessage& Message ();

	private:

		Den::RSafeMessage iMessage;   // Not owned

	};

NONSHARABLE_CLASS(CSocket) : public CSockSubSession, public ASocket

/**

Represents client-facing part of socket.

Implements ESOCK client socket sub-session specific handling.

Deals with RMessage2, player and session properties

@see ASocket

@internalTechnology

*/

	{

	friend class ::ProtocolManager;

	friend class ::Nif;

	friend class ::CInternalSocketImpl;	// need access to TSocketState enum - for esock "internal sockets"

	typedef CSockSubSession inherited;

public:

	static CSocket* NewLC(TServerProtocolDesc* aServiceInfo, CSockSession* aSession, CPlayer* aPlayer, CProtocolBase* aProt, const TSubSessionUniqueId aSubSessionUniqueId, TInt aSocketType);

	virtual ~CSocket();

	virtual Den::TSubSessInfo Type() const

		{

		return TCFSubSessInfo(TCFSubSessInfo::ESocket);

		}

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

	// Request service routines.

	void ConnectL();

	void ShutdownL();

	TBool CloseSocket();

	void ListenL();

	void SetSockOptionL();

	void GetSockOptionL();

	void IoctlL();

	void ReferenceL();

	virtual void ProcessMessageL();

	virtual void InitiateDestruction();

	void AdoptFlowRequestMessage(const RMessage2& aFlowRequestMessage)

		{

		iFlowRequestMessage.Adopt(static_cast<Den::RSafeMessage&>(const_cast<RMessage2&>(aFlowRequestMessage)));

		}

	void CompleteFlowRequestMessage(TInt err);

private:

   	CSocket(CSockSession* aSession, CPlayer* aPlayer, const TSubSessionUniqueId aSubSessionUniqueId, TInt aSocketType);

	virtual void SetClosing();

	virtual TBool IsClosing();

	virtual void DontCompleteCurrentRequest();

	virtual ASocket* InitiateAcceptingSocket();

    virtual ASocket* GetAcceptingSocket();

	virtual void PanicSocketClient(TESockPanic aPanic);

	virtual void SetReturn(TInt aReturnValue) const;

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

    virtual TInt SecurityCheck();

	void FinalCompleteAllBlockedMessages(TInt aResult);

	void ConstructL (CProtocolBase* aProtocol);

	void InitUserMessageL ( TSocketMessage aMessage );

	virtual TDes8* BorrowTemporaryBuffer(TInt aSize);

    virtual TDes8* BorrowTemporaryBufferL(TInt aSize);

private:

	Den::RSafeMessage iFlowRequestMessage;	

    };

// ---------------------------------------------

inline void CSocketMessage::SetMessage ( Den::RSafeMessage& aMessage )

	{

	iMessage.Duplicate(aMessage);

	}

inline void CSocketMessage::ProcessedMessage ()

    {

    // Resets the handle to reflect the fact that the message has been processed

    iMessage.ResetHandle();

    }

inline Den::RSafeMessage& CSocketMessage::Message ()

	{

	return iMessage;

	}

inline const Den::RSafeMessage& CSocketMessage::Message() const

	{

	return iMessage;

	}

}  //namespace ESock

#endif

// __SS_SOCK_H__