Constructs the server object, specifying the server type and the active object priority.

Derived classes must define and implement a constructor through which the priority can be specified. A typical implementation calls this server base class constructor through a constructor initialization list.

Frees resources prior to destruction.

Specifically, it cancels any outstanding request for messages, and deletes all server-side client session objects.

Implements the cancellation of any outstanding request for messages.

Handles the connect request from the client. We trap Leaves, to ensure that existing sessions aren't affected by failure to create a new one.

Extension function

Gets a reference to the server's current message.

Creates a server-side session object.

The session represents a communication link between a client and a server, and its creation is initiated by the client through a call to one of the RSessionBase::CreateSession() variants.

A server must provide an implementation, which as a minimum should:

User::QueryVersionSupported()

Restarts the server.

The function issues a request for messages.

Handles the situation where a call to CServer2::RunL() , leaves.

This is the server active object's implementation of the active object framework's RunError() function.

In practice, the leave can only be caused by a session's ServiceL() function, which is called from this RunL() ; this error is reflected back to that session by calling its ServiceError() function.

CActive::RunL() CActive::RunError() CSession2::ServiceError()

Handles the receipt of a message.

Gets a handle to the server.

Note that the RServer2 object is classified as Symbian internal, and its member functions cannot be acessed. However, the handle can be passed to the RSessionBase::CreateSession() variants that take a server handle.

Assigns a role (master or slave) for this server.

The master server is typically named, and receives all Connect messages from clients. It can hand off some sessions to be processed by one or more anonymous slave servers, each running in a separate thread.

Both master and slave servers must call this function before calling Start() , in order to define their roles. Once the server is started, its role cannot be changed.

Sets whether the kernel will pin descriptors passed to this server in the context of the client thread.

Setting this is one way of ensuring that the server will not take page faults when accessing client descriptors, which would otherwise happen if the data was paged out.

This method overrides the default pinning policy of the server which is for the server to pin its client's descriptors if the process creating the server is not data paged. I.e. if CServer2::SetPinClientDescriptors() is not invoked on the server and RProcess::DefaultDataPaged() of the process creating the server returns EFalse, the server will pin its client's descriptors, otherwise the server will not pin its client's descriptors.

This method must be called prior to starting the server by calling the Start() method.

Adds the server with the specified name to the active scheduler, and issues the first request for messages.

If KNullDesC is specified for the name, then an anonymous server will be created. To create a session to such a server, an overload of RSessionBase::CreateSession() which takes RServer2 object as a parameter can be used.

Adds the server with the specified name to the active scheduler, and issues the first request for messages, and leaves if the operation fails.

If KNullDesC is specified for the name, then an anonymous server will be created. To create a session to such a server, the overload of RSessionBase::CreateSession() which takes an RServer2 object as a parameter can be used.

This enumeration defines the maximum sharability of sessions opened with this server; for backwards compatibilty, these should be have the same values as the corresponding EIpcSessionType enumeration