cpp/platform/es__sock_8h_source.html

// 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(__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>

#include <elements/sd_errors.h>

#include <comms-infras/es_parameterset.h>


#include <comms-infras/es_event.h>


using Meta::STypeId;

using Meta::SMetaDataECom;

using Meta::RMetaDataEComContainer;


// Forward declaration of CCommsDataObjectBase

namespace ESock

{


    class CCommsDataObjectBase;

}


_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


const TUint KConnectionUp    = 7000;

const TUint KConnectionDown  = 8000;


const TUint KESockDefaultMessageSlots=8;


const TUint KMaxSubConnectionEventSize = 512;


typedef TUint TSubConnectionUniqueId;


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

    {

public:

    IMPORT_C TSessionPref();


public:

    TUint iAddrFamily;

    TUint iProtocol;

    TUint iReserved;

    TUint iReserved1;

    TUint iReserved2;

    TUint iReserved3;

    TUint iReserved4;

    };


class TNifProgress

    {

public:

    inline TNifProgress();

    inline TNifProgress(TInt aStage, TInt aError);


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


    TInt iStage;

    TInt iError;

    };


class TNifAgentInfo

    {

public:

    TVersion iVersion;


    TName iName;

    };


typedef TPckgBuf<TNifProgress> TNifProgressBuf;


struct SSockAddr

    {

    TUint iFamily;

    TUint iPort;

    };


const TUint KMaxSockAddrSize=0x20;


class TSockAddr : public TBuf8<KMaxSockAddrSize>

    {

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)

const TUint KAFUnspec=0;


// Socket types

const TUint KSockStream=1;

const TUint KSockDatagram=2;

const TUint KSockSeqPacket=3;

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

const TInt KSOLSocket=1;

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.

const TUint KSODebug=1;

const TUint KSORecvBuf=2;

const TUint KSOSendBuf=3;

const TUint KSONonBlockingIO=4;

const TUint KSOBlockingIO=5;

const TUint KSOSelectPoll=6;

const TUint KSOReadBytesPending=7;

const TUint KSOUrgentDataOffset=8;

const TUint KSOSelectLastError=9;


const TUint KSOEnableTransfer = 10;


const TUint KSODisableTransfer = 11;


// The following constants relating to buffer sizes are defined


const TInt  KSocketBufSizeUndefined=0;

const TInt  KSocketDefaultBufferSize=4096;


//internal

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


const TUint KIOctlSelect=1;


// Select ioctl states

// Socket status. See also KSOSelectLastError and KSOSelectPoll.

const TUint KSockSelectRead   =0x00000001;

const TUint KSockSelectWrite  =0x00000002;

const TUint KSockSelectExcept =0x00000004;

const TUint KSockSelectReadContinuation = 0x01000000;


// Socket write flags

const TUint KSockWriteUrgent=0x00000001;

const TUint KSocketInternalWriteBit=0x80000000;

const TUint KSockWriteSystemMask=0xFF000000;


// Socket read flags

const TUint KSockReadPeek=0x00000001;

const TUint KSocketInternalReadBit=0x80000000;

const TUint KSockReadContinuation = 0x01000000;

// Types


enum TByteOrder

    {

    EBigEndian,

    ELittleEndian,

    EOtherByteOrder,

    };


//

// Protocol Service information bitmasks.

// The following constants are defined for

// TServerProtocolDesc and TProtocolDesc

//

const TUint KSIConnectionLess=0x00000001;

const TUint KSIReliable=0x00000002;

const TUint KSIInOrder=0x00000004;

const TUint KSIMessageBased=0x00000008;

const TUint KSIDatagram=KSIMessageBased;

const TUint KSIStreamBased=0x00000010;

const TUint KSIPseudoStream=0x00000020;

const TUint KSIUrgentData=0x00000040;

const TUint KSIConnectData=0x00000080;

const TUint KSIDisconnectData=0x00000100;

const TUint KSIBroadcast=0x00000200;

const TUint KSIMultiPoint=0x00000400;

const TUint KSIQOS=0x00000800;

const TUint KSIWriteOnly=0x00001000;

const TUint KSIReadOnly=0x00002000;

const TUint KSIGracefulClose=0x00004000;


const TUint KSICanReconnect=0x00008000;

const TUint KSIPeekData=0x00010000;

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


const TUint KSIReserved=0xFFFC0000;


//

// Naming service constants

// The following constants are defined for

// TServerProtocolDesc and TProtocolDesc

//

const TUint KNSNameResolution=0x00000001;

const TUint KNSHierarchicalNaming=0x00000002;

const TUint KNSHeirarchicalNaming=KNSHierarchicalNaming;

const TUint KNSRemoteDiscovery=0x00000004;

const TUint KNSServiceResolution=0x00000008;

const TUint KNSNameRegistration=0x00000010;

const TUint KNSServiceRegistration=0x00000020;

const TUint KNSDynamicAddressing=0x00000040;

const TUint KNSInfoDatabase=0x00000080;

const TUint KNSRequiresConnectionStartup=0x00000100;

const TUint KNSReserved=0xFFFFFE00;


// Security Schemes

// The following constants are defined for

// TServerProtocolDesc and TProtocolDesc

const TUint KSocketNoSecurity=0x00000000;

const TUint KSecureSockets=0x00000001;


// Special message sizes

// The following constants are defined for

// TServerProtocolDesc and TProtocolDesc

const TInt KSocketMessageSizeIsStream=0;

const TInt KSocketMessageSizeUndefined=1;

const TInt KSocketMessageSizeNoLimit=-1;


const TUint KUndefinedSockType=0xFFFFFFFF;


const TUint KUndefinedProtocol=0xFFFFFFFE;


const TUint KUndefinedAddressFamily = 0;


typedef TBuf<0x20> TProtocolName;

typedef TBuf<0x20> TServiceName;

typedef TBuf<0x100> THostName;


struct TProtocolDesc

    {

public:

    TProtocolName iName;

    TUint iAddrFamily;

    TUint iSockType;

    TUint iProtocol;

    TVersion iVersion;

    TByteOrder iByteOrder;

    TUint iServiceInfo;

    TUint iNamingServices;

    TUint iSecurity;

    TInt iMessageSize;

    };


// socket errors

const TInt KErrWouldBlock=-1000;


const TInt KErrConnectionTerminated=-17210;


const TInt KErrCannotFindProtocol = Den::KErrPlayerNotFound;

const TInt KErrTierNotFound = -17212;

const TInt KErrConnectionContention = -17213;


const TInt KErrProtocolNotReady = -17214;


// -17215 used for non published error. Do not use here.


typedef TPckgBuf<TInt> TSockXfrLength;


namespace ESockDebug

    {

    class TControlMsg;

    }


class RSocket;

class RConnection;


NONSHARABLE_CLASS(RCommsSession) : public RSessionBase

    {

    friend class RCommsApiExtensionBase;

    friend class CCommsSessionApiExtProvider;

    };


class RSocketServ : public RCommsSession

    {


public:

    IMPORT_C RSocketServ();

    IMPORT_C TInt Connect(TUint aMessageSlots = (TUint) -1);

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

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

    IMPORT_C TInt __DbgControl(const ESockDebug::TControlMsg& aRequestMsg);

    };


NONSHARABLE_CLASS(RCommsSubSession) : public RSubSessionBase

    {

    friend class RCommsApiExtensionBase;

    friend class CCommsSubSessionApiExtProvider;

    };


class RSubConnection;

class RSocket : public RCommsSubSession


    {

friend class RSocketServ;

public:


    enum TShutdown

        {

        ENormal,

        EStopInput,

        EStopOutput,


        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 RecvOneOrMore(TDes8& aDesc,TUint flags,TRequestStatus& aStatus);

    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

    {

public:

    inline TNameRecord();


    enum

    {

    EAlias=0x00000001,

    EPartial=0x00000002,

    };

    THostName iName;

    TSockAddr iAddr;

    TInt iFlags;

    };


typedef TPckgBuf<TNameRecord> TNameEntry;


class RHostResolver : public RSubSessionBase

    {

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

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


private:

    };


typedef TPckgBuf<TInt> TPortNum;


class RServiceResolver : public RSubSessionBase


    {

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

    {

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:

    };


const TUint KConnectionTypeDefault = 0x0800;        // KAfInet is the default connection type


class TConnPref;

class TSubConnectionInfo;

class TSubConnectionEvent;


class RConnection : public RCommsSubSession


    {

public:

    enum TConnAttachType

        {

        EAttachTypeNormal,

        EAttachTypeMonitor

        };

    enum TConnStopType

        {

        EStopNormal,


        EStopAuthoritative

        };


    IMPORT_C RConnection();

    IMPORT_C virtual ~RConnection();

    IMPORT_C TInt Open(RSocketServ& aSocketServer, TUint aConnectionType = KConnectionTypeDefault);

    IMPORT_C TInt Open(RSocketServ& aSocketServer, TName& aName);

    IMPORT_C void Close();


    IMPORT_C void Start(TRequestStatus& aStatus);

    IMPORT_C void Start(TConnPref& aPref, TRequestStatus& aStatus);

    IMPORT_C TInt Start();

    IMPORT_C TInt Start(TConnPref& aPref);

    IMPORT_C TInt Stop();

    IMPORT_C TInt Stop(TConnStopType aStopType);

    IMPORT_C TInt Stop(TSubConnectionUniqueId aSubConnectionUniqueId);

    IMPORT_C TInt Stop(TSubConnectionUniqueId aSubConnectionUniqueId, TConnStopType aStopType);


    IMPORT_C void WaitForIncoming(RSubConnection& aIncomingSubConnection, TRequestStatus& aStatus);

    IMPORT_C TInt WaitForIncoming(RSubConnection& aIncomingSubConnection);

    IMPORT_C void CancelWaitForIncoming();


    IMPORT_C void ProgressNotification(TNifProgressBuf& aProgress, TRequestStatus& aStatus, TUint aSelectedProgress = KConnProgressDefault);

    IMPORT_C void ProgressNotification(TSubConnectionUniqueId aSubConnectionUniqueId, TNifProgressBuf& aProgress, TRequestStatus& aStatus, TUint aSelectedProgress = KConnProgressDefault);

    IMPORT_C void CancelProgressNotification();

    IMPORT_C void CancelProgressNotification(TSubConnectionUniqueId aSubConnectionUniqueId);

    IMPORT_C TInt Progress(TNifProgress& aProgress);

    IMPORT_C TInt Progress(TSubConnectionUniqueId aSubConnectionUniqueId, TNifProgress& aProgress);

    IMPORT_C TInt LastProgressError(TNifProgress& aProgress);

    IMPORT_C void ServiceChangeNotification(TUint32& aNewISPId, TDes& aNewServiceType, TRequestStatus& aStatus);


    IMPORT_C void CancelServiceChangeNotification();


    IMPORT_C TInt GetIntSetting(const TDesC& aSettingName, TUint32& aValue);


    IMPORT_C TInt GetBoolSetting(const TDesC& aSettingName, TBool& aValue);


    IMPORT_C TInt GetDesSetting(const TDesC& aSettingName, TDes8& aValue);


    IMPORT_C TInt GetDesSetting(const TDesC& aSettingName, TDes16& aValue);


    IMPORT_C TInt GetLongDesSetting(const TDesC& aSettingName, TDes& aValue);


    IMPORT_C TInt GetParameters(ESock::CCommsDataObjectBase& aDataObject);

    IMPORT_C TInt SetParameters(ESock::CCommsDataObjectBase& aDataObject);


    IMPORT_C TInt Name(TName& aName);


    IMPORT_C TInt EnumerateConnections(TUint& aCount);

    IMPORT_C TInt GetConnectionInfo(TUint aIndex, TDes8& aConnectionInfo);


    IMPORT_C void AllInterfaceNotification(TDes8& aNotification, TRequestStatus& aStatus);

    IMPORT_C void CancelAllInterfaceNotification();


    IMPORT_C void Ioctl(TUint aOptionLevel, TUint aOptionName, TRequestStatus& aStatus, TDes8* aDesc);

    IMPORT_C void Ioctl(TUint aOptionLevel, TUint aOptionName, TRequestStatus& aStatus);

    IMPORT_C void CancelIoctl();

    IMPORT_C TInt Control(TUint aOptionLevel, TUint aOptionName, TDes8& aOption);

    IMPORT_C TInt GetOpt(TUint aOptionLevel, TUint aOptionName, TInt& aOption);

    IMPORT_C TInt SetOpt(TUint aOptionLevel, TUint aOptionName, TInt aOption = 0);


    IMPORT_C TInt Attach(const TDesC8& aConnectionInfo, TConnAttachType aAttachType);


    IMPORT_C TInt EnumerateSubConnections(TUint& aCount);

    IMPORT_C TInt GetSubConnectionInfo(TDes8& aSubConnectionInfo);

    IMPORT_C TInt GetSubConnectionInfo(TUint aIndex, TDes8& aSubConnectionInfo);

    IMPORT_C void AllSubConnectionNotification(TSubConnectionNotificationBuf& aSubConnectionEvent, TRequestStatus& aStatus);

    IMPORT_C void CancelAllSubConnectionNotification();


    IMPORT_C void DataTransferredRequest(TPckg<TUint>& aUplinkVolume, TPckg<TUint>& aDownlinkVolume, TRequestStatus& aStatus);

    IMPORT_C void DataTransferredRequest(TSubConnectionUniqueId aSubConnectionUniqueId, TPckg<TUint>& aUplinkVolume, TPckg<TUint>& aDownlinkVolume, TRequestStatus& aStatus);

    IMPORT_C void DataTransferredCancel();

    IMPORT_C void DataTransferredCancel(TSubConnectionUniqueId aSubConnectionUniqueId);

    IMPORT_C void DataSentNotificationRequest(TUint aThreshold, TPckg<TUint>& aUplinkVolume, TRequestStatus& aStatus);

    IMPORT_C void DataSentNotificationRequest(TSubConnectionUniqueId aSubConnectionUniqueId, TUint aThreshold, TPckg<TUint>& aUplinkVolume, TRequestStatus& aStatus);


    IMPORT_C void DataSentNotificationCancel();

    IMPORT_C void DataSentNotificationCancel(TSubConnectionUniqueId aSubConnectionUniqueId);

    IMPORT_C void DataReceivedNotificationRequest(TUint aThreshold, TPckg<TUint>& aDownlinkVolume, TRequestStatus& aStatus);

    IMPORT_C void DataReceivedNotificationRequest(TSubConnectionUniqueId aSubConnectionUniqueId, TUint aThreshold, TPckg<TUint>& aDownlinkVolume, TRequestStatus& aStatus);

    IMPORT_C void DataReceivedNotificationCancel();

    IMPORT_C void DataReceivedNotificationCancel(TSubConnectionUniqueId aSubConnectionUniqueId);

    IMPORT_C void IsConnectionActiveRequest(TUint aSecs, TPckg<TBool>& aState, TRequestStatus& aStatus);

    IMPORT_C void IsConnectionActiveCancel();

    IMPORT_C void IsSubConnectionActiveRequest(TSubConnectionUniqueId aSubConnectionUniqueId, TUint aSecs, TPckg<TBool>& aState, TRequestStatus& aStatus);

    IMPORT_C void IsSubConnectionActiveCancel(TSubConnectionUniqueId aSubConnectionUniqueId);


    TBool SameSession(TInt aSessionHandle);

private:

    TPckg<TUint32> iNewISPId;

    TUint32 iReserved[4];

    };


class CSubConParameterSet : public XParameterSetBase


    {

public:

    IMPORT_C static CSubConParameterSet* NewL(const STypeId& aTypeId);

    virtual ~CSubConParameterSet();


protected:

    CSubConParameterSet();

    };


class CSubConGenericParameterSet : public CSubConParameterSet

    {

public:

    IMPORT_C ~CSubConGenericParameterSet();


protected:

    IMPORT_C CSubConGenericParameterSet();

    };


class CSubConExtensionParameterSet : public CSubConParameterSet

    {

public:

    IMPORT_C ~CSubConExtensionParameterSet();


protected:

    IMPORT_C CSubConExtensionParameterSet();

    };


class RSubConParameterBundle;

class CSubConParameterBundle;


const TInt32 KSubConnParamsInterfaceUid = 0x10204303;

const TInt32 KSubConnEventInterfaceUid = 0x10204305;


const TInt32 KSubConnGenericParamsImplUid  = 0x10204304;

const TInt32 KSubConnGenericEventsImplUid  = 0x10204306;


const TUint32 KSubConGlobalFamily               = 0;

const TUint32 KSubConQoSFamily                  = 1;

const TUint32 KSubConAuthorisationFamily        = 2;

const TUint32 KSubConnCallDescrParamsFamily     = 3;

const TUint32 KSubConnContextDescrParamsFamily  = 4;


const TUint32 KSubConIPAddressInfoFamily        = 5;


const TInt32 KProtocolExtensionFamily       = 6;

const TInt32 KFlowParametersFamily      = 7;

class RParameterFamily;


class CSubConParameterFamily : public CBase

    {

public:


    enum TParameterSetType

         {

         ERequested = 0,

         EAcceptable = 1,

         EGranted = 2,

         ENumValues = 3 // The number of values in this enum

         };


public:

    IMPORT_C static CSubConParameterFamily* NewL(RSubConParameterBundle& aBundle, TUint32 aFamilyId);

    IMPORT_C static CSubConParameterFamily* LoadL(RSubConParameterBundle& aBundle, TPtrC8& aBuffer);

    IMPORT_C static CSubConParameterFamily* NewL(CSubConParameterBundle& aBundle, TUint32 aFamilyId);

    IMPORT_C static CSubConParameterFamily* LoadL(CSubConParameterBundle& aBundle, TPtrC8& aBuffer);


public:

    IMPORT_C virtual ~CSubConParameterFamily();

    IMPORT_C void SetGenericSetL(CSubConGenericParameterSet& aGenericSet, TParameterSetType aType);

    IMPORT_C void AddExtensionSetL(CSubConExtensionParameterSet& aExtensionSet, TParameterSetType aType);


    IMPORT_C CSubConExtensionParameterSet* FindExtensionSet(TUid aSetId, TParameterSetType aType);

    IMPORT_C CSubConExtensionParameterSet* FindExtensionSet(STypeId aSetId, TParameterSetType aType);

    IMPORT_C CSubConGenericParameterSet* GetGenericSet(TParameterSetType aType);


    inline TUint32 Id();


    IMPORT_C TUint Length() const;

    IMPORT_C TInt Load(TPtrC8& aDes);

    IMPORT_C TInt Store(TDes8& aDes) const;


    IMPORT_C void ClearAllParameters(TParameterSetType aType);


    void CopyToFamilyL(RParameterFamily& aDest) const;


    void CopyFromFamilyL(RParameterFamily& aSrc);

protected:

    IMPORT_C explicit CSubConParameterFamily(TUint32 aFamilyId);

    IMPORT_C void ConstructL(RSubConParameterBundle& aBundle);

    IMPORT_C void ConstructL(CSubConParameterBundle& aBundle);


    IMPORT_C static TInt32 ExtractFamilyAndCreateBufferL(TPtrC8& aBuffer, TPtrC8& aContainerBuffer);


private:


    const TUint32 iFamilyId;   // This member variable is accessed by an inline function ( Id () ).

    RMetaDataEComContainer iGenericSets;

protected:

    RMetaDataEComContainer iExtensionSets[ENumValues];


    };


class RParameterFamilyBundle;

class RSubConParameterBundle


    {

public:

    IMPORT_C RSubConParameterBundle();

    IMPORT_C void Close();


    IMPORT_C TUint Length() const;

    IMPORT_C TInt Load(const TDesC8& aDes);

    IMPORT_C TInt Store(TDes8& aDes) const;

    IMPORT_C void AddFamilyL(CSubConParameterFamily* aFamily);

    IMPORT_C CSubConParameterFamily* FindFamily(TUint32 aFamilyId);

    IMPORT_C void ClearAllParameters(CSubConParameterFamily::TParameterSetType aType);


    void CopyToFamilyBundleL(RParameterFamilyBundle& aDest) const;


    void CopyFromFamilyBundleL(RParameterFamilyBundle& aSrc);


protected:

    TInt CheckBundle() const;

private:

    RSubConParameterBundle(const RSubConParameterBundle& aBundle);

    RSubConParameterBundle& operator=(const RSubConParameterBundle& aBundle);


private:

    mutable CSubConParameterBundle* iBundle;

    };


const TInt KNotificationEventMaxSize = 2048;

class TNotificationEventBuf : public TBuf8<KNotificationEventMaxSize>

    {

public:

    IMPORT_C TNotificationEventBuf();

    IMPORT_C ~TNotificationEventBuf();


    IMPORT_C TBool IsGeneric() const;

    IMPORT_C TInt32 GroupId() const;

    IMPORT_C TUint32 Id() const;

    };


#ifndef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

class CSubConNotificationEvent : public SMetaDataECom

#else

class CSubConNotificationEvent : public ESock::XEventBase


#endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

    {

public:

    IMPORT_C static CSubConNotificationEvent* NewL(const STypeId& aTypeId);

    IMPORT_C static CSubConNotificationEvent* NewL(const TNotificationEventBuf& aEventBuffer);


    IMPORT_C TBool IsGeneric() const;


    IMPORT_C TInt32 GroupId() const;

    IMPORT_C TUint32 Id() const;


private:

    };


class TSubConnOpen

    {

public:

    enum TSubConnType

        {

        EAttachToDefault,   // will attach to the default sub connection

        ECreateNew,         // will create a new sub connection


        //private extension to subconnection openning modes below:

        EWaitForIncoming

        };


    TSubConnType iType;

    TInt  iHandle;

    TInt  iReserved;

    };


class RSubConnection : public RCommsSubSession

    {

public:

    friend class RConnection;


    enum TSubConnType

        {

        EAttachToDefault,

        ECreateNew,

        EWaitIncoming

        };


    struct TEventFilter

        {


        inline TEventFilter(TInt32 aEventGroupId = KSubConnGenericEventsImplUid, TUint32 aEventMask = 0xffffffff);

        TInt32  iEventGroupUid;


        TUint32 iEventMask;

        };


public:

    // Sub Connection Management

    IMPORT_C RSubConnection();

    IMPORT_C TInt Open(RSocketServ& aServer, TSubConnType aSubConnType, RConnection& aConnection);

    IMPORT_C void Close();

    IMPORT_C void Start(TRequestStatus& aStatus);

    IMPORT_C TInt Start();

    IMPORT_C TInt Stop();


    // Socket Management

    IMPORT_C void Add(RSocket& aSocket, TRequestStatus& aStatus);

    IMPORT_C void Remove(RSocket& aSocket, TRequestStatus& aStatus);


    // QoS Properties (legacy bundles - to be deprecated)

    IMPORT_C TInt SetParameters(const RSubConParameterBundle& aParametersSet);

    IMPORT_C TInt GetParameters(RSubConParameterBundle& aParametersSet);


    // QoS Properties (new prototype bundles)

    IMPORT_C TInt SetParameters(const RParameterFamilyBundle& aParametersSet);

    IMPORT_C TInt GetParameters(RParameterFamilyBundle& aParametersSet);


    // Event Notification

    IMPORT_C void EventNotification(TNotificationEventBuf& aEventBuffer, TBool aGenericEventsOnly, TRequestStatus& aStatus);

    IMPORT_C void EventNotification(TNotificationEventBuf& aEventBuffer, TEventFilter aEventFilterList[], TUint aEventListLength, TRequestStatus& aStatus);

    IMPORT_C void CancelEventNotification();


    // Generic Control

    IMPORT_C TInt Control(TUint aOptionLevel, TUint aOptionName, TDes8& aOption);


    //

    // IMPORT_C TInt Stop(TConnStopType aStopType);

    // IMPORT_C void ProgressNotification(TNifProgressBuf& aProgress, TRequestStatus& aStatus, TUint aSelectedProgress = KConnProgressDefault);

    // IMPORT_C void CancelProgressNotification();

    // IMPORT_C TInt Progress(TNifProgress& aProgress);

    // IMPORT_C void IsSubConnectionActiveRequest(TUint aSecs, TPckg<TBool>& aState, TRequestStatus& aStatus);

    // IMPORT_C void IsSubConnectionActiveCancel();

    //


    TBool SameSession(TInt aSessionHandle);


private:

    IMPORT_C TInt Open(RSocketServ& aServer, TSubConnOpen::TSubConnType aSubConnType, RConnection& aConnection);


    //Note : Not used anywhere else in the code, kept in order to avoid the BC Break

    TInt iSpare;

};


class ByteOrder

    {

public:

    IMPORT_C static TUint32 Swap32(TUint32 aVal);

    IMPORT_C static TUint16 Swap16(TUint16 aVal);

    inline static TUint16 Swap16(TUint aVal);

    };


class BigEndian

    {

public:

    IMPORT_C static TUint32 Get32(const TUint8* aPtr);

    IMPORT_C static TUint16 Get16(const TUint8* aPtr);

    IMPORT_C static void Put32(TUint8* aPtr, TUint32 aVal);

    IMPORT_C static void Put16(TUint8* aPtr, TUint16 aVal);


    };


class LittleEndian

    {

public:

    IMPORT_C static TUint32 Get32(const TUint8* aPtr);

    IMPORT_C static TUint16 Get16(const TUint8* aPtr);

    IMPORT_C static void Put32(TUint8* aPtr, TUint32 aVal);

    IMPORT_C static void Put16(TUint8* aPtr, TUint16 aVal);

    };


class TAccessPointInfo


    {

public:

    TAccessPointInfo(TUint aApId = 0);


    TUint AccessPoint() const;

    void SetAccessPoint(TUint aAccessPoint);


    TBool operator== (const TAccessPointInfo& aRhs) const;

private:

    TUint iAccessPointId;

    };


#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS


#include <es_sock_internal.h>

#include <es_sock_partner.h>

#endif


#include <es_sock.inl>


#endif  //__ES_SOCK_H__


BigEndian
Inserts and extracts integers in big-endian format.
Definition es_sock.h:1666

BigEndian::Put16
static IMPORT_C void Put16(TUint8 *aPtr, TUint16 aVal)

BigEndian::Get32
static IMPORT_C TUint32 Get32(const TUint8 *aPtr)

BigEndian::Put32
static IMPORT_C void Put32(TUint8 *aPtr, TUint32 aVal)

BigEndian::Get16
static IMPORT_C TUint16 Get16(const TUint8 *aPtr)

ByteOrder
Reverses the byte order in 16 and 32-bit values.
Definition es_sock.h:1652

ByteOrder::Swap32
static IMPORT_C TUint32 Swap32(TUint32 aVal)
Reverses the order of the bytes in a 32-bit value.

ByteOrder::Swap16
static IMPORT_C TUint16 Swap16(TUint16 aVal)
Reverses the order of the bytes in a 16-bit value.

CBase
Container Base Class.
Definition e32base.h:60

CSubConExtensionParameterSet
Base class for extended RSubConnection parameter sets.
Definition es_sock.h:1348

CSubConExtensionParameterSet::CSubConExtensionParameterSet
IMPORT_C CSubConExtensionParameterSet()

CSubConExtensionParameterSet::~CSubConExtensionParameterSet
IMPORT_C ~CSubConExtensionParameterSet()

CSubConGenericParameterSet
Base class for generic RSubConnection parameter sets.
Definition es_sock.h:1330

CSubConGenericParameterSet::CSubConGenericParameterSet
IMPORT_C CSubConGenericParameterSet()

CSubConGenericParameterSet::~CSubConGenericParameterSet
IMPORT_C ~CSubConGenericParameterSet()

CSubConNotificationEvent
Definition es_sock.h:1532

CSubConNotificationEvent::Id
IMPORT_C TUint32 Id() const

CSubConNotificationEvent::NewL
static IMPORT_C CSubConNotificationEvent * NewL(const STypeId &aTypeId)

CSubConNotificationEvent::IsGeneric
IMPORT_C TBool IsGeneric() const

CSubConNotificationEvent::GroupId
IMPORT_C TInt32 GroupId() const

CSubConParameterFamily
Container of RSubConnection parameter sets.
Definition es_sock.h:1396

CSubConParameterFamily::AddExtensionSetL
IMPORT_C void AddExtensionSetL(CSubConExtensionParameterSet &aExtensionSet, TParameterSetType aType)
Adds an extension parameter set to a sub-connection parameter set family.

CSubConParameterFamily::Store
IMPORT_C TInt Store(TDes8 &aDes) const
Instructs this sub-connection family to create a serialised version of itself and append it to the bu...

CSubConParameterFamily::FindExtensionSet
IMPORT_C CSubConExtensionParameterSet * FindExtensionSet(TUid aSetId, TParameterSetType aType)
Searches a sub-connection parameter family for an extension parameter set.

CSubConParameterFamily::TParameterSetType
TParameterSetType
Definition es_sock.h:1400

CSubConParameterFamily::ERequested
@ ERequested
Definition es_sock.h:1401

CSubConParameterFamily::EAcceptable
@ EAcceptable
Definition es_sock.h:1402

CSubConParameterFamily::ENumValues
@ ENumValues
Definition es_sock.h:1404

CSubConParameterFamily::EGranted
@ EGranted
Definition es_sock.h:1403

CSubConParameterFamily::ClearAllParameters
IMPORT_C void ClearAllParameters(TParameterSetType aType)
Clears (removes and deletes) all parameter sets with the type specified.

CSubConParameterFamily::Id
TUint32 Id()
Fetch the identity of the sub-connection parameter family.

CSubConParameterFamily::NewL
static IMPORT_C CSubConParameterFamily * NewL(RSubConParameterBundle &aBundle, TUint32 aFamilyId)
Creates a new sub-connection parameter set family.

CSubConParameterFamily::iExtensionSets
RMetaDataEComContainer iExtensionSets[ENumValues]
Definition es_sock.h:1451

CSubConParameterFamily::LoadL
static IMPORT_C CSubConParameterFamily * LoadL(RSubConParameterBundle &aBundle, TPtrC8 &aBuffer)
Creates a new sub-connection parameter set family from a buffer containing the serialised object.

CSubConParameterFamily::GetGenericSet
IMPORT_C CSubConGenericParameterSet * GetGenericSet(TParameterSetType aType)
Accessor for the sub-connection generic parameter set of a family.

CSubConParameterFamily::Load
IMPORT_C TInt Load(TPtrC8 &aDes)
Instructs this sub-connection family to set its members based on the serialiesd data in the buffer pa...

CSubConParameterFamily::SetGenericSetL
IMPORT_C void SetGenericSetL(CSubConGenericParameterSet &aGenericSet, TParameterSetType aType)
Assigns the generic parameter set of a sub-connection parameter set family.

CSubConParameterFamily::CopyToFamilyL
void CopyToFamilyL(RParameterFamily &aDest) const
Copy the parameters of this CSubConParameterFamily to a RParameterFamily.

CSubConParameterFamily::~CSubConParameterFamily
virtual IMPORT_C ~CSubConParameterFamily()
Sub-connection parameter family destructor.

CSubConParameterFamily::Length
IMPORT_C TUint Length() const
Calculates the length of buffer required to serialise this parameter set family.

CSubConParameterFamily::ConstructL
IMPORT_C void ConstructL(RSubConParameterBundle &aBundle)
Set up the sub-connection family with empty sets.

CSubConParameterFamily::ExtractFamilyAndCreateBufferL
static IMPORT_C TInt32 ExtractFamilyAndCreateBufferL(TPtrC8 &aBuffer, TPtrC8 &aContainerBuffer)
Used internally to extract the family id for the descriptor storing the serialised version of this ob...

CSubConParameterFamily::CopyFromFamilyL
void CopyFromFamilyL(RParameterFamily &aSrc)
Copy the parameters of this CSubConParameterFamily from a RParameterFamily.

CSubConParameterSet
Base class for all RSubConnection parameter sets.
Definition es_sock.h:1310

CSubConParameterSet::NewL
static IMPORT_C CSubConParameterSet * NewL(const STypeId &aTypeId)

CSubConParameterSet::CSubConParameterSet
CSubConParameterSet()

CSubConParameterSet::~CSubConParameterSet
virtual ~CSubConParameterSet()

LittleEndian
Inserts and extracts integers in little-endian format.
Definition es_sock.h:1681

LittleEndian::Put32
static IMPORT_C void Put32(TUint8 *aPtr, TUint32 aVal)

LittleEndian::Get16
static IMPORT_C TUint16 Get16(const TUint8 *aPtr)

LittleEndian::Put16
static IMPORT_C void Put16(TUint8 *aPtr, TUint16 aVal)

LittleEndian::Get32
static IMPORT_C TUint32 Get32(const TUint8 *aPtr)

RConnection
The management interface for a network connection or subconnection.
Definition es_sock.h:1164

RConnection::DataSentNotificationCancel
IMPORT_C void DataSentNotificationCancel()
Cancels a request for the amount of data sent on this connection, as issued by DataSentNotificationRe...

RConnection::DataReceivedNotificationRequest
IMPORT_C void DataReceivedNotificationRequest(TUint aThreshold, TPckg< TUint > &aDownlinkVolume, TRequestStatus &aStatus)
Requests a notification after an additional aThreshold bytes have been received by this connection.

RConnection::CancelAllInterfaceNotification
IMPORT_C void CancelAllInterfaceNotification()
Cancels a change notification request previously issued by a call to AllInterfaceNotification().

RConnection::SameSession
TBool SameSession(TInt aSessionHandle)
Checks that the Session Handle passed is the same as that of this RConnection.

RConnection::WaitForIncoming
IMPORT_C void WaitForIncoming(RSubConnection &aIncomingSubConnection, TRequestStatus &aStatus)
Subscribe for an incoming session on this connection.

RConnection::GetConnectionInfo
IMPORT_C TInt GetConnectionInfo(TUint aIndex, TDes8 &aConnectionInfo)
Gets information about one of the currently active connections.

RConnection::CancelAllSubConnectionNotification
IMPORT_C void CancelAllSubConnectionNotification()
Cancels the request for notification to changes to the state of subconnections, made using the AllSub...

RConnection::IsSubConnectionActiveRequest
IMPORT_C void IsSubConnectionActiveRequest(TSubConnectionUniqueId aSubConnectionUniqueId, TUint aSecs, TPckg< TBool > &aState, TRequestStatus &aStatus)
Checks whether the subconnection is active or has changed state (active/inactive)

RConnection::AllSubConnectionNotification
IMPORT_C void AllSubConnectionNotification(TSubConnectionNotificationBuf &aSubConnectionEvent, TRequestStatus &aStatus)
Requests notification of any change in the state of any of the subconnections belonging to this RConn...

RConnection::Open
IMPORT_C TInt Open(RSocketServ &aSocketServer, TUint aConnectionType=KConnectionTypeDefault)
Opens a new RConnection instance.

RConnection::RConnection
IMPORT_C RConnection()
Connection Management Interface.

RConnection::CancelWaitForIncoming
IMPORT_C void CancelWaitForIncoming()
Cancel the previous subscription for an incoming session.

RConnection::CancelServiceChangeNotification
IMPORT_C void CancelServiceChangeNotification()
Cancels a request for notification of change of service for the connection, as issued by ServiceChang...

RConnection::IsSubConnectionActiveCancel
IMPORT_C void IsSubConnectionActiveCancel(TSubConnectionUniqueId aSubConnectionUniqueId)

RConnection::GetOpt
IMPORT_C TInt GetOpt(TUint aOptionLevel, TUint aOptionName, TInt &aOption)
Gets an option.

RConnection::GetIntSetting
IMPORT_C TInt GetIntSetting(const TDesC &aSettingName, TUint32 &aValue)

RConnection::GetLongDesSetting
IMPORT_C TInt GetLongDesSetting(const TDesC &aSettingName, TDes &aValue)

RConnection::ServiceChangeNotification
IMPORT_C void ServiceChangeNotification(TUint32 &aNewISPId, TDes &aNewServiceType, TRequestStatus &aStatus)
Requests service change notification from the agent.

RConnection::Close
IMPORT_C void Close()
Closes the connection.

RConnection::EnumerateSubConnections
IMPORT_C TInt EnumerateSubConnections(TUint &aCount)
Asks the server to gather information on the currently active subconnections.

RConnection::Ioctl
IMPORT_C void Ioctl(TUint aOptionLevel, TUint aOptionName, TRequestStatus &aStatus, TDes8 *aDesc)
Get information on the connection in an asynchronous manner.

RConnection::Stop
IMPORT_C TInt Stop()
Stops the entire connection by disconnecting the underlying network interface immediately,...

RConnection::DataTransferredCancel
IMPORT_C void DataTransferredCancel()
Cancels a request for the amount of data transferred on the entire connection, issued by DataTransfer...

RConnection::TConnStopType
TConnStopType
Identifies the type of requirement for stopping the connection.
Definition es_sock.h:1179

RConnection::EStopAuthoritative
@ EStopAuthoritative
Any sockets or host/service resolvers associated with this interface will be errored with KErrConnect...
Definition es_sock.h:1189

RConnection::EStopNormal
@ EStopNormal
Any sockets or host/service resolvers associated with this interface will be errored with KErrCancel.
Definition es_sock.h:1183

RConnection::GetBoolSetting
IMPORT_C TInt GetBoolSetting(const TDesC &aSettingName, TBool &aValue)

RConnection::Attach
IMPORT_C TInt Attach(const TDesC8 &aConnectionInfo, TConnAttachType aAttachType)
Attaches the RConnection object to an existing interface.

RConnection::Progress
IMPORT_C TInt Progress(TNifProgress &aProgress)
Obtains the current progress information for the connection.

RConnection::EnumerateConnections
IMPORT_C TInt EnumerateConnections(TUint &aCount)
Enumerates the number of currently active interfaces.

RConnection::DataSentNotificationRequest
IMPORT_C void DataSentNotificationRequest(TUint aThreshold, TPckg< TUint > &aUplinkVolume, TRequestStatus &aStatus)
Requests a notification after an additional aThreshold bytes have been sent by the entire connection.

RConnection::AllInterfaceNotification
IMPORT_C void AllInterfaceNotification(TDes8 &aNotification, TRequestStatus &aStatus)
Requests asynchronous change notification for all interfaces.

RConnection::LastProgressError
IMPORT_C TInt LastProgressError(TNifProgress &aProgress)
Obtains information about the last Progress() call which failed with an error.

RConnection::ProgressNotification
IMPORT_C void ProgressNotification(TNifProgressBuf &aProgress, TRequestStatus &aStatus, TUint aSelectedProgress=KConnProgressDefault)
Requests asynchronous progress notification for the connection.

RConnection::DataReceivedNotificationCancel
IMPORT_C void DataReceivedNotificationCancel()
Cancels a request (issued by DataReceivedNotificationRequest ()) for the amount of data received by t...

RConnection::Control
IMPORT_C TInt Control(TUint aOptionLevel, TUint aOptionName, TDes8 &aOption)
Gets detailed information on connection clients and sockets.

RConnection::CancelProgressNotification
IMPORT_C void CancelProgressNotification()
Cancels a request for progress notification for the connection, as issued by ProgressNotification().

RConnection::DataTransferredRequest
IMPORT_C void DataTransferredRequest(TPckg< TUint > &aUplinkVolume, TPckg< TUint > &aDownlinkVolume, TRequestStatus &aStatus)
Gets the amount of data that has been transferred by the entire connection.

RConnection::GetDesSetting
IMPORT_C TInt GetDesSetting(const TDesC &aSettingName, TDes8 &aValue)

RConnection::Name
IMPORT_C TInt Name(TName &aName)
Gets the unique name of an RConnection.

RConnection::IsConnectionActiveRequest
IMPORT_C void IsConnectionActiveRequest(TUint aSecs, TPckg< TBool > &aState, TRequestStatus &aStatus)
Checks whether the connection is active or inactive.

RConnection::SetParameters
IMPORT_C TInt SetParameters(ESock::CCommsDataObjectBase &aDataObject)
Speculative method - Not yet supported Do not call this function, it has ony been introduced for symm...

RConnection::SetOpt
IMPORT_C TInt SetOpt(TUint aOptionLevel, TUint aOptionName, TInt aOption=0)
Sets an option.

RConnection::~RConnection
virtual IMPORT_C ~RConnection()
Empty destructor.

RConnection::GetSubConnectionInfo
IMPORT_C TInt GetSubConnectionInfo(TDes8 &aSubConnectionInfo)
Gets information about one of the currently active subconnections.

RConnection::IsConnectionActiveCancel
IMPORT_C void IsConnectionActiveCancel()

RConnection::CancelIoctl
IMPORT_C void CancelIoctl()
Cancel any outstanding Ioctl request.

RConnection::TConnAttachType
TConnAttachType
Identifies the intended use of the connection.
Definition es_sock.h:1168

RConnection::EAttachTypeMonitor
@ EAttachTypeMonitor
The system control type of application wishes to monitor the state of the connection without otherwis...
Definition es_sock.h:1175

RConnection::EAttachTypeNormal
@ EAttachTypeNormal
The application wishes to use the connection for normal data transfer, and the idle timers will take ...
Definition es_sock.h:1171

RConnection::GetParameters
IMPORT_C TInt GetParameters(ESock::CCommsDataObjectBase &aDataObject)

RConnection::Start
IMPORT_C TInt Start()
Start a connection synchonously using the default connection preferences.

RHostResolver
Provides an interface to host name resolution services, such as DNS, that may be provided by particul...
Definition es_sock.h:1001

RHostResolver::GetByAddress
IMPORT_C void GetByAddress(const TSockAddr &anAddr, TNameEntry &aResult, TRequestStatus &aStatus)
Get host by address (as get by name)

RHostResolver::Close
IMPORT_C void Close()
Closes a name resolution service.

RHostResolver::Cancel
IMPORT_C void Cancel()
Cancels any outstanding asynchronous calls, which will return with error code KErrCancel.

RHostResolver::QueryGetNext
IMPORT_C void QueryGetNext(TDes8 &aResult, TRequestStatus &aStatus)
Get the next query result.

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

RHostResolver::Open
IMPORT_C TInt Open(RSocketServ &aSocketServer, TUint anAddrFamily, TUint aProtocol)
Initialises a name resolution service provided by a particular protocol.

RHostResolver::Query
IMPORT_C void Query(const TDesC8 &aQuery, TDes8 &aResult, TRequestStatus &aStatus)
Protocol - independent query.

RHostResolver::SetHostName
IMPORT_C TInt SetHostName(const TDesC &aName)

RHostResolver::GetHostName
IMPORT_C TInt GetHostName(TDes &aName)
Gets the name of the local host.

RHostResolver::GetByName
IMPORT_C void GetByName(const TDesC &aName, TNameEntry &aResult, TRequestStatus &aStatus)
Resolves a machine name to a TSockAddress asynchronously.

RHostResolver::Next
IMPORT_C void Next(TNameEntry &aResult, TRequestStatus &aStatus)
Get the next response if there is more than one response for a given host name (alias list)

RNetDatabase
Provides an interface to network databases, such as LM-IAS with IrDA, that may be provided by particu...
Definition es_sock.h:1077

RNetDatabase::Remove
IMPORT_C void Remove(const TDesC8 &anItem, TRequestStatus &aStat)
Removes a record from the database asynchronously.

RNetDatabase::Close
IMPORT_C void Close()
Closes a database access service.

RNetDatabase::Query
IMPORT_C void Query(const TDesC8 &aQuery, TDes8 &aResult, TRequestStatus &aStat)
Makes a query to the database asynchronously.

RNetDatabase::Open
IMPORT_C TInt Open(RSocketServ &aSocketServer, TUint anAddrFamily, TUint aProtocol)
Initialises a database access service provided by a particular protocol.

RNetDatabase::Cancel
IMPORT_C void Cancel()
Cancels any outstanding asynchronous calls, which will return with error code KErrCancel.

RNetDatabase::Add
IMPORT_C void Add(const TDesC8 &anItem, TRequestStatus &aStat)
Adds a record to the database asynchronously.

RServiceResolver
Provides an interface to resolver service names and ports.
Definition es_sock.h:1042

RServiceResolver::GetByNumber
IMPORT_C void GetByNumber(const TUint aPort, TDes &aName, TRequestStatus &aStatus)
Gets the name of the service asynchronously.

RServiceResolver::Cancel
IMPORT_C void Cancel()
Cancels any pending request.

RServiceResolver::RemoveService
IMPORT_C void RemoveService(const TDesC &aName, const TUint &aPort, TRequestStatus &aStatus)
Removes a service asynchronously.

RServiceResolver::Open
IMPORT_C TInt Open(RSocketServ &aSocketServer, TUint anAddrFamily, TUint sockType, TUint aProtocol)
set up the sub session - unlike name resolvers and net databases, services can be socket type specifi...

RServiceResolver::Close
IMPORT_C void Close()
Closes a service resolver service.

RServiceResolver::GetByName
IMPORT_C void GetByName(const TDesC &aName, TPortNum &aPort, TRequestStatus &aStatus)
Gets a service by name asynchronously.

RServiceResolver::RegisterService
IMPORT_C void RegisterService(const TDesC &aName, const TUint &aPort, TRequestStatus &aStatus)
Registers a new service asynchronously.

RSessionBase
Client-side handle to a session with a server.
Definition e32std.h:4611

RSocketServ
Provides the Connect() function to create an IPC communication channel to the socket server.
Definition es_sock.h:800

RSocketServ::SetExclusiveMode
IMPORT_C void SetExclusiveMode(TRequestStatus &aStatus)
Set this session as the socket server exclusive session.

RSocketServ::__DbgCheckHeap
IMPORT_C TInt __DbgCheckHeap(TInt aCount)
Set a heap mark in the socket server.

RSocketServ::Version
IMPORT_C TVersion Version() const
Gets the version number of this client.

RSocketServ::__DbgControl
IMPORT_C TInt __DbgControl(const ESockDebug::TControlMsg &aRequestMsg)
General purpose control message for esock debug, self dispatching messages to be thrown over it.

RSocketServ::__DbgMbufFreeSpace
IMPORT_C TInt __DbgMbufFreeSpace()
Get the amount of free space in the MBuf manager.

RSocketServ::__DbgCheckMbuf
IMPORT_C TInt __DbgCheckMbuf(TInt asize)
Set the Mbuf pool limit.

RSocketServ::RSocketServ
IMPORT_C RSocketServ()
Default Constructor.

RSocketServ::__DbgSetMbufPoolLimit
IMPORT_C TInt __DbgSetMbufPoolLimit(TInt asize)
Set the Mbuf pool limit.

RSocketServ::__DbgMbufTotalSpace
IMPORT_C TInt __DbgMbufTotalSpace()
Get the amount of free space in the MBuf manager.

RSocketServ::ClearExclusiveMode
IMPORT_C void ClearExclusiveMode()
Clear exclusive mode for this session PLEASE NOTE: This API is currently unsupported,...

RSocketServ::StopProtocol
IMPORT_C void StopProtocol(TUint anAddrFamily, TUint aSockType, TUint aProtocol, TRequestStatus &aStatus)
Unload a protocol asynchronously - note it will fail if there are any resources open.

RSocketServ::__DbgMarkHeap
IMPORT_C TInt __DbgMarkHeap()
Set a heap mark in the socket server.

RSocketServ::FindProtocol
IMPORT_C TInt FindProtocol(const TProtocolName &aName, TProtocolDesc &aProtocol)
Gets information about a specific protocol, identified by it's name.

RSocketServ::__DbgMarkEnd
IMPORT_C TInt __DbgMarkEnd(TInt aCount)
Set a heap mark in the socket server.

RSocketServ::Connect
IMPORT_C TInt Connect(TUint aMessageSlots=(TUint) -1)
Opens a session to the socket server.

RSocketServ::InstallExtension
IMPORT_C TInt InstallExtension(const TDesC &aDllName, const TDesC &aArgs=TPtrC())
Install an Esock Extension.

RSocketServ::__DbgFailNextMbuf
IMPORT_C TInt __DbgFailNextMbuf(TInt aCount)
Set a Mbuf mark in the socket server.

RSocketServ::NumProtocols
IMPORT_C TInt NumProtocols(TUint &aCount)
Gets the number of protocols the socket server is currently aware of.

RSocketServ::GetProtocolInfo
IMPORT_C TInt GetProtocolInfo(TUint anIndex, TProtocolDesc &aProtocol)
Gets information about a specific protocol.

RSocketServ::__DbgFailNext
IMPORT_C TInt __DbgFailNext(TInt aCount)
Set a heap mark in the socket server.

RSocketServ::__DbgCheckFailNext
IMPORT_C TBool __DbgCheckFailNext() const
Empty release implementation.

RSocketServ::StartProtocol
IMPORT_C void StartProtocol(TUint anAddrFamily, TUint aSockType, TUint aProtocol, TRequestStatus &aStatus)
Loads a specified protocol asynchronously.

RSocket
Provides a client endpoint to a protocol.
Definition es_sock.h:855

RSocket::GetDisconnectData
IMPORT_C TInt GetDisconnectData(TDes8 &aDesc)
Gets data for use in the disconnection of a socket, namely the remote name of the connected socket.

RSocket::CancelSend
IMPORT_C void CancelSend()
Cancels an outstanding Send() operation.

RSocket::GetOpt
IMPORT_C TInt GetOpt(TUint anOptionName, TUint anOptionLevel, TDes8 &anOption)
Gets a socket option.

RSocket::Bind
IMPORT_C TInt Bind(TSockAddr &anAddr)
Sets the local address of a socket.

RSocket::CancelRecv
IMPORT_C void CancelRecv()
Cancels an outstanding Recv() operation.

RSocket::Shutdown
IMPORT_C void Shutdown(TShutdown aHow, TRequestStatus &aStatus)
Shuts down a connected socket - asynchronous.

RSocket::RemoteName
IMPORT_C void RemoteName(TSockAddr &anAddr)
Gets the remote name of a connected socket.

RSocket::Recv
IMPORT_C void Recv(TDes8 &aDesc, TUint flags, TRequestStatus &aStatus)
Receives data from a remote host, allowing flags for protocol specific information.

RSocket::Close
IMPORT_C void Close()
Closes a socket.

RSocket::SetOpt
IMPORT_C TInt SetOpt(TUint anOptionName, TUint anOptionLevel, const TDesC8 &anOption=TPtrC8(NULL, 0))
Sets a socket option.

RSocket::Write
IMPORT_C void Write(const TDesC8 &aDesc, TRequestStatus &aStatus)
Sends data to a remote host.

RSocket::Open
IMPORT_C TInt Open(RSocketServ &aServer, TUint addrFamily, TUint sockType, TUint protocol)
Opens an implicit socket by creating a new subsession to the socket server.

RSocket::RecvFrom
IMPORT_C void RecvFrom(TDes8 &aDesc, TSockAddr &anAddr, TUint flags, TRequestStatus &aStatus)
Receives data from a remote host through a (possibly) unconnected socket and returns a source address...

RSocket::CancelAll
IMPORT_C void CancelAll()
Cancels all outstanding operations.

RSocket::Ioctl
IMPORT_C void Ioctl(TUint aCommand, TRequestStatus &aStatus, TDes8 *aDesc=NULL, TUint aLevel=KLevelUnspecified)
Applies an asynchronous I/O control operation on a socket.

RSocket::Connect
IMPORT_C void Connect(TSockAddr &anAddr, TRequestStatus &aStatus)
Connects to a remote host asynchronously.

RSocket::Transfer
IMPORT_C TInt Transfer(RSocketServ &aServer, const TDesC &aName)
Transfers a socket from one socket server session to another.

RSocket::LocalName
IMPORT_C void LocalName(TSockAddr &anAddr)
Gets the local address of a bound socket.

RSocket::CancelConnect
IMPORT_C void CancelConnect()
Cancels an outstanding connect operation.

RSocket::Info
IMPORT_C TInt Info(TProtocolDesc &aProtocol)
Gets information in the protocol description for the protocol which a socket is opened on.

RSocket::CancelWrite
IMPORT_C void CancelWrite()
Cancels an outstanding Write() operation.

RSocket::RSocket
IMPORT_C RSocket()
Default Constructor.

RSocket::LocalPort
IMPORT_C TUint LocalPort()
Gets the local port number of a bound socket.

RSocket::TShutdown
TShutdown
Argument to RSocket::Shutdown() specifying how abruptly the shutdown occurs.
Definition es_sock.h:861

RSocket::EStopInput
@ EStopInput
Stop socket input and complete when output is stopped.
Definition es_sock.h:865

RSocket::EImmediate
@ EImmediate
Stop socket input/output and complete (abortive close).
Definition es_sock.h:869

RSocket::ENormal
@ ENormal
Complete when socket output/input stopped.
Definition es_sock.h:863

RSocket::EStopOutput
@ EStopOutput
Stop socket output and complete when input is stopped.
Definition es_sock.h:867

RSocket::RecvOneOrMore
IMPORT_C void RecvOneOrMore(TDes8 &aDesc, TUint flags, TRequestStatus &aStatus, TSockXfrLength &aLen)
Receives data from a remote host and completes when data is available.

RSocket::CancelRead
IMPORT_C void CancelRead()
Cancels an outstanding Read() operation.

RSocket::Accept
IMPORT_C void Accept(RSocket &aBlankSocket, TRequestStatus &aStatus)
Facilitates a client/server connection from a remote socket.

RSocket::SendTo
IMPORT_C void SendTo(const TDesC8 &aDesc, TSockAddr &anAddr, TUint flags, TRequestStatus &aStatus)
Sends data to a remote host through a (possibly) unconnected socket to a specified destination addres...

RSocket::Read
IMPORT_C void Read(TDes8 &aDesc, TRequestStatus &aStatus)
Receives data from a remote host.

RSocket::CancelAccept
IMPORT_C void CancelAccept()
Cancels an outstanding accept operation.

RSocket::SetLocalPort
IMPORT_C TInt SetLocalPort(TInt aPort)
Sets the local port of a socket.

RSocket::Send
IMPORT_C void Send(const TDesC8 &aDesc, TUint someFlags, TRequestStatus &aStatus)
Sends data to a remote host on a connected socket with options set by protocol specific flags.

RSocket::Name
IMPORT_C TInt Name(TName &aName)
Gets a unique system name for the socket.

RSocket::CancelIoctl
IMPORT_C void CancelIoctl()
Cancels an outstanding Ioctl() operation.

RSocket::Listen
IMPORT_C TInt Listen(TUint qSize)
Sets up a socket to listen for incoming connections.

RSubConParameterBundle
Container for (bundle of) SubConnection parameter families.
Definition es_sock.h:1473

RSubConParameterBundle::AddFamilyL
IMPORT_C void AddFamilyL(CSubConParameterFamily *aFamily)
Add a sub-connection parameter family to the bundle.

RSubConParameterBundle::Close
IMPORT_C void Close()
Close the parameter bundle handle.

RSubConParameterBundle::CopyFromFamilyBundleL
void CopyFromFamilyBundleL(RParameterFamilyBundle &aSrc)
Copy the contents of an RParameterFamilyBundle to this RSubConParameterBundle.

RSubConParameterBundle::Load
IMPORT_C TInt Load(const TDesC8 &aDes)
Instructs this sub-connection bundle to set its members based on the serialiesd data in the buffer pa...

RSubConParameterBundle::CheckBundle
TInt CheckBundle() const
Check to see if the handle has a heap object.

RSubConParameterBundle::RSubConParameterBundle
IMPORT_C RSubConParameterBundle()
Empty sub-connection parameter bundle constructor.

RSubConParameterBundle::FindFamily
IMPORT_C CSubConParameterFamily * FindFamily(TUint32 aFamilyId)
Search the sub-connection parameter bundle for a parameter family.

RSubConParameterBundle::Store
IMPORT_C TInt Store(TDes8 &aDes) const
Instructs this sub-connection parameter bundle to create a serilised version of itself and append it ...

RSubConParameterBundle::Length
IMPORT_C TUint Length() const
Calculates the length of buffer required to serialise this parameter set bundle.

RSubConParameterBundle::CopyToFamilyBundleL
void CopyToFamilyBundleL(RParameterFamilyBundle &aDest) const
Copy the contents of this parameter bundle to a RParameterFamilyBundle.

RSubConParameterBundle::ClearAllParameters
IMPORT_C void ClearAllParameters(CSubConParameterFamily::TParameterSetType aType)
Clears (removes and deletes) all parameter sets with the type specified (delegated to the families)

RSubConnection
A Sub-Connection, a channel within a Connection.
Definition es_sock.h:1579

RSubConnection::CancelEventNotification
IMPORT_C void CancelEventNotification()
Cancel an outstanding Event Notification request.

RSubConnection::SetParameters
IMPORT_C TInt SetParameters(const RSubConParameterBundle &aParametersSet)
Set Parameters of the sub-connection.

RSubConnection::Control
IMPORT_C TInt Control(TUint aOptionLevel, TUint aOptionName, TDes8 &aOption)

RSubConnection::GetParameters
IMPORT_C TInt GetParameters(RSubConParameterBundle &aParametersSet)
Fetch the sub-connection's current parameters (Requested, Acceptable and Granted)

RSubConnection::EventNotification
IMPORT_C void EventNotification(TNotificationEventBuf &aEventBuffer, TBool aGenericEventsOnly, TRequestStatus &aStatus)
Requests asynchronous event notification for the sub-connection.

RSubConnection::Close
IMPORT_C void Close()
Closes the sub-connection.

RSubConnection::Start
IMPORT_C TInt Start()
Unused.

RSubConnection::Stop
IMPORT_C TInt Stop()
Unused.

RSubConnection::Add
IMPORT_C void Add(RSocket &aSocket, TRequestStatus &aStatus)
Associate a socket with a subconnection.

RSubConnection::Open
IMPORT_C TInt Open(RSocketServ &aServer, TSubConnType aSubConnType, RConnection &aConnection)
Opens a new RSubConnection instance.

RSubConnection::RSubConnection
IMPORT_C RSubConnection()
Empty sub-connection handle constructor.

RSubConnection::Remove
IMPORT_C void Remove(RSocket &aSocket, TRequestStatus &aStatus)
Remove a socket from a subconnection.

RSubConnection::TSubConnType
TSubConnType
Definition es_sock.h:1584

RSubConnection::ECreateNew
@ ECreateNew
Definition es_sock.h:1586

RSubConnection::EWaitIncoming
@ EWaitIncoming
Definition es_sock.h:1587

RSubConnection::EAttachToDefault
@ EAttachToDefault
Definition es_sock.h:1585

RSubConnection::SameSession
TBool SameSession(TInt aSessionHandle)
Checks that the Session Handle passed is the same as that of this RSubConnection.

RSubSessionBase
Client-side handle to a sub-session.
Definition e32std.h:4727

TAccessPointInfo
Stores Access Point information.
Definition es_sock.h:1696

TAccessPointInfo::SetAccessPoint
void SetAccessPoint(TUint aAccessPoint)
Sets the 32-bit long integer ID of the access point.

TAccessPointInfo::operator==
TBool operator==(const TAccessPointInfo &aRhs) const
Compares the 32-bit long integer ID of the specified object with our own.

TAccessPointInfo::AccessPoint
TUint AccessPoint() const
Returns the 32-bit long integer ID of the access point.

TBuf< KMaxName >

TNameRecord
Contains the results of name queries.
Definition es_sock.h:940

TNameRecord::EPartial
@ EPartial
Indicates a partial (truncated) host name.
Definition es_sock.h:947

TNameRecord::EAlias
@ EAlias
Definition es_sock.h:946

TNameRecord::iName
THostName iName
A host name.
Definition es_sock.h:953

TNameRecord::TNameRecord
TNameRecord()
Trivial C++ constructor.

TNameRecord::iFlags
TInt iFlags
Flags indicating some attribute about the name, i.e.
Definition es_sock.h:959

TNameRecord::iAddr
TSockAddr iAddr
An address.
Definition es_sock.h:957

TNifAgentInfo
Contains information describing an agent.
Definition es_sock.h:190

TNifAgentInfo::iVersion
TVersion iVersion
This class Contains version information.
Definition es_sock.h:193

TNifAgentInfo::iName
TName iName
This class Defines a modifiable buffer descriptor that can contain the name of a reference counting o...
Definition es_sock.h:196

TNifProgress
Contains progress information on a dial-up connection.
Definition es_sock.h:173

TNifProgress::TNifProgress
TNifProgress()
It sets the iStage data member to 0 and the iError data member to KErrNone.

TNifProgress::iStage
TInt iStage
Definition es_sock.h:178

TNifProgress::iError
TInt iError
Definition es_sock.h:179

TNifProgress::operator==
TBool operator==(const TNifProgress &aRHS) const

TNotificationEventBuf
Buffer for Sub-connection event notiifcation.
Definition es_sock.h:1517

TNotificationEventBuf::Id
IMPORT_C TUint32 Id() const
Provides the sub-type Id of the event.

TNotificationEventBuf::GroupId
IMPORT_C TInt32 GroupId() const
Provides the group id (Uid) of the event.

TNotificationEventBuf::IsGeneric
IMPORT_C TBool IsGeneric() const
Check whether an event is a generic event (not an extension)

TNotificationEventBuf::TNotificationEventBuf
IMPORT_C TNotificationEventBuf()

TNotificationEventBuf::~TNotificationEventBuf
IMPORT_C ~TNotificationEventBuf()

TPckgBuf
Packages an object into a modifiable buffer descriptor.
Definition e32cmn.h:1807

TPckg
Packages a modifiable pointer descriptor which represents an object of specific type.
Definition e32cmn.h:1778

TRequestStatus
Indicates the completion status of a request made to a service provider.
Definition e32cmn.h:2243

TSessionPref
Hint to the Socket Server on what will be the principal usage of the connection.
Definition es_sock.h:145

TSessionPref::iAddrFamily
TUint iAddrFamily
The protocol's address family.
Definition es_sock.h:150

TSessionPref::iProtocol
TUint iProtocol
The protocol type.
Definition es_sock.h:152

TSessionPref::iReserved3
TUint iReserved3
Reserved.
Definition es_sock.h:160

TSessionPref::iReserved
TUint iReserved
Reserved.
Definition es_sock.h:154

TSessionPref::TSessionPref
IMPORT_C TSessionPref()
Default Constructor, makes sure that member data doesn't contain unnitialised values.

TSessionPref::iReserved4
TUint iReserved4
Reserved.
Definition es_sock.h:162

TSessionPref::iReserved1
TUint iReserved1
Reserved.
Definition es_sock.h:156

TSessionPref::iReserved2
TUint iReserved2
Reserved.
Definition es_sock.h:158

TSockAddr
Represents an end point address.
Definition es_sock.h:258

TSockAddr::SetPort
IMPORT_C void SetPort(TUint aPort)
Sets the address port of an address.

TSockAddr::TSockAddr
IMPORT_C TSockAddr()
Default constructor initialises the address to be zero-filled.

TSockAddr::SetFamily
IMPORT_C void SetFamily(TUint aFamily)
Sets the address family of an address.

TSockAddr::Family
IMPORT_C TUint Family() const
Gets the address family and thereby the type of address.

TSockAddr::Port
IMPORT_C TUint Port() const
Gets the port value.

TSockAddr::SetUserLen
IMPORT_C void SetUserLen(TInt aLen)
Sets the length of data it appends after the base class' data.

TSockAddr::GetUserLen
IMPORT_C TInt GetUserLen()
Gets the number of bytes a derived class has set beyond the SSockAddr part of the address.

TSockAddr::UserPtr
TUint8 * UserPtr() const
Gets an offset to place data after the base class data.

TSockAddr::CmpPort
IMPORT_C TBool CmpPort(const TSockAddr &anAddr) const
Compare two ports.

TSubConnOpen
Definition es_sock.h:1550

TSubConnOpen::TSubConnType
TSubConnType
Defines the type of a subconnection.
Definition es_sock.h:1554

TSubConnOpen::EWaitForIncoming
@ EWaitForIncoming
Definition es_sock.h:1559

TSubConnOpen::ECreateNew
@ ECreateNew
Definition es_sock.h:1556

TSubConnOpen::EAttachToDefault
@ EAttachToDefault
Definition es_sock.h:1555

TSubConnOpen::iReserved
TInt iReserved
Definition es_sock.h:1564

TSubConnOpen::iType
TSubConnType iType
Definition es_sock.h:1562

TSubConnOpen::iHandle
TInt iHandle
Definition es_sock.h:1563

TUid
A globally unique 32-bit number.
Definition e32cmn.h:1959

TVersion
Contains version information.
Definition e32cmn.h:2200

e32base.h

NONSHARABLE_CLASS
NONSHARABLE_CLASS(TCleanupTrapHandler)
Implementation for a handler to work with the TRAP mechanism.
Definition e32base.h:1453

TDes
TDes8 TDes
Defines a build-independent modifiable descriptor.
Definition e32cmn.h:1387

TPtrC
TPtrC8 TPtrC
Defines a build-independent non-modifiable pointer descriptor.
Definition e32cmn.h:1366

TDesC
TDesC8 TDesC
Defines a build-independent non-modifiable descriptor.
Definition e32cmn.h:1345

_LIT8
_LIT8(SOCKET_SERVER_MAIN_MODULE_NAME, "ESock_Main")
Canonical names for the core ESOCKSVR modules.

KSIDatagram
const TUint KSIDatagram
The same as message based.
Definition es_sock.h:506

KSOUrgentDataOffset
const TUint KSOUrgentDataOffset
Getting only: retrieve the urgent data offset (only for stream protocols that support urgent data).
Definition es_sock.h:373

KNSDynamicAddressing
const TUint KNSDynamicAddressing
Addressing is dynamic - i.e.
Definition es_sock.h:575

TSockXfrLength
TPckgBuf< TInt > TSockXfrLength
Used in RSocket read and write calls to pass the length of data read and written.
Definition es_sock.h:756

KSOSelectPoll
const TUint KSOSelectPoll
Getting only: gets a bitmask of flags describing the read/write/exception status of the socket.
Definition es_sock.h:366

KIOctlSelect
const TUint KIOctlSelect
The aDesc parameter of RSocket::Ioctl() specifies a TUint containing a bitmask of Socket status const...
Definition es_sock.h:422

KSONonBlockingIO
const TUint KSONonBlockingIO
Socket nonblocking mode.
Definition es_sock.h:356

KSIPeekData
const TUint KSIPeekData
Protocol supports peeking (looking at the data without removing it from the protocol).
Definition es_sock.h:533

KNSReserved
const TUint KNSReserved
Definition es_sock.h:588

KSIMessageBased
const TUint KSIMessageBased
The protocol is message based.
Definition es_sock.h:504

KSIGracefulClose
const TUint KSIGracefulClose
The protocol supports graceful close.
Definition es_sock.h:528

KSIDisconnectData
const TUint KSIDisconnectData
The protocol can send user data on a disconnect request.
Definition es_sock.h:516

KSIMultiPoint
const TUint KSIMultiPoint
The protocol supports point to multi-point connections.
Definition es_sock.h:520

KSockSelectWrite
const TUint KSockSelectWrite
Writing to the socket is not currently blocked by flow-control.
Definition es_sock.h:434

KSockSelectReadContinuation
const TUint KSockSelectReadContinuation
Include tail of prior read datagram as available data (ie indicates next read will be with read conti...
Definition es_sock.h:438

KConnProgressDefault
const TUint KConnProgressDefault
Definition es_sock.h:134

KSOSendBuf
const TUint KSOSendBuf
Socket send buffer size.
Definition es_sock.h:349

KSIPseudoStream
const TUint KSIPseudoStream
The protocol supports a stream like interface but maintains datagram boundaries.
Definition es_sock.h:510

KSocketInternalOptionBit
const TUint KSocketInternalOptionBit
Definition es_sock.h:410

KSocketNoSecurity
const TUint KSocketNoSecurity
No security.
Definition es_sock.h:599

KSIQOS
const TUint KSIQOS
The protocol supports a quality of service metric.
Definition es_sock.h:522

KUndefinedProtocol
const TUint KUndefinedProtocol
Undefined socket type.
Definition es_sock.h:638

KMaxSockAddrSize
const TUint KMaxSockAddrSize
Maximum sockets address size.
Definition es_sock.h:234

KSIReliable
const TUint KSIReliable
The protocol is reliable.
Definition es_sock.h:500

KSocketBufSizeUndefined
const TInt KSocketBufSizeUndefined
Use default buffer size.
Definition es_sock.h:405

KSocketMessageSizeUndefined
const TInt KSocketMessageSizeUndefined
Depends on lower layer or is dynamic.
Definition es_sock.h:616

THostName
TBuf< 0x100 > THostName
Defines a descriptor to hold a host name string.
Definition es_sock.h:658

KSIRequiresOwnerInfo
const TUint KSIRequiresOwnerInfo
Protocol is to be informed of the identity of the client (i.e.
Definition es_sock.h:538

KNSNameRegistration
const TUint KNSNameRegistration
Protocol supports additions to the name database.
Definition es_sock.h:570

KSODisableTransfer
const TUint KSODisableTransfer
Setting only.
Definition es_sock.h:400

KMaxSubConnectionEventSize
const TUint KMaxSubConnectionEventSize
Size of Maximum SubConnection event.
Definition es_sock.h:108

KSubConGlobalFamily
const TUint32 KSubConGlobalFamily
Definition es_sock.h:1365

KNSInfoDatabase
const TUint KNSInfoDatabase
Protocol has another database which is defined by the protocol.
Definition es_sock.h:577

KUndefinedSockType
const TUint KUndefinedSockType
Undefined socket type.
Definition es_sock.h:629

KSIStreamBased
const TUint KSIStreamBased
The protocol is stream based.
Definition es_sock.h:508

KNSHierarchicalNaming
const TUint KNSHierarchicalNaming
Network naming is hierarchical.
Definition es_sock.h:560

KSocketMessageSizeIsStream
const TInt KSocketMessageSizeIsStream
Reads and writes can be of any size: the data is treated as a stream.
Definition es_sock.h:614

KLevelUnspecified
const TInt KLevelUnspecified
Unspecified level.
Definition es_sock.h:310

TServiceName
TBuf< 0x20 > TServiceName
Defines a descriptor to hold a service name string.
Definition es_sock.h:656

KNSRemoteDiscovery
const TUint KNSRemoteDiscovery
Addressing is dynamic and should be attempted every time before connecting (like IrDA).
Definition es_sock.h:565

KNSNameResolution
const TUint KNSNameResolution
Protocol supports resolving human readable entity names into network addresses (like DNS).
Definition es_sock.h:558

KErrCannotFindProtocol
const TInt KErrCannotFindProtocol
Definition es_sock.h:732

KSubConQoSFamily
const TUint32 KSubConQoSFamily
Definition es_sock.h:1366

KErrConnectionTerminated
const TInt KErrConnectionTerminated
socket errors
Definition es_sock.h:730

KErrWouldBlock
const TInt KErrWouldBlock
This error is returned from operations on non-blocking sockets that cannot be completed immediately,...
Definition es_sock.h:718

KSubConIPAddressInfoFamily
const TUint32 KSubConIPAddressInfoFamily
Definition es_sock.h:1371

KSIReadOnly
const TUint KSIReadOnly
The protocol is read only.
Definition es_sock.h:526

KSIReserved
const TUint KSIReserved
Definition es_sock.h:544

KSocketInternalReadBit
const TUint KSocketInternalReadBit
Must not be set for client requests.
Definition es_sock.h:466

KSockSeqPacket
const TUint KSockSeqPacket
Datagrams with sequence numbers.
Definition es_sock.h:295

TPortNum
TPckgBuf< TInt > TPortNum
Port number on service.
Definition es_sock.h:1033

TNameEntry
TPckgBuf< TNameRecord > TNameEntry
Packages the TNameRecord class so that it can be passed between a client and the socket server.
Definition es_sock.h:969

KSockReadPeek
const TUint KSockReadPeek
Read data without consuming it, data remains in the receive queue.
Definition es_sock.h:464

KSocketDefaultBufferSize
const TInt KSocketDefaultBufferSize
Default buffer size.
Definition es_sock.h:407

KProtocolExtensionFamily
const TInt32 KProtocolExtensionFamily
Definition es_sock.h:1373

KAFUnspec
const TUint KAFUnspec
Default (unspecified) protocol module.
Definition es_sock.h:282

TSubConnectionUniqueId
TUint TSubConnectionUniqueId
SubConnection Unique Id.
Definition es_sock.h:119

KSORecvBuf
const TUint KSORecvBuf
Socket receive buffer size.
Definition es_sock.h:343

KESockDefaultMessageSlots
const TUint KESockDefaultMessageSlots
Default number of message slots.
Definition es_sock.h:95

KSubConnGenericEventsImplUid
const TInt32 KSubConnGenericEventsImplUid
Definition es_sock.h:1363

KSockWriteSystemMask
const TUint KSockWriteSystemMask
The top 8 bits are reserved for system purposes; protocols must not define these bits.
Definition es_sock.h:453

KErrTierNotFound
const TInt KErrTierNotFound
Definition es_sock.h:733

KSecureSockets
const TUint KSecureSockets
Secure Sockets Layer.
Definition es_sock.h:603

KSOBlockingIO
const TUint KSOBlockingIO
Socket blocking mode.
Definition es_sock.h:362

TSubConnectionNotificationBuf
TBuf8< KMaxSubConnectionEventSize > TSubConnectionNotificationBuf
Buffer for notification of any change in the state of SubConnection.
Definition es_sock.h:130

KSOSelectLastError
const TUint KSOSelectLastError
Getting only: retrieves the last error.
Definition es_sock.h:379

KSubConnGenericParamsImplUid
const TInt32 KSubConnGenericParamsImplUid
Definition es_sock.h:1362

KConnectionUp
const TUint KConnectionUp
Progress Notification to inform clients Connection is up This event has the same numerical values as ...
Definition es_sock.h:73

KSIUrgentData
const TUint KSIUrgentData
The protocol offers an expedited data service.
Definition es_sock.h:512

KNSRequiresConnectionStartup
const TUint KNSRequiresConnectionStartup
Protocol may request Socket Server to startup a connection on its behalf (via the KErrCompletion erro...
Definition es_sock.h:582

KSIBroadcast
const TUint KSIBroadcast
The protocol supports broadcast addresses.
Definition es_sock.h:518

KSockWriteUrgent
const TUint KSockWriteUrgent
The data to be sent is urgent and is given a higher priority than ordinary data in the send queue.
Definition es_sock.h:449

KSubConAuthorisationFamily
const TUint32 KSubConAuthorisationFamily
Definition es_sock.h:1367

KSubConnParamsInterfaceUid
const TInt32 KSubConnParamsInterfaceUid
Definition es_sock.h:1359

KNSHeirarchicalNaming
const TUint KNSHeirarchicalNaming
Definition es_sock.h:562

KSOReadBytesPending
const TUint KSOReadBytesPending
Getting only: retrieve the number of bytes currently available for reading.
Definition es_sock.h:369

KSockSelectExcept
const TUint KSockSelectExcept
An error has occurred.
Definition es_sock.h:436

KNotificationEventMaxSize
const TInt KNotificationEventMaxSize
Definition es_sock.h:1508

KSockSelectRead
const TUint KSockSelectRead
Data is available to be read; for listening sockets, a connect is pending.
Definition es_sock.h:432

TByteOrder
TByteOrder
Used in structure TProtocolDesc to describes the endianness of a protocol.
Definition es_sock.h:478

EOtherByteOrder
@ EOtherByteOrder
Other byte order.
Definition es_sock.h:484

ELittleEndian
@ ELittleEndian
Little endian.
Definition es_sock.h:482

EBigEndian
@ EBigEndian
Big endian.
Definition es_sock.h:480

KSocketInternalWriteBit
const TUint KSocketInternalWriteBit
Must not be set for client requests.
Definition es_sock.h:451

KSOLSocket
const TInt KSOLSocket
Generic socket options/commands.
Definition es_sock.h:308

KSICanReconnect
const TUint KSICanReconnect
The same socket can be reconnected if it disconnects (for whatever reason).
Definition es_sock.h:530

KFlowParametersFamily
const TInt32 KFlowParametersFamily
Definition es_sock.h:1374

KNSServiceResolution
const TUint KNSServiceResolution
Protocol supports service name to port number resolution.
Definition es_sock.h:568

TProtocolName
TBuf< 0x20 > TProtocolName
Contains the name of a protocol in structure TProtocolDesc.
Definition es_sock.h:654

KSIWriteOnly
const TUint KSIWriteOnly
The protocol is write only.
Definition es_sock.h:524

KErrProtocolNotReady
const TInt KErrProtocolNotReady
The protocol requested for the socket was recognised but was not able to be used.
Definition es_sock.h:745

TNifProgressBuf
TPckgBuf< TNifProgress > TNifProgressBuf
Buffer for Network Interface Progress.
Definition es_sock.h:206

KErrConnectionContention
const TInt KErrConnectionContention
Definition es_sock.h:734

KSockReadContinuation
const TUint KSockReadContinuation
Read from datagram in a stream-like fashion (not discarding tails).
Definition es_sock.h:468

KUndefinedAddressFamily
const TUint KUndefinedAddressFamily
Undefined address family.
Definition es_sock.h:646

KSockRaw
const TUint KSockRaw
Raw socket.
Definition es_sock.h:297

KSIConnectData
const TUint KSIConnectData
The protocol can send user data on a connection request.
Definition es_sock.h:514

KSockStream
const TUint KSockStream
Stream socket.
Definition es_sock.h:291

KSOEnableTransfer
const TUint KSOEnableTransfer
Setting only.
Definition es_sock.h:391

KSubConnCallDescrParamsFamily
const TUint32 KSubConnCallDescrParamsFamily
Definition es_sock.h:1368

KSIConnectionLess
const TUint KSIConnectionLess
The protocol is connectionless.
Definition es_sock.h:498

KSubConnEventInterfaceUid
const TInt32 KSubConnEventInterfaceUid
Definition es_sock.h:1360

KSIInOrder
const TUint KSIInOrder
The protocol guarantees in-order delivery.
Definition es_sock.h:502

KNSServiceRegistration
const TUint KNSServiceRegistration
Protocol supports additions to the service database.
Definition es_sock.h:572

KUseEmbeddedUniqueId
const TUint KUseEmbeddedUniqueId
Definition es_sock.h:132

KConnectionTypeDefault
const TUint KConnectionTypeDefault
Default connection type.
Definition es_sock.h:1099

KSubConnContextDescrParamsFamily
const TUint32 KSubConnContextDescrParamsFamily
Definition es_sock.h:1369

KSockDatagram
const TUint KSockDatagram
Datagram socket.
Definition es_sock.h:293

KSocketMessageSizeNoLimit
const TInt KSocketMessageSizeNoLimit
Data is packet-oriented but packets can be of any size (i.e.
Definition es_sock.h:620

KSODebug
const TUint KSODebug
Debugging enabled or disabled .
Definition es_sock.h:337

KConnectionDown
const TUint KConnectionDown
Progress Notification to inform clients Connection is up This event has the same numerical values as ...
Definition es_sock.h:84

ESockDebug
Definition es_sock.h:761

ESock
Definition es_sock.h:49

RSubConnection::TEventFilter::iEventMask
TUint32 iEventMask
Definition es_sock.h:1594

RSubConnection::TEventFilter::iEventGroupUid
TInt32 iEventGroupUid
Definition es_sock.h:1593

SSockAddr
Socket address offsets.
Definition es_sock.h:220

SSockAddr::iPort
TUint iPort
Port (or equivilent) number.
Definition es_sock.h:224

SSockAddr::iFamily
TUint iFamily
Address family of socket address.
Definition es_sock.h:222

TProtocolDesc
Socket protocol information for use by clients.
Definition es_sock.h:669

TProtocolDesc::iByteOrder
TByteOrder iByteOrder
The byte order that the protocol uses.
Definition es_sock.h:689

TProtocolDesc::iProtocol
TUint iProtocol
An integer specifying the specific protocol.
Definition es_sock.h:681

TProtocolDesc::iSecurity
TUint iSecurity
A bitmask of security flags.
Definition es_sock.h:702

TProtocolDesc::iAddrFamily
TUint iAddrFamily
An integer identifying the protocol's address family.
Definition es_sock.h:677

TProtocolDesc::iVersion
TVersion iVersion
The version of the protocol.
Definition es_sock.h:685

TProtocolDesc::iServiceInfo
TUint iServiceInfo
A bit mask of service information flags.
Definition es_sock.h:693

TProtocolDesc::iNamingServices
TUint iNamingServices
A bit mask indicating if the protocol supports name resolution, service resolution,...
Definition es_sock.h:698

TProtocolDesc::iSockType
TUint iSockType
An integer specifying the socket type.
Definition es_sock.h:679

TProtocolDesc::iMessageSize
TInt iMessageSize
The message size of datagram protocols.
Definition es_sock.h:706

TProtocolDesc::iName
TProtocolName iName
The name of the protocol.
Definition es_sock.h:674