RMessagePtr2 Class Reference

class RMessagePtr2

A handle to a message sent by the client to the server.

A server's interaction with its clients is channelled through an RMessagePtr2 object, which acts as a handle to a message sent by the client. The details of the original message are kept by the kernel allowing it enforce correct usage of the member functions of this class.

RMessage2

Public Member Functions
RMessagePtr2 ()
IMPORT_C TInt Client ( RThread &, TOwnerType )
IMPORT_C TBool ClientIsRealtime ()
void ClientL ( RThread &, TOwnerType )
IMPORT_C TUint ClientProcessFlags ()
IMPORT_C const TRequestStatus * ClientStatus ()
IMPORT_C void Complete ( TInt )
IMPORT_C void Complete ( RHandleBase )
IMPORT_C TInt GetDesLength ( TInt )
IMPORT_C TInt GetDesLengthL ( TInt )
IMPORT_C TInt GetDesMaxLength ( TInt )
IMPORT_C TInt GetDesMaxLengthL ( TInt )
TInt Handle ()
TBool HasCapability ( TCapability , const char *)
TBool HasCapability ( TCapability , TCapability , const char *)
void HasCapabilityL ( TCapability , const char *)
void HasCapabilityL ( TCapability , TCapability , const char *)
TUid Identity ()
TBool IsNull ()
IMPORT_C void Kill ( TInt )
IMPORT_C void Panic (const TDesC &, TInt )
IMPORT_C TInt Read ( TInt , TDes8 &, TInt )
IMPORT_C TInt Read ( TInt , TDes16 &, TInt )
IMPORT_C void ReadL ( TInt , TDes8 &, TInt )
IMPORT_C void ReadL ( TInt , TDes16 &, TInt )
IMPORT_C TSecureId SecureId ()
IMPORT_C TInt SetProcessPriority ( TProcessPriority )
void SetProcessPriorityL ( TProcessPriority )
IMPORT_C void Terminate ( TInt )
IMPORT_C TVendorId VendorId ()
IMPORT_C TInt Write ( TInt , const TDesC8 &, TInt )
IMPORT_C TInt Write ( TInt , const TDesC16 &, TInt )
IMPORT_C void WriteL ( TInt , const TDesC8 &, TInt )
IMPORT_C void WriteL ( TInt , const TDesC16 &, TInt )
Private Member Functions
IMPORT_C TBool DoHasCapability ( TCapability , const char *)
IMPORT_C TBool DoHasCapability ( TCapability )
IMPORT_C TBool DoHasCapability ( TCapability , TCapability , const char *)
IMPORT_C TBool DoHasCapability ( TCapability , TCapability )
Protected Attributes
TInt iHandle

Constructor & Destructor Documentation

RMessagePtr2()

RMessagePtr2 ( ) [inline]

Default constructor

Member Functions Documentation

Client(RThread &, TOwnerType)

IMPORT_C TInt Client ( RThread & aClient,
TOwnerType aOwnerType = EOwnerProcess
) const

Opens a handle on the client thread.

Parameters

RThread & aClient On successful return, the handle to the client thread.
TOwnerType aOwnerType = EOwnerProcess An enumeration whose enumerators define the ownership of the handle. If not explicitly specified, EOwnerProcess is taken as default.

ClientIsRealtime()

IMPORT_C TBool ClientIsRealtime ( ) const

ClientL(RThread &, TOwnerType)

void ClientL ( RThread & aClient,
TOwnerType aOwnerType = EOwnerProcess
) const [inline]

Opens a handle on the client thread.

Parameters

RThread & aClient On successful return, the handle to the client thread.
TOwnerType aOwnerType = EOwnerProcess An enumeration whose enumerators define the ownership of the handle. If not explicitly specified, EOwnerProcess is taken as default.

ClientProcessFlags()

IMPORT_C TUint ClientProcessFlags ( ) const

ClientStatus()

IMPORT_C const TRequestStatus * ClientStatus ( ) const

Returns the pointer to the clients TRequestStatus associated with the message.

The return value is intended to be used as a unique identifier (for example, to uniquely identify an asynchronous message when cancelling the request). The memory must never be accessed directly or completed.

Complete(TInt)

IMPORT_C void Complete ( TInt aReason ) const

Frees this message.

Parameters

TInt aReason The completion code.

Complete(RHandleBase)

IMPORT_C void Complete ( RHandleBase aHandle ) const

Duplicates the specified handle in the client thread, and returns this handle as a message completion code

Parameters

RHandleBase aHandle The handle to be duplicated.

DoHasCapability(TCapability, const char *)

IMPORT_C TBool DoHasCapability ( TCapability aCapability,
const char * aDiagnostic
) const [private]

Parameters

TCapability aCapability
const char * aDiagnostic

DoHasCapability(TCapability)

IMPORT_C TBool DoHasCapability ( TCapability aCapability ) const [private]

Parameters

TCapability aCapability

DoHasCapability(TCapability, TCapability, const char *)

IMPORT_C TBool DoHasCapability ( TCapability aCapability,
TCapability aCapability2,
const char * aDiagnostic
) const [private]

Parameters

TCapability aCapability
TCapability aCapability2
const char * aDiagnostic

DoHasCapability(TCapability, TCapability)

IMPORT_C TBool DoHasCapability ( TCapability aCapability,
TCapability aCapability2
) const [private]

Parameters

TCapability aCapability
TCapability aCapability2

GetDesLength(TInt)

IMPORT_C TInt GetDesLength ( TInt aParam ) const

Gets the length of a descriptor argument in the client's process.

Parameters

TInt aParam The index value identifying the argument. This is a value in the range 0 to (KMaxMessageArguments-1) inclusive.

GetDesLengthL(TInt)

IMPORT_C TInt GetDesLengthL ( TInt aParam ) const

Gets the length of a descriptor argument in the client's process, leaving on failure.

leave
KErrArgument if aParam has a value outside the valid range.
leave
KErrBadDescriptor, if the message argument is not a descriptor type.

Parameters

TInt aParam The index value identifying the argument. This is a value in the range 0 to (KMaxMessageArguments-1) inclusive.

GetDesMaxLength(TInt)

IMPORT_C TInt GetDesMaxLength ( TInt aParam ) const

Gets the maximum length of a descriptor argument in the client's process.

Parameters

TInt aParam The index value identifying the argument. This is a value in the range 0 to (KMaxMessageArguments-1) inclusive.

GetDesMaxLengthL(TInt)

IMPORT_C TInt GetDesMaxLengthL ( TInt aParam ) const

Gets the maximum length of a descriptor argument in the client's process, leaving on failure.

leave
KErrArgument if aParam has a value outside the valid range.
leave
KErrBadDescriptor, if the message argument is not a descriptor type.

Parameters

TInt aParam The index value identifying the argument. This is a value in the range 0 to (KMaxMessageArguments-1) inclusive.

Handle()

TInt Handle ( ) const [inline]

Gets the message handle value.

HasCapability(TCapability, const char *)

TBool HasCapability ( TCapability aCapability,
const char * aDiagnostic = 0
) const [inline]

Check if the process which sent this message has a given capability.

When a check fails the action taken is determined by the system wide Platform Security configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted. If PlatSecEnforcement is OFF, then this function will return ETrue even though the check failed.

Parameters

TCapability aCapability The capability to test.
const char * aDiagnostic = 0 A string that will be emitted along with any diagnostic message that may be issued if the test finds the capability is not present. This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro which enables it to be easily removed from the system.

HasCapability(TCapability, TCapability, const char *)

TBool HasCapability ( TCapability aCapability1,
TCapability aCapability2,
const char * aDiagnostic = 0
) const [inline]

Check if the process which sent this message has both of the given capabilities.

When a check fails the action taken is determined by the system wide Platform Security configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted. If PlatSecEnforcement is OFF, then this function will return ETrue even though the check failed.

Parameters

TCapability aCapability1 The first capability to test.
TCapability aCapability2 The second capability to test.
const char * aDiagnostic = 0 A string that will be emitted along with any diagnostic message that may be issued if the test finds a capability is not present. This string should be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro which enables it to be easily removed from the system.

HasCapabilityL(TCapability, const char *)

void HasCapabilityL ( TCapability aCapability,
const char * aDiagnosticMessage = 0
) const [inline]

Check if the process which sent this message has a given capability.

When a check fails the action taken is determined by the system wide Platform Security configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted. If PlatSecEnforcement is OFF, then this function will not leave even though the check failed.

leave
KErrPermissionDenied, if the process does not have the capability.

Parameters

TCapability aCapability The capability to test.
const char * aDiagnosticMessage = 0 A string that will be emitted along with any diagnostic message that may be issued if the test finds the capability is not present. This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro which enables it to be easily removed from the system.

HasCapabilityL(TCapability, TCapability, const char *)

void HasCapabilityL ( TCapability aCapability1,
TCapability aCapability2,
const char * aDiagnosticMessage = 0
) const [inline]

Check if the process which sent this message has both of the given capabilities.

When a check fails the action taken is determined by the system wide Platform Security configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted. If PlatSecEnforcement is OFF, then this function will not leave even though the check failed.

leave
KErrPermissionDenied, if the process does not have the capabilities.

Parameters

TCapability aCapability1 The first capability to test.
TCapability aCapability2 The second capability to test.
const char * aDiagnosticMessage = 0 A string that will be emitted along with any diagnostic message that may be issued if the test finds a capability is not present. This string should be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro which enables it to be easily removed from the system.

Identity()

TUid Identity ( ) const [inline]

IsNull()

TBool IsNull ( ) const [inline]

Tests whether this message handle is empty.

Kill(TInt)

IMPORT_C void Kill ( TInt aReason ) const

Kills the client.

Note that this method also completes the message. A subsequent call to Complete(TInt aReason) would cause a server panic.

Parameters

TInt aReason The reason code associated with killing the client.

Panic(const TDesC &, TInt)

IMPORT_C void Panic ( const TDesC & aCategory,
TInt aReason
) const

Panics the client.

The length of the category name should be no greater than 16; any name with a length greater than 16 is truncated to 16.

Note that this method also completes the message. A subsequent call to Complete(TInt aReason) would cause a server panic.

Parameters

const TDesC & aCategory The panic category.
TInt aReason The panic code.

Read(TInt, TDes8 &, TInt)

IMPORT_C TInt Read ( TInt aParam,
TDes8 & aDes,
TInt aOffset = 0
) const

Reads data from the specified offset within the 8-bit descriptor argument, into the specified target descriptor.

Parameters

TInt aParam The index value identifying the argument. This is a value in the range 0 to (KMaxMessageArguments-1) inclusive.
TDes8 & aDes The target descriptor into which the client data is to be written.
TInt aOffset = 0 The offset from the start of the client's descriptor data. If not explicitly specified, the offset defaults to zero.

Read(TInt, TDes16 &, TInt)

IMPORT_C TInt Read ( TInt aParam,
TDes16 & aDes,
TInt aOffset = 0
) const

Reads data from the specified offset within the 16-bit descriptor argument, into the specified target descriptor.

Parameters

TInt aParam The index value identifying the argument. This is a value in the range 0 to (KMaxMessageArguments-1) inclusive.
TDes16 & aDes The target descriptor into which the client data is to be written.
TInt aOffset = 0 The offset from the start of the client's descriptor data. If not explicitly specified, the offset defaults to zero.

ReadL(TInt, TDes8 &, TInt)

IMPORT_C void ReadL ( TInt aParam,
TDes8 & aDes,
TInt aOffset = 0
) const

Reads data from the specified offset within the 8-bit descriptor argument, into the specified target descriptor, and leaving on failure.

leave
KErrArgument if aParam has a value outside the valid range, or if aOffset is negative.
leave
KErrBadDescriptor, if the message argument is not an 8-bit descriptor.

Parameters

TInt aParam The index value identifying the argument. This is a value in the range 0 to (KMaxMessageArguments-1) inclusive.
TDes8 & aDes The target descriptor into which the client data is to be written.
TInt aOffset = 0 The offset from the start of the client's descriptor data. If not explicitly specified, the offset defaults to zero.

ReadL(TInt, TDes16 &, TInt)

IMPORT_C void ReadL ( TInt aParam,
TDes16 & aDes,
TInt aOffset = 0
) const

Reads data from the specified offset within the 16-bit descriptor argument, into the specified target descriptor, and leaving on failure.

leave
KErrArgument if aParam has a value outside the valid range, or if aOffset is negative.
leave
KErrBadDescriptor, if the message argument is not a 16-bit descriptor.

Parameters

TInt aParam The index value identifying the argument. This is a value in the range 0 to (KMaxMessageArguments-1) inclusive.
TDes16 & aDes The target descriptor into which the client data is to be written.
TInt aOffset = 0 The offset from the start of the client's descriptor data. If not explicitly specified, the offset defaults to zero.

SecureId()

IMPORT_C TSecureId SecureId ( ) const

Return the Secure ID of the process which sent this message.

If an intended use of this method is to check that the Secure ID is a given value, then the use of a TSecurityPolicy object should be considered. E.g. Instead of something like:

         RMessagePtr2& message;
		TInt error = message.SecureId()==KRequiredSecureId ? KErrNone : KErrPermissionDenied;
        

this could be used;

         RMessagePtr2& message;
		static _LIT_SECURITY_POLICY_S0(mySidPolicy, KRequiredSecureId);
		TBool pass = mySidPolicy().CheckPolicy(message);
        

This has the benefit that the TSecurityPolicy::CheckPolicy methods are configured by the system wide Platform Security configuration. I.e. are capable of emitting diagnostic messages when a check fails and/or the check can be forced to always pass.

TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const _LIT_SECURITY_POLICY_S0

SetProcessPriority(TProcessPriority)

IMPORT_C TInt SetProcessPriority ( TProcessPriority aPriority ) const

Sets the priority of the client's process.

Parameters

TProcessPriority aPriority The priority value.

SetProcessPriorityL(TProcessPriority)

void SetProcessPriorityL ( TProcessPriority aPriority ) const [inline]

Sets the priority of the client's process.

Parameters

TProcessPriority aPriority The priority value.

Terminate(TInt)

IMPORT_C void Terminate ( TInt aReason ) const

Terminates the client.

Note that this method also completes the message. A subsequent call to Complete(TInt aReason) would cause a server panic.

Parameters

TInt aReason The reason code associated with terminating the client.

VendorId()

IMPORT_C TVendorId VendorId ( ) const

Return the Vendor ID of the process which sent this message.

If an intended use of this method is to check that the Vendor ID is a given value, then the use of a TSecurityPolicy object should be considered. E.g. Instead of something like:

         RMessagePtr2& message;
		TInt error = message.VendorId()==KRequiredVendorId ? KErrNone : KErrPermissionDenied;
        

this could be used;

         RMessagePtr2& message;
		static _LIT_SECURITY_POLICY_V0(myVidPolicy, KRequiredVendorId);
		TBool pass = myVidPolicy().CheckPolicy(message);
        

This has the benefit that the TSecurityPolicy::CheckPolicy methods are configured by the system wide Platform Security configuration. I.e. are capable of emitting diagnostic messages when a check fails and/or the check can be forced to always pass.

TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const _LIT_SECURITY_POLICY_V0

Write(TInt, const TDesC8 &, TInt)

IMPORT_C TInt Write ( TInt aParam,
const TDesC8 & aDes,
TInt aOffset = 0
) const

Writes data from the specified source descriptor to the specified offset within the 8-bit descriptor argument.

Parameters

TInt aParam The index value identifying the argument. This is a value in the range 0 to (KMaxMessageArguments-1) inclusive.
const TDesC8 & aDes The source descriptor containing the data to be written.
TInt aOffset = 0 The offset from the start of the client's descriptor. If not explicitly specified, the offset defaults to zero.

Write(TInt, const TDesC16 &, TInt)

IMPORT_C TInt Write ( TInt aParam,
const TDesC16 & aDes,
TInt aOffset = 0
) const

Writes data from the specified source descriptor to the specified offset within the 16-bit descriptor argument.

Parameters

TInt aParam The index value identifying the argument. This is a value in the range 0 to (KMaxMessageArguments-1) inclusive.
const TDesC16 & aDes The source descriptor containing the data to be written.
TInt aOffset = 0 The offset from the start of the client's descriptor. If not explicitly specified, the offset defaults to zero.

WriteL(TInt, const TDesC8 &, TInt)

IMPORT_C void WriteL ( TInt aParam,
const TDesC8 & aDes,
TInt aOffset = 0
) const

Writes data from the specified source descriptor to the specified offset within the 8-bit descriptor argument, and leaving on failure.

leave
KErrArgument if aParam has a value outside the valid range, or if aOffset is negative.
leave
KErrBadDescriptor, if the message argument is not an 8-bit descriptor.

Parameters

TInt aParam The index value identifying the argument. This is a value in the range 0 to (KMaxMessageArguments-1) inclusive.
const TDesC8 & aDes The source descriptor containing the data to be written.
TInt aOffset = 0 The offset from the start of the client's descriptor. If not explicitly specified, the offset defaults to zero.

WriteL(TInt, const TDesC16 &, TInt)

IMPORT_C void WriteL ( TInt aParam,
const TDesC16 & aDes,
TInt aOffset = 0
) const

Writes data from the specified source descriptor to the specified offset within the 16-bit descriptor argument, and leaving on failure.

leave
KErrArgument if aParam has a value outside the valid range, or if aOffset is negative.
leave
KErrBadDescriptor, if the message argument is not a 16-bit descriptor.

Parameters

TInt aParam The index value identifying the argument. This is a value in the range 0 to (KMaxMessageArguments-1) inclusive.
const TDesC16 & aDes The source descriptor containing the data to be written.
TInt aOffset = 0 The offset from the start of the client's descriptor. If not explicitly specified, the offset defaults to zero.

Member Data Documentation

TInt iHandle

TInt iHandle [protected]