// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "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:

 // e32\euser\us_ksvr.cpp

 // 

 //

 #include "us_std.h"

 #include "us_data.h"

 #include <e32svr.h>

 #include <e32uid.h>

 #include <e32ldr.h>	

 //#define __DEBUG_IMAGE__ 1

 #if defined(__DEBUG_IMAGE__) && defined (__EPOC32__)

 #define __IF_DEBUG(t) {RDebug::t;}

 #else

 #define __IF_DEBUG(t)

 #endif

 //

 // class RNotifier

 //

 /**

 Requests the extended notifier server to start the notifier identified by

 the specified UID.

 The request is synchronous; the call returns when the request is complete.

 The notifier may not be started immediately if a higher priority notifier is

 already active. In this case, the notifier is queued until it has the highest

 priority outstanding request for the channel(s) it operates on.

 @param aNotifierUid The UID identifying the notifier.

 @param aBuffer      Data that can be passed to the notifier; the format and meaning

                     of this depends on the notifier.

 @return KErrNone, if successful;

         KErrNotFound, if there is no notifier matching the specified UID;

         KErrAlreadyExists, if the notifier has already been started, or has

         an outstanding start request. It may also return with one of the other

         system-wide error codes, if the notifier cannot be started by

         the server due to low memory or it leaves from its server side

         call to StartL().

 @see CServer

 */

 EXPORT_C TInt RNotifier::StartNotifier(TUid aNotifierUid, const TDesC8& aBuffer)

 	{

 	return SendReceive(EStartNotifier, TIpcArgs(

 										(TInt)aNotifierUid.iUid,

 										&aBuffer,

 										(TAny*)NULL // No resonse required

 										));

 	}

 /**

 Requests the extended notifier server to start the notifier identified by

 the specified UID.

 The request is synchronous; the call returns when the request is complete.

 The notifier may not start immediately if a higher priority notifier is

 already active. In this case, the notifier is queued until it has the highest

 priority outstanding request for the channel(s) it operates on.

 This can also cause unexpected behaviour: the function can return

 before the notifier has been started with the added consequence that no response

 data is written.

 For this reason, this function has been deprecated. Instead, use

 RNotifier::StartNotifierAndGetResponse(), or if there is no need to wait for a

 response, use the two argument overload of RNotifier::StartNotifier().

 @param aNotifierUid The UID identifying the notifier.

 @param aBuffer      Data that can be passed to the notifier; the format and meaning

                     of this depends on the notifier.

 @param aResponse    Response data; the format

                     and meaning of this depends on the notifier.

 @return KErrNone, if successful;

         KErrNotFound, if there is no notifier matching the specified UID;

         KErrAlreadyExists, if the notifier has already been started, or has

         an outstanding start request. It may also return with one of the other

         system-wide error codes, if the notifier cannot be started by

         the server due to low memory or it leaves from its server side

         call to StartL().

 @see CServer

 @deprecated use RNotifier::StartNotifierAndGetResponse(), or if there is no

             need to wait for a response, use the two argument overload

             of RNotifier::StartNotifier()

 */

 EXPORT_C TInt RNotifier::StartNotifier(TUid aNotifierUid, const TDesC8& aBuffer, TDes8& aResponse)

 	{

 	return SendReceive(EStartNotifier, TIpcArgs(

 										(TInt)aNotifierUid.iUid,

 										&aBuffer,

 										&aResponse

 										));

 	}

 /*

 This function has never been implemented on any Symbian OS version.

 It always returns KErrNotSupported.

 @publishedPartner

 @removed

 */

 EXPORT_C TInt RNotifier::StartNotifier(TUid aNotifierDllUid,TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse)

 	{

 	return SendReceive(EStartNotifierFromSpecifiedDll, TIpcArgs(

 										(TInt)aNotifierUid.iUid,

 										&aBuffer,

 										&aResponse,

 										(TInt)aNotifierDllUid.iUid

 										));

 	}

 /**

 Requests the extended notifier server to cancel the notifier identified by

 the specified UID.

 The request is synchronous; the call returns when the request is complete.

 Any notifier that was queued pending the completion of aNotifierUid will be

 automatically started.

 @param  aNotifierUid The UID identifying the notifier.

 @return KErrNone, if successful;

         KErrNotFound, if there is no notifier matching the specified UID.

 */

 EXPORT_C TInt RNotifier::CancelNotifier(TUid aNotifierUid)

 	{

 	return SendReceive(ECancelNotifier, TIpcArgs( (TInt)aNotifierUid.iUid ));

 	}

 /**

 Requests the extended notifier server to update the active notifier identified by

 the specified UID.

 The request is synchronous; the call returns when the request is complete.

 @param aNotifierUid The UID identifying the notifier.

 @param aBuffer      Data that can be passed to the notifier; the format and meaning

                     of this depends on the notifier.

 @param aResponse    Reserved for future use.

 @return KErrNone, if successful;

         KErrNotFound, if there is no notifier matching the specified UID.

 */

 EXPORT_C TInt RNotifier::UpdateNotifier(TUid aNotifierUid, const TDesC8& aBuffer,TDes8& aResponse)

 	{

 	return SendReceive(EUpdateNotifier, TIpcArgs(

 										(TInt)aNotifierUid.iUid,

 										&aBuffer,

 										&aResponse

 										));

 	}

 /**

 Requests the extended notifier server to update the active notifier identified by

 the specified UID.

 This is an asynchronous request.It may be called multiple times for

 some notifier implementations; see specific notifier documentation for exact details.

 @param aRs          The request status. On request completion, contains:

                     KErrNone, if successful; otherwise, one of the other system

                     wide error codes.

 @param aNotifierUid The UID identifying the notifier.

 @param aBuffer      Data that can be passed to the notifier; the format and meaning

                     of this depends on the notifier.

 @param aResponse    Reserved for future use.

 */

 EXPORT_C void RNotifier::UpdateNotifierAndGetResponse(TRequestStatus& aRs, TUid aNotifierUid, const TDesC8& aBuffer, TDes8& aResponse)

 	{

 	SendReceive(EUpdateNotifierAndGetResponse, TIpcArgs(

 										(TInt)aNotifierUid.iUid,

 										&aBuffer,

 										&aResponse

 										), aRs);

 	}

 /**

 Requests the extended notifier server to start the notifier identified by

 the specified UID.

 This is an asynchronous request.It may be called multiple times for

 some notifier implementations; see specific notifier documentation for exact details.

 @param aRs          The request status. On request completion, contains:

                     KErrNone, if successful; otherwise, one of the other system

                     wide error codes.

 @param aNotifierUid The UID identifying the notifier.

 @param aBuffer      Data that can be passed to the notifier; the format

                     and meaning of this depends on the notifier.

 @param aResponse    Response data; the format

                     and meaning of this depends on the notifier.

 */

 EXPORT_C void RNotifier::StartNotifierAndGetResponse(TRequestStatus& aRs,TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse)

 	{

 	SendReceive(EStartNotifierAndGetResponse, TIpcArgs(

 										(TInt)aNotifierUid.iUid,

 										&aBuffer,

 										&aResponse

 										), aRs);

 	}

 /**

 @publishedPartner

 @removed

 This function has never been implemented on any Symbian OS version.

 The request always completes with KErrNotSupported.

 */

 EXPORT_C void RNotifier::StartNotifierAndGetResponse(TRequestStatus& aRs,TUid aNotifierDllUid,TUid aNotifierUid,const TDesC8& aBuffer,TDes8& aResponse)

 	{

 	SendReceive(EStartNotifierFromSpecifiedDllAndGetResponse, TIpcArgs(

 										(TInt)aNotifierUid.iUid,

 										&aBuffer,

 										&aResponse,

 										(TInt)aNotifierDllUid.iUid

 										), aRs);

 	}

 /**

 @publishedPartner

 @removed

 This function has never been implemented on any Symbian OS version.

 It always returns KErrNotSupported.

 */

 EXPORT_C TInt RNotifier::UnloadNotifiers(TUid /*aNotifierUid*/)

 	{

 	return KErrNotSupported;

 	}

 /**

 @publishedPartner

 @removed

 This function has never been implemented on any Symbian OS version.

 It always returns KErrNotSupported.

 */

 EXPORT_C TInt RNotifier::LoadNotifiers(TUid /*aNotifierUid*/)

 	{

 	return KErrNotSupported;

 	}

 /**

 Default constructor.

 */		

 EXPORT_C RNotifier::RNotifier()

 	:	iButtonVal(NULL,0),

 		iCombinedBuffer(NULL)

 	{}

 /**

 Connects to the extended notifier server, creating a session with that server.

 Note: Notifier server is started during window server start-up sequence.

 The function must be called before any other function.

 @return KErrNone, if successful, otherwise one of the other system-wide error codes 

 */

 EXPORT_C TInt RNotifier::Connect()

 	{

 	return CreateSession(__NOTIFIER_NAME,TVersion(KNotifierMajorVersionNumber,KNotifierMinorVersionNumber,KNotifierBuildVersionNumber),-1);

 	}

 /**

 Launches a simple two line dialog that displays two lines of text.

 This is an asynchronous request that completes when the dialog exits.

 @param aLine1     A descriptor containing the first line of text to be displayed.

 @param aLine2     A descriptor containing the second line of text to be displayed.

 @param aBut1      A descriptor containing text to be displayed in the first button.

 @param aBut2      A descriptor containing text to be displayed in the (optional) second button.

 @param aButtonVal An integer value which is set when the dialog exits. It is set to:

                   0, if the first button is selected;

                   1, if the second button is selected.

 @param aStatus    The request status object. If the request completes normally, this is set to KErrNone.

 */

 EXPORT_C void RNotifier::Notify(const TDesC& aLine1,const TDesC& aLine2,const TDesC& aBut1,const TDesC& aBut2, TInt& aButtonVal, TRequestStatus& aStatus)

 	{

 	const TInt requiredLengthOfCombinedBuffer=aLine1.Length()+aLine2.Length()+aBut1.Length()+aBut2.Length();

 	if ((iCombinedBuffer!=NULL) && (iCombinedBuffer->Des().MaxLength()<requiredLengthOfCombinedBuffer))

 		{

 		delete iCombinedBuffer;

 		iCombinedBuffer=NULL;

 		}

 	if (iCombinedBuffer==NULL)

 		{

 		iCombinedBuffer=HBufC::New(requiredLengthOfCombinedBuffer);

 		}

 	if (iCombinedBuffer==NULL)

 		{

 		// report the error back via the TRequestStatus

 		TRequestStatus* status=&aStatus;

 		User::RequestComplete(status,KErrNoMemory);

 		}

 	else

 		{

 		TPtr combinedBufferForNotify(iCombinedBuffer->Des());

 		combinedBufferForNotify = aLine1;

 		combinedBufferForNotify.Append(aLine2);

 		combinedBufferForNotify.Append(aBut1);

 		combinedBufferForNotify.Append(aBut2);

 		iButtonVal.Set(REINTERPRET_CAST(TUint8*,&aButtonVal),sizeof(TInt),sizeof(TInt));

 		__ASSERT_ALWAYS(((aLine1.Length()|aLine2.Length()|aBut1.Length()|aBut2.Length())&~KMaxTUint16)==0,Panic(ENotifierTextTooLong)); // check that all of the descriptor lengths are less than or equal to KMaxTUint16

 		SendReceive(ENotifierNotify,TIpcArgs(&iButtonVal,iCombinedBuffer,(aLine1.Length()<<16)|aLine2.Length(),(aBut1.Length()<<16)|aBut2.Length()),aStatus);

 		}

 	}

 /**

 Not implemented by the server.

 */

 EXPORT_C void RNotifier::NotifyCancel()

 	{

 	SendReceive(ENotifierNotifyCancel,TIpcArgs()); // ignores any returned error

 	}

 /**

 Closes the notifier.

 */

 EXPORT_C void RNotifier::Close()

 	{

 	delete iCombinedBuffer;

 	iCombinedBuffer=NULL;

 	RSessionBase::Close();

 	}

 /**

 @internalAll

 */

 EXPORT_C TInt RNotifier::InfoPrint(const TDesC& aDes)

 	{

 	return SendReceive(ENotifierInfoPrint, TIpcArgs(&aDes));

 	}

 //

 // Class TChunkCreateInfo

 //

 /**

 Default constructor. 

 This defaults the chunk to be created to be local, to have no attributes set

 and to use the default clear byte.

 A local chunk is private to the process creating it and is not 

 intended for access by other user processes.

 */

 EXPORT_C TChunkCreateInfo::TChunkCreateInfo() :

 	// Specifing individual initialisers for members instead of using memclear

 	// so that Coverity doesn't complain about uninitialised local variables in

 	// calls to e.g., TChunkCreateInfo::SetPaging().

 	iVersionNumber(0),

 	iType(TChunkCreate::ENormal),

     iGlobal(EFalse),

     iMaxSize(0),

     iOwnerType(EOwnerProcess),

     iName(NULL),

     iInitialBottom(0),

     iInitialTop(0),

     iAttributes(TChunkCreate::EPagingUnspec),

 	iClearByte(KChunkClearByteDefault)

 	{

 	}

 /**	

 Sets the chunk to be created to have a committed region that always starts at the 

 bottom of the reserved region.

 @param aSize    The number of bytes committed to this chunk.

 @param aMaxSize The maximum size to which the reserved region of this chunk 

                 can grow.

 @see RChunk::CreateLocal()

 */

 EXPORT_C void TChunkCreateInfo::SetNormal(TInt aInitialSize, TInt aMaxSize)

 	{

 	iType = TChunkCreate::ENormal | TChunkCreate::EData;

 	iInitialBottom = 0;

 	iInitialTop = aInitialSize;

 	iMaxSize = aMaxSize;

 	}

 /**

 Sets the chunk to be created to be user writable and to be marked by the kernel

 as containing code.

 This can only be set on local chunks.

 @param aInitialSize	The number of bytes committed to this chunk.

 @param aMaxSize 	The maximum size to which the reserved region of this chunk

                 	can grow.

 @see RChunk::CreateLocalCode()

 */

 EXPORT_C void TChunkCreateInfo::SetCode(TInt aInitialSize, TInt aMaxSize)

 	{

 	iType = TChunkCreate::ENormal | TChunkCreate::ECode;

 	iInitialBottom = 0;

 	iInitialTop = aInitialSize;

 	iMaxSize = aMaxSize;

 	}

 /**	

 Sets the chunk to be created to have a commited region that that can be any 

 contiguous subset of the reserved region.

 @param aInitialBottom The offset of the bottom of the new committed region 

                       from the base of the chunk's reserved region.

 @param aInitialTop    The offset of the top of the new committed region from

                       the  base of the chunk's reserved region. 

 @param aMaxSize       The maximum size to which the reserved region of

                       this chunk can grow.

 @see RChunk::CreateDoubleEndedLocal()

 */

 EXPORT_C void TChunkCreateInfo::SetDoubleEnded(TInt aInitialBottom, TInt aInitialTop, TInt aMaxSize)

 	{

 	iType = TChunkCreate::EDoubleEnded | TChunkCreate::EData;

 	iInitialBottom = aInitialBottom;

 	iInitialTop = aInitialTop;

 	iMaxSize = aMaxSize;

 	}

 /** 

 Set the chunk to be created to have a committed region consisting of an 

 arbitrary set of MMU pages within the reserved region.

 @param aInitialBottom 	The offset of the bottom of the new committed region 

                       	from the base of the chunk's reserved region.

 @param aInitialTop		The offset of the top of the new committed region 

 						from the  base of the chunk's reserved region. 

 @param aMaxSize       	The maximum size to which the reserved region of

                       	this chunk can grow.

 @see RChunk::CreateDisconnectedLocal()

 */

 EXPORT_C void TChunkCreateInfo::SetDisconnected(TInt aInitialBottom, TInt aInitialTop, TInt aMaxSize)

 	{

 	iType = TChunkCreate::EDisconnected | TChunkCreate::EData;

 	iInitialBottom = aInitialBottom;

 	iInitialTop = aInitialTop;

 	iMaxSize = aMaxSize;

 	}

 /**	

 Sets the chunk to be created to be a thread heap chunk.

 For internal use only.

 @param aInitialSize	The number of bytes committed to this chunk.

 @param aMaxSize 	The maximum size to which the reserved region of this chunk 

                 	can grow.

 @param aName		The name to be given to the chunk to be created

 @internalComponent

 */

 void TChunkCreateInfo::SetThreadHeap(TInt aInitialSize, TInt aMaxSize, const TDesC& aName)

 	{

 	iType = TChunkCreate::ENormal | TChunkCreate::EData;

 	iInitialBottom = 0;

 	iInitialTop = aInitialSize;

 	iMaxSize = aMaxSize;

 	iAttributes |= TChunkCreate::ELocalNamed;

 	iName = &aName;

 	iOwnerType = EOwnerThread;

 	}

 /** 

 Sets the owner of the chunk to be created.

 @param aType	The owner of the chunk to be created.

 */

 EXPORT_C void TChunkCreateInfo::SetOwner(TOwnerType aType)

 	{

 	iOwnerType = aType;

 	}

 /** 

 Sets the chunk to be created to be global, i.e. it is potentially visible

 to all processes and is intended for access by other user processes.

 @param aName          A reference to a descriptor containing the name to be

                       assigned to the global chunk. The length of

                       the descriptor must be no greater than that allowed for

                       a TKName type.

 */

 EXPORT_C void TChunkCreateInfo::SetGlobal(const TDesC& aName)

 	{

 	iName = &aName;

 	iGlobal = ETrue;

 	}

 /** 

 Sets the byte value that all memory committed to the chunk will be cleared to.

 @param TUint8 aClearByte.

 */

 EXPORT_C void TChunkCreateInfo::SetClearByte(TUint8 aClearByte)

 	{

 	iClearByte = aClearByte;

 	}

 /** 

 Sets the data paging attributes for the chunk to be created.  Any previous calls

 to this method will be overridden for this TChunkCreateInfo object.

 @param aPaging	The data paging attributes of the chunk to be created.

 @prototype

 */

 EXPORT_C void TChunkCreateInfo::SetPaging(const TChunkPagingAtt aPaging)

 	{

 	__ASSERT_COMPILE(TChunkCreate::EPagingUnspec == 0);

 	iAttributes &= ~TChunkCreate::EPagingMask;

 	if (aPaging == EPaged)

 		iAttributes |= TChunkCreate::EPaged;

 	if (aPaging == EUnpaged)

 		iAttributes |= TChunkCreate::EUnpaged;

 	}

 /**

 Sets the global chunk to be created to be read only. Only the creating process

 will be able to write to it, not other processes.

 Read-Only chunks are currently only available on the Flexible Memory Model.

 Chunk must be global.

 */

 EXPORT_C void TChunkCreateInfo::SetReadOnly()

 	{

 	iAttributes |= TChunkCreate::EReadOnly;

 	}

 EXPORT_C void TChunkCreateInfo::SetCache(TInt aMaxSize)

 	{

 	iType = TChunkCreate::ECache | TChunkCreate::EData;

 	iInitialBottom = 0;

 	iInitialTop = 0;

 	iMaxSize = aMaxSize;

 	SetPaging(EUnpaged);

 	}

 //

 // class RChunk

 //

 EXPORT_C TInt RChunk::CreateLocal(TInt aSize,TInt aMaxSize,TOwnerType aType)

 /**

 Creates a local chunk.

 The chunk is local to the process creating it; i.e. it is private to the process 

 creating it and is not intended for access by other user processes.

 aMaxSize specifies the maximum size of the chunk and aSize specifies the number 

 of bytes to be committed on creation of the chunk. Both values are rounded 

 up to the next nearest processor page boundary value if they are not already 

 on a processor page boundary.

 The committed region always starts at the bottom of the reserved region.

 By default, ownership of this chunk handle is vested in the current process. 

 Ownership of the chunk handle can be vested in the current thread by passing 

 EOwnerThread as the third parameter to this function. 

 @param aSize    The number of bytes committed to this chunk.

 @param aMaxSize The maximum size to which the reserved region of this chunk 

                 can grow.

 @param aType    An enumeration whose enumerators define the ownership of this 

                 chunk handle. If not explicitly specified, EOwnerProcess is

                 taken as default.

 @return KErrNone if successful, otherwise another of the system-wide error 

         codes.

 @panic USER 99  if aMaxSize is negative.

 @panic USER 100 if aSize is negative.

 @panic USER 101 if aSize is greater than or equal to the supplied

        value of aMaxSize.

 */

 	{

 	TChunkCreateInfo createInfo;

 	createInfo.SetNormal(aSize, aMaxSize);

 	createInfo.SetOwner(aType);

 	return Create(createInfo);

 	}

 EXPORT_C TInt RChunk::CreateLocalCode(TInt aSize,TInt aMaxSize,TOwnerType aType)

 /**

 Creates a user writable chunk that is marked by the kernel as containing code.

 The chunk is local to the process creating it, i.e. it is private to the process 

 creating it and is not intended for access by other user processes.

 On systems using a Harvard cache, this type of chunk removes the need to flush 

 the instruction cache (I-Cache) on a context switch. However, the instruction 

 Translation Look-aside Buffer (ITLB) still needs to be flushed when switching 

 to or from a process with one of these chunks in its address space.  Systems with

 a dynamic branch predictor may also need to flush their branch target buffer when

 switching from one process using this type of chunk to another.

 @param aSize    The number of bytes committed to this chunk.

 @param aMaxSize The maximum size to which the reserved region of this chunk 

                 can grow. 

 @param aType    An enumeration whose enumerators define the ownership of this 

                 chunk handle. If not explicitly specified, EOwnerProcess is

                 taken as default.

 @return KErrNone if successful, otherwise another of the system-wide error 

         codes.

 @panic USER 99  if aMaxSize is negative.

 @panic USER 100 if aSize is negative.

 @panic USER 101 if aSize is greater than or equal to the supplied

        value of aMaxSize.

 @see UserHeap::ChunkHeap

 @see User::IMB_Range

 */

 	{

 	TChunkCreateInfo createInfo;

 	createInfo.SetCode(aSize, aMaxSize);

 	createInfo.SetOwner(aType);

 	return Create(createInfo);

 	}

 EXPORT_C TInt RChunk::CreateGlobal(const TDesC &aName,TInt aSize,TInt aMaxSize,TOwnerType aType)

 /**

 Creates a global chunk.

 The chunk is global; i.e. it is potentially visible to all processes and is

 intended for access by other user processes.

 aMaxSize specifies the maximum size of the chunk and aSize specifies the number 

 of bytes to be committed on creation of the chunk. Both values are rounded 

 up to the next nearest processor page boundary value ,if they are not already 

 on a processor page boundary value.

 The committed region always starts at the bottom of the reserved region.

 The descriptor aName contains the name to be assigned to this global chunk. If

 this name is empty, the chunk will be anonymous. Anonymous chunks cannot be

 accessed by other processes unless the creator explicitly passes them a handle

 to the chunk - this can be used to transfer large amounts of data between

 processes in a secure fashion.

 By default, ownership of this chunk handle is vested in the current process. 

 Ownership of the chunk handle can be vested in the current thread by passing 

 EOwnerThread as the third parameter to this function.

 @param aName    A reference to a descriptor containing the name to be assigned 

                 to this global chunk. The length of the descriptor must be no

                 greater than that allowed for a TKName type.

 @param aSize    The number of bytes committed to this chunk.

 @param aMaxSize The maximum size to which the reserved region of this chunk 

                 can grow. 

 @param aType    An enumeration whose enumerators define the ownership of this 

                 chunk handle. If not explicitly specified, EOwnerProcess is taken

                 as default.

 @return KErrNone if successful, otherwise another of the system error codes.

 @panic USER 99  if aMaxSize is negative.

 @panic USER 100 if aSize is negative.

 @panic USER 101 if aSize is greater than or equal to the supplied

        value of aMaxSize.

 */

 	{

 	TChunkCreateInfo createInfo;

 	createInfo.SetNormal(aSize, aMaxSize);

 	createInfo.SetGlobal(aName);

 	createInfo.SetOwner(aType);

 	return Create(createInfo);

 	}

 EXPORT_C TInt RChunk::CreateDoubleEndedLocal(TInt aInitialBottom, TInt aInitialTop,TInt aMaxSize,TOwnerType aType)

 /**

 Creates a local, double ended, chunk.

 The chunk is local to the process creating it; i.e. it is private to

 the process creating it and is not intended for access by other

 user processes.

 The committed region of a double ended chunk can be any contiguous subset 

 of the reserved region.

 aMaxSize specifies the maximum size of the chunk.

 The difference between aInitialTop and aInitialBottom gives the number of 

 bytes to be committed, on creation of the chunk; aInitialBottom gives the 

 offset of the bottom of the committed region from the base of the chunk's 

 reserved region; aInitialTop gives the offset of the top of the committed 

 region from the base of the chunk's reserved region.

 Both aInitialBottom and aInitialTop are rounded up to the next nearest

 processor page boundary value, if they are not already on

 a processor page boundary value.

 By default, ownership of this chunk handle is vested in the current process. 

 Ownership of the chunk handle can be vested in the current thread by passing 

 EOwnerThread as the third parameter to this function.

 Note that:

 1. the lowest valid address in a double ended chunk is the sum of the base of 

    the chunk's reserved region plus the adjusted value of aInitialBottom

 2. the highest valid address in a double ended chunk is the the sum of the base 

    of the chunk's reserved region plus the adjusted value of aInitialTop - 1.

 @param aInitialBottom The offset of the bottom of the new committed region 

                       from the base of the chunk's reserved region.

 @param aInitialTop    The offset of the top of the new committed region from

                       the  base of the chunk's reserved region. 

 @param aMaxSize       The maximum size to which the reserved region of

                       this chunk can grow.

 @param aType          An enumeration whose enumerators define the ownership of

                       this chunk handle. If not explicitly specified,

                       EOwnerProcess is taken as default.

 @return KErrNone if successful, otherwise another of the system error codes.

 @panic USER 99  if aMaxSize is negative.

 @panic USER 120 if aInitialBottom is negative.

 @panic USER 121 if aInitialTop is negative.

 @panic USER 122 if aInitialBottom is greater than the supplied value

        of aInitialTop.

 @panic USER 123 if aInitialTop is greater than the supplied value of aMaxSize.

 */

 	{

 	TChunkCreateInfo createInfo;

 	createInfo.SetDoubleEnded(aInitialBottom, aInitialTop, aMaxSize);

 	createInfo.SetOwner(aType);

 	return Create(createInfo);

 	}

 EXPORT_C TInt RChunk::CreateDoubleEndedGlobal(const TDesC &aName,TInt aInitialBottom,TInt aInitialTop,TInt aMaxSize,TOwnerType aType)

 /**

 Creates a global, double ended, chunk.

 The chunk is global; i.e. it is visible to all processes and is intended

 for access by other user processes.

 The committed region of a double ended chunk can be any contiguous subset 

 of the reserved region.

 aMaxSize specifies the maximum size of the chunk.

 The difference between aInitialTop and aInitialBottom gives the number of 

 bytes to be committed, on creation of the chunk; aInitialBottom gives the 

 offset of the bottom of the committed region from the base of the chunk's 

 reserved region; aInitialTop gives the offset of the top of the committed 

 region from the base of the chunk's reserved region.

 Both aInitialBottom and aInitialTop are rounded up to the next nearest

 processor page boundary value, if they are not already on a processor page

 boundary value.

 The descriptor aName contains the name to be assigned to this global chunk.

 By default, ownership of this chunk handle is vested in the current process. 

 Ownership of the chunk handle can be vested in the current thread by passing 

 EOwnerThread as the third parameter to this function. 

 Note that:

 1. the lowest valid address in a double ended chunk is the sum of the base of 

    the chunk's reserved region plus the adjusted value of aInitialBottom

 2. the highest valid address in a double ended chunk is the the sum of the base 

    of the chunk's reserved region plus the adjusted value of aInitialTop - 1.

 @param aName          A reference to a descriptor containing the name to be

                       assigned to this global chunk. The length of

                       the descriptor must be no greater than that allowed for

                       a TKName type.

 @param aInitialBottom The offset of the bottom of the new committed region 

                       from the base of the chunk's reserved region.

 @param aInitialTop    The offset of the top of the new committed region from

                       the base of the chunk's reserved region. 

 @param aMaxSize       The maximum size to which the reserved region of

                       this chunk can grow. 

 @param aType          An enumeration whose enumerators define the ownership of

                       this chunk handle. If not explicitly specified,

                       EOwnerProcess is taken as default.

 @return KErrNone if successful, otherwise another of the system error codes.

 @panic USER 99  if aMaxSize is negative.

 @panic USER 120 if aInitialBottom is negative.

 @panic USER 121 if aInitialTop is negative.

 @panic USER 122 if aInitialBottom is greater than the supplied value

        of aInitialTop.

 @panic USER 123 if aInitialTop is greater than the supplied value of aMaxSize.

 @panic USER 163 if aName is empty.

 */

 	{

 	TChunkCreateInfo createInfo;

 	createInfo.SetDoubleEnded(aInitialBottom, aInitialTop, aMaxSize);

 	createInfo.SetGlobal(aName);

 	createInfo.SetOwner(aType);

 	return Create(createInfo);

 	}

 EXPORT_C TInt RChunk::CreateDisconnectedLocal(TInt aInitialBottom, TInt aInitialTop,TInt aMaxSize,TOwnerType aType)

 /**

 Creates a local, disconnected chunk.

 The chunk is local to the process creating it; i.e. it is private to

 the process creating it and is not intended for access by other

 user processes.

 A disconnected chunk has a committed region consisting of an arbitrary set

 of MMU pages within the reserved region, i.e. each page-sized address range

 within the reserved region which begins on a page boundary may be committed

 independently.

 aMaxSize specifies the maximum size of the chunk.

 The difference between aInitialTop and aInitialBottom gives the number of 

 bytes to be committed, on creation of the chunk; aInitialBottom gives the 

 offset of the bottom of the committed region from the base of the chunk's 

 reserved region; aInitialTop gives the offset of the top of the committed 

 region from the base of the chunk's reserved region.

 Both aInitialBottom and aInitialTop are rounded up to the next nearest

 processor page boundary value, if they are not already on

 a processor page boundary value.

 By default, ownership of this chunk handle is vested in the current process. 

 Ownership of the chunk handle can be vested in the current thread by passing 

 EOwnerThread as the third parameter to this function.

 @param aInitialBottom The offset of the bottom of the new committed region 

                       from the base of the chunk's reserved region.

 @param aInitialTop    The offset of the top of the new committed region from

                       the  base of the chunk's reserved region. 

 @param aMaxSize       The maximum size to which the reserved region of

                       this chunk can grow.

 @param aType          An enumeration whose enumerators define the ownership of

                       this chunk handle. If not explicitly specified,

                       EOwnerProcess is taken as default.

 @return KErrNone if successful, otherwise another of the system error codes.

 @panic USER 99  if aMaxSize is negative.

 @panic USER 120 if aInitialBottom is negative.

 @panic USER 121 if aInitialTop is negative.

 @panic USER 122 if aInitialBottom is greater than the supplied value

        of aInitialTop.

 @panic USER 123 if aInitialTop is greater than the supplied value of aMaxSize.

 */

 	{

 	TChunkCreateInfo createInfo;

 	createInfo.SetDisconnected(aInitialBottom, aInitialTop, aMaxSize);

 	createInfo.SetOwner(aType);

 	return Create(createInfo);

 	}

 EXPORT_C TInt RChunk::CreateDisconnectedGlobal(const TDesC &aName,TInt aInitialBottom,TInt aInitialTop,TInt aMaxSize,TOwnerType aType)

 /**

 Creates a global, disconnected, chunk.

 The chunk is global; i.e. it is visible to all processes and is intended

 for access by other user processes.

 A disconnected chunk has a committed region consisting of an arbitrary set

 of MMU pages within the reserved region, i.e. each page-sized address range

 within the reserved region which begins on a page boundary may be committed

 independently.

 aMaxSize specifies the maximum size of the chunk.

 The difference between aInitialTop and aInitialBottom gives the number of 

 bytes to be committed, on creation of the chunk; aInitialBottom gives the 

 offset of the bottom of the committed region from the base of the chunk's 

 reserved region; aInitialTop gives the offset of the top of the committed 

 region from the base of the chunk's reserved region.

 Both aInitialBottom and aInitialTop are rounded up to the next nearest

 processor page boundary value, if they are not already on a processor page

 boundary value.

 The descriptor aName contains the name to be assigned to this global chunk.

 By default, ownership of this chunk handle is vested in the current process. 

 Ownership of the chunk handle can be vested in the current thread by passing 

 EOwnerThread as the third parameter to this function. 

 @param aName          A reference to a descriptor containing the name to be

                       assigned to this global chunk. The length of

                       the descriptor must be no greater than that allowed for

                       a TKName type.

 @param aInitialBottom The offset of the bottom of the new committed region 

                       from the base of the chunk's reserved region.

 @param aInitialTop    The offset of the top of the new committed region from

                       the base of the chunk's reserved region. 

 @param aMaxSize       The maximum size to which the reserved region of

                       this chunk can grow. 

 @param aType          An enumeration whose enumerators define the ownership of

                       this chunk handle. If not explicitly specified,

                       EOwnerProcess is taken as default.

 @return KErrNone if successful, otherwise another of the system error codes.

 @panic USER 99  if aMaxSize is negative.

 @panic USER 120 if aInitialBottom is negative.

 @panic USER 121 if aInitialTop is negative.

 @panic USER 122 if aInitialBottom is greater than the supplied value

        of aInitialTop.

 @panic USER 123 if aInitialTop is greater than the supplied value of aMaxSize.

 */

 	{

 	TChunkCreateInfo createInfo;

 	createInfo.SetDisconnected(aInitialBottom, aInitialTop, aMaxSize);

 	createInfo.SetGlobal(aName);

 	createInfo.SetOwner(aType);

 	return Create(createInfo);

 	}

 /**

 Creates a chunk of the type specified by the parameter aCreateInfo.

 @param aCreate	A reference to a TChunkCreateInfo object specifying the type of 

 				chunk to create.

 @return KErrNone on success, otherwise on of the system wide error codes.

 @panic USER 99  if the specified maximum size is negative.

 @panic USER 120 if any specified initial bottom is negative.

 @panic USER 121 if any specified initial top is negative.

 @panic USER 122 if any specified initial bottom is greater than the supplied value

        for the intial top.

 @panic USER 123 if any specified initial top is greater than the supplied value for the maximum size.

 @panic USER 214 if any of the specified attributes is invalid.

 @panic USER 215 if the version number of aCreateInfo is invalid.

 */

 EXPORT_C TInt RChunk::Create(TChunkCreateInfo& aCreateInfo)

 	{

 	// Verify the version number of TChunkCreateInfo is supported

 	__ASSERT_ALWAYS(aCreateInfo.iVersionNumber < TChunkCreateInfo::ESupportedVersions, 

 					Panic(EChkCreateInvalidVersion));

 	TUint mapping = aCreateInfo.iType & ~TChunkCreate::ECode;

 	TBool shouldBeNamed = 	aCreateInfo.iGlobal || 

 							(aCreateInfo.iAttributes & TChunkCreate::ELocalNamed);

 	__ASSERT_ALWAYS(mapping <= (TUint)TChunkCreate::ECache, Panic(EChkCreateInvalidType));

 	__ASSERT_ALWAYS(!(aCreateInfo.iType & TChunkCreate::ECode) || !aCreateInfo.iGlobal, 

 					Panic(EChkCreateInvalidType));

 	__ASSERT_ALWAYS((!shouldBeNamed && aCreateInfo.iName == NULL) || 

 					(shouldBeNamed && aCreateInfo.iName),

 					Panic(EChkCreateInvalidName));

 	__ASSERT_ALWAYS(aCreateInfo.iMaxSize >= 0, Panic(EChkCreateMaxSizeNegative));

 	__ASSERT_ALWAYS(!(aCreateInfo.iAttributes & ~TChunkCreate::EChunkCreateAttMask), Panic(EChkCreateInvalidAttribute));

 	if(mapping == TChunkCreate::ENormal)

 		{

 		// 'normal' chunks have different semantics for the meanings of

 		// aInitialBottom and aInitialTop

 		__ASSERT_ALWAYS(!aCreateInfo.iInitialBottom, Panic(EChkCreateInvalidBottom));

 		__ASSERT_ALWAYS(aCreateInfo.iInitialTop >= 0, Panic(EChkCreateSizeNotPositive));

 		__ASSERT_ALWAYS(aCreateInfo.iInitialTop <= aCreateInfo.iMaxSize, Panic(EChkCreateMaxLessThanMin));

 		}

 	else

 		{

 		__ASSERT_ALWAYS(aCreateInfo.iInitialBottom >= 0, Panic(EChkCreateBottomNegative));

 		__ASSERT_ALWAYS(aCreateInfo.iInitialTop >= 0, Panic(EChkCreateTopNegative));

 		__ASSERT_ALWAYS(aCreateInfo.iInitialTop >= aCreateInfo.iInitialBottom, Panic(EChkCreateTopLessThanBottom));

 		__ASSERT_ALWAYS(aCreateInfo.iInitialTop <= aCreateInfo.iMaxSize, Panic(EChkCreateTopBiggerThanMax));

 		}

 	TChunkCreate info;

 	info.iAtt = aCreateInfo.iAttributes | (TUint)aCreateInfo.iType;

 	info.iAtt |= (aCreateInfo.iGlobal)? TChunkCreate::EGlobal : TChunkCreate::ELocal;	// Add the global attribute

 	info.iForceFixed = EFalse;

 	info.iInitialBottom = aCreateInfo.iInitialBottom;

 	info.iInitialTop = aCreateInfo.iInitialTop;

 	info.iMaxSize = aCreateInfo.iMaxSize;

 	info.iClearByte = aCreateInfo.iClearByte;

 	TDesC8* ptrName = NULL;

 	TBuf8<KMaxKernelName> name8;

 	if(aCreateInfo.iName)

 		{

 		TInt r = User::ValidateName(*aCreateInfo.iName);

 		if(KErrNone!=r)

 			return r;

 		name8.Copy(*aCreateInfo.iName);

 		ptrName = &name8;

 		}

 	return SetReturnedHandle(Exec::ChunkCreate(aCreateInfo.iOwnerType, ptrName, info),*this);	

 	}

 EXPORT_C TInt RChunk::OpenGlobal(const TDesC &aName,TBool isReadOnly,TOwnerType aType)

 /**

 Opens a handle to a specific named global chunk.

 Full read/write access can be allowed or access can be limited to read only.

 By default, ownership of this process handle is vested in the current process, 

 but can be vested in the current thread by passing EOwnerThread as the second 

 parameter to this function.

 @param aName      A reference to the descriptor containing the name of

                   the chunk to be opened.

 @param isReadOnly This is currently not implemented and setting it to ETrue

 				  will have no effect.

 				  (Intended implementation will be as below:

 				  Defines the type of access to the chunk: Specify ETrue if 

                   access is limited to read only, otherwise specify EFalse

                   for full read/write access.)

 @param aType      An enumeration whose enumerators define ownership of

                   this chunk handle. If not explicitly specified,

                   EOwnerProcess is taken as default.

 @return KErrNone if successful, otherwise another of the system error codes.

 */

 	{

 	(void) isReadOnly; // This is not currently used

 	return OpenByName(aName,aType,EChunk);

 	}

 /**

 Opens a handle to a chunk using a handle number sent by a client

 to a server.

 This function is called by the server.

 @param aMessage   The message pointer.

 @param aParam     An index specifying which of the four message arguments

                   contains the handle number.

 @param isReadOnly This is currently not implemented and setting it to ETrue

 				  will have no effect.

 				  (Intended implementation will be as below:

 				  Defines the type of access to the chunk: Specify ETrue if 

                   access is limited to read only, otherwise specify EFalse

                   for full read/write access.)

 @param aType      An enumeration whose enumerators define the ownership of this 

                   chunk handle. If not explicitly specified, EOwnerProcess is

                   taken as default. 

 @return KErrNone, if successful;

         KErrArgument, if the value of aParam is outside the range 0-3;

         KErrBadHandle, if not a valid handle;

         otherwise one of the other system-wide error codes.

 */

 EXPORT_C TInt RChunk::Open(RMessagePtr2 aMessage,TInt aParam,TBool isReadOnly,TOwnerType aType)

 	{

 	(void) isReadOnly; // This is not currently used

 	return SetReturnedHandle(Exec::MessageOpenObject(aMessage.Handle(),EChunk,aParam,aType));

 	}

 /**

 Opens a handle to a chunk using a handle number passed as an

 environment data item to the child process during the creation of

 that child process.

 Note that this function can only be called successfully once.

 @param aArgumentIndex An index that identifies the slot in the process

                       environment data that contains the handle number. This is

                       a value relative to zero, i.e. 0 is the first item/slot.

                       This can range from 0 to 15.

 @param aOwnerType     An enumeration whose enumerators define the ownership of

                       this chunk handle. If not explicitly specified,

                       EOwnerProcess is taken as default.

 @return KErrNone, if successful; 

         KErrNotFound, if the slot indicated by aArgumentIndex is empty;

         KErrArgument, if the slot does not contain a Semaphore handle;

         otherwise one of the other system-wide error codes.

 @see RProcess::SetParameter()

 */

 EXPORT_C TInt RChunk::Open(TInt aArgumentIndex, TOwnerType aOwnerType)

 	{

 	return SetReturnedHandle(Exec::ProcessGetHandleParameter(aArgumentIndex, EChunk, aOwnerType));

 	}

 EXPORT_C TInt RChunk::SetRestrictions(TUint aFlags)

 /**

 Sets or removes restrictions on the ability of the chunk to change.

 For example, to adjust, commit etc

 @param aFlags One of the values defined by TRestrictions.

 @return KErrNone if successful, otherwise another of the system error codes.

 @see RChunk::TRestrictions()

 */

 	{

 	return Exec::ChunkSetRestrictions(iHandle,aFlags);

 	}

 EXPORT_C TInt RChunk::Adjust(TInt aNewSize) const

 /**

 Changes the number of bytes committed to the chunk.

 This value is always rounded up to the next nearest processor page boundary.

 @param aNewSize The number of bytes to be committed to this chunk.

 @return KErrNone if successful, otherwise another of the system error codes.

 @panic USER 102 if aNewSize is negative.

 */

 	{

 	__ASSERT_ALWAYS(aNewSize>=0,Panic(EChkAdjustNewSizeNegative));

 	return Exec::ChunkAdjust(iHandle,EChunkAdjust,aNewSize,0);

 	}

 EXPORT_C TInt RChunk::AdjustDoubleEnded(TInt aBottom, TInt aTop) const

 /**

 Changes the number of bytes and the position of this double ended

 chunk's committed region.

 The difference between aTop and aBottom gives the new size of the committed 

 region; aBottom gives the offset of the bottom of the committed region from 

 the base of the chunk's reserved region.

 Both aBottom and aTop are rounded up to the next nearest processor

 page boundary.

 The function fails if this chunk is not a double ended chunk; for a standard 

 chunk, use the Adjust() function.

 Note that if the initial and final committed regions intersect, the contents 

 of the intersection are unchanged. Other parts of the committed region have 

 undefined contents.

 Note also that:

 1. the lowest valid address in a double ended chunk is the sum of the base of 

    the chunk's reserved region plus the adjusted value of aBottom

 2. the highest valid address in a double ended chunk is the the sum of the base 

    of the chunk's reserved region plus the adjusted value of aTop - 1.

 @param aBottom The offset from the base of the chunk of the bottom of the 

                committed region.

 @param aTop    The offset from the base of the chunk of the top of the committed 

                region.

 @return KErrNone if successful, otherwise another of the system error codes.

 @panic USER 124 if aBottom is negative.

 @panic USER 125 if aTop is negative.

 @panic USER 126 if aBottom is greater than the supplied value of aTop.

 */

 	{

 	__ASSERT_ALWAYS(aBottom>=0,Panic(EChkAdjustBottomNegative));

 	__ASSERT_ALWAYS(aTop>=0,Panic(EChkAdjustTopNegative));

 	__ASSERT_ALWAYS(aTop>=aBottom,Panic(EChkAdjustTopLessThanBottom));

 	return Exec::ChunkAdjust(iHandle,EChunkAdjustDoubleEnded,aBottom,aTop);

 	}

 EXPORT_C TInt RChunk::Commit(TInt aOffset, TInt aSize) const

 /**

 Commits memory to a disconnected chunk.

 Memory is committed in blocks of the MMU page size.

 E.g. Commit(pageSize-1,2) which asks for the last byte of the first page

 and the first byte of the second page and will result in the first 2 pages

 in the chunk being committed.

 For this reason it is best to only use values for aOffset and aSize which

 are multiples of the MMU page size. This size can be obtained with the

 following code.

 @code

 TInt pageSize;

 HAL::Get(HAL::EMemoryPageSize,pageSize)

 @endcode

 @param aOffset	The offset of the committed region from the base of the chunk's 

                 reserved region.

 @param aSize    The size of the committed region.

 @return KErrNone if successful, otherwise another of the system error codes.

 @panic USER 157 if anOffset is negative.

 @panic USER 158 if aSize is negative.

 */

 	{

 	__ASSERT_ALWAYS(aOffset>=0,Panic(EChkCommitOffsetNegative));

 	__ASSERT_ALWAYS(aSize>=0,Panic(EChkCommitSizeNegative));

 	return Exec::ChunkAdjust(iHandle,EChunkCommit,aOffset,aSize);

 	}

 EXPORT_C TInt RChunk::Allocate(TInt aSize) const

 /**

 Allocates and commits to a disconnected chunk.

 @param aSize The size of the committed region.

 @panic USER 159 if aSize is negative.

 */

 	{

 	__ASSERT_ALWAYS(aSize>=0,Panic(EChkAllocateSizeNegative));

 	return Exec::ChunkAdjust(iHandle,EChunkAllocate,aSize,0);

 	}

 EXPORT_C TInt RChunk::Decommit(TInt aOffset, TInt aSize) const

 /**

 Decommits memory from a disconnected chunk.

 Memory is decommitted in blocks of the MMU page size.

 E.g. Decommit(pageSize-1,2) which asks for the last byte of the first page

 and the first byte of the second page and will result in the first 2 pages

 in the chunk being decommitted.

 For this reason it is best to only use values for aOffset and aSize which

 are multiples of the MMU page size. This size can be obtained with the

 following code.

 @code

 TInt pageSize;

 HAL::Get(HAL::EMemoryPageSize,pageSize)

 @endcode

 @param aOffset The offset of the committed region from the base of the chunk's 

                 reserved region;

 @param aSize    The size of the committed region.

 @return KErrNone if successful, otherwise another of the system error codes.

 @panic USER 160 if anOffset is negative.

 @panic USER 161 if aSize is negative.

 */

 	{

 	__ASSERT_ALWAYS(aOffset>=0,Panic(EChkDecommitOffsetNegative));

 	__ASSERT_ALWAYS(aSize>=0,Panic(EChkDecommitSizeNegative));

 	return Exec::ChunkAdjust(iHandle,EChunkDecommit,aOffset,aSize);

 	}

 /* THIS IS A DELIBERATE NON DOXGEN STYLE TAG TO EXCLUDE THIS DOC FROM AUTO GENERATED DOCS

 Unlocks previously committed memory in a disconnected chunk.

 Unlocked memory is an intermediate state between committed and decommitted.

 Whilst in this state, the memory must not be accessed in any way, and the

 system is free to reclaim this RAM for other purposes, (it counts as free

 system memory). A program may attempt to relock the memory with #Lock which,

 when it succeeds, returns it to the committed state with its contents unchanged.

 This is intended for use in the implementation of memory caches for data

 which can be regenerated from other sources. I.e. in situations when the

 loss of cache contents is not a fatal condition.

 #Unlock may be used on memory which is already unlocked, in which case the memory

 state is left unaltered. Attempting to unlock memory which is decommitted results

 in an error.

 Unlocked memory may decommitted with #Decommit.

 Memory is unlocked in blocks of the MMU page size.

 E.g. Unlock(pageSize-1,2) which asks for the last byte of the first page

 and the first byte of the second page and will result in the first 2 pages

 in the chunk being unlocked.

 For this reason it is best to only use values for aOffset and aSize which

 are multiples of the MMU page size. This size can be obtained with the

 following code.

 @code

 TInt pageSize;

 HAL::Get(HAL::EMemoryPageSize,pageSize)

 @endcode

 @param aOffset The offset of the committed region from the base of the chunk's 

                reserved region;

 @param aSize   The size of the committed region.

 @return KErrNone if successful, otherwise another of the system error codes.

 @panic USER 160 if anOffset is negative.

 @panic USER 161 if aSize is negative.

 @see RChunk::Lock

 @internalTechnology

 */

 EXPORT_C TInt RChunk::Unlock(TInt aOffset, TInt aSize)

 	{

 	__ASSERT_ALWAYS(aOffset>=0,Panic(EChkDecommitOffsetNegative));

 	__ASSERT_ALWAYS(aSize>=0,Panic(EChkDecommitSizeNegative));

 	return Exec::ChunkAdjust(iHandle,EChunkUnlock,aOffset,aSize);

 	}

 /* THIS IS A DELIBERATE NON DOXGEN STYLE TAG TO EXCLUDE THIS DOC FROM AUTO GENERATED DOCS

 Locks memory in a disconnected chunk.

 This attempts to reverse the action of #Unlock and return memory to the committed

 state. If any RAM in the region had been previously reclaimed by the system,

 then this function fails with KErrNotFound and the whole region is decommited.

 #Lock may be used on memory which is already committed, in which case the memory

 state is left unaltered. Attempting to lock memory which is decommitted results in an

 error.

 Memory is locked in blocks of the MMU page size.

 E.g. Lock(pageSize-1,2) which asks for the last byte of the first page

 and the first byte of the second page and will result in the first 2 pages

 in the chunk being locked.

 For this reason it is best to only use values for aOffset and aSize which

 are multiples of the MMU page size. This size can be obtained with the

 following code.

 @code

 TInt pageSize;

 HAL::Get(HAL::EMemoryPageSize,pageSize)

 @endcode

 @param aOffset The offset of the unlocked region from the base of the chunk's 

                reserved region.

 @param aSize   The size of the unlocked region.

 @return KErrNone if successful, otherwise another of the system error codes.

 @panic USER 160 if anOffset is negative.

 @panic USER 161 if aSize is negative.

 @see RChunk::Unlock

 @internalTechnology

 */

 EXPORT_C TInt RChunk::Lock(TInt aOffset, TInt aSize)

 	{

 	__ASSERT_ALWAYS(aOffset>=0,Panic(EChkDecommitOffsetNegative));

 	__ASSERT_ALWAYS(aSize>=0,Panic(EChkDecommitSizeNegative));

 	return Exec::ChunkAdjust(iHandle,EChunkLock,aOffset,aSize);

 	}

 /**

 This can be used to determine whether the data for the chunk is demand paged

 or not.

 @return ETrue if the data for the chunk is demand paged, EFalse otherwise.

 */

 EXPORT_C TBool RChunk::IsPaged() const

 	{

 	return Exec::ChunkIsPaged(iHandle);

 	}

 /**

 Opens a handle to an LDD factory object by name.

 @param aName	The name of the LDD factory object to be opened.

 @param aType	An enumeration whose enumerators define the ownership of this 

 				LDD factory object handle.

 @return KErrNone, if successful; otherwise one of the other system wide error codes.

 */

 EXPORT_C TInt RDevice::Open(const TDesC &aName,TOwnerType aType)

 	{

 	return OpenByName(aName,aType,ELogicalDevice);

 	}

 EXPORT_C TInt RBusLogicalChannel::DoCreate(const TDesC& aLogicalDevice, const TVersion& aVer, TInt aUnit, const TDesC* aPhysicalDevice, const TDesC8* anInfo, TInt aType)

 //

 // Call the kernel to create a channel on a device.

 //

 	{

 	TInt r = User::ValidateName(aLogicalDevice);

 	if(KErrNone!=r)

 		return r;

 	TBuf8<KMaxKernelName> name8;

 	name8.Copy(aLogicalDevice);

 	TBuf8<KMaxKernelName> physicalDeviceName;

 	TChannelCreateInfo8 info;

 	info.iVersion=aVer;

 	info.iUnit=aUnit;

 	if(aPhysicalDevice)

 		{

 		physicalDeviceName.Copy(*aPhysicalDevice);

 		info.iPhysicalDevice = &physicalDeviceName;

 		}

 	else

 		info.iPhysicalDevice = NULL;

 	info.iInfo=anInfo;

 	return SetReturnedHandle(Exec::ChannelCreate(name8, info, aType),*this);

 	}

 /**

 Opens a handle to a logical channel using a handle number sent by a client

 to a server.

 This function is called by the server.

 @param aMessage The message pointer.

 @param aParam   An index specifying which of the four message arguments

                 contains the handle number.

 @param aType    An enumeration whose enumerators define the ownership of this 

                 logical channel handle. If not explicitly specified,

                 EOwnerProcess is taken as default. 

 @return KErrNone, if successful;

         KErrArgument, if the value of aParam is outside the range 0-3;

         KErrBadHandle, if not a valid handle;

         otherwise one of the other system-wide error codes.

 */

 EXPORT_C TInt RBusLogicalChannel::Open(RMessagePtr2 aMessage,TInt aParam,TOwnerType aType)

 	{

 	return SetReturnedHandle(Exec::MessageOpenObject(aMessage.Handle(),ELogicalChannel,aParam,aType));

 	}

 /**

 Opens a logical channel handle using a handle number passed as an

 environment data item to the child process during the creation of

 that child process.

 Note that this function can only be called successfully once.

 @param aArgumentIndex An index that identifies the slot in the process

                       environment data that contains the handle number. This is

                       a value relative to zero, i.e. 0 is the first item/slot.

                       This can range from 0 to 15.

 @param aOwnerType     An enumeration whose enumerators define the ownership of

                       this logical channel handle. If not explicitly specified,

                       EOwnerProcess is taken as default.

 @return KErrNone, if successful; 

         KErrNotFound, if the slot indicated by aArgumentIndex is empty;

         KErrArgument, if the slot does not contain a logical channel handle;

         otherwise one of the other system-wide error codes.

 */

 EXPORT_C TInt RBusLogicalChannel::Open(TInt aArgumentIndex, TOwnerType aOwnerType)

 	{

 	return SetReturnedHandle(Exec::ProcessGetHandleParameter(aArgumentIndex, ELogicalChannel, aOwnerType));

 	}

 EXPORT_C TInt RHandleBase::Duplicate(const RThread &aSrc,TOwnerType aType)

 /**

 Creates a valid handle to the kernel object for which the specified thread 

 already has a handle.

 The function assumes that this handle has been copy constructed from an existing 

 handle (or the handle-number has been explicitly copied through calls to Handle() 

 and SetHandle()).

 By default, any thread in the process can use this handle to access the kernel 

 side object that the handle represents. However, specifying EOwnerThread as 

 the second parameter to this function, means that only the creating thread 

 can use this handle to access the kernel side object; any other thread in 

 this process that wants to access the kernel side object must, again, duplicate 

 this handle.

 @param aSrc  A reference to the thread containing the handle which is to be 

              duplicated for this thread.

 @param aType An enumeration whose enumerators define the ownership of this 

              handle. If not explicitly specified, EOwnerProcess is taken

              as default.

 @return KErrNone, if successful; otherwise, one of the other system wide error 

         codes.

 */

 	{

 	return Exec::HandleDuplicate(aSrc.Handle(), aType, iHandle);

 	}

 EXPORT_C TInt RHandleBase::Open(const TFindHandleBase& aFindHandle, TOwnerType aType)

 /**

 Opens a handle to a kernel side object found using a find-handle object.

 @param aFindHandle A find-handle object; an object that is used in searching

                    for kernel side objects.

 @param aType       An enumeration whose enumerators define the ownership of

                    this handle. If not explicitly specified, EOwnerProcess

                    is taken as default, and ownership is vested in the

                    current process. Ownership can be vested in the current

                    thread by passing the EOwnerThread enumerator.

 @return KErrNone, if successful; otherwise one of the other system wide

         error codes.

 */

 	{

 	return SetReturnedHandle(Exec::FindHandleOpen(aType, aFindHandle), *this);

 	}

 /**

 	Implementation for RXxxxx::Open/OpenGlocbal(const TDesC &aName,,TOwnerType aType) functions

 	@internalComponent

 */

 TInt RHandleBase::OpenByName(const TDesC &aName,TOwnerType aOwnerType,TInt aObjectType)

 	{

 	TBuf8<KMaxFullName> name8;

 	name8.Copy(aName);

 	return SetReturnedHandle(Exec::OpenObject((TObjectType)aObjectType,name8,aOwnerType));

 	}

 TInt RHandleBase::SetReturnedHandle(TInt aHandleOrError,RHandleBase& aHandle)

 //

 // Set the handle value or return error

 //

 	{

 	return aHandle.SetReturnedHandle(aHandleOrError);

 	}

 EXPORT_C void RHandleBase::Close()

 /**

 Closes the handle.

 This has the effect of closing the associated kernel side object.

 As the associated object is a reference counting object, it is destroyed if 

 there are no other open references to it.

 @see CObject

 */

 	{

 	__IF_DEBUG(Print(_L("RHandleBase::Close")));

 	TInt h=iHandle;

 	if (h!=KNullHandle)

 		{

 //

 // We take a copy of the handle and set it to zero before the close in case this

 // object is actually a Chunk created in its own heap in which case the close

 // will destroy the object as well.

 //

 		iHandle=0;

 		if ((h&CObjectIx::ENoClose)==0 && Exec::HandleClose(h)>0)

 			DoExtendedClose();

 		}

 	}

 void RHandleBase::DoExtendedClose()

 //

 // Call static data destructors following a library handle close

 //

 	{

 	TRAPD(r,DoExtendedCloseL());	// catch attempts to leave from destructors

 	__ASSERT_ALWAYS(r==KErrNone, Panic(EDllStaticDestructorLeave));

 	}

 void RHandleBase::DoExtendedCloseL()

 //

 // Call static data destructors following a library handle close

 //

 	{

 	TLinAddr ep[KMaxLibraryEntryPoints];

 	TInt r=KErrNone;

 	while (r!=KErrEof)

 		{

 		TInt numEps=KMaxLibraryEntryPoints;

 		r=E32Loader::LibraryDetach(numEps, ep);

 		if (r==KErrEof)

 			break;

 		TInt i;

 		for (i=numEps-1; i>=0; --i)

 			{

 			TLibraryEntry f=(TLibraryEntry)ep[i];

 			(*f)(KModuleEntryReasonProcessDetach);

 			}

 		r=E32Loader::LibraryDetached();

 		}

 	}

 /**

 Constructs an RMessage2 from an RMessagePtr2.

 @param aPtr A reference to an existing RMessagePtr2 object.

 */

 EXPORT_C RMessage2::RMessage2(const RMessagePtr2& aPtr)

 	{

 	iHandle = aPtr.Handle();

 	Exec::MessageConstructFromPtr(iHandle, this);

 	iFlags = 0;

 	iSpare3 = 0;

 	}

 /** Sets this message to an authorised state.  This is used only by

 CPolicyServer.  This flags use by the policy server implies two things:

 1) That the message has passed any appropriate security checks. (ie. one of the

 static policy check, CustomSecurityCheckL, or CustomFailureActionL,

 returned ETrue.)

 2) That any leaves that occur subsequent to this flag being set happen _only_

 in the session's ServiceL.  ie.  Nothing can leave between this flag being set

 and the session's ServiceL being called.

 This is labelled as a const functions as everybody handles const RMessage2&'s.

 The constness is actually referring to the underlying RMessagePtr2 not the

 tranisent RMessage2 class.

 @internalComponent

 */

 void RMessage2::SetAuthorised() const

 	{

 	iFlags = ETrue;

 	}

 /** Sets the authorised flag to a state of not authorised.  This is required as

 there is a default constructor for RMessage2 and one cannot guarantee that

 iFlags was initialised.  This is called from CPolicyServer::RunL.

 This is labelled as a const functions as everybody handles const RMessage2&'s.

 The constness is actually referring to the underlying RMessagePtr2 not the

 tranisent RMessage2 class.

 @internalComponent

 */

 void RMessage2::ClearAuthorised() const

 	{

 	iFlags = EFalse;

 	}

 /** Returns whether this message has been authorised by CPolicyServer.  See

 RMessage2::SetAuthorised for implications of this state.

 @internalComponent

 */

 TBool RMessage2::Authorised() const

 	{

 	return iFlags;

 	}

 /**

 Frees this message.

 @param aReason The completion code.

 */

 EXPORT_C void RMessagePtr2::Complete(TInt aReason) const

 //

 // Free this message. If it's a disconnect, need to switch to kernel context as we'll be

 // freeing the DSession

 //

 	{

 	TInt h=iHandle;

 	const_cast<TInt&>(iHandle)=0;

 	if (h)

 		Exec::MessageComplete(h,aReason);

 	else

 		::Panic(ETMesCompletion);

 	}

 /**

 Duplicates the specified handle in the client thread, and returns this

 handle as a message completion code

 @param aHandle The handle to be duplicated.

 */

 EXPORT_C void RMessagePtr2::Complete(RHandleBase aHandle) const

 	{

 	TInt h=iHandle;

 	const_cast<TInt&>(iHandle)=0;

 	if (h)

 		Exec::MessageCompleteWithHandle(h,aHandle.Handle());

 	else

 		::Panic(ETMesCompletion);

 	}

 /**

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

 @param aParam The index value identifying the argument.

               This is a value in the range 0 to (KMaxMessageArguments-1)

               inclusive.

 @return The length of the descriptor, if successful.

         KErrArgument, if aParam has a value outside the valid range.

         KErrBadDescriptor, if the message argument is not a descriptor type.

 */

 EXPORT_C TInt RMessagePtr2::GetDesLength(TInt aParam) const

 	{

 	return Exec::MessageGetDesLength(iHandle,aParam);

 	}

 /**

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

 leaving on failure.

 @param aParam The index value identifying the argument.

               This is a value in the range 0 to (KMaxMessageArguments-1)

               inclusive.

 @return The length of the descriptor.

 @leave  KErrArgument if aParam has a value outside the valid range.

 @leave  KErrBadDescriptor, if the message argument is not a descriptor type.

 */

 EXPORT_C TInt RMessagePtr2::GetDesLengthL(TInt aParam) const

 	{

 	return User::LeaveIfError(GetDesLength(aParam));

 	}

 /**

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

 @param aParam The index value identifying the argument.

               This is a value in the range 0 to (KMaxMessageArguments-1)

               inclusive.

 @return The maximum length of the descriptor, if successful.

         KErrArgument, if aParam has a value outside the valid range.

         KErrBadDescriptor, if the message argument is not a descriptor type.

 */

 EXPORT_C TInt RMessagePtr2::GetDesMaxLength(TInt aParam) const

 	{

 	return Exec::MessageGetDesMaxLength(iHandle,aParam);

 	}

 /**

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

 leaving on failure.

 @param aParam The index value identifying the argument.

               This is a value in the range 0 to (KMaxMessageArguments-1)

               inclusive.

 @return The length of the descriptor.

 @leave  KErrArgument if aParam has a value outside the valid range.

 @leave  KErrBadDescriptor, if the message argument is not a descriptor type.

 */

 EXPORT_C TInt RMessagePtr2::GetDesMaxLengthL(TInt aParam) const

 	{

 	return User::LeaveIfError(GetDesMaxLength(aParam));

 	}

 /**

 Reads data from the specified offset within the 8-bit descriptor

 argument, into the specified target descriptor, and leaving on failure.

 @param aParam  The index value identifying the argument.

                This is a value in the range 0 to (KMaxMessageArguments-1)

                inclusive.

 @param aDes    The target descriptor into which the client data is

                to be written.

 @param aOffset The offset from the start of the client's descriptor data.

                If not explicitly specified, the offset defaults to zero.

 @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.

 */

 EXPORT_C void RMessagePtr2::ReadL(TInt aParam,TDes8& aDes,TInt aOffset) const

 	{

 	TInt error = Read(aParam,aDes,aOffset);

 	User::LeaveIfError(error);

 	}

 /**

 Reads data from the specified offset within the 16-bit descriptor

 argument, into the specified target descriptor, and leaving on failure.

 @param aParam  The index value identifying the argument.

                This is a value in the range 0 to (KMaxMessageArguments-1)

                inclusive.

 @param aDes    The target descriptor into which the client data is

                to be written.

 @param aOffset The offset from the start of the client's descriptor data.

                If not explicitly specified, the offset defaults to zero.

 @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.

 */

 EXPORT_C void RMessagePtr2::ReadL(TInt aParam,TDes16 &aDes,TInt aOffset) const

 	{

 	TInt error = Read(aParam,aDes,aOffset);

 	User::LeaveIfError(error);

 	}

 /**

 Writes data from the specified source descriptor to the specified offset within

 the 8-bit descriptor argument, and leaving on failure.

 @param aParam  The index value identifying the argument.

                This is a value in the range 0 to (KMaxMessageArguments-1)

                inclusive.

 @param aDes    The source descriptor containing the data to be written.

 @param aOffset The offset from the start of the client's descriptor.

                If not explicitly specified, the offset defaults to zero.

 @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.

 */

 EXPORT_C void RMessagePtr2::WriteL(TInt aParam,const TDesC8& aDes,TInt aOffset) const

 	{

 	TInt error = Write(aParam,aDes,aOffset);

 	User::LeaveIfError(error);

 	}

 /**

 Writes data from the specified source descriptor to the specified offset within

 the 16-bit descriptor argument, and leaving on failure.

 @param aParam  The index value identifying the argument.

                This is a value in the range 0 to (KMaxMessageArguments-1)

                inclusive.

 @param aDes    The source descriptor containing the data to be written.

 @param aOffset The offset from the start of the client's descriptor.

                If not explicitly specified, the offset defaults to zero.

 @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.

 */

 EXPORT_C void RMessagePtr2::WriteL(TInt aParam,const TDesC16& aDes,TInt aOffset) const

 	{

 	TInt error = Write(aParam,aDes,aOffset);

 	User::LeaveIfError(error);

 	}

 /**

 Reads data from the specified offset within the 8-bit descriptor

 argument, into the specified target descriptor.

 @param aParam  The index value identifying the argument.

                This is a value in the range 0 to (KMaxMessageArguments-1)

                inclusive.

 @param aDes    The target descriptor into which the client data is

                to be written.

 @param aOffset The offset from the start of the client's descriptor data.

                If not explicitly specified, the offset defaults to zero.

 @return KErrNone, if successful;

         KErrArgument if aParam has a value outside the valid range, or

                      if aOffset is negative.

         KErrBadDescriptor, if the message argument is not an 8-bit descriptor.

 */

 EXPORT_C TInt RMessagePtr2::Read(TInt aParam,TDes8& aDes,TInt aOffset) const

 	{

 	SIpcCopyInfo info;

 	info.iFlags=KChunkShiftBy0|KIpcDirRead;

 	info.iLocalLen=aDes.MaxLength();

 	info.iLocalPtr=(TUint8*)aDes.Ptr();

 	TInt r=Exec::MessageIpcCopy(iHandle,aParam,info,aOffset);

 	if (r<0)

 		return r;

 	aDes.SetLength(r);

 	return KErrNone;

 	}

 /**

 Reads data from the specified offset within the 16-bit descriptor

 argument, into the specified target descriptor.

 @param aParam  The index value identifying the argument.

                This is a value in the range 0 to (KMaxMessageArguments-1)

                inclusive.

 @param aDes    The target descriptor into which the client data is

                to be written.

 @param aOffset The offset from the start of the client's descriptor data.

                If not explicitly specified, the offset defaults to zero.

 @return KErrNone, if successful;

         KErrArgument if aParam has a value outside the valid range, or

                      if aOffset is negative.

         KErrBadDescriptor, if the message argument is not a 16-bit descriptor.

 */

 EXPORT_C TInt RMessagePtr2::Read(TInt aParam,TDes16 &aDes,TInt aOffset) const

 	{

 	SIpcCopyInfo info;

 	info.iFlags=KChunkShiftBy1|KIpcDirRead;

 	info.iLocalLen=aDes.MaxLength();

 	info.iLocalPtr=(TUint8*)aDes.Ptr();

 	TInt r=Exec::MessageIpcCopy(iHandle,aParam,info,aOffset);

 	if (r<0)

 		return r;

 	aDes.SetLength(r);

 	return KErrNone;

 	}

 /**

 Writes data from the specified source descriptor to the specified offset within

 the 8-bit descriptor argument.

 @param aParam  The index value identifying the argument.

                This is a value in the range 0 to (KMaxMessageArguments-1)

                inclusive.

 @param aDes    The source descriptor containing the data to be written.

 @param aOffset The offset from the start of the client's descriptor.

                If not explicitly specified, the offset defaults to zero.

 @return KErrNone, if successful;

         KErrArgument if aParam has a value outside the valid range, or

                      if aOffset is negative.

         KErrBadDescriptor, if the message argument is not an 8-bit descriptor;

         KErrOverflow, if the target descriptor is too small

                       to containt the data.

 */

 EXPORT_C TInt RMessagePtr2::Write(TInt aParam,const TDesC8& aDes,TInt aOffset) const

 	{

 	SIpcCopyInfo info;

 	info.iFlags=KChunkShiftBy0|KIpcDirWrite;

 	info.iLocalLen=aDes.Length();

 	info.iLocalPtr=(TUint8*)aDes.Ptr();

 	return Exec::MessageIpcCopy(iHandle,aParam,info,aOffset);

 	}

 /**

 Writes data from the specified source descriptor to the specified offset within 

 the 16-bit descriptor argument.

 @param aParam  The index value identifying the argument.

                This is a value in the range 0 to (KMaxMessageArguments-1)

                inclusive.

 @param aDes    The source descriptor containing the data to be written.

 @param aOffset The offset from the start of the client's descriptor.

                If not explicitly specified, the offset defaults to zero.

 @return KErrNone, if successful;

         KErrArgument if aParam has a value outside the valid range, or

                      if aOffset is negative.

         KErrBadDescriptor, if the message argument is not an 16-bit descriptor;

         KErrOverflow, if the target descriptor is too small

                       to containt the data.

 */

 EXPORT_C TInt RMessagePtr2::Write(TInt aParam,const TDesC16& aDes,TInt aOffset) const

 	{

 	SIpcCopyInfo info;

 	info.iFlags=KChunkShiftBy1|KIpcDirWrite;

 	info.iLocalLen=aDes.Length();

 	info.iLocalPtr=(TUint8*)aDes.Ptr();

 	return Exec::MessageIpcCopy(iHandle,aParam,info,aOffset);

 	}

 /**

 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.

 @param aCategory The panic category.

 @param aReason   The panic code.

 */

 EXPORT_C void RMessagePtr2::Panic(const TDesC& aCategory,TInt aReason) const

 	{

 	TBuf8<KMaxExitCategoryName> cat;

 	TInt length=aCategory.Length();

 	if(length>KMaxExitCategoryName)

 		{

 		TPtr catPtr((TUint16*)aCategory.Ptr(),KMaxExitCategoryName,KMaxExitCategoryName);

 		cat.Copy(catPtr);

 		}

 	else

 		{

 		cat.Copy(aCategory);

 		}

 	Exec::MessageKill(iHandle,EExitPanic,aReason,&cat);

 	Complete(KErrNone);

 	}

 /**

 Kills the client.

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

 @param aReason The reason code associated with killing the client.

 */

 EXPORT_C void RMessagePtr2::Kill(TInt aReason) const

 	{

 	Exec::MessageKill(iHandle,EExitKill,aReason,NULL);

 	Complete(KErrNone);

 	}

 /**

 Terminates the client.

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

 @param aReason The reason code associated with terminating the client.

 */

 EXPORT_C void RMessagePtr2::Terminate(TInt aReason) const

 	{

 	Exec::MessageKill(iHandle,EExitTerminate,aReason,NULL);

 	Complete(KErrNone);

 	}

 /**

 Sets the priority of the client's process.

 @param aPriority The priority value.

 @return KErrNone, if successful, otherwise one of the other system-wide error codes.

 */

 EXPORT_C TInt RMessagePtr2::SetProcessPriority(TProcessPriority aPriority) const

 	{

 	return Exec::MessageSetProcessPriority(iHandle,aPriority);

 	}

 /**

 Opens a handle on the client thread.

 @param aClient    On successful return, the handle to the client thread.

 @param aOwnerType An enumeration whose enumerators define the ownership of

                   the handle. If not explicitly specified,

                   EOwnerProcess is taken as default.

 @return KErrNone.

 */

 EXPORT_C TInt RMessagePtr2::Client(RThread& aClient, TOwnerType aOwnerType) const

 	{

 	return aClient.SetReturnedHandle(Exec::MessageClient(iHandle,aOwnerType));

 	}

 EXPORT_C TUint RMessagePtr2::ClientProcessFlags() const

 	{

 	return Exec::MessageClientProcessFlags(iHandle);

 	}

 EXPORT_C TBool RMessagePtr2::ClientIsRealtime() const

 	{

 	return (Exec::MessageClientProcessFlags(iHandle) & KThreadFlagRealtime) != 0;

 	}

 /**

 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.

 @return The clients TRequestStatus (returns NULL if the request is not asynchronous)

 */

 EXPORT_C const TRequestStatus* RMessagePtr2::ClientStatus() const

 	{

 	return Exec::MessageClientStatus(iHandle);

 	}

 EXPORT_C TInt RServer2::CreateGlobal(const TDesC& aName, TInt aMode, TInt aRole, TInt aOpts)

 //

 // Create a new server.

 //

 	{

 	TInt r = User::ValidateName(aName);

 	if (r != KErrNone)

 		return r;

 	TBuf8<KMaxKernelName> name8;

 	name8.Copy(aName);

 	r = Exec::ServerCreateWithOptions(&name8, aMode, aRole, aOpts);

 	return SetReturnedHandle(r, *this);

 	}

 EXPORT_C TInt RServer2::CreateGlobal(const TDesC& aName, TInt aMode)

 	{

 	return CreateGlobal(aName, aMode, EServerRole_Default, 0);

 	}

 EXPORT_C TInt RServer2::CreateGlobal(const TDesC& aName)

 	{

 	return CreateGlobal(aName, EIpcSession_Sharable);

 	}

 TInt RSessionBase::DoConnect(const TVersion &aVersion,TRequestStatus* aStatus)

 	{

 	extern int TVersion_size_assert[sizeof(TVersion)==sizeof(TInt)?1:-1]; // Make sure TVersion is same size as int

 	(void)TVersion_size_assert;

 	TIpcArgs p(*(TInt*)&aVersion);

 	TInt r;

 	if(aStatus==NULL)

 		r = SendSync(RMessage2::EConnect, &p);

 	else

 		r = SendAsync(RMessage2::EConnect, &p, aStatus);

 	if (r!=KErrNone)

 		Close();

 	return r;

 	}

 /**

 Creates a session with a server.

 It should be called as part of session initialisation in the derived class.

 @param aServer   The name of the server with which a session is to

                  be established.

 @param aVersion  The lowest version of the server with which this client

                  is compatible.

 @param aAsyncMessageSlots The number of message slots available to this session.

                  This determines the number of outstanding requests the client

                  may have with the server at any one time.

                  The maximum number of slots is 255.

 				 If aAsyncMessageSlots==-1 then this indicates that the session should use

 				 messages from the global free pool of messages.

 @param aType     The type of session to create. See TIpcSessionType.

 @param aPolicy   A pointer to a TSecurityPolicy object. If this pointer is not 0 (zero)

 				 then the policy is applied to the process in which the server is running.

 				 If that process doesn't pass this security policy check, then the session

 				 creation will fail with the error KErrPermissionDenied.

 				 This security check allows clients to verify that the server has the expected

 				 Platform Security attributes.

 				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 KErrNone even though the

 				check failed.

 @param aStatus   A pointer to TRequestStatus object which will be signalled when the session

 				 has been created, or in the event of an error.

 				 If aStatus==0 then session creation is done synchronously.

 @return          KErrNone if successful;

                  KErrArgument, if an attempt is made to specify more

                  than 255 message slots;

                  otherwise one of the other system-wide error codes.

 */

 EXPORT_C TInt RSessionBase::CreateSession(const TDesC& aServer,const TVersion& aVersion,TInt aAsyncMessageSlots,TIpcSessionType aType,const TSecurityPolicy* aPolicy, TRequestStatus* aStatus)

 	{

 	TInt r = User::ValidateName(aServer);

 	if(KErrNone!=r)

 		return r;

 	TBuf8<KMaxKernelName> name8;

 	name8.Copy(aServer);

 	r=SetReturnedHandle(Exec::SessionCreate(name8,aAsyncMessageSlots,aPolicy,aType));

 	if(r==KErrNone)

 		r=DoConnect(aVersion,aStatus);

 	return r;

 	}

 /**

 Creates a session with a server.

 It should be called as part of session initialisation in the derived class.

 @param aServer   The name of the server with which a session is to

                  be established.

 @param aVersion  The lowest version of the server with which this client

                  is compatible.

 @param aAsyncMessageSlots The number of message slots available to this session.

                  This determines the number of outstanding requests the client

                  may have with the server at any one time.

                  The maximum number of slots is 255.

 				 If aAsyncMessageSlots==-1 then this indicates that the session should use

 				 messages from the global free pool of messages.

 @return          KErrNone if successful;

                  KErrArgument, if an attempt is made to specify more

                  than 255 message slots;

                  otherwise one of the other system-wide error codes.

 */

 EXPORT_C TInt RSessionBase::CreateSession(const TDesC &aServer, const TVersion &aVersion, TInt aAsyncMessageSlots)

 	{

 	return RSessionBase::CreateSession(aServer,aVersion,aAsyncMessageSlots,EIpcSession_Unsharable,NULL,0);

 	}

 /**

 Creates a session with a server.

 It should be called as part of session initialisation in the derived class.

 @param aServer   A handle to a server with which a session is to be established.	 

 @param aVersion  The lowest version of the server with which this client

                  is compatible.

 @param aAsyncMessageSlots The number of message slots available to this session.

                  This determines the number of outstanding requests the client

                  may have with the server at any one time.

                  The maximum number of slots is 255.

 				 If aAsyncMessageSlots==-1 then this indicates that the session should use

 				 messages from the global free pool of messages.

 @param aType     The type of session to create. See TIpcSessionType.

 @param aPolicy   A pointer to a TSecurityPolicy object. If this pointer is not 0 (zero)

 				 then the policy is applied to the process in which the server is running.

 				 If that process doesn't pass this security policy check, then the session

 				 creation will fail with the error KErrPermissionDenied.

 				 This security check allows clients to verify that the server has the expected

 				 Platform Security attributes.

 				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 KErrNone even though the

 				check failed.

 @param aStatus   A pointer to TRequestStatus object which will be signalled when the session

 				 has been created, or in the event of an error.

 				 If aStatus==0 then session creation is done synchronously.

 @return          KErrNone if successful;

                  KErrArgument, if an attempt is made to specify more

                  than 255 message slots;

                  otherwise one of the other system-wide error codes.

 */

 EXPORT_C TInt RSessionBase::CreateSession(RServer2 aServer,const TVersion& aVersion,TInt aAsyncMessageSlots,TIpcSessionType aType,const TSecurityPolicy* aPolicy, TRequestStatus* aStatus)

 	{

 	TInt r;

 	r=SetReturnedHandle(Exec::SessionCreateFromHandle(aServer.Handle(),aAsyncMessageSlots,aPolicy,aType));

 	if(r==KErrNone)

 		r=DoConnect(aVersion,aStatus);

 	return r;

 	}

 /**

 Creates a session with a server.

 It should be called as part of session initialisation in the derived class.

 @param aServer   A handle to a server with which a session is to be established.                

 @param aVersion  The lowest version of the server with which this client

                  is compatible.

 @param aAsyncMessageSlots The number of message slots available to this session.

                  This determines the number of outstanding requests the client

                  may have with the server at any one time.

                  The maximum number of slots is 255.

 				 If aAsyncMessageSlots==-1 then this indicates that the session should use

 				 messages from the global free pool of messages.

 @return          KErrNone if successful;

                  KErrArgument, if an attempt is made to specify more

                  than 255 message slots;

                  otherwise one of the other system-wide error codes.

 */

 EXPORT_C TInt RSessionBase::CreateSession(RServer2 aServer, const TVersion &aVersion, TInt aAsyncMessageSlots)

 	{

 	return RSessionBase::CreateSession(aServer,aVersion,aAsyncMessageSlots,EIpcSession_Unsharable,NULL,0);

 	}

 /**

 Opens a handle to a session using a handle number sent by a client

 to a server.

 This function is called by the server.

 @param aMessage The message pointer.

 @param aParam   An index specifying which of the four message arguments

                 contains the handle number.

 @param aType    An enumeration whose enumerators define the ownership of this 

                 session handle. If not explicitly specified, EOwnerProcess

 				is taken as default.

 @return KErrNone, if successful;

         KErrArgument, if the value of aParam is outside the range 0-3;

         KErrBadHandle, if not a valid handle;

         otherwise one of the other system-wide error codes.

 */

 EXPORT_C TInt RSessionBase::Open(RMessagePtr2 aMessage,TInt aParam,TOwnerType aType)

 	{

 	return SetReturnedHandle(Exec::MessageOpenObject(aMessage.Handle(),ESession,aParam,aType));

 	}

 /**

 Opens a handle to a session using a handle number sent by a client

 to a server, and validate that the session's server passes a given

 security policy.

 This function is called by the server.

 @param aMessage 		The message pointer.

 @param aParam   		An index specifying which of the four message arguments

                 		contains the handle number.

 @param aServerPolicy	The policy to validate the session's server against.

 @param aType    		An enumeration whose enumerators define the ownership of this 

                 		session handle. If not explicitly specified, EOwnerProcess

 						is taken as default.

 @return KErrNone, if successful;

         KErrArgument, if the value of aParam is outside the range 0-3;

         KErrBadHandle, if not a valid handle;

 		KErrServerTerminating, if the session is no longer connected to a server;

 		KErrPermissionDenied, if the session's server does not pass the given security policy;

         otherwise one of the other system-wide error codes.

 */

 EXPORT_C TInt RSessionBase::Open(RMessagePtr2 aMessage,TInt aParam,const TSecurityPolicy& aServerPolicy,TOwnerType aType)

 	{

 	return SetReturnedHandle(Exec::MessageOpenObject(aMessage.Handle(),ESession,aParam,aType),aServerPolicy);

 	}

 /**

 Sets the handle-number of this session handle to the specified value after

 validating that the session's server passes a given security policy.

 The function can take a (zero or positive) handle-number,

 or a (negative) error number.

 If aHandleOrError represents a handle-number, then the handle-number of this handle

 is set to that value, as long as the session's server passes the security policy.

 If aHandleOrError represents an error number, then the handle-number of this handle is set to zero

 and the negative value is returned.

 @param aHandleOrError A handle-number, if zero or positive; an error value, if negative.

 @param aServerPolicy  The policy to validate the session's server against.

 @return KErrNone, if aHandle is a handle-number; KErrPermissionDenied, if the session's server

         does not pass the security policy; the value of aHandleOrError, otherwise.

 */

 EXPORT_C TInt RSessionBase::SetReturnedHandle(TInt aHandleOrError,const TSecurityPolicy& aServerPolicy)

 	{

 	if(aHandleOrError<0)

 		return aHandleOrError;

 	TInt r = aServerPolicy.CheckPolicy((RSessionBase&)aHandleOrError);

 	if (r!=KErrNone)

 		{

 		((RHandleBase&)aHandleOrError).Close();

 		return r;

 		}

 	iHandle=aHandleOrError;

 	return KErrNone;

 	}

 /**

 Opens a handle to a session using a handle number passed as an

 environment data item to the child process during the creation of

 that child process.

 Note that this function can only be called successfully once.

 @param aArgumentIndex An index that identifies the slot in the process

                       environment data that contains the handle number. This is

                       a value relative to zero, i.e. 0 is the first item/slot.

                       This can range from 0 to 15.

 @param aOwnerType     An enumeration whose enumerators define the ownership of

                       this session handle. If not explicitly specified,

                       EOwnerProcess is taken as default.

 @return KErrNone, if successful; 

         KErrNotFound, if the slot indicated by aArgumentIndex is empty;

         KErrArgument, if the slot does not contain a session handle;

         otherwise one of the other system-wide error codes.                      

 */

 EXPORT_C TInt RSessionBase::Open(TInt aArgumentIndex, TOwnerType aOwnerType)

 	{

 	return SetReturnedHandle(Exec::ProcessGetHandleParameter(aArgumentIndex, ESession, aOwnerType));

 	}

 /**

 Opens a handle to a session using a handle number passed as an

 environment data item to the child process during the creation of

 that child process, after validating that the session's server passes

 the given security policy.

 Note that this function can only be called successfully once.

 @param aArgumentIndex An index that identifies the slot in the process

                       environment data that contains the handle number. This is

                       a value relative to zero, i.e. 0 is the first item/slot.

                       This can range from 0 to 15.

 @param aServerPolicy  The policy to validate the session's server against.

 @param aOwnerType     An enumeration whose enumerators define the ownership of

                       this session handle. If not explicitly specified,

                       EOwnerProcess is taken as default.

 @return KErrNone, if successful; 

         KErrNotFound, if the slot indicated by aArgumentIndex is empty;

         KErrArgument, if the slot does not contain a session handle;

 		KErrServerTerminating, if the session is no longer connected to a server;

 		KErrPermissionDenied, if the session's server does not pass the given security policy;

         otherwise one of the other system-wide error codes.                      

 */

 EXPORT_C TInt RSessionBase::Open(TInt aArgumentIndex, const TSecurityPolicy& aServerPolicy, TOwnerType aOwnerType)

 	{

 	return SetReturnedHandle(Exec::ProcessGetHandleParameter(aArgumentIndex, ESession, aOwnerType), aServerPolicy);

 	}

 EXPORT_C TInt RSessionBase::DoShare(TInt aMode)

 //

 // Make the session accessible to all threads in this process

 //

 	{

 	return Exec::SessionShare(iHandle, (aMode&KCreateProtectedObject) ? EIpcSession_GlobalSharable : EIpcSession_Sharable);

 	}

 TInt RSessionBase::SendSync(TInt aFunction,const TIpcArgs* aArgs) const

 //

 // Send a synchronous message.

 //

 	{

 	TRequestStatus s=KRequestPending;

 	TInt r=Exec::SessionSendSync(iHandle,aFunction,(TAny*)aArgs,&s);

 	if (r==KErrNone)

 		{

 		User::WaitForRequest(s);

 		r=s.Int();

 		}

 	return r;

 	}

 TInt RSessionBase::SendAsync(TInt aFunction,const TIpcArgs* aArgs,TRequestStatus *aStatus) const

 //

 // Send an asynchronous message.

 //

 	{

 	if (aStatus)

 		*aStatus=KRequestPending;

 	return Exec::SessionSend(iHandle,aFunction,(TAny*)aArgs,aStatus);

 	}

 EXPORT_C TInt RMutex::CreateLocal(TOwnerType aType)

 /**

 Creates a mutex and opens this handle to the mutex.

 The kernel side object representing the mutex is unnamed. This means that 

 it is not possible to search for the mutex, which makes it local to the current 

 process.

 By default, any thread in the process can use this instance of RMutex to access 

 the mutex. However, specifying EOwnerThread as the parameter to this function, 

 means that only the creating thread can use this instance of RMutex to access 

 the mutex; any other thread in this process that wants to access the mutex 

 must duplicate this handle.

 @param aType An enumeration whose enumerators define the ownership of this 

              mutex handle. If not explicitly specified, EOwnerProcess is taken

              as default.

 @return KErrNone if successful, otherwise one of the system wide error codes.

 @see RHandleBase::Duplicate()

 */

 	{

 	return SetReturnedHandle(Exec::MutexCreate(NULL,aType),*this);

 	}

 EXPORT_C TInt RMutex::CreateGlobal(const TDesC &aName,TOwnerType aType)

 /**

 Creates a global mutex and opens this handle to the mutex.

 The kernel side object representing the mutex is given the name contained 

 in the specified descriptor, which makes it global. This means that any thread 

 in any process can search for the mutex, using TFindMutex, and open a handle 

 to it. If the specified name is empty the kernel side object representing the

 mutex is unnamed and so cannot be opened by name. It can however be passed

 to another process as a process parameter or via IPC.

 By default, any thread in the process can use this instance of RMutex to access 

 the mutex. However, specifying EOwnerThread as the second parameter to this 

 function, means that only the creating thread can use this instance of RMutex 

 to access the mutex; any other thread in this process that wants to access 

 the mutex must either duplicate this handle or use OpenGlobal().

 @param aName The name to be assigned to this global mutex.

 @param aType An enumeration whose enumerators define the ownership of this 

              mutex handle. If not explicitly specified, EOwnerProcess is

              taken as default. 

 @return KErrNone if successful, otherwise one of the other system wide error 

         codes. 

 @see OpenGlobal

 @see RHandleBase::Duplicate()

 @see TFindMutex

 */

 	{

 	TInt r = User::ValidateName(aName);

 	if(KErrNone!=r)

 		return r;