// 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(__IPC_MAIN_H__)

#define __IPC_MAIN_H__

#include <es_sock.h>

#include <es_prot.h>

#include <e32base_private.h>

class CIpcProtocolFamily: public CProtocolFamilyBase

/**

@internalComponent

*/

	{

private:

	CIpcProtocolFamily();	

public:

	static CIpcProtocolFamily * NewL();

	TInt Install();

	TInt Remove();

	CProtocolBase * NewProtocolL(TUint aSockType,TUint aProtocol);

	TUint ProtocolList(TServerProtocolDesc *& aProtocolList);

	};

class CIpcProvdBase;

class CIpcProtocolHolder : public CBase

/**

@internalComponent

*/

	{

friend class CIpcProtocol;

private:

	CIpcProtocolHolder();

public:

	static CIpcProtocolHolder* NewL();

// Protocol internal functions.

	void SocketRemoved(TInt aPort);

	TInt GetNextFreePort();

	TInt CheckAndAllocatePortNumber(TInt aPort);

	void Add(CIpcProvdBase* aSAP);

	CIpcProvdBase* FindPeerForConnection(TInt aPort);

	~CIpcProtocolHolder();

private:

	TDblQue<CIpcProvdBase> iSAPs;

	TInt iNumSockets;

	CBitMapAllocator* iPortNumbers;

	};

class CIpcProtocol: public CProtocolBase

/**

@internalComponent

*/

	{

public:

	virtual ~CIpcProtocol();

	static CIpcProtocol *NewL(TInt aProtocol);

// Calls from the socket server which we implement

	CServProviderBase *NewSAPL(TUint aProtocol);

	void InitL(TDesC& aTag);

	void StartL(void);

	TBool CanCreateSockets();

	void Identify(TServerProtocolDesc *)const;

// Calls from the socket server which we don't implement

	virtual CHostResolvProvdBase *NewHostResolverL();

	virtual CServiceResolvProvdBase *NewServiceResolverL();

	virtual CNetDBProvdBase* NewNetDatabaseL();

// Calls from the socket server and other protocols which we just panic

	void BindL(CProtocolBase *aProtocol, TUint anId);

	virtual void BindToL(CProtocolBase *protocol);

	TInt Send(RMBufChain &,CProtocolBase* aSourceProtocol);

	void Process(RMBufChain &,CProtocolBase* aSourceProtocol);

	TInt Send(TDes8 &, TSockAddr *to,TSockAddr *from,CProtocolBase* aSourceProtocol);

	void Process(TDes8 & ,TSockAddr *from,TSockAddr *to,CProtocolBase* aSourceProtocol);

	TInt GetOption(TUint level,TUint name,TDes8 &anOption,CProtocolBase* aSourceProtocol);

	TInt SetOption(TUint level,TUint name,const TDesC8& option,CProtocolBase* aSourceProtocol);

	void Error(TInt anError,CProtocolBase* aSourceProtocol);

private:

	CIpcProtocol(TInt aProtocol);

private:

	TInt iProtocol;

	CIpcProtocolHolder* iStreamProtocolSAPs;

	};

class CIpcProvdBase : public CServProviderBase

/**

@internalComponent

*/

	{

friend class CIpcProtocolHolder;

public:

	enum TIpcProvdState {ECreated=0,EConnected,EWaitingConnect,EDisconnected};

	virtual void RemName(TSockAddr &anAddr)const;

	virtual void LocalName(TSockAddr &anAddr)const;

	virtual TInt SetLocalName(TSockAddr &anAddr);

	virtual TInt SetRemName(TSockAddr& anAddr);

	virtual TInt GetOption(TUint level,TUint name,TDes8 &anOption)const;

	virtual TInt SetOption(TUint level,TUint name,const TDesC8 &anOption);

	virtual void AutoBind( void );

	virtual void Ioctl(TUint level,TUint name,TDes8 *anOption);

	virtual void CancelIoctl(TUint aLevel,TUint aName);

	virtual TInt PassiveOpen(TUint aQue,const TDesC8 &aConnectionData);

	virtual void Shutdown(TCloseType option,const TDesC8 &aDisconnectData);

	virtual void ActiveOpen(const TDesC8 &aConnectionData);

	virtual ~CIpcProvdBase();

	virtual void Start();

	virtual void ActiveOpen(void);

	virtual void Shutdown(TCloseType option);

	virtual TInt PassiveOpen(TUint aQue);

	virtual void Disconnect();

	void Connected(CIpcProvdBase& aSocket);

// Pure virtual

	virtual CIpcProvdBase* GetCloneSocket()=0;

	virtual void NewData(TInt aLen)=0;

	virtual void CanSend()=0;

protected:

	CIpcProvdBase(CIpcProtocolHolder* aProtocol);

protected:

	TIpcProvdState iState;

	CIpcProtocolHolder* iProtocol;

	TInt iLocalAddr;

	TInt iRemoteAddr;

	CIpcProvdBase* iConnection;

public:

	TDblQueLink iLink;

	};

class CIpcStreamProvd : public CIpcProvdBase

/**

@internalComponent

*/

	{

public:

	void NewData(TInt aLen);

	void CanSend();

	virtual TUint Write(const TDesC8& aDesc,TUint options, TSockAddr* anAddr=NULL);

	virtual void GetData(TDes8 &aDesc,TUint options,TSockAddr *anAddr=NULL);

	static CIpcStreamProvd* NewL(CIpcProtocolHolder* aProtocol);

	virtual CIpcProvdBase* GetCloneSocket();

private:

	CIpcStreamProvd(CIpcProtocolHolder* aProtocol);

	CCirBuffer iBuffer;

	};

/**

@internalComponent

*/

enum TIPCProtPanic

	{

	ECantBind,

	ECantBindTo,

	ESendCallCantBind,

	EProcessCallCantBind,

	EErrorUpCallCantBind,

	ESetOptionCallCantBind,

	EGetOptionCallCantBind,

	ECantCreateNetDatabase,

	ECantCreateServiceResolver,

	ECantCreateHostResolver,

	EBadWriteCall,

	EBadGetDataCall,

	EReadGetTooMuch,

	ECloseWithoutDeleteingAllSockets,

	EBMABroken

	};

/**

@internalComponent

*/

void Panic(TIPCProtPanic aPanic);

#endif