diff -r 000000000000 -r dfb7c4ff071f datacommsserver/esockserver/inc/ES_PROT.H --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/datacommsserver/esockserver/inc/ES_PROT.H Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,987 @@ +// 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: +// + +/** + @file + @publishedPartner + @released +*/ + +#if !defined(__ES_PROT_H__) +#define __ES_PROT_H__ + +#define SYMBIAN_NETWORKING_UPS + +#include + +#include + + + +/** +End of data,Socket can't receive more data. +@publishedPartner +@released +*/ +const TUint KNewDataEndofData = 0xFFFFFFFF; + +class CServProviderBase; + +namespace ESock +{ +class CSocket; +} + + +class MSocketNotify +/** Abstract base class used by a CServProviderBase-derived object, through its +iSocket member, to notify the socket server that various events have occurred. + +The class provides several up-call member functions. + +All up-calls on an MSocketNotify should be made in the context of the socket +server's thread - i.e. the thread which called NewSAPL() on the protocol. + +@publishedPartner +@released Since v5.0 */ + { +public: + /** Delete and detach flags. */ + enum TDelete + { + /** Delete SAP */ + EDelete, + /** Don't delete SAP */ + EDetach + }; + /** Error codes. */ + enum TOperationBitmasks + { + /** An error has occurred which affects Send() operations */ + EErrorSend=0x0000001, + + /** An error has occurred which affects Receive() operations. */ + EErrorRecv=0x0000002, + + /** An error has occurred which affects Connect() operations */ + EErrorConnect=0x0000004, + + /** An error has occurred which affects Close() operations */ + EErrorClose=0x00000008, + + /** An error has occurred which affects Ioctl() operations */ + EErrorIoctl=0x00000010, + + /** A fatal error has occurred */ + EErrorFatal=0x10000000, + + /** An error has occurred which affects all operations */ + EErrorAllOperations=0x7fffffff, + }; + + /** + Indicates that new data is available on a service access point + + For a stream-oriented protocol aCount should be a byte count; for datagram-oriented + sockets aCount should be a datagram count. + + @note aCount is the amount of new data, not the total amount of data waiting + to be read. + + @param aCount The amount of new data. A value of KNewDataEndofData indicates + that the socket is in a half-closed state and will receive no more data. Any subsequent + reads will complete with KErrEof and a length of 0. */ + virtual void NewData(TUint aCount) = 0; + /** Indicates that new buffer space is available on a service. */ + virtual void CanSend() = 0; + /** Indicates that a connection attempt has completed successfully (for active opens). + + There are four versions of this up-call: two are for active opens and two are for passive + opens. Both active and passive versions support a variant carrying user connection + data for protocols which support it. + + @note A connection-less protocol should never call the ConnectComplete() up-calls. + @note A protocol should keep a count of sockets which have called ConnectComplete() + but have not had Start() called. Sockets in this state have their Error() + and NewData() calls deferred until Start() is called.*/ + virtual void ConnectComplete() = 0; + /** Indicates that a connection attempt has completed successfully (for active opens). + + There are four versions of this up-call: two are for active opens and two are for passive + opens. Both active and passive versions support a variant carrying user connection + data for protocols which support it. + + @note A connection-less protocol should never call the ConnectComplete() up-calls. + @note A protocol should keep a count of sockets which have called ConnectComplete() + but have not had Start() called. Sockets in this state have their Error() + and NewData() calls deferred until Start() is called. + + @param aConnectData Connect data (if supported). + */ + virtual void ConnectComplete(const TDesC8& aConnectData) = 0; + /** Indicates that a connection attempt has completed successfully (for passive opens). + + There are four versions of this up-call: two are for active opens and two are for passive + opens. Both active and passive versions support a variant carrying user connection + data for protocols which support it. + + The versions of ConnectComplete() for passive opens carry a new SSP (socket service + provider, or SAP) for the newly created socket. A new socket will then be linked up to + the SSP and data transfer can take place. The original socket stays listening. + + @note A connection-less protocol should never call the ConnectComplete() up-calls. + @note A protocol should keep a count of sockets which have called ConnectComplete() + but have not had Start() called. Sockets in this state have their Error() + and NewData() calls deferred until Start() is called. + + @param aSSP The new SSP for passive opens. + */ + virtual void ConnectComplete(CServProviderBase& aSSP) = 0; + /** Indicates that a connection attempt has completed successfully (for passive opens). + + There are four versions of this up-call: two are for active opens and two are for passive + opens. Both active and passive versions support a variant carrying user connection + data for protocols which support it. + + The versions of ConnectComplete() for passive opens carry a new SSP (socket service + provider, or SAP) for the newly created socket. A new socket will then be linked up to + the SSP and data transfer can take place. The original socket stays listening. + + @note A connection-less protocol should never call the ConnectComplete() up-calls. + @note A protocol should keep a count of sockets which have called ConnectComplete() + but have not had Start() called. Sockets in this state have their Error() + and NewData() calls deferred until Start() is called. + + @param aSSP The new SSP for passive opens. + @param aConnectData Connect data (if supported). */ + virtual void ConnectComplete(CServProviderBase& aSSP,const TDesC8& aConnectData) = 0; + /** Indicates that the SAP has finished closing down. + + This up-call is the response to a Shutdown(). A connection-oriented protocol should call + CanClose() when it has terminated communications with the remote host. Protocols can call + CanClose() from within their Shutdown() code. After CanClose() has been called, an SAP may + be deleted by the socket server. + + @note The protocol must not access the CServProviderBase object after calling CanClose(). + @param aDelete Delete SAP. + */ + virtual void CanClose(TDelete aDelete=EDelete) = 0; + /** Indicates that the SAP has finished closing down. + + This up-call is the response to a Shutdown(). A connection-oriented protocol should call + CanClose() when it has terminated communications with the remote host. Protocols can call + CanClose() from within their Shutdown() code. After CanClose() has been called, an SAP may + be deleted by the socket server. + + @note The protocol must not access the CServProviderBase object after calling CanClose(). + @param aDisconnectData Any user data carried on the disconnect frame. + @param aDelete Delete SAP. + */ + virtual void CanClose(const TDesC8& aDisconnectData,TDelete aDelete=EDelete) = 0; + /** Tells the socket server that an error state has arisen within the protocol. + + It should not be used to report programmatic errors, either in the protocol + itself or the socket server (a panic should be used in these cases). When + Error() is called on a connection-oriented socket, the socket is moved into + a dead state which denies user access to it. + + @param anError KErrNone or another of the system-wide error codes. + @param anOperationMask A bitmask of TOperationBitmasks values specifying which + pending operations are affected by the Error up-call. */ + virtual void Error(TInt anError,TUint anOperationMask=EErrorAllOperations) = 0; + /** Indicates that the other end of a connection has disconnected. + + This is analogous to CanClose(), but in this case the other end initiated it. + + Once the client has called Shutdown() it is illegal to call Disconnect(). Instead, + CanClose() or Error(KErrDisconnected) should be called. + */ + virtual void Disconnect(void) = 0; + /** Indicates that the other end of a connection has disconnected. + + This is analogous to CanClose(), but in this case the other end initiated it. + + Once the client has called Shutdown() it is illegal to call Disconnect(). Instead, + CanClose() or Error(KErrDisconnected) should be called. + + @param aConnectData User data in the disconnect frame. + */ + virtual void Disconnect(TDesC8& aDisconnectData) = 0; + /** Indicates that the currently pending Ioctl has completed. + + The parameter aBuf is protocol defined - in fact it is defined by the specific + Ioctl. + + @param aBuf Any data requested by the Ioctl operation. */ + virtual void IoctlComplete(TDesC8* aBuf) = 0; + + /** + Indicates that there are no bearer available + + @param aConnectionParams, the connection parameters. + */ + virtual void NoBearer(const TDesC8& aConnectionParams) = 0; + + /** + Indicates the bearer available. + + @param aConnectionInfo, Information about socket connection. + */ + virtual void Bearer(const TDesC8& aConnectionInfo) = 0; + + /** + Indicates that this socket is now completed an asynchronous join + with a sub-connection. It now can use the properties of the sub-connection + */ + virtual void JoinedSubConnection() {;}; + + /** + Indicates that this socket was not able to complete an asynchronous join + with a sub-connection. The socket is still joined, but cannot use the + properties of the sub-connection + + @param aError Reason the socket could not be joined + */ + virtual void SubConnectionJoinFailed(TInt /*aError*/) {;}; + + /** + Indicates that this socket has now completed an asynchronous leave + from a sub-connection. The socket is now connected to the sub-connection + anymore. + */ + virtual void LeftSubConnection() {;}; + }; + + + +/** +@publishedPartner +@released +*/ +const TInt KUnlimitedSockets=-1; + +struct TServerProtocolDesc : public TProtocolDesc +/** +Contains data that describes a particular protocol. +@publishedPartner +@released + +@see CProtocolFamilyBase::ProtocolList(). +*/ + { + TInt iServiceTypeInfo; //< Options from TProtocolServiceInfo bitwise OR'd together. @see TProtocolServiceInfo + TInt iNumSockets; //< The maximum number of SSPs the protocol supports + }; + + +class MResolverNotify +/** +@publishedPartner +@released +*/ + { +public: + virtual void QueryComplete(TInt anError)=0; + }; + +/** +Security checker class passed down to providers which is used to perform security checks on the client +of the provider. The provider calls the CheckPolicy(...) method with a suitable TSecurityPolicy +class and a diagnostic string as arguments. + +@see CServProviderBase +@see CResolverProvdBase + +@code +_LIT_SECURITY_POLICY_C1(myPolicy1, ECapabilityNetworkServices); +... +TInt CMyProvider::SecurityCheck(MProvdSecurityChecker *aChecker) +{ + ... + if (aChecker->CheckPolicy(myPolicy1, "CMyProvider main") == KErrNone) + { + // client has NetworkServices capability + } + ... +} +@endcode + +@publishedPartner +@released +*/ +class MProvdSecurityChecker +{ +public: + /** + Check the security policy of a client process. + + Called from a socket or resolver provider to check whether the client process conforms to a security policy. + + @param aPolicy A TSecurityPolicy class instance containing the security information to be checked against the client. + @param aDiagnostic A diagnostic string used when logging system-wide security failures, else 0. + @return KErrNone if client process has the required security information, else KErrPermissionDenied. + (In the future, some other system error may be returned). + */ + virtual TInt CheckPolicy(const TSecurityPolicy& aPolicy, const char *aDiagnostic) = 0; +}; + +namespace ESock +{ +class CSubConnectionProviderBase; +} + +class RMBufChain; +class CServProviderBase : public CBase +/** Service Access Point. + +Provides transport services to a single protocol. Several of the calls to +CServProviderBase have pre-conditions attached to them - for example +a connection oriented protocol must have its local address set (either by +a SetLocalName() or AutoBind()) before it is opened. If the socket server +calls the CServProviderBase in such an erroneous way, the protocol should panic. + +@publishedPartner +@released Since 5.0 */ + { + friend class ProtocolManager; +public: + + /** Describes the behaviour the SAP should take on shutdown.*/ + enum TCloseType + { + ENormal, //< The protocol should shutdown gracefully — no further input or output will be requested. + EStopInput, //< The protocol should shut down gracefully — all further and pending input should be discarded. + EStopOutput, //< The protocol should shutdown gracefully — all pending output should be discarded. + EImmediate //< The protocol should close the connection immediately and free all resources without performing a graceful disconnect. + }; + IMPORT_C CServProviderBase(); + IMPORT_C virtual ~CServProviderBase(); + + IMPORT_C virtual void SetNotify(MSocketNotify* aSocket); + //V1.0 itf support + IMPORT_C virtual void SetSockType(TUint aSockType); + IMPORT_C TUint SockType() const; + + IMPORT_C virtual void JoinSubConnectionL(ESock::CSubConnectionProviderBase& aSubConnProvider); + IMPORT_C virtual void LeaveSubConnection(ESock::CSubConnectionProviderBase& aSubConnProvider); + +public: + +/** +pure virtual +*/ + /** + Start a service provider. + */ + virtual void Start()=0; + /** Gets the local name (address) of the socket service provider entity. The format + of the data in the TSockAddr object is defined by individual protocols. + + The local address is the address of the local machine plus a local port number. + Generally only the port number is important, unless you have two IP interfaces, + for example. + + @param anAddr The address to be filled in */ + virtual void LocalName(TSockAddr& anAddr) const =0; + /** Sets the local name (address) of the socket service provider entity. The format + of the data in the TSockAddr object is defined by individual protocols. + + @param anAddr The address + @return Returns KErrNone if the local name is correctly set or, if this is + not the case, an informative error number. */ + virtual TInt SetLocalName(TSockAddr& anAddr)=0; + /** Gets the remote name (address) of the socket service provider entity. The format + of the data in the TSockAddr object is defined by individual protocols. + + A remote address is either the address you're sending data to (non connection-oriented + sockets)* or the remote end of the connection. It is the address of the remote + machine (your peer in the network) plus a port number. + + @note RemName is only meaningful if the socket server client has called Connect() + to set up a default address for SendTo(). This function will only be called + on the protocol if this is the case. + + @param anAddr The address to be filled in */ + virtual void RemName(TSockAddr& anAddr) const =0; + /** Sets the remote name (address) of the socket service provider entity. The format + of the data in the TSockAddr object is defined by individual protocols. + + @param anAddr The address + @return Returns KErrNone if the remote name is correctly set or, if this is + not the case, an informative error number. */ + virtual TInt SetRemName(TSockAddr& anAddr)=0; + /** Gets some protocol specific option when called by the socket server on behalf of a + client. A protocol may pass the request down a protocol stack (to protocols it is bound + to) using the GetOption() function of CProtocolBase. + + @param aLevel Option level. + @param aName Option name. + @param anOption Option data. + @return System wide error code. + */ + virtual TInt GetOption(TUint level,TUint name,TDes8& anOption)const =0; + /** Performs some protocol specific IO control. + + @note If this function is called erroneously, the protocol should call Error() on the + socket. If an Ioctl call is already outstanding, the client will be panicked with the + value ETwoIoctls. + + @param aLevel Option level. + @param aName Option name. + @param anOption Option data. + @return System wide error code. + */ + virtual void Ioctl(TUint level,TUint name,TDes8* anOption)=0; + /** Cancels an outstanding Ioctl call. You are guaranteed only to have one outstanding + at once. + + @param aLevel IOCTL level. + @param aName IOCTL name. + */ + virtual void CancelIoctl(TUint aLevel,TUint aName)=0; + /** Sets some protocol specific option when called by the socket server on behalf of a + client. A protocol may pass the request down a protocol stack (to protocols it is bound + to) using the SetOption() function of CProtocolBase. + + @param aLevel Option level. + @param aName Option name. + @param anOption Option data. + @return System wide error code. + */ + virtual TInt SetOption(TUint level,TUint name,const TDesC8& anOption)=0; + virtual void ActiveOpen()=0; + /** Initiates a connection operation - this means that it tells the protocol to + attempt to connect to a peer. It is called by the socket server in response + to a connect request from a client. + + This version of the function has user data in the connection frame. + + Only ever called on connection-oriented sockets. Such a socket + should always have both the local address and the remote address specified + before this function is called. If this is not the case then the protocol + should panic. + + When a connection has completed, the protocol should call ConnectComplete() + on its TNotify. If an error occurs during connection the protocol should not + call ConnectComplete() at all; instead it should call Error(). + + @param aConnectionData If the protocol supports user specified connection + data, then it will be held in this buffer. */ + virtual void ActiveOpen(const TDesC8& aConnectionData)=0; + /** Tells the protocol to start waiting for an incoming connection request on this + socket (i.e. port). It is called by the socket server in response to a listen + request from a client. + + Only ever called on connection-oriented sockets. Such a socket + should always have both the local address and the remote address specified + before this function is called. If this is not the case, then the protocol + should panic. + + The aQue parameter is the number of sockets which can be waiting for an outstanding + Start after calling ConnectComplete(). The protocol should keep a count of + sockets in this state - incrementing a variable in ConnectComplete(), and + decrementing it in Start(). + + When a connection has completed, the protocol should call ConnectComplete() + on its TNotify. If an error occurs during connection the protocol should not + call ConnectComplete() at all; instead it should call Error(). + + @param aQueSize Size of connect queue. + */ + virtual TInt PassiveOpen(TUint aQueSize)=0; + /** Tells the protocol to start waiting for an incoming connection request on this + socket (i.e. port). It is called by the socket server in response to a listen + request from a client. + + This version of the function has user data in the connection frame. + + Only ever called on connection-oriented sockets. Such a socket + should always have both the local address and the remote address specified + before this function is called. If this is not the case then the protocol + should panic. + + The aQue parameter is the number of sockets which can be waiting for an outstanding + Start after calling ConnectComplete(). The protocol should keep a count of + sockets in this state - incrementing a variable in ConnectComplete(), and + decrementing it in Start(). + + When a connection has completed the protocol should call ConnectComplete() + on its TNotify. If an error occurs during connection the protocol should not + call ConnectComplete() at all; instead it should call Error(). + + @param aQueSize size of connect queue + @param aConnectionData if the protocol supports user specified connection data + then it will be held in this buffer. */ + virtual TInt PassiveOpen(TUint aQueSize,const TDesC8& aConnectionData)=0; + /** Terminates a connection (or closes a non connection-oriented socket down). + + The value of the option argument specifies the type of processing which will + be required of the protocol after this function is called. + + Normally, when the socket server has called Shutdown() for a socket, it will + wait for the socket to call CanClose() before destroying the CServProviderBase + object. However, if the option argument is EImmediate, the CServProviderBase + will be destroyed as soon as Shutdown() returns. + + @param option The shutdown type. */ + virtual void Shutdown(TCloseType option)=0; + /** Terminates a connection (or closes a non connection-oriented socket down). + + The value of the option argument specifies the type of processing which will + be required of the protocol after this function is called. + + Normally, when the socket server has called Shutdown() for a socket, it will + wait for the socket to call CanClose() before destroying the CServProviderBase + object. However, if the option argument is EImmediate, the CServProviderBase + will be destroyed as soon as Shutdown() returns. + + @param option The shutdown type. + @param aDisconnectionData If the protocol supports disconnect data, any such + data required will be held in this buffer. */ + virtual void Shutdown(TCloseType option,const TDesC8& aDisconnectionData)=0; + /** Specifies that the protocol should choose a local address for the service access + point itself. */ + virtual void AutoBind()=0; + +// protocol read/write data; ESock v1.5 calls down to the v1.5 itf (RMBufChain). +// v1.5-ready protocols implement this, laggard protocols inherit these base class +// implementations which call the v1.0 descriptor itf instead. + + /** Sends data onto the network via the protocol. + + Connection-oriented sockets must be in a connected state (that is ConnectComplete() has + been called on their MSocketNotify before Write() is called). + + The socket server keeps track of how much data is waiting and then tries to send it all + until the protocol tells it to hold off by returning 0 (datagram sockets) or 'less than + all data consumed' (stream sockets) to Write(). The protocol should call CanSend() when it + is ready to send more data. + + anAddr is the address to write the data to. Connection oriented sockets always use the + default value. + + @param aDesc The data to be sent. + @param aOptions Protocol specific options. + @param anAddr Address to write the data to. + + @returns For stream-oriented protocols the return value is the number of bytes actually written. + If this is less than the length of the descriptor then the protocol should call CanSend() + when it is ready to send more data. For datagram-oriented protocols, the write should return + either 0 if the write cannot be completed, or the length of the descriptor if the write succeeds - + no other values are valid. If the Write() must return 0, then it should call CanSend() when it is + ready to send more data. If the Write() fails due to some error, then it should call Error() with + an informative error number. + */ + IMPORT_C virtual TUint Write(const TDesC8& aDesc,TUint options, TSockAddr* anAddr=NULL); + /** Sends data onto the network via the protocol. + + Connection-oriented sockets must be in a connected state (that is ConnectComplete() has + been called on their MSocketNotify before Write() is called). + + The socket server keeps track of how much data is waiting and then tries to send it all + until the protocol tells it to hold off by returning 0 (datagram sockets) or 'less than + all data consumed' (stream sockets) to Write(). The protocol should call CanSend() when it + is ready to send more data. + + anAddr is the address to write the data to. Connection oriented sockets always use the + default value. + + @param aData The data to be sent. + @param aOptions Protocol specific options. + @param anAddr Address to write the data to. + + @returns For stream-oriented protocols the return value is the number of bytes actually written. + If this is less than the length of the descriptor then the protocol should call CanSend() + when it is ready to send more data. For datagram-oriented protocols, the write should return + either 0 if the write cannot be completed, or the length of the descriptor if the write succeeds - + no other values are valid. If the Write() must return 0, then it should call CanSend() when it is + ready to send more data. If the Write() fails due to some error, then it should call Error() with + an informative error number. + */ + IMPORT_C virtual TInt Write(RMBufChain& aData, TUint aOptions, TSockAddr* anAddr=NULL); + + /** Gets data which the protocol has indicated is waiting in its buffers using the NewData + up-call on the MSocketNotify. + + GetData() will only ever be called for as much data as the protocol has specified it can process + using the NewData up-call. + + For stream oriented protocols GetData() should fill the descriptor with data from the stream. On + a datagram protocol GetData() should copy one datagram into the descriptor and set the length of + the descriptor. If a full datagram will not fit into the supplied descriptor, the overflow should + be discarded. + + anAddr should be filled in by the protocol with the address of where the data came from. + + @param aDesc The buffer for data. + @param aOptions Protocol specific options. + @param anAddr Address where the data came from. + */ + IMPORT_C virtual void GetData(TDes8& aDesc,TUint options,TSockAddr* anAddr=NULL); + /** Gets data which the protocol has indicated is waiting in its buffers using the NewData + up-call on the MSocketNotify. + + GetData() will only ever be called for as much data as the protocol has specified it can process + using the NewData up-call. + + For stream oriented protocols GetData() should fill the descriptor with data from the stream. On + a datagram protocol GetData() should copy one datagram into the descriptor and set the length of + the descriptor. If a full datagram will not fit into the supplied descriptor, the overflow should + be discarded. + + anAddr should be filled in by the protocol with the address of where the data came from. + + @param aDesc The buffer for data. + @param aOptions Protocol specific options. + @param anAddr Address where the data came from. + */ + IMPORT_C virtual TInt GetData(RMBufChain& aData, TUint aLength, TUint aOptions, TSockAddr* anAddr=NULL); + + /** Use the class instance argument to perform security policy checks on the originating client process. + + This method is called when a SAP is created and when a socket is transferred between sessions. The SAP is + required to check whether the originating client process has enough privileges to request services from the SAP. + The MProvdSecurityChecker class instance is used to perform security policy checks. The SAP may choose + to perform a security policy check in its SecurityCheck(...) method, or it may choose to store the + MProvdSecurityChecker class instance argument and perform checking later (i.e. when subsequent + SAP methods are called). + + @param aSecurityChecker Pointer to class used by SAP to perform security checks on the client process. This + pointer becomes invalid when the SAP is destroyed or detached. + @returns KErrPermissionDenied if SAP wishes to disallow access to the client, else KErrNone. This would + normally be as a result of calling MProvdSecurityChecker::CheckPolicy(...) with a suitable security policy argument. + */ + IMPORT_C virtual TInt SecurityCheck(MProvdSecurityChecker *aSecurityChecker); + +protected: + /** On socket creation, the socket server sets this member to point to a server + notification interface. */ + MSocketNotify* iSocket; +private: + //V1.0 interface support specifics + HBufC8* iV1ShimDataIn; + HBufC8* iV1ShimDataOut; + TUint iSockType; + }; + +class CProtocolBase; +class CResolverProvdBase : public CBase +/** +@publishedPartner +@released +*/ + { + friend class ProtocolManager; +public: + inline void SetNotify(MResolverNotify* aNotifier); + + /** + @internalComponent + */ + virtual void CancelCurrentOperation()=0; + + /** Use the class instance argument to perform security policy checks on the originating client process. + + This method is called when a resolver is created. The resolver is required to check whether the originating + client process has enough privileges to request services from the resolver. The MProvdSecurityChecker + class instance is used to perform security policy checks. The resolver may choose to perform a security + policy check in its SecurityCheck(...) method, or it may choose to store the MProvdSecurityChecker class + instance argument and use it to perform checking later (i.e. when subsequent resolver methods are called). + + @param aSecurityChecker Pointer to class used by resolver to perform security checks on the client process. This + pointer becomes invalid when the resolver is destroyed or detached. + @returns KErrPermissionDenied if resolver wishes to disallow access to the client, else KErrNone. This would + normally be as a result of calling MProvdSecurityChecker::CheckPolicy(...) with a suitable security policy argument. + */ + IMPORT_C virtual TInt SecurityCheck(MProvdSecurityChecker *aSecurityChecker); + +protected: + MResolverNotify* iNotify; +private: + CProtocolBase* iProtocol; + }; + +class CHostResolvProvdBase : public CResolverProvdBase +/** +Provides Host name resolver service +@publishedPartner +@released +*/ + { + friend class ProtocolManager; +public: + + /** + Get the Host name by name + @param aName, results of name queries + */ + virtual void GetByName(TNameRecord& aName)=0; + + /** + Gets the Host name by address + @param aName, results of name queries + */ + virtual void GetByAddress(TNameRecord& aName)=0; + + /** + Sets the Host name + @param aNameBuf, name to set + */ + virtual void SetHostName(TDes& aNameBuf)=0; + + /** + Gets the Host name + @param aNameBuf, name to retrieve + */ + virtual void GetHostName(TDes& aNameBuf)=0; + IMPORT_C virtual TInt SetOption(TUint level,TUint name,const TDesC8& anOption); + IMPORT_C virtual void Query(const TDesC8& aQryBuf, TDes8& aResBuf, TInt aCounter); + }; + +class CServiceResolvProvdBase : public CResolverProvdBase +/** +@publishedPartner +@released +*/ + { + friend class ProtocolManager; +public: + + /** + Get the Host name by name + @param aName, results of name queries + */ + virtual void GetByName(const TDesC& aNameBuf,TInt32& aPortNum)=0; + + /** + Gets the Host name by address + @param aName, results of name queries + */ + virtual void GetByNumber(TDes& aNameBuf,TInt32 aPortNum)=0; + + /** + Sets the Host name + @param aNameBuf, name to set + */ + virtual void RegisterService(const TDesC& aNameBuf,TInt32 aPortNum)=0; + + /** + Gets the Host name + @param aNameBuf, name to retrieve + */ + virtual void RemoveService(const TDesC& aNameBuf,TInt32 aPortNum)=0; + }; + +class CNetDBProvdBase : public CResolverProvdBase +/** +Provides network Database access +@publishedPartner +@released +*/ + { + friend class ProtocolManager; +public: + virtual void Query(TDes8& aBuffer)=0; + virtual void Add(TDes8& aBuffer)=0; + virtual void Remove(TDes8& aBuffer)=0; + }; + +namespace ESock +{ +class CSubConnectionProviderBase; +} + + +class CProtocolFamilyBase; +class RMBufChain; +class CProtocolRef; +class CProtocolBase : public CBase +/** Protocols created by protocol families must be instances of sub-classes of +the abstract CProtocolBase. +@publishedPartner +@released Since v5.0 */ + { + friend class ProtocolManager; + friend class CProtocolRef; + +public: + IMPORT_C virtual CServProviderBase* NewSAPL(TUint aProtocol); + IMPORT_C virtual CHostResolvProvdBase* NewHostResolverL(); + IMPORT_C virtual CServiceResolvProvdBase* NewServiceResolverL(); + IMPORT_C virtual CNetDBProvdBase* NewNetDatabaseL(); + IMPORT_C CProtocolBase(); + IMPORT_C virtual ~CProtocolBase(); + CProtocolFamilyBase* ProtocolFamily(); + IMPORT_C virtual void Close(); + IMPORT_C virtual void Open(); + IMPORT_C virtual void CloseNow(); + IMPORT_C virtual void StartSending(CProtocolBase* aProtocol); // Up + IMPORT_C TPtrC Tag(); + IMPORT_C virtual void InitL(TDesC& aTag); // From ProtocolManager before all binding. + IMPORT_C virtual void StartL(); // From Protocol Manager - after all binding + IMPORT_C virtual void BindL(CProtocolBase* protocol, TUint id); // From higher protocol + IMPORT_C virtual void BindToL(CProtocolBase* protocol); // From Protocol Manager + IMPORT_C virtual TInt Send(RMBufChain& aPDU,CProtocolBase* aSourceProtocol=NULL); // Down + IMPORT_C virtual TInt Send(TDes8& aPDU,TSockAddr* to,TSockAddr* from=NULL,CProtocolBase* aSourceProtocol=NULL); // Done + IMPORT_C virtual void Process(RMBufChain&,CProtocolBase* aSourceProtocol=NULL); // Up + IMPORT_C virtual void Process(TDes8& aPDU,TSockAddr* from,TSockAddr* to=NULL,CProtocolBase* aSourceProtocol=NULL); // Up + IMPORT_C virtual TInt GetOption(TUint level,TUint name,TDes8& option,CProtocolBase* aSourceProtocol=NULL); // Down + IMPORT_C virtual TInt SetOption(TUint level,TUint name,const TDesC8& option,CProtocolBase* aSourceProtocol=NULL); // Down + IMPORT_C virtual void Error(TInt anError,CProtocolBase* aSourceProtocol=NULL); // Up + +// Pure virtual + /** Fills in the passed TServerProtocolDesc with data describing the protocol. + + @param aProtocolDesc Protocol description object to fill in */ + virtual void Identify(TServerProtocolDesc* aProtocolDesc)const =0; // from anyone. + + inline TInt RefCount() const; +protected: + IMPORT_C void CanClose(); // Up +private: + void TryDelete(); +protected: +// TProtocolDesc iDesc; +private: + CProtocolRef* iManagerRef; + TInt iRefCount; + }; + +namespace ESock +{ +class CConnection; +} +class CProtocolFamilyRef; +class CLibUnloader; +class CConnectionProvdBase; +class CProtocolFamilyBase : public CBase +/** Defines the interface for protocol families. + +Protocol families must: + +be able to identify the protocols which they can create + +be able to create instances of protocol objects for all the protocols they +advertise + +@publishedPartner +@released */ + { +friend class ProtocolManager; +friend class CProtocolFamilyRef; +public: + IMPORT_C virtual ~CProtocolFamilyBase(); + IMPORT_C CProtocolFamilyBase(); + IMPORT_C virtual void Close(); + IMPORT_C virtual void Open(); + IMPORT_C virtual TInt Remove(); + IMPORT_C virtual TBool QueryVersionSupported(const TVersion& aVer) const; + + void SetLibraryL(RLibrary& aLib); + + // Pure virtual + /** Initialises a protocol family. + + After the CProtocolFamilyBase-derived object has been created, the first function + called by the socket server on that object is Install(). It is at this point that the + CProtocolFamilyBase-derived object should perform any initialisation which it needs. + + @return System-wide error code */ + virtual TInt Install()=0; + /** Creates a new protocol object. + + During socket creation, after the socket server has called Open() on a protocol family, + it next calls this function to create an instance of a CProtocolBase-derived object - + the protocol itself. + + @param aSockType A supported socket type for the protocol family as advertised + in the protocol list. + @param aProtocol A protocol number specifying a protocol returned by ProtocolList(). + + @return A protocol, or NULL if some error has prevented the protocol from being + created. */ + virtual CProtocolBase * NewProtocolL(TUint aSockType,TUint aProtocol)=0; + /** Gets a list of supported protocols. + + Called during initialisation, directly after Install(). ProtocolList() returns a list + of all the protocols in the protocol family. The protocol family object should allocate + memory to hold an array of TServerProtocolDesc structures. This function should then + fill them in and return the pointer and a count of the number of protocols + supported. The socket server caches this information, so that it does not + need to keep the protocol module loaded. + + The protocol family should not attempt to use static data (which it can't) + or to free this memory later, as the socket server will automatically free + this storage. + + @param aProtocolList This pointer is set to point to memory allocated by the + protocol family and filled in as described above + @return The number of protocols in this protocol family (and entries in the + list of protocols) */ + virtual TUint ProtocolList(TServerProtocolDesc*& aProtocolList)=0; + + inline TInt RefCount() const; + +protected: + + /** Contains version information */ + TVersion iVersion; +private: + TInt iRefCount; + CLibUnloader* iLibUnloader; + CProtocolFamilyRef* iManagerRef; + }; + +/** +@publishedPartner +@released +*/ +typedef CProtocolFamilyBase* (*TProtocolNew)(); + + + +class TSoOwnerInfo +/** +Class used to communicate the owner of a socket from ESOCK to Provider. + +Note that this only represents the thread/process that initially opened the socket and +not, for example, any subsequent thread/process that issues IPC's on the socket from a +shared session. + +@publishedPartner. +@released +*/ + { +public: + TUidType iUid; + TProcessId iProcessId; + TThreadId iThreadId; + }; + + + +/** +UID of Protocol Modules +@publishedPartner +@released */ +const TInt KUidProtocolModule = 0x1000004A; + +#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#endif + +#include + +#endif