// 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:
// Internal Sockets API 
// Written by Mal September 1997
// Based on work by AdamG
// 
//

/**
 @file
 @internalComponent 
*/

#if !defined(__INTSOCK_H__)
#define __INTSOCK_H__

#include <e32std.h>
#include <e32base.h>
#include <es_prot.h>
#include <es_sock.h>

/**
Specifies Internal Max buffer size.
*/
const TUint KInternalMaxBufSize=2048;

enum TPanicCode
{ 
	EPanic_NotReady,
	EPanic_InUse,
	EPanic_StatusRecv,
	EPanic_StatusComplete
};

class CInternalSocketTimers;
/**
Provides internal socket access direct to a SAP 
Based on CServProviderBase
@internalComponent
*/
NONSHARABLE_CLASS(CInternalSocket) : public CServProviderBase, public MSocketNotify
{
private:
	enum TInternalSockState
		{ ENew, EOpen, EConnecting, EConnected, 
		  EListening, EClosing, EClosed, EFault };
public:
	CInternalSocket();
	static CInternalSocket *NewL(CServProviderBase *aSock,MSocketNotify *aNotify);
	~CInternalSocket();
	//CInternalSocket* NewL();
	TInt OpenL(const TDesC& aProtocolName,MSocketNotify* aNotify);

	// inherited from CServProviderBase 
	virtual void Start(void);
	virtual TInt SetLocalName(TSockAddr& aAddr);
	virtual void LocalName(TSockAddr& anAddr)const;
	virtual TInt SetRemName(TSockAddr& aAddr);
	virtual void RemName(TSockAddr& aAddr)const;
	virtual TInt GetOption(TUint level,TUint name,TDes8& anOption)const;
	virtual void Ioctl(TUint level,TUint name,TDes8* anOption);
	virtual void CancelIoctl(TUint aLevel,TUint aName);
	virtual TInt SetOption(TUint,TUint,const TDesC8&);
	virtual TUint Write(const TDesC8 &,TUint,TSockAddr *);
	virtual void GetData(TDes8 &,TUint,TSockAddr *);
	virtual void ActiveOpen(const class TDesC8 &);
	virtual void ActiveOpen(void);
	virtual TInt PassiveOpen(TUint,const TDesC8 &);
	virtual TInt PassiveOpen(TUint);
	virtual void Shutdown(enum CServProviderBase::TCloseType,const TDesC8 &);
	virtual void Shutdown(enum CServProviderBase::TCloseType);
	virtual void AutoBind(void);
	
	TInt Connect(TSockAddr& aAddr);
	TInt WaitForConnect(TUint aQSize);
	void Close();
	TUint Recv(TDes8& aDes,TSockAddr* anAddr,TRequestStatus& aStat,TUint aOptions);
	void RecvFrom(TDes8& aDes, TSockAddr& aAddr,TUint aFlags,TRequestStatus& aStatus);
    TUint Write(RMBufChain& aPdu,TUint options,TRequestStatus& aStat,TSockAddr* anAddr);
	void SendTo(const TDesC8& aDes, const TSockAddr& aAddr,TUint aFlags,TRequestStatus& aStatus);
	void CancelRecv();
	void CancelSend();
	
	void SetNotify(MSocketNotify* aControl){ iNotify=aControl; };
	static TInt InternalSocketTimerExpired(TAny *aCIntSock);
protected:
	virtual void NewData(TUint aCount);
	virtual void CanSend();
	virtual void CanClose(TDelete aDelete=EDelete);
	virtual void Error(TInt anError,TUint anOperationMask=EErrorAllOperations);

	// Pass the following up to layer above via iNotify 
	virtual void ConnectComplete();
    virtual void ConnectComplete(CServProviderBase& aSSP);
	virtual void Disconnect(void);
	virtual void IoctlComplete(TDesC8 *aBuf);
	virtual void ConnectComplete(const TDesC8& aConnectData);
	virtual void ConnectComplete(CServProviderBase& aSSP,const TDesC8& aConnectData);
	virtual void Disconnect(TDesC8& aDisconnectData);
	virtual void CanClose(const TDesC8& aDisconnectData,TDelete aDelete=EDelete);
	virtual void NoBearer(const TDesC8& aConnectionParams);
	virtual void Bearer(const TDesC8& aConnectionInfo);
private:
	void Panic(TPanicCode aPanic);
	void DoRecv();
	void CompleteRecv(TInt aStatus);
	void DoSend();
	void CompleteSend(TInt aStatus);
public:
/** A pointer to the object which signalled it is ready to StartSending. */
	CProtocolBase* iProtocol;
/** A pointer to the object to indicate the server socket. */
	CServProviderBase* iCServSocket;	
private:
	MSocketNotify* iNotify;
	TInternalSockState iState;
	CInternalSocketTimers *iTimers;
	TUint iSockType;

	TUint iSendBufLength;
	HBufC8* iSendBuffer;
	TPtr8 iSendBufPtr;

	TUint iFlags;
	TInt iRecvNotifyCount;
	const TDesC8* iSendDes;
	TUint iSendFlags;
	TSockAddr* iSendAddr;
	TRequestStatus* iSendStat;

	TDes8* iRecvDes;
	TUint iRecvFlags;
	TSockAddr* iRecvAddr;
	TRequestStatus* iRecvStat;
};

/**
@internalComponent
*/
NONSHARABLE_CLASS(CInternalHostResolver) : public CBase, public MResolverNotify
{
private:
	enum TInternalHRState
		{ ENew, EConnected, EDiscovering,
		  EClosed, EFault };
public:
	CInternalHostResolver();
	~CInternalHostResolver();
	static CInternalHostResolver* NewL();
	TInt OpenL(const TDesC& aProtocolName,MResolverNotify *aEngine);
	// Notifier call back 
	void QueryComplete(TInt aError);
	// Need the following to mimic CHostResolvProvdBase 
	TInt GetByName(TNameRecord& aName);
	void GetByAddress(TNameRecord& aName);
	void SetHostName(TDes8& aNameBuf);
	void GetHostName(TDes8& aNameBuf);
protected:
	void SetNotify(MResolverNotify* aControl){ iNotify=aControl; };
public:
	CHostResolvProvdBase* iHostResolver;
	CProtocolBase* iProtocol;
	/** Set to MResolverNotify ABOVE. */
	MResolverNotify* iNotify;	
private:
	TInternalHRState iState;
	TBool iBusy;
};

/**
@internalComponent
*/
NONSHARABLE_CLASS(CInternalNetDB) : public CBase , public MResolverNotify
{
private:
	enum TInternalNetDBState
		{ ENew, EOpen, EQuery,
		  EClosed, EFault };
public:
	CInternalNetDB();
	~CInternalNetDB();
	static CInternalNetDB* NewL();
	TInt OpenL(const TDesC& aProtocolName,MResolverNotify *aEngine);

	// Notifier call back 
	void QueryComplete(TInt aError);
	// Need the following to mimic CNetDBProvdBase 
	TInt Query(TDes8& aBuffer);
	void Add(TDes8& aBuffer);
	void Remove(TDes8& aBuffer);
protected:
	void SetNotify(MResolverNotify* aControl){ iNotify=aControl; };
public:
	CProtocolBase* iProtocol;
	CNetDBProvdBase* iNetDatabase;
	/** Set to MResolverNotify ABOVE. */
	MResolverNotify* iNotify;	
private:
	TInternalNetDBState iState;
	TBool iBusy;
};

/**
@internalComponent
*/
NONSHARABLE_CLASS(CInternalSocketTimers) : public CBase
{
public:
	friend class CInternalSocket;
	virtual ~CInternalSocketTimers();
	static CInternalSocketTimers *NewL(CInternalSocket *aIntSock);
	void StartInternalSocketTimer(TCallBack aCallBack,TInt aTimeout);
	void StopInternalSocketTimer();
	void DoInternalSocketTimerExpired();
private:
	CInternalSocketTimers(CInternalSocket *aIntSock);
private:
	CInternalSocket *iInternalSocket;
	TDeltaTimerEntry iInternalSocketTimer;
	TDeltaTimerEntry *iInternalSocketTimerH;
};

// Added back in as the new stack does not contain sock.h
const TUint KSoConnectPending = 0x0001;	 //< Connect request pending
const TUint KSoIoctlPending = 0x0002; //< Ioctl request pending
const TUint KSoRecvPending = 0x0004; //< Recv/RecvFrom request pending
const TUint KSoSendPending = 0x0008; //< Send/SendTo request pending
const TUint KSoConnectionless = 0x0020;	 //< Does not need to Connect
const TUint KSoCantRecvMore = 0x0100; //< Recvd EOF indication from peer - used with RecvNotifyCount
const TUint KSoCantSendMore = 0x0200; //< Send EOF idication to peer
const TUint KSoSendFlowOff = 0x0400; //< Send is flowed off
const TUint KSoUseCanSend = 0x0800;	//< Use CanSend()
const TUint KSoGracefulClose = 0x1000;	//< Use Graceful close


#endif