/*

* Copyright (c) 1997-2006 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:  

*

*/

/** @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;

/**

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

	inline TNifProgress(TInt aStage, TInt aError);

	inline TBool operator==(const TNifProgress& aRHS) const;

	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;