// 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 the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

// which accompanies this distribution, and is available

// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

/**

 @file

 @publishedAll

 @released

*/

#if !defined(__ES_SOCK_H__)

#define __ES_SOCK_H__

#include <e32base.h>

#include <nifvar.h>

#undef	_DEBUG_SOCKET_FUNCTIONS

#if defined(_DEBUG)

#define	_DEBUG_SOCKET_FUNCTIONS

#endif

#include <comms-infras/metacontainer.h>

using Meta::STypeId;

using Meta::SMetaDataECom;

using Meta::RMetaDataEComContainer;

// Forward declaration of CCommsDataObjectBase

namespace ESock

{

	class CCommsDataObjectBase;

}

/**

Name of ESock server in EKA2

@internalComponent

*/

_LIT(SOCKET_SERVER_NAME, "!SocketServer");

/**

Canonical names for the core ESOCKSVR modules

*/

_LIT8(SOCKET_SERVER_MAIN_MODULE_NAME, "ESock_Main");		// Worker 0

_LIT8(SOCKET_SERVER_IP_MODULE_NAME, "ESock_IP");			// Worker 1

_LIT8(SOCKET_SERVER_BT_MODULE_NAME, "ESock_Bt");			// Worker 2

_LIT8(SOCKET_SERVER_IR_MODULE_NAME, "ESock_Ir");			// Worker 3

_LIT8(SOCKET_SERVER_SMSWAP_MODULE_NAME, "ESock_SmsWap");	// Worker 4

/**

Id of the network layer.

@publishedPartner

*/

const TUint KCommsNetworkLayerId = 1;

/**

Default number of message slots.

@publishedAll

@released

*/

const TUint KESockDefaultMessageSlots=8;

/**

Major Version Number of Connection

@internalComponent

*/

const TUint KConnectionMajorVersionNumber=1;

/**

Minor Version Number of Connection

@internalComponent

*/

const TUint KConnectionMinorVersionNumber=0;

/**

Build Version Number of Connection

this must not be changed - expected by TCPIP to be >=68

@internalComponent

*/

const TUint KConnectionBuildVersionNumber=68;

/**

Size of Maximum SubConnection event

@internalComponent

@note If you allocate this on the heap, remember to delete through the pointer to the buffer and not any pointers to the events held inside it

if you change this value, you will alter the function signature and break the .def file

*/

const TUint KMaxSubConnectionEventSize = 512;

/**

SubConnection Unique Id

@publishedPartner

@released

*/

typedef TUint TSubConnectionUniqueId;

/**

Buffer for  notification of any change in the state of  SubConnection.

@publishedPartner

@released

*/

typedef TBuf8<KMaxSubConnectionEventSize> TSubConnectionNotificationBuf;

//

const TUint KUseEmbeddedUniqueId = 0; ///< Used by RConnection to identify cases where the subconnection id is embedded in the data structure

const TUint KConnProgressDefault = 0; ///< Default Connection Progress

class TSessionPref

/**

Hint to the Socket Server on what will be the principal usage of the connection.

It is by no means a restriction but may result in better performance for the session.

@publishedAll

@released

*/

	{

public:

    IMPORT_C TSessionPref();

public:

	/** The protocol's address family. For example, for TCP/IP protocols, KAfInet. */

	TUint iAddrFamily;

	/** The protocol type. */

	TUint iProtocol;

	/** Reserved. */

	TUint iReserved;

	/** Reserved. */

	TUint iReserved1;

	/** Reserved. */

	TUint iReserved2;

	/** Reserved. */

	TUint iReserved3;

	/** Reserved. */

	TUint iReserved4;

	};

class TNifProgress

/**

Contains progress information on a dial-up connection

@publishedAll

@released

*/

	{

public:

	inline TNifProgress();

	TInt iStage;

	TInt iError;

	};

class TNifAgentInfo

/**

Contains information describing an agent

@publishedAll

@released

*/

	{

public:

	/**	This class Contains version information	*/

	TVersion iVersion;

	/**	This class Defines a modifiable buffer descriptor that can contain the name of a reference counting object	*/

	TName iName;

	};

/**

Buffer for Network Interface Progress

@publishedAll

@released

*/

typedef TPckgBuf<TNifProgress> TNifProgressBuf;

/**

Socket address offsets.

@publishedAll

@released

*/

struct SSockAddr

/** Socket address offsets.

This class defines the internal offsets of data members for the TSockAddr

class. */

	{

	/** Address family of socket address */

	TUint iFamily;

	/** Port (or equivilent) number */

	TUint iPort;

	};

/**

Maximum sockets address size.

@publishedAll

@released

*/

const TUint KMaxSockAddrSize=0x20;

class TSockAddr : public TBuf8<KMaxSockAddrSize>

/** Represents an end point address.

Protocols interpret the class within the socket server to route packets and

form connections. It can be used on its own or as derived by protocols. The

SSockAddr class acts as an offset map for the TSockAddr class which has a

family field and a port field. The family field may be used by protocols to

"up-cast" the base-class to the correct derived class. The port field is provided

because it is a common practice for protocols to use port equivalents in addressing.

Writing derived classes:

The two protected member functions allow further data members to be defined

past the area of the base SSockAddr. In any derived constructor the length

of the descriptor should be set to the length of the valid data contained

in the address. Subsequent member function calls should also adjust the length

if it affects valid data.

@publishedAll

@released */

	{

public:

	IMPORT_C TSockAddr();

	IMPORT_C TSockAddr(TUint aFamily);

	IMPORT_C TUint Family() const;

	IMPORT_C void SetFamily(TUint aFamily);

	IMPORT_C TUint Port() const;

	IMPORT_C void SetPort(TUint aPort);

	IMPORT_C TBool CmpPort(const TSockAddr& anAddr) const;

	IMPORT_C TInt GetUserLen();

protected:

	IMPORT_C void SetUserLen(TInt aLen);

	inline TUint8* UserPtr() const;

private:

	inline SSockAddr* BasePtr() const;

	};

// Address families (based upon protocol IDs used by ARP/REVARP)

/** Default (unspecified) protocol module.

@publishedAll

@released */

const TUint KAFUnspec=0;

// Socket types

/** Stream socket.

@publishedAll

@released */

const TUint KSockStream=1;

/** Datagram socket. */

const TUint KSockDatagram=2;

/** Datagrams with sequence numbers. */

const TUint KSockSeqPacket=3;

/** Raw socket. */

const TUint KSockRaw=4;

// constants for various socket calls - can't be enums cos they're largely defined by protocols

// The following constants are used to define level parameters for RSocket::Ioctl(), RSocket::GetOpt()

// and RSocket::SetOpt().

/** Generic socket options/commands.

@publishedAll

@released */

const TInt KSOLSocket=1;

/** Unspecified level. */

const TInt KLevelUnspecified=0;

// Socket options defined by the server.

// Used through RSocket::SetOpt(), and RSocket::GetOpt() with anOptionLevel set

// to KSOLSocket. Options can be both get and set unless otherwise.

// stated.

// Notes:

// Setting the send and receive buffer sizes explicitly can help to reduce

// the memory requirements if many data sockets are used in an application. If a

// socket is datagram-oriented and its receive/send buffer size is set

// to KSocketBufSizeUndefined, then the initial buffer size will

// be KSocketDefaultBufferSize and buffers will grow to accommodate

// larger sends/receives. If the buffer size is set explicitly for

// datagram-oriented sockets, sends which exceed the set size will fail

// with KErrTooBig and receives will be truncated. For stream based

// sockets there should be no noticeable effect on client reads, unless the buffer

// size is set to a prohibitively low value.

/** Debugging enabled or disabled . Values are:

(TInt)0. Disabled

(TInt)1. Enabled

@publishedAll

@released */

const TUint KSODebug=1;

/** Socket receive buffer size. Values are:

KSocketBufSizeUndefined

1 to KMaxTUint: explicit buffer size, supplied as a TPckgBuf<TUint> */

const TUint KSORecvBuf=2;

/** Socket send buffer size. Values are:

KSocketBufSizeUndefined

1 to KMaxTUint: explicit buffer size, supplied as a TPckgBuf<TUint> */

const TUint KSOSendBuf=3;

/** Socket nonblocking mode. To set, no option values are required. For getting,

values are:

(TInt)0. Disabled

(TInt)1. Enabled */

const TUint KSONonBlockingIO=4;

/** Socket blocking mode. To set, no values are required. For getting, values are:

(TInt)0. Disabled

(TInt)1. Enabled */

const TUint KSOBlockingIO=5;

/** Getting only: gets a bitmask of flags describing the read/write/exception status

of the socket. Value is a TInt containing a bitmask of socket status (KSockSelectExcept

etc.) constants. */

const TUint KSOSelectPoll=6;

/** Getting only: retrieve the number of bytes currently available for reading.

Value is a TInt. */

const TUint KSOReadBytesPending=7;

/** Getting only: retrieve the urgent data offset (only for stream protocols that

support urgent data).

Value is a TInt. */

const TUint KSOUrgentDataOffset=8;

/** Getting only: retrieves the last error. Value is a TInt. */

const TUint KSOSelectLastError=9;

/**

Setting only. Enables socket to be transferred to the process with given capabilities.

The capabilities set should be supplied as TPckgBuf<TSecurityPolicy>.

Each RSocket::Transfer() call must be enabled by setting this option.

@publishedAll

@released */

const TUint KSOEnableTransfer = 10;

/** Setting only. Disables a socket's possibility to be transferred. No option required.

@publishedAll

@released */

const TUint KSODisableTransfer = 11;

// The following constants relating to buffer sizes are defined

/** Use default buffer size. */

const TInt  KSocketBufSizeUndefined=0;

/** Default buffer size. */

const TInt  KSocketDefaultBufferSize=4096;

//internal

const TUint KSocketInternalOptionBit=0x80000000;	///< Must not be set for client requests

/**

Ioctls

Must not be set for client requests

@internalComponent

@released

*/

const TUint KInternalIoctlBit=0x80000000;

/** The aDesc parameter of RSocket::Ioctl() specifies a TUint containing a bitmask

of Socket status constants. The completion status will be the subset of those

conditions which is now true for the socket.

Used through RSocket::Ioctl(), with aLevel set to KSOLSocket.

@see KSOSelectPoll parameter to RSocket::GetOpt(), which allows the

current select state of the socket to be read synchronously, and KSOSelectLastError,

which returns the error code. */

const TUint KIOctlSelect=1;

// Select ioctl states

// Socket status. See also KSOSelectLastError and KSOSelectPoll.

/** Data is available to be read; for listening sockets, a connect is pending.

@publishedAll

@released */

const TUint KSockSelectRead   =0x00000001;

/** Writing to the socket is not currently blocked by flow-control. */

const TUint KSockSelectWrite  =0x00000002;

/** An error has occurred. */

const TUint KSockSelectExcept =0x00000004;

/** Include tail of prior read datagram as available data (ie indicates next read will be with read continuation) */

const TUint KSockSelectReadContinuation = 0x01000000;

// Socket write flags

/** The data to be sent is urgent and is given a higher priority than ordinary data in the send queue.

KSockWriteUrgent may only be provided as a flag to Send() if the protocol's information flag is marked with

KSIUrgentData, otherwise Send() will return with KErrNotSupported. AKA: Out of band or unit data.

@publishedAll

@released */

const TUint KSockWriteUrgent=0x00000001;

/** Must not be set for client requests. */

const TUint KSocketInternalWriteBit=0x80000000;

/** The top 8 bits are reserved for system purposes; protocols must not define these bits. */

const TUint KSockWriteSystemMask=0xFF000000;

// Socket read flags

/** Read data without consuming it, data remains in the receive queue. KSockReadPeek may only be provided

as a flag to Recv() if the protocol's information flag is marked with KSIPeekData, otherwise Recv() will

return with KErrNotSupported.

@publishedAll

@released

*/

const TUint KSockReadPeek=0x00000001;

/** Must not be set for client requests. */

const TUint KSocketInternalReadBit=0x80000000;

/** Read from datagram in a stream-like fashion (not discarding tails). */

const TUint KSockReadContinuation = 0x01000000;

// Types

/** Used in structure TProtocolDesc to describes the endianness of a protocol.

@publishedAll

@released */

enum TByteOrder

	{

	/** Big endian */

	EBigEndian,

	/** Little endian */

	ELittleEndian,

	/** Other byte order */

	EOtherByteOrder,

	};

//

// Protocol Service information bitmasks.

// The following constants are defined for

// TServerProtocolDesc and TProtocolDesc

//

/** The protocol is connectionless.

@publishedPartner

@released */

const TUint KSIConnectionLess=0x00000001;

/** The protocol is reliable. */

const TUint KSIReliable=0x00000002;

/** The protocol guarantees in-order delivery. */

const TUint KSIInOrder=0x00000004;

/** The protocol is message based. */

const TUint KSIMessageBased=0x00000008;

/** The same as message based. */

const TUint KSIDatagram=KSIMessageBased;

/** The protocol is stream based. */

const TUint KSIStreamBased=0x00000010;

/** The protocol supports a stream like interface but maintains datagram boundaries. */

const TUint KSIPseudoStream=0x00000020;

/** The protocol offers an expedited data service. */

const TUint KSIUrgentData=0x00000040;

/** The protocol can send user data on a connection request. */

const TUint KSIConnectData=0x00000080;

/** The protocol can send user data on a disconnect request. */

const TUint KSIDisconnectData=0x00000100;

/** The protocol supports broadcast addresses. */

const TUint KSIBroadcast=0x00000200;

/** The protocol supports point to multi-point connections. */

const TUint KSIMultiPoint=0x00000400;

/** The protocol supports a quality of service metric. */

const TUint KSIQOS=0x00000800;

/** The protocol is write only. */

const TUint KSIWriteOnly=0x00001000;

/** The protocol is read only. */

const TUint KSIReadOnly=0x00002000;

/** The protocol supports graceful close. */

const TUint KSIGracefulClose=0x00004000;

/** The same socket can be reconnected if it disconnects (for whatever reason). */

const TUint KSICanReconnect=0x00008000;

/** Protocol supports peeking (looking at the data without removing it from the

protocol). */

const TUint KSIPeekData=0x00010000;

/** Protocol is to be informed of the identity of the client (i.e. process ID,

thread ID and UID) of each SAP (i.e. Socket Service Provider) created.

@see KSoOwnerInfo and TSoOwnerInfo */

const TUint KSIRequiresOwnerInfo=0x00020000;	// SetOption(KSoOwnerInfo) invoked on each SAP

//

// Naming service constants

// The following constants are defined for

// TServerProtocolDesc and TProtocolDesc

//

/** Protocol supports resolving human readable entity names into network addresses

(like DNS).

@publishedPartner

@released */

const TUint KNSNameResolution=0x00000001;

/** Network naming is hierarchical. */

const TUint KNSHierarchicalNaming=0x00000002;

/** @deprecated Use KNSHierarchicalNaming instead. */

const TUint KNSHeirarchicalNaming=0x00000002;

/** Addressing is dynamic and should be attempted every time before connecting

(like IrDA). */

const TUint KNSRemoteDiscovery=0x00000004;

/** Protocol supports service name to port number resolution. (For example, you

can look up TCP to get port 48.) */

const TUint KNSServiceResolution=0x00000008;

/** Protocol supports additions to the name database. */

const TUint KNSNameRegistration=0x00000010;

/** Protocol supports additions to the service database. */

const TUint KNSServiceRegistration=0x00000020;

/** Addressing is dynamic - i.e. name to address mapping may change (like IrDA

which randomly chooses machine addresses.) */

const TUint KNSDynamicAddressing=0x00000040;

/** Protocol has another database which is defined by the protocol. */

const TUint KNSInfoDatabase=0x00000080;

/** Protocol may request Socket Server to startup a connection on its behalf (via

the KErrCompletion error code)*/

const TUint KNSRequiresConnectionStartup=0x00000100;

// Security Schemes

// The following constants are defined for

// TServerProtocolDesc and TProtocolDesc

/** No security

@publishedAll

@released */

const TUint KSocketNoSecurity=0x00000000;

/** Secure Sockets Layer.

@see CSecureSocket */

const TUint KSecureSockets=0x00000001;

// Special message sizes

// The following constants are defined for

// TServerProtocolDesc and TProtocolDesc

/** Reads and writes can be of any size: the data is treated as a stream.

@publishedAll

@released */

const TInt KSocketMessageSizeIsStream=0;

/** Depends on lower layer or is dynamic. */

const TInt KSocketMessageSizeUndefined=1;

/** Data is packet-oriented but packets can be of any size (i.e. the remote end

must specify a Read of the same size as your Write, but there is no limit

on this size.) */

const TInt KSocketMessageSizeNoLimit=-1;

/** Undefined socket type.

@publishedAll

@released */

const TUint KUndefinedSockType=0xFFFFFFFF;

/** Undefined socket type.

Undefined Protocol

@released */

const TUint KUndefinedProtocol=0xFFFFFFFE;

/** Contains the name of a protocol in structure TProtocolDesc.

@publishedAll

@released */

typedef TBuf<0x20> TProtocolName;

/** Defines a descriptor to hold a service name string. */

typedef TBuf<0x20> TServiceName;

/** Defines a descriptor to hold a host name string. */

typedef TBuf<0x100> THostName;

/**

Socket protocol information for use by clients

@publishedAll

@released

*/

struct TProtocolDesc

/** Socket protocol information for use by clients. */

	{

public:

	/** The name of the protocol

	@see TProtocolName */

	TProtocolName iName;

	/** An integer identifying the protocol's address family. For example, for TCP/IP

	protocols, KAfInet. */

	TUint iAddrFamily;

	/** An integer specifying the socket type. For example, for TCP, KSockStream. */

	TUint iSockType;

	/** An integer specifying the specific protocol. For example, for TCP, KProtocolInetTcp. */

	TUint iProtocol;

	/** The version of the protocol

	@see TVersion */

	TVersion iVersion;

	/** The byte order that the protocol uses

	@see TByteOrder */

	TByteOrder iByteOrder;

	/** A bit mask of service information flags.

	@see KSockStream etc. */

	TUint iServiceInfo;

	/** A bit mask indicating if the protocol supports name resolution, service resolution,

	or database access services.

	@see KNSNameResolution etc. */

	TUint iNamingServices;

	/** A bitmask of security flags.

	@see KSocketNoSecurity etc. */

	TUint iSecurity;

	/** The message size of datagram protocols.

	@see KSocketMessageSizeIsStream etc. */

	TInt iMessageSize;

	};

// socket errors

/** This error is returned from operations on non-blocking sockets that cannot

be completed immediately, for example receive when no data is queued for reading.

It is a non-fatal error, and the operation should be retried later.

@publishedAll

@released */

const TInt KErrWouldBlock=-1000;

/**

socket errors

The value -17210 is taken from the range allocated for Esock (beginning at -17200)

A gap has been left between the currently existing vals and this one.

@publishedAll

@released

*/

const TInt KErrConnectionTerminated=-17210;

const TInt KErrCannotFindProtocol = -17211;

/** Used in RSocket read and write calls to pass the length of data read and written.

@publishedAll

@released */

typedef TPckgBuf<TInt> TSockXfrLength;

class TSockIO

/**

IPC Data holder

@internalComponent

*/

	{

public:

	const TSockXfrLength* iLength;  ///< length of data read and written

	TUint iFlags;                   ///<  Flag

	TSockAddr* iAddr;               ///< Socket Address

	};

class TSockIOBufC : public TPckgC<TSockIO>

/** @internalComponent */

	{

public:

	inline TSockIOBufC();

	TSockIO iArgs;

	};

class TSockOpen

/** @internalComponent */

	{

public:

	TUint iAddrFamily;

	TUint iSockType;

	TUint iProtocol;

	TInt  iHandle;

	TInt  iReserved;

	};

class TSockOpenBufC : public TPckgC<TSockOpen>

/** @internalComponent */

	{

public:

	inline TSockOpenBufC();

	TSockOpen iArgs;

	};

class RSocket;

class RConnection;

class RSocketServ : public RSessionBase

/** Provides the Connect() function to create an IPC communication channel to the

socket server. To close the channel RHandleBase provides a RHandleBase::Close()

function.

The prime use for instances of RSocketServ is to establish subsession communications

for RSocket, RHostResolver, RNetDatabase and RConnection.  Any of the resources

which are open using the session are automatically closed when the session is

terminated, however it is more appropriate to issue a Close() on each subsession object

before closing the session.

The following operations are also provided:

NumProtocols() - enumerates the number of protocols of which the socket server

is currently aware.

GetProtocolInfo()/FindProtocol() - return information about a specific protocol.

StartProtocol() - loads a protocol asynchronously.

@note This class is not intended for user derivation.

@publishedAll

@released  */

	{

public:

    IMPORT_C RSocketServ();

	IMPORT_C TInt Connect(TUint aMessageSlots=KESockDefaultMessageSlots);

	IMPORT_C TInt Connect(const TSessionPref& aPref, TUint aMessageSlots=KESockDefaultMessageSlots);

	IMPORT_C TVersion Version() const;

	IMPORT_C TInt NumProtocols(TUint& aCount);

	IMPORT_C TInt GetProtocolInfo(TUint anIndex,TProtocolDesc& aProtocol);

	IMPORT_C TInt FindProtocol(const TProtocolName& aName,TProtocolDesc& aProtocol);

	IMPORT_C void StartProtocol(TUint anAddrFamily,TUint aSockType,TUint aProtocol,TRequestStatus& aStatus);

	IMPORT_C void StopProtocol(TUint anAddrFamily,TUint aSockType,TUint aProtocol,TRequestStatus& aStatus);

	IMPORT_C TInt InstallExtension(const TDesC& aDllName, const TDesC& aArgs=TPtrC());

	IMPORT_C void SetExclusiveMode(TRequestStatus& aStatus);

	IMPORT_C void ClearExclusiveMode();

	IMPORT_C TInt __DbgMarkHeap();

	IMPORT_C TInt __DbgCheckHeap(TInt aCount);

	IMPORT_C TInt __DbgMarkEnd(TInt aCount);

	IMPORT_C TInt __DbgFailNext(TInt aCount);

	IMPORT_C TBool __DbgCheckFailNext() const;

	IMPORT_C TInt __DbgFailNextMbuf(TInt aCount);

	IMPORT_C TInt __DbgSetMbufPoolLimit(TInt asize);

	IMPORT_C TInt __DbgCheckMbuf(TInt asize);

	IMPORT_C TInt __DbgMbufFreeSpace();

	IMPORT_C TInt __DbgMbufTotalSpace();

	};

NONSHARABLE_CLASS(RCommsSubSession) : public RSubSessionBase

	{

	friend class RCommsApiExtensionBase;

	};

class RSubConnection;

class RSocket : public RCommsSubSession

/** Provides a client endpoint to a protocol. It provides functions for socket

creation, reading, writing, passive connection, active connection, setting

addresses and querying addresses. Use this class as an endpoint for network

type communications. It provides the following services:

reading from and writing to protocol

binding to addresses

active connecting

passive connection through the listen/accept model

Before using any of these services, a connection to a socket server session

must have been made and the socket must be open.

@publishedAll

@released Since v5.0*/

	{

friend class RSocketServ;

public:

	/** Used in structure TProtocolDesc to describes the endianness of a protocol. */

	enum TShutdown

		{

		/** Complete when socket output/input stopped. */

		ENormal,

		/** Stop socket input and complete when output is stopped. */

		EStopInput,

		/** Stop socket output and complete when input is stopped. */

		EStopOutput,

		/** Stop socket input/output and complete (abortive close). */

		EImmediate

		};

public:

	IMPORT_C RSocket();

	IMPORT_C TInt Open(RSocketServ& aServer,TUint addrFamily,TUint sockType,TUint protocol);

	IMPORT_C TInt Open(RSocketServ& aServer,TUint addrFamily,TUint sockType,TUint protocol, RConnection& aConnection);

	IMPORT_C TInt Open(RSocketServ& aServer,TUint addrFamily,TUint sockType,TUint protocol, RSubConnection& aSubConnection);

	IMPORT_C TInt Open(RSocketServ &aServer,const TDesC& aName);

	IMPORT_C TInt Open(RSocketServ& aServer);

	IMPORT_C void Send(const TDesC8& aDesc,TUint someFlags,TRequestStatus& aStatus);

	IMPORT_C void Send(const TDesC8& aDesc,TUint someFlags,TRequestStatus& aStatus,TSockXfrLength& aLen);

	IMPORT_C void CancelSend();

	IMPORT_C void Recv(TDes8& aDesc,TUint flags,TRequestStatus& aStatus);

	IMPORT_C void Recv(TDes8& aDesc,TUint flags,TRequestStatus& aStatus,TSockXfrLength& aLen);

	IMPORT_C void RecvOneOrMore(TDes8& aDesc,TUint flags,TRequestStatus& aStatus,TSockXfrLength& aLen);

	IMPORT_C void CancelRecv();

	IMPORT_C void Read(TDes8& aDesc,TRequestStatus& aStatus);

	IMPORT_C void CancelRead();

	IMPORT_C void Write(const TDesC8& aDesc,TRequestStatus& aStatus);

	IMPORT_C void CancelWrite();

	IMPORT_C void SendTo(const TDesC8& aDesc,TSockAddr& anAddr,TUint flags,TRequestStatus& aStatus);

	IMPORT_C void SendTo(const TDesC8& aDesc,TSockAddr& anAddr,TUint flags,TRequestStatus& aStatus,TSockXfrLength& aLen);

	IMPORT_C void RecvFrom(TDes8& aDesc,TSockAddr& anAddr,TUint flags,TRequestStatus& aStatus);

	IMPORT_C void RecvFrom(TDes8& aDesc,TSockAddr& anAddr,TUint flags,TRequestStatus& aStatus,TSockXfrLength& aLen);

	IMPORT_C void Connect(TSockAddr& anAddr,TRequestStatus& aStatus);

	IMPORT_C void Connect(TSockAddr& anAddr,const TDesC8& aConnectDataOut,TDes8& aConnectDataIn,TRequestStatus& aStatus);

	IMPORT_C void CancelConnect();

	IMPORT_C TInt Bind(TSockAddr& anAddr);

	IMPORT_C TInt SetLocalPort(TInt aPort);

	IMPORT_C void Accept(RSocket& aBlankSocket,TRequestStatus& aStatus);

	IMPORT_C void Accept(RSocket& aBlankSocket,TDes8& aConnectData,TRequestStatus& aStatus);

	IMPORT_C void CancelAccept();

	IMPORT_C TInt Listen(TUint qSize);

	IMPORT_C TInt Listen(TUint qSize,const TDesC8& aConnectData);

	IMPORT_C TInt SetOpt(TUint anOptionName,TUint anOptionLevel,const TDesC8& anOption=TPtrC8(NULL,0));

	IMPORT_C TInt SetOpt(TUint anOptionName,TUint anOptionLevel,TInt anOption);

	IMPORT_C TInt GetOpt(TUint anOptionName,TUint anOptionLevel,TDes8& anOption);

	IMPORT_C TInt GetOpt(TUint anOptionName,TUint anOptionLevel,TInt& anOption);

	IMPORT_C void Ioctl(TUint aCommand,TRequestStatus& aStatus,TDes8* aDesc=NULL,TUint aLevel=KLevelUnspecified);

	IMPORT_C void CancelIoctl();

	IMPORT_C TInt GetDisconnectData(TDes8& aDesc);

	IMPORT_C void LocalName(TSockAddr& anAddr);

	IMPORT_C TUint LocalPort();

	IMPORT_C void RemoteName(TSockAddr& anAddr);

	IMPORT_C void Close();

	IMPORT_C void Shutdown(TShutdown aHow,TRequestStatus& aStatus);

	IMPORT_C void Shutdown(TShutdown aHow,const TDesC8& aDisconnectDataOut,TDes8& aDisconnectDataIn,TRequestStatus& aStatus);

	IMPORT_C void CancelAll();

	IMPORT_C TInt Info(TProtocolDesc& aProtocol);

	IMPORT_C TInt Name(TName& aName);

	IMPORT_C TInt Transfer(RSocketServ& aServer, const TDesC& aName);

	};

class TNameRecord

/** Contains the results of name queries.

@publishedAll

@released */

	{

public:

	inline TNameRecord();

	/**

	@internalComponent

	*/

	enum {EAlias=0x00000001,};

	/** A host name

	@see THostName */

	THostName iName;

	/** An address

	@see TSockAddr */

	TSockAddr iAddr;

	/** Flags indicating some attribute about the name, i.e. EAlias */

	TInt iFlags;

	};

/** Packages the TNameRecord class so that it can be passed between a client and

the socket server.

@publishedAll

@released  */

typedef TPckgBuf<TNameRecord> TNameEntry;

class RHostResolver : public RSubSessionBase

/** Provides an interface to host name resolution services, such as DNS, that may

be provided by particular protocol modules.

The interface provides functions to access the following facilities:

Obtaining names from addresses.

Obtaining addresses from names.

Getting and setting local host name.

Not all actual services provide all these facilities. You should also consult

the documentation on the protocol you are intending to use. Functions return

KErrNotSupported if the protocol does not support a given operation. Note

that a description of the protocol family name resolution capabilities is

available at run-time from TProtocolDesc::iNamingServices.

Before using any service, a connection to a socket server session must be

made.

Each function is available in both synchronous and asynchronous versions.

A single RHostResolver can only perform one request of any type at once. A

client is panicked if it makes two requests.

@publishedAll

@released */

	{

public:

	IMPORT_C TInt Open(RSocketServ& aSocketServer,TUint anAddrFamily,TUint aProtocol);

	IMPORT_C TInt Open(RSocketServ& aSocketServer,TUint anAddrFamily,TUint aProtocol, RConnection& aConnection);

	IMPORT_C void GetByName(const TDesC& aName,TNameEntry& aResult,TRequestStatus& aStatus);

	IMPORT_C TInt GetByName(const TDesC& aName,TNameEntry& aResult);

	IMPORT_C void Next(TNameEntry& aResult,TRequestStatus& aStatus);

	IMPORT_C TInt Next(TNameEntry& aResult);

	IMPORT_C void GetByAddress(const TSockAddr& anAddr,TNameEntry& aResult,TRequestStatus& aStatus);

	IMPORT_C TInt GetByAddress(const TSockAddr& anAddr,TNameEntry& aResult);

	IMPORT_C TInt GetHostName(TDes& aName);

	IMPORT_C void GetHostName(TDes& aName,TRequestStatus& aStatus);

	IMPORT_C TInt SetHostName(const TDesC& aName);

	IMPORT_C void Close();

	IMPORT_C void Cancel();

    IMPORT_C void Query(const TDesC8& aQuery, TDes8& aResult, TRequestStatus& aStatus);

    IMPORT_C TInt Query(const TDesC8& aQuery, TDes8& aResult);

    IMPORT_C void QueryGetNext(TDes8& aResult, TRequestStatus& aStatus);

    IMPORT_C TInt QueryGetNext(TDes8& aResult);

private:

	};

/**

Port number on service

@publishedAll

@released

*/

typedef TPckgBuf<TInt> TPortNum;

class RServiceResolver : public RSubSessionBase

/** Provides an interface to resolver service names and ports.

@publishedAll

@released */

	{

public:

	IMPORT_C TInt Open(RSocketServ& aSocketServer,TUint anAddrFamily,TUint sockType,TUint aProtocol);

	IMPORT_C void GetByName(const TDesC& aName,TPortNum& aPort,TRequestStatus& aStatus);

	IMPORT_C TInt GetByName(const TDesC& aName,TPortNum& aPort);

	IMPORT_C void GetByNumber(const TUint aPort,TDes& aName,TRequestStatus& aStatus);

	IMPORT_C TInt GetByNumber(const TUint aPort,TDes& aName);

	IMPORT_C void RegisterService(const TDesC& aName,const TUint& aPort,TRequestStatus& aStatus);

	IMPORT_C TInt RegisterService(const TDesC& aName,const TUint& aPort);

	IMPORT_C void RemoveService(const TDesC& aName,const TUint& aPort,TRequestStatus& aStatus);

	IMPORT_C TInt RemoveService(const TDesC& aName,const TUint& aPort);

	IMPORT_C void Close();

	IMPORT_C void Cancel();

private:

	};

class RNetDatabase: public RSubSessionBase

/** Provides an interface to network databases, such as LM-IAS with IrDA, that

may be provided by particular protocol modules.

Before making any queries, a connection to a socket server session must be

made.

Each function is available in both synchronous and asynchronous versions.

A single RNetDatabase can only perform one request of any type at once. A

client is panicked if it makes two requests.

Particular database access services will specify the format of queries and

of responses.

@publishedAll

@released */

	{

public:

	IMPORT_C TInt Open(RSocketServ& aSocketServer,TUint anAddrFamily,TUint aProtocol);

	IMPORT_C void Query(const TDesC8& aQuery,TDes8& aResult,TRequestStatus& aStat);

	IMPORT_C TInt Query(const TDesC8& aQuery,TDes8& aResult);

	IMPORT_C void Add(const TDesC8& anItem,TRequestStatus& aStat);

	IMPORT_C TInt Add(const TDesC8& anItem);

	IMPORT_C void Remove(const TDesC8& anItem,TRequestStatus& aStat);

	IMPORT_C TInt Remove(const TDesC8& anItem);

	IMPORT_C void Close();

	IMPORT_C void Cancel();

private:

	};

/**

@publishedPartner

@released

*/

const TUint KCOLConnection = 1;						// level for RConnection::Control()

const TUint KCOLProvider = 2;						// level for RConnection::Control()

const TUint KConnInternalOptionBit = 0x80000000;	// Must not be set for client requests

const TUint KConnWriteUserDataBit = 0x40000000;

const TUint KConnReadUserDataBit = 0x20000000;

/**

Level for RConnection::Control()

@publishedPartner

@deprecated in 8.1

@capability NetworkControl Restrict access to connection clients

@ref RConnection::Control()

*/

const TUint KCoEnumerateConnectionClients  =  1 | (KConnWriteUserDataBit | KConnReadUserDataBit);