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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Client handling

    15 // 

    16 //

    17 

    18 #include "CLIENT.H"

    19 

    20 #include "ANIM.H"

    21 #include "Direct.H"

    22 #include "EVENT.H"

    23 #include "KEYCLICK.H"

    24 #include "server.h"

    25 #include "gc.h"

    26 #include "rootwin.h"

    27 #include "windowgroup.h"

    28 #include "wstop.h"

    29 #include "panics.h"

    30 #include "../CLIENT/w32comm.h"

    31 #include "password.h"

    32 #include "pointer.h"

    33 #include <u32hal.h> // EHalGroupEmulator

    34 #include "WsMemMgr.h"

    35 #include <e32hashtab.h>  // for RHashMap

    36 #include "registeredsurfacemap.h"

    37 #include <graphics/wselement.h>

    38 

    39 #include "windowelementset.h"

    40 #include "drawresource.h"

    41 

    42 extern CDebugLogBase* wsDebugLog;

    43 _LIT(KWSERVSessionPanicCategory,"WSERV");

    44 

    45 GLREF_D TPtr nullDescriptor;

    46 

    47 TWsCmdHeaderBase CWsClient::iCurrentCommand;

    48 TBuf8<EClientBufferMaxSize> CWsClient::iCmdBuf;

    49 TInt CWsClient::iReply;

    50 TInt CWsClient::iReplyOffset;

    51 CWsClient* CWsClient::iCurrentClient;

    52 CWsObject* CWsClient::iDestObj;

    53 const TUint8* CWsClient::iNextCmd;

    54 CIdle* CWsClient::iMoreCommands=NULL;

    55 

    56 TUint CWsClient::iConnectionId = CDebugLogBase::EDummyConnectionId+1;

    57 CArrayFixFlat<CWsClient::TWsCursorArrayItem>* CWsClient::iSystemPointerCursors = NULL;

    58 TInt CWsClient::iDefaultSystemPointerCursorIndex = 0;		//Negative when there isn't one

    59 CWsPointerCursor* CWsClient::iDefaultSystemPointerCursor;

    60 CWsClient* CWsClient::iSystemPointerCursorListOwner = NULL;

    61 CArrayFixFlat<CWsClient::TWsCursorArrayItem>* CWsClient::iTextCursorArray = NULL;

    62 

    63 TKeyArrayFix CWsClient::iCursorKey(_FOFF(CWsClient::TWsCursorArrayItem,iIndex), ECmpTInt);

    64 

    65 /**

    66 Used for enforcing the redraw calling convention in emulator builds.

    67 When enabled this will panic any client calling a CWindowGc draw operation outside a 

    68 RWindow::BeginRedraw() / RWindow::EndRedraw() pair (known as non-redraw drawing).

    69 

    70 Enable by adding "debug_wserv_exe_EnforceRedrawCallingConvention X" to epoc.ini 

    71 where X is either 0 (zero) for "off" or 1 (one) for "on". 

    72 

    73 Then enable globally in WServ AutoFlush by defining __AUTO_FLUSH in ../client/client.h 

    74 or locally by calling RWsSession::SetAutoFlush(ETrue) for a specific client programatically, 

    75 or locally pressing Ctrl-Alt-Shift-F in the emulator.

    76 */

    77 TBool CWsClient::iDebug_EnforceRedrawCallingConvention = EFalse;

    78 

    79 // Security policy stings

    80 static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_WriteDeviceData,ECapabilityWriteDeviceData);

    81 static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_SwEvent,ECapabilitySwEvent);

    82 static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_PowerMgmt,ECapabilityPowerMgmt);

    83 

    84 //

    85 // class CWsClient

    86 // 

    87 

    88 CWsClient::CWsClient(RThread aClient) : iClient(aClient), iGraphicMessageQueue(this), iInternalFlags(ERemoveKeyCode|EFinishedProcessingCommands)

    89 	{

    90 	iScreen = CWsTop::Screen();

    91 	}

    92 

    93 CWsClient::~CWsClient()

    94 	{

    95 	CWsTop::WindowServer()->RemoveAllGraphicDrawers(*this); // deindexes all graphic drawers owned by this client

    96 

    97 	delete iTempCustomTextCursor.iCursor;

    98 	FreeSystemPointerCursorList();

    99 	CWsTop::ClientDestroyed(this);

   100 	if (wsDebugLog)

   101 		{

   102 		_LIT(ClientDestuct,"Client %d destructing");

   103 		wsDebugLog->MiscMessage(CDebugLogBase::ELogIntermediate,ClientDestuct, iConnectionHandle);

   104 		}

   105 		

   106 	iInternalFlags |= EClientIsClosing;

   107 	delete iObjectIndex;

   108 	delete iEventQueue;

   109 	delete iRedrawQueue;

   110 	delete iPriorityKeyEvent;

   111 	CWsTop::ClearSurfaceMap(this);

   112 

   113 	CWsTop::SessionExited(this);

   114 	iClient.Close();

   115 	}

   116 

   117 void CWsClient::CompleteInitializationL()

   118 	{

   119 	iObjectIndex = new(ELeave) CWsObjectIx();

   120 	iObjectIndex->ConstructL();

   121 	

   122     iEventQueue = new(ELeave) CEventQueue(this);

   123 	iEventQueue->ConstructL();

   124     

   125     iRedrawQueue = new(ELeave) CRedrawQueue(this);

   126 	iRedrawQueue->ConstructL();

   127     

   128     iPriorityKeyEvent = new(ELeave) CPriorityKey(this);

   129 	

   130 	CWsCliObj::NewL(this);

   131 	

   132 	iComputeMode = RWsSession::EPriorityControlComputeOff;

   133 	

   134 	CWsTop::NewSession(this);

   135 	

   136 #ifdef __WINS__

   137 	TBool halValue = EFalse;

   138 	if (UserSvr::HalFunction(EHalGroupEmulator, EEmulatorHalIntProperty, 

   139 		(TAny*)"debug_wserv_exe_EnforceRedrawCallingConvention", &halValue) == KErrNone)

   140 		{

   141 		iDebug_EnforceRedrawCallingConvention = halValue;

   142 		}

   143 #endif

   144 	

   145 	iInternalFlags |= EIsInitialised;

   146 	}

   147 

   148 TBool CWsClient::DebugEnforceRedrawCallingConvention()

   149 	{

   150 	return iDebug_EnforceRedrawCallingConvention;

   151 	}

   152 

   153 void CWsClient::StartInitializationL(TUint aConnectionHandle)

   154 	{

   155 	if (wsDebugLog)

   156 		wsDebugLog->NewClient(aConnectionHandle);

   157 	

   158 	if (iObjectIndex)

   159 		PPanic(EWservPanicReInitialise);

   160 	else

   161 		{

   162 		iConnectionHandle = aConnectionHandle;

   163 		CompleteInitializationL();

   164 		}

   165 	}

   166 

   167 //

   168 // Convert a handle to object checking it is of the correct type.

   169 //

   170 void CWsClient::HandleToWindow(TInt aHandle,CWsWindowBase** pWin)

   171 	{

   172 	if ((*pWin=(CWsWindowBase* )HandleToObjUntyped(aHandle))==NULL ||

   173 		((*pWin)->Type()!=WS_HANDLE_WINDOW && (*pWin)->Type()!=WS_HANDLE_GROUP_WINDOW))

   174 		PPanic(EWservPanicWindow);

   175 	}

   176 

   177 //

   178 // Convert a handle to object checking it is of the correct type.

   179 //

   180 void CWsClient::HandleToClientWindow(TInt aHandle,CWsClientWindow** pWin)

   181 	{

   182 	if ((*pWin=(CWsClientWindow*)HandleToObj(aHandle, WS_HANDLE_WINDOW))==NULL)

   183 		PPanic(EWservPanicWindow);

   184 	}

   185 

   186 void CWsClient::CreateNewPointerCursorL(const TWsClCmdCreatePointerCursor &aCmd)

   187 	{

   188 	CWsPointerCursor* pc=new(ELeave) CWsPointerCursor(this);

   189 	CleanupStack::PushL(pc);

   190 	pc->ConstructL(aCmd);

   191 	CleanupStack::Pop();

   192 	}

   193 

   194 // Create a new custom text cursor

   195 void CWsClient::StartSetCustomTextCursorL(const TWsClCmdCustomTextCursorData& aCmd)

   196 	{

   197 	if (!iTextCursorArray)

   198 		{

   199 		const TInt textCursorArrayGranularity = 4;

   200 		iTextCursorArray = new(ELeave) CArrayFixFlat<TWsCursorArrayItem>(textCursorArrayGranularity);

   201 		}

   202 		

   203 	TInt arrayIndex = KErrNotFound;

   204 	if (FindCursorArrayItem(iTextCursorArray, aCmd.identifier, arrayIndex))

   205 		User::Leave(KErrAlreadyExists);

   206 	

   207 	delete iTempCustomTextCursor.iCursor;

   208 	iTempCustomTextCursor.iCursor = NULL;

   209 	iTempCustomTextCursor.iCursor = new(ELeave) CWsCustomTextCursor(this, aCmd.alignment);

   210 	

   211 	static_cast<CWsCustomTextCursor*>(iTempCustomTextCursor.iCursor)->ConstructL(aCmd.flags);

   212 	iTempCustomTextCursor.iIndex = aCmd.identifier;

   213 	}

   214 

   215 // Add new custom text cursor to global list

   216 void CWsClient::CompleteSetCustomTextCursorL(TInt aError)

   217 	{

   218 	if (aError)

   219 		{

   220 		delete iTempCustomTextCursor.iCursor;

   221 		iTempCustomTextCursor.iCursor = NULL;

   222 		User::Leave(aError);

   223 		}

   224 

   225 	TWsCursorArrayItem entry = iTempCustomTextCursor;

   226 	iTempCustomTextCursor.iCursor = NULL;

   227 	CleanupStack::PushL(entry.iCursor);

   228 

   229 	TInt arrayIndex;

   230 	if (FindCursorArrayItem(iTextCursorArray, entry.iIndex, arrayIndex))

   231 		User::Leave(KErrAlreadyExists);

   232 	else

   233 		iTextCursorArray->InsertIsqL(entry, iCursorKey);

   234 

   235 	CleanupStack::Pop(entry.iCursor);

   236 	}

   237 

   238 CWsCustomTextCursor* CWsClient::FindCustomTextCursor(TInt aIdentifier)

   239 	{

   240 	TInt arrayIndex;

   241 	if (!FindCursorArrayItem(iTextCursorArray, aIdentifier, arrayIndex))

   242 		return NULL;

   243 

   244 	return TextCursor(arrayIndex);

   245 	}

   246 

   247 void CWsClient::CreateNewSpriteL(const TWsClCmdCreateSprite &aCmd)

   248 	{

   249 	CWsSprite* sprite = new(ELeave) CWsSprite(this);

   250 	CleanupStack::PushL(sprite);

   251 	sprite->ConstructL(aCmd);

   252 	CleanupStack::Pop();

   253 	}

   254 

   255 void CWsClient::CreateNewBitmapL(const TWsClCmdCreateBitmap &aCmd)

   256 	{

   257 	DWsBitmap* bitmap = new(ELeave) DWsBitmap(this);

   258 	CleanupStack::PushL(bitmap);

   259 	bitmap->ConstructL(aCmd);

   260 	CleanupStack::Pop();

   261 	}

   262 

   263 /** Creates a new window.

   264 

   265 If the parent is a window group then a new CWsTopClientWindow instance is created. If the parent is

   266 a window then a new CWsClientWindow instance is created.

   267 

   268 @param aCmd The command received from the client

   269 @internalComponent

   270 @released

   271 */

   272 void CWsClient::CreateNewWindowL(const TWsClCmdCreateWindow &aCmd)

   273 	{

   274 	CWsWindowBase* parent;

   275 	HandleToWindow(aCmd.parent,&parent);

   276 	CWsClientWindow* win = NULL;

   277 	TBool deviceIsInvalid = EFalse;

   278 	CScreen* screen = parent->Screen();

   279 	if (parent->WinType()==EWinTypeGroup)

   280 		{

   281 		__ASSERT_DEBUG(!((CWsWindowGroup*)parent)->ScreenDeviceDeleted(),PPanic(EWservPanicGroupWinScreenDeviceDeleted));

   282 		win=new(ELeave) CWsTopClientWindow(this, screen);

   283 		deviceIsInvalid=!((CWsWindowGroup*)parent)->ScreenDeviceValid();

   284 		}

   285 	else

   286 		win=new(ELeave) CWsClientWindow(this, screen);

   287 

   288 	CleanupStack::PushL(win);

   289 	win->ConstructL(aCmd,parent,deviceIsInvalid);

   290 	CleanupStack::Pop(win);

   291 	}

   292 

   293 void CWsClient::CreateNewWindowGroupL(const TWsClCmdCreateWindowGroup &aCmd)

   294 	{

   295 	CWsWindowGroup::NewL(this, NULL, aCmd); //screen is initialised inside the constructL

   296 	}

   297 

   298 void CWsClient::CreateNewAnimDllL(const TWsClCmdUnion &aParams)

   299 	{

   300 	CWsAnimDll* animDll = new(ELeave) CWsAnimDll(this);

   301 	CleanupStack::PushL(animDll);

   302 	animDll->LoadL(BufferTPtr((TText*)(aParams.LoadAnimDll+1),aParams.LoadAnimDll->length));

   303 	CleanupStack::Pop();

   304 	}	

   305 

   306 void CWsClient::CreateNewScreenDeviceL(TInt aDefaultScreenNumber, TUint aClientScreenDevicePointer)

   307 	{

   308 	DWsScreenDevice* screenDevice = new(ELeave) DWsScreenDevice(this, aDefaultScreenNumber,aClientScreenDevicePointer);

   309 	CleanupStack::PushL(screenDevice);

   310 	screenDevice->ConstructL();

   311 	CleanupStack::Pop(screenDevice);

   312 	if (iPrimaryScreenDevice==NULL)

   313 		{

   314 		iPrimaryScreenDevice=screenDevice;

   315 		// When client create screen device, change default screen to the one specified.

   316 		// Client should do this immediately after establishing session

   317 		iScreen = iPrimaryScreenDevice->Screen();

   318 		InitialiseScreenDevices();

   319 		}

   320 	}

   321 

   322 void CWsClient::InitialiseScreenDevices()

   323 	{

   324 	const TWsObject* ptr = iObjectIndex->FirstObject();

   325 	const TWsObject* end = ptr+iObjectIndex->Length();

   326 	WS_ASSERT_DEBUG(ptr->iObject==NULL, EWsPanicObjectIndexError);

   327 	while(++ptr<end)

   328 		{

   329 		if (ptr->iObject && ptr->iObject->Type()==WS_HANDLE_GROUP_WINDOW)

   330 			{

   331 			CWsWindowGroup* gw = static_cast<CWsWindowGroup*>(ptr->iObject);

   332 			if(!gw->Device())

   333 				gw->SetScreenDevice(iPrimaryScreenDevice);

   334 			}

   335 		}

   336 	}

   337 

   338 void CWsClient::CreateNewClickHandlerL(const TUid& aUid)

   339 	{

   340 	CClick* click = new(ELeave) CClick(this);

   341 	CleanupStack::PushL(click);

   342 	click->ConstructL(aUid);

   343 	CleanupStack::Pop(click);

   344 	}

   345 

   346 void CWsClient::RequestComplete(TRequestStatus*  &aStatus, TInt aErr)

   347 	{

   348 	Client().RequestComplete(aStatus,aErr);

   349 	}

   350 

   351 void CWsClient::PanicCurrentClient(TClientPanic aPanic)

   352 	{

   353 	iCurrentClient->PPanic(aPanic);

   354 	}

   355 

   356 void CWsClient::PPanic(TClientPanic aPanic) const

   357 //This function is allowed to leave with out the 'L' convention for special reasons

   358 	{

   359 	SessionPanic(aPanic);

   360 	User::Leave(EPanicLeave);

   361 	}

   362 

   363 void CWsClient::SessionPanic(TClientPanic aReason) const

   364 	{

   365 	if (wsDebugLog)

   366 		wsDebugLog->Panic(iConnectionHandle, aReason);

   367 	

   368 	if (!(iInternalFlags&EPanicClientAsSoonAsPossible)) // keep the first error code

   369 		{

   370 		iInternalFlags |= EPanicClientAsSoonAsPossible;

   371 		iPanicReason = aReason;

   372 		}

   373 	}

   374 

   375 void CWsClient::SessionTerminate()

   376 	{

   377 	if (wsDebugLog)

   378 		wsDebugLog->Panic(iConnectionHandle, 0);

   379 

   380 	const RThread thread=Client();

   381 	RProcess process;

   382 	if (thread.Process(process)==KErrNone)

   383 		{

   384 		process.Terminate(0);

   385 		process.Close();

   386 		}

   387 	}

   388 

   389 /**	

   390 Returns the remaining space in the descriptor

   391 */

   392 TInt CWsClient::ReplyBufSpace() 

   393 	{

   394 	const TInt retVal = iCurrentClient->ClientMessage().GetDesLength(KReplyBufferMessageSlot);

   395 	

   396 	if (iReplyOffset>=0 && retVal>=iReplyOffset)

   397 		return retVal-iReplyOffset;

   398 	else

   399 		return (retVal<0 ? retVal : KErrBadDescriptor);

   400 	}

   401 

   402 void CWsClient::ReplyBuf(const TDesC16 &aDes)	// static

   403 	{

   404 	WS_ASSERT_DEBUG(!iCurrentClient->ClientMessage().IsNull(), EWsPanicInvalidMessageHandle);

   405 	

   406 	if(iCurrentClient->ClientMessage().Write(KReplyBufferMessageSlot,aDes,iReplyOffset) != KErrNone)

   407 		PanicCurrentClient(EWservPanicDescriptor);

   408 	

   409 	iReplyOffset += aDes.Length();

   410 	if (wsDebugLog)

   411 		wsDebugLog->ReplyBuf(aDes);

   412 	}

   413 

   414 void CWsClient::ReplyBuf(const TDesC8 &aDes)	// static

   415 	{

   416 	WS_ASSERT_DEBUG(!iCurrentClient->ClientMessage().IsNull(), EWsPanicInvalidMessageHandle);

   417 	

   418 	if(iCurrentClient->ClientMessage().Write(KReplyBufferMessageSlot, aDes, iReplyOffset) != KErrNone)

   419 		PanicCurrentClient(EWservPanicDescriptor);

   420 	

   421 	iReplyOffset += aDes.Length();

   422 	if (wsDebugLog)

   423 		wsDebugLog->ReplyBuf(aDes);

   424 	}

   425 

   426 void CWsClient::ReplyBuf(const TAny* aSource, TInt aLength)	// static

   427 //

   428 // Send a buffer to the client process.

   429 //

   430 	{

   431 	TPtrC8 src(reinterpret_cast<const TUint8*>(aSource),aLength);

   432 	ReplyBuf(src);

   433 	}

   434 

   435 void CWsClient::ReplySize(const TSize &aSize)	// static

   436 	{

   437 	ReplyBuf(&aSize, sizeof(aSize));

   438 	}

   439 

   440 void CWsClient::ReplyPoint(const TPoint &aPoint)	// static

   441 	{

   442 	ReplyBuf(&aPoint, sizeof(aPoint));

   443 	}

   444 

   445 void CWsClient::ReplyRect(const TRect &aRect)	// static

   446 	{

   447 	ReplyBuf(&aRect, sizeof(aRect));

   448 	}

   449 

   450 void CWsClient::SetReply(TInt reply)

   451 	{

   452 	iReply = reply;

   453 	if (wsDebugLog)

   454 		wsDebugLog->Reply(reply);

   455 	}

   456 

   457 const TUint8* CWsClient::EndOfCommandBuffer()

   458 	{

   459 	return(iCmdBuf.Ptr()+iCmdBuf.Size());

   460 	}

   461 

   462 const TPtrC CWsClient::BufferTPtr(TText *aStart,TInt aLen)

   463 	{

   464 	TPtrC ptr;

   465 	if (!BufferTPtrGc(aStart,aLen,ptr))

   466 		PanicCurrentClient(EWservPanicBufferPtr);

   467 	return(ptr);

   468 	}

   469 

   470 TBool CWsClient::BufferTPtrGc(TText* aStart,TInt aLen, TPtrC& aPtr)

   471 	{

   472 	if (iCurrentCommand.iOpcode>0)

   473 		{

   474 		if ((REINTERPRET_CAST(TUint8*,aStart)<iCmdBuf.Ptr()

   475 										|| REINTERPRET_CAST(TUint8*,aStart+aLen)>(iCmdBuf.Ptr()+iCmdBuf.Size())))

   476 			return(EFalse);

   477 		}

   478 	else

   479 		{

   480 		if (aLen>=iCurrentCommand.iCmdLength)

   481 			return(EFalse);

   482 		}

   483 	aPtr.Set(aStart,aLen);

   484 	return(ETrue);

   485 	}

   486 

   487 const TPtrC8 CWsClient::BufferTPtr8(TUint8* aStart,TInt aLen)

   488 	{

   489 	if (iCurrentCommand.iOpcode>0 && (REINTERPRET_CAST(TUint8*,aStart)<iCmdBuf.Ptr()

   490 										|| REINTERPRET_CAST(TUint8*,aStart+aLen)>(iCmdBuf.Ptr()+iCmdBuf.Size())))

   491 		PanicCurrentClient(EWservPanicBufferPtr);

   492 		

   493 	return(TPtrC8(aStart,aLen));

   494 	}

   495 

   496 /**

   497 Process a command buffer

   498 

   499 @internalComponent

   500 @released

   501 */

   502 void CWsClient::DispatchCommandsInBufL()	// (step #4)

   503 	{		

   504 	if (wsDebugLog)

   505 		{

   506  		wsDebugLog->CommandBuf(iConnectionHandle);

   507  		RThread client = Client(); 

   508  		wsDebugLog->MiscMessage(CDebugLogBase::ELogEverything, client.FullName());

   509 		}

   510 	const TUint8* endCmd=iCmdBuf.Ptr()+iCmdBuf.Length();

   511 	do

   512 		{

   513 		const TWsCmdHeader* pCmd=

   514 				reinterpret_cast<const TWsCmdHeader*>(iNextCmd);

   515 		TUint opcode = pCmd->iBase.iOpcode;

   516 		TInt headerLen = sizeof(pCmd->iBase);

   517 		iCurrentCommand = pCmd->iBase;

   518 		

   519 		// For performance reasons the handle is only included

   520 		// if it is different from the previous command. The EWsOpcodeHandle

   521 		// flag indicates whether a new handle has been included in the

   522 		// current command. If not we use the same handle as the previous

   523 		// command.

   524 		if (opcode&EWsOpcodeHandle)

   525 			{

   526 			// Find the WServ object associated with this op code

   527 			opcode &= ~EWsOpcodeHandle;

   528 			iCurrentCommand.iOpcode = reinterpret_cast<TUint16&>(opcode);

   529 			iDestObj=HandleToObjUntyped(pCmd->iDestHandle);

   530 			headerLen = sizeof(*pCmd);

   531 			}

   532 			

   533 		iNextCmd += headerLen;

   534 		const TAny* cmdParams = iNextCmd;

   535 		iNextCmd += pCmd->iBase.iCmdLength;

   536 		if (!iDestObj || iNextCmd>endCmd)		// Invalid handle or Corrupt buffer

   537 			{

   538 			SessionPanic(iDestObj==NULL ? EWservPanicHandle : EWservPanicBuffer);

   539 			iInternalFlags|=EFinishedProcessingCommands;

   540 			break;

   541 			}

   542 

   543 		if (iNextCmd==endCmd)

   544 			iInternalFlags|=EFinishedProcessingCommands;

   545 			

   546 		if (wsDebugLog)

   547 			wsDebugLog->Command(iDestObj->Type(), opcode, cmdParams, iDestObj->LogHandle());

   548 		

   549 		// Dispatch the command to the WServ object that will process it

   550 		iDestObj->CommandL(opcode, cmdParams);	// (call #5)

   551 		} 

   552 	while(iNextCmd<endCmd && !TWindowServerEvent::EventReceiver()->IsReadyToRun());

   553 	

   554 	}

   555 

   556 void CWsClient::DoServiceCommandBuf() // (step #3.1)

   557 	{

   558 	iCurrentClient=this;

   559 	iInternalFlags&=~EFinishedProcessingCommands;

   560 	TRAPD(err, DispatchCommandsInBufL());	// (call #4)

   561 	

   562 #if defined(_DEBUG)

   563 	if (err!=KErrNone && !(iInternalFlags&(EFinishedProcessingCommands|EPanicClientAsSoonAsPossible)))

   564 		SessionPanic(EWservPanicFunctionLeave);

   565 #endif

   566 

   567 	if (err<KErrNone)

   568 		SetReply(err);

   569 

   570 	if (iInternalFlags&(EFinishedProcessingCommands|EPanicClientAsSoonAsPossible))

   571 		CompleteMessage(iClientMessage,iReply);	// (finish)

   572 	else

   573 		iMoreCommands->Start(TCallBack(CWsClient::DoContinueDeferredServiceOfCommandBuf,this));	// (call #3.1.1)

   574 	

   575 	iCurrentClient=NULL;

   576 #if defined(_DEBUG)

   577 	User::Heap().Check();

   578 #endif

   579 	}

   580 

   581 TInt CWsClient::DoContinueDeferredServiceOfCommandBuf(TAny* aClient)	// (step #3.1.1)

   582 	{

   583 	static_cast<CWsClient*>(aClient)->DoServiceCommandBuf();	// (call #3.1)

   584 	return KErrNone;

   585 	}

   586 

   587 

   588 void CWsClient::ExecuteAsyncClientCommandL(TInt aOpcode, const RMessage2& aMessage)	// (step #3.2)

   589 	{

   590 	switch(aOpcode)

   591 		{

   592 		case EWsClOpEventReady:

   593 			EventReady(aMessage);

   594 			break;

   595 		case EWsClOpPriorityKeyReady:

   596 			PriorityKeyEventReady(aMessage);

   597 			break;

   598 		case EWsClOpRedrawReady:

   599 			RedrawEventReady(aMessage);

   600 			break;

   601 		case EWsClOpGraphicMessageReady:

   602 			iGraphicMessageQueue.EventReady(aMessage);

   603 			break;

   604 		default:

   605 			{

   606 			PPanic(EWservPanicOpcode);

   607 			break;

   608 			}

   609 		}

   610 	}

   611 

   612 

   613 

   614 void CWsClient::ExecuteCommandL(TInt aOpcode, const TAny* aCmdData)	// (step #6)

   615 	{

   616 	TWsClCmdUnion pData;

   617 	pData.any=aCmdData;

   618 	switch(aOpcode)

   619 		{

   620 		case EWsClOpCreateWindowGroup:

   621 			CreateNewWindowGroupL(*pData.CreateWindowGroup);

   622 			break;

   623 		case EWsClOpCreateWindow:

   624 			CreateNewWindowL(*pData.CreateWindow);

   625 			break;

   626 		case EWsClOpCreateGc:

   627 			CWsGc::NewL(this);

   628 			break;

   629 		case EWsClOpCreateAnimDll:

   630 			if (!CheckBuffer(pData.LoadAnimDll->length, KMaxFileName))

   631 				PanicCurrentClient(EWservPanicBufferPtr);

   632 			CreateNewAnimDllL(pData);

   633 			break;

   634 		case EWsClOpCreateGraphic:

   635 			CWsGraphicDrawerObject::NewL(this,pData);

   636 			break;

   637 		case EWsClOpCreateScreenDevice:

   638 			{

   639 			const TInt screenNumber = pData.CreateScreenDevice->screenNumber;

   640 			const TUint clientScreenDevicePointer = pData.CreateScreenDevice->clientScreenDevicePointer;

   641 			if (screenNumber<0 || screenNumber>=CWsTop::NumberOfScreens())

   642 				{

   643 				PPanic(EWservPanicScreenNumber);

   644 				}

   645 			else

   646 				{

   647 				CreateNewScreenDeviceL(screenNumber,clientScreenDevicePointer);

   648 				}

   649 			}

   650 			break;

   651 		case EWsClOpCreateSprite:

   652 			CreateNewSpriteL(*pData.CreateSprite);

   653 			break;

   654 		case EWsClOpCreatePointerCursor:

   655 			CreateNewPointerCursorL(*pData.CreatePointerCursor);

   656 			break;

   657 		case EWsClOpStartSetCustomTextCursor:

   658 			StartSetCustomTextCursorL(*pData.CustomTextCursorData);

   659 			break;

   660 		case EWsClOpCompleteSetCustomTextCursor:

   661 			CompleteSetCustomTextCursorL(*pData.Int);

   662 			break;

   663 		case EWsClOpCreateBitmap:

   664 			CreateNewBitmapL(*pData.CreateBitmap);

   665 			break;

   666 		case EWsClOpCreateDirectScreenAccess:

   667 			CWsDirectScreenAccess::NewL(this,EFalse);

   668 			break;

   669 		case EWsClOpCreateDirectScreenAccessRegionTrackingOnly:

   670 			CWsDirectScreenAccess::NewL(this,ETrue);	//creates a DSA object that will not draw to the screen, but will use just the region tracking functionality

   671 			break;

   672 		case EWsClOpCreateClick:

   673 			CreateNewClickHandlerL(*pData.Uid);

   674 			break;

   675 		case EWsClOpSetHotKey:

   676 			{

   677 			if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetHotKey API")))

   678 				{

   679 				User::Leave(KErrPermissionDenied);

   680 				}

   681 			TWindowServerEvent::SetHotKeyL(*pData.SetHotKey);

   682 			}

   683 			break;

   684 		case EWsClOpClearHotKeys:

   685 			{

   686 			if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::ClearHotKeys API")))

   687 				{

   688 				User::Leave(KErrPermissionDenied);

   689 				}

   690 			TWindowServerEvent::ClearHotKeysL(*pData.UInt);

   691 			}

   692 			break;

   693 		case EWsClOpRestoreDefaultHotKey:

   694 			TWindowServerEvent::ResetDefaultHotKeyL(*pData.UInt);

   695 			break;

   696 		case EWsClOpSetShadowVector:

   697 			PPanic(EWservPanicOpcode); //this op code is deprecated, should never be generated by the client

   698 			break;

   699 		case EWsClOpShadowVector:

   700 			PPanic(EWservPanicOpcode); //this op code is deprecated, should never be generated by the client

   701 			break;

   702 		case EWsClOpSetKeyboardRepeatRate:

   703 			{

   704 			if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetKeyboardRepeatRate API")))

   705 				{

   706 				User::Leave(KErrPermissionDenied);

   707 				}

   708 			if ((pData.SetKeyboardRepeatRate->initial.Int()<0) || (pData.SetKeyboardRepeatRate->time.Int()<0))

   709 				{

   710 				User::Leave(KErrArgument);

   711 				}

   712 			CKeyboardRepeat::SetRepeatTime(pData.SetKeyboardRepeatRate->initial,pData.SetKeyboardRepeatRate->time);

   713 			}

   714 			break;

   715 		case EWsClOpGetKeyboardRepeatRate:

   716 			{

   717 			SKeyRepeatSettings settings;

   718 			CKeyboardRepeat::GetRepeatTime(settings.iInitialTime,settings.iTime);

   719 			ReplyBuf(&settings,sizeof(settings));

   720 			}

   721 			break;

   722 		case EWsClOpSetDoubleClick:

   723 			{

   724 			if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetDoubleClick API")))

   725 				{

   726 				User::Leave(KErrPermissionDenied);

   727 				}

   728 			TWsPointer::SetDoubleClick(pData.SetDoubleClick->interval,pData.SetDoubleClick->distance);

   729 			}

   730 			break;

   731 		case EWsClOpGetDoubleClickSettings:

   732 			{

   733 			SDoubleClickSettings settings;

   734 			TWsPointer::GetDoubleClickSettings(settings.iInterval,settings.iDistance);

   735 			ReplyBuf(&settings,sizeof(settings));

   736 			}

   737 			break;

   738 		case EWsClOpEventReady:

   739 			// No need to do anything

   740 			break;

   741 		case EWsClOpGetEvent:

   742 			HandleClientRequestForEventData();

   743 			// Check flag if the group message queue is overflow and has pended messages  

   744 			if (iInternalFlags & EWgMsgQueueOverflow)

   745 				{

   746 				iInternalFlags &= ~EWgMsgQueueOverflow;

   747 				CWsWindowGroup::ReleasePendedMessagesToAllGroups(this);

   748 				}

   749 			break;

   750 		case EWsClOpPurgePointerEvents:

   751 			PurgePointerEvents();

   752 			break;

   753 		case EWsClOpEventReadyCancel:

   754 			CancelClientRequestForEventData();

   755 			break;

   756 		case EWsClOpRedrawReady:

   757 			iInternalFlags&=~EIsPerformingRedrawEvent;

   758 			break;

   759 		case EWsClOpRedrawReadyCancel:

   760 			CancelClientRequestForRedrawEvent();

   761 			break;

   762 		case EWsClOpGetRedraw:

   763 			HandleClientRequestForRedrawData();

   764 			break;

   765 		case EWsClOpPriorityKeyReady:

   766 			// No need to do anything

   767 			break;

   768 		case EWsClOpPriorityKeyReadyCancel:

   769 			CancelClientRequestForPriorityKeyEvent();

   770 			break;

   771 		case EWsClOpGetPriorityKey:

   772 			HandleClientRequestForPriorityKeyData();

   773 			break;

   774 		case EWsClOpNumWindowGroups:

   775 			SetReply(CWsWindowGroup::NumWindowGroups(EFalse,* pData.Int));

   776 			break;

   777 		case EWsClOpNumWindowGroupsAllPriorities:

   778 			SetReply(CWsWindowGroup::NumWindowGroups(ETrue, 0));

   779 			break;

   780 		case EWsClOpNumWindowGroupsOnScreen:

   781 			{

   782 			const TInt screenNumber=pData.NumWinGroups->screenNumber;

   783 			if (screenNumber<0 || screenNumber>=CWsTop::NumberOfScreens())

   784 				PPanic(EWservPanicScreenNumber);

   785 			else

   786 				SetReply(CWsWindowGroup::NumWindowGroupsOnScreen(CWsTop::Screen(screenNumber)->RootWindow()->Child(),(pData.NumWinGroups->priority==EAllPriorities),pData.NumWinGroups->priority));

   787 			}

   788 			break;

   789 		case EWsClOpWindowGroupList:

   790 			{

   791 			const TInt screenNumber=pData.WindowGroupList->screenNumber;

   792 			if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())

   793 				PPanic(EWservPanicScreenNumber);

   794 			else

   795 				SetReply(CWsWindowGroup::SendWindowGroupListL(screenNumber,(pData.WindowGroupList->priority==EAllPriorities), pData.WindowGroupList->priority, pData.WindowGroupList->count));

   796 			}

   797 			break;

   798 		case EWsClOpWindowGroupListAllPriorities:

   799 			{

   800 			const TInt screenNumber=pData.WindowGroupList->screenNumber;

   801 			if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())

   802 				PPanic(EWservPanicScreenNumber);

   803 			else

   804 				SetReply(CWsWindowGroup::SendWindowGroupListL(screenNumber,ETrue, 0, pData.WindowGroupList->count));

   805 			}

   806 			break;

   807 		case EWsClOpWindowGroupListAndChain:

   808 			SetReply(CWsWindowGroup::SendWindowGroupListAndChainL(EFalse, pData.WindowGroupList->priority, pData.WindowGroupList->count));

   809 			break;

   810 		case EWsClOpWindowGroupListAndChainAllPriorities:

   811 			SetReply(CWsWindowGroup::SendWindowGroupListAndChainL(ETrue, 0, pData.WindowGroupList->count));

   812 			break;

   813 		case EWsClOpGetDefaultOwningWindow:

   814 			{

   815 			const TInt screenNumber = *pData.Int;

   816 			if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())

   817 				PPanic(EWservPanicScreenNumber);

   818 			else

   819 				{

   820 				CScreen* screen = (screenNumber ==KDummyScreenNumber) ? iScreen : CWsTop::Screen(screenNumber);

   821 				SetReply(screen->DefaultOwningWindowGroup() ? screen->DefaultOwningWindowGroup()->Identifier():0);

   822 				}

   823 			}

   824 			break;

   825 		case EWsClOpGetFocusWindowGroup:

   826 			{

   827 			const TInt screenNumber = *pData.Int;

   828 			if (screenNumber<KDummyScreenNumber || screenNumber>=CWsTop::NumberOfScreens())

   829 				PPanic(EWservPanicScreenNumber);

   830 			else

   831 				CWsWindowGroup::GetFocusWindowGroupL(screenNumber);

   832 			}

   833 			break;

   834 		case EWsClOpSetWindowGroupOrdinalPosition:

   835 			CWsWindowGroup::WindowGroupFromIdentifierL(pData.SetWindowGroupOrdinalPosition->identifier)->SetOrdinalPosition(pData.SetWindowGroupOrdinalPosition->position);

   836 			break;

   837 		case EWsClOpGetWindowGroupHandle:

   838 			SetReply(CWsWindowGroup::WindowGroupFromIdentifierL(*pData.Int)->ClientHandle());

   839 			break;

   840 		case EWsClOpGetWindowGroupOrdinalPriority:

   841 			SetReply(CWsWindowGroup::WindowGroupFromIdentifierL(*pData.Int)->OrdinalPriority());

   842 			break;

   843 		case EWsClOpGetWindowGroupClientThreadId:

   844 			{

   845 			TThreadId id=CWsWindowGroup::WindowGroupFromIdentifierL(*pData.Int)->WsOwner()->Client().Id();

   846 			ReplyBuf(&id,sizeof(id));

   847 			}

   848 			break;

   849 		case EWsClOpSendEventToWindowGroup:

   850 			{

   851 			CWsWindowGroup* group=CWsWindowGroup::WindowGroupFromIdentifierL(pData.SendEventToWindowGroup->parameter);

   852 			TWsEvent event=pData.SendEventToWindowGroup->event;

   853 			event.SetHandle(group->ClientHandle());

   854 			// Events in enum TEventCode is protected by capabilities

   855 			if (group->WsOwner()!=this && event.Type()>=EEventNull && event.Type()<EEventUser)

   856 				{

   857 				if (event.Type()<EEventPowerMgmt || event.Type()>=EEventReserved)

   858 					{

   859 					if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendEventToWindowGroup API")))

   860 						User::Leave(KErrPermissionDenied);

   861 					}

   862 				else

   863 					{

   864 					if (!KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendEventToWindowGroup API")))

   865 						User::Leave(KErrPermissionDenied);

   866 					}

   867 				}

   868 			if (event.Type()==EEventKey && event.Key()->iRepeats!=0)

   869 				CKeyboardRepeat::CancelRepeat(NULL);		//Otherwise we will trip an invarient

   870 			if (!group->EventQueue()->QueueEvent(event))

   871 				User::Leave(KErrNoMemory);

   872 			}

   873 			break;

   874 		case EWsClOpSendEventToAllWindowGroup:

   875 		case EWsClOpSendEventToAllWindowGroupPriority:

   876 		case EWsClOpSendEventToOneWindowGroupPerClient:

   877 			{

   878 			TWsEvent event=pData.SendEventToWindowGroup->event;

   879 			if (event.Type()<0)

   880 				User::Leave(KErrArgument);

   881 			if(event.Type()<EEventUser)

   882 				{

   883 				if (event.Type()<EEventPowerMgmt || event.Type()>=EEventReserved)

   884 					{

   885 					if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendEventToAllWindowGroup API")))

   886 						User::Leave(KErrPermissionDenied);

   887 					}

   888 				else 

   889 					{

   890 					if (!KSecurityPolicy_PowerMgmt().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendEventToAllWindowGroup API")))

   891 						User::Leave(KErrPermissionDenied);

   892 					}

   893 				}

   894 			if (!CWsWindowGroup::SendEventToAllGroups(aOpcode!=EWsClOpSendEventToAllWindowGroupPriority

   895 													,aOpcode==EWsClOpSendEventToOneWindowGroupPerClient,*pData.SendEventToWindowGroup))

   896 				User::Leave(KErrNoMemory);

   897 			}

   898 			break;

   899 		case EWsClOpSendMessageToWindowGroup:

   900 			{

   901 			CWsWindowGroup* group=CWsWindowGroup::WindowGroupFromIdentifierL(pData.SendMessageToWindowGroup->identifierOrPriority);

   902 			if (group->WsOwner()!=this)

   903 				{

   904 				if (!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SendMessageToWindowGroup API")))

   905 					{

   906 					User::Leave(KErrPermissionDenied);

   907 					}

   908 				}

   909 			group->QueueMessageL(pData.SendMessageToWindowGroup->uid, pData.SendMessageToWindowGroup->dataLength,* this);

   910 			}

   911 			break;

   912 		case EWsClOpSendMessageToAllWindowGroups:

   913 		case EWsClOpSendMessageToAllWindowGroupsPriority:

   914 			{

   915 			if ((pData.SendMessageToWindowGroup->dataLength<0) || (pData.SendMessageToWindowGroup->dataLength>=(KMaxTInt/2)))

   916 				{

   917 				User::Leave(KErrArgument);

   918 				}

   919 			CWsWindowGroup::SendMessageToAllGroupsL(*this,aOpcode==EWsClOpSendMessageToAllWindowGroups,*pData.SendMessageToWindowGroup);

   920 			}

   921 			break;

   922 		case EWsClOpFetchMessage:

   923 			CWsWindowGroup::WindowGroupFromIdentifierL(pData.FetchMessage->windowGroupIdentifier)->FetchMessageL();

   924 			break;

   925 		case EWsClOpGetWindowGroupNameFromIdentifier:

   926 			ReplyGroupName(CWsWindowGroup::WindowGroupFromIdentifierL(pData.GetWindowGroupNameFromIdentifier->identifier)->GroupName(),pData.GetWindowGroupNameFromIdentifier->maxLength);

   927 			break;

   928 		case EWsClOpFindWindowGroupIdentifier:

   929 			{

   930 			if (pData.FindWindowGroupIdentifier->length<0)

   931 				User::Leave(KErrArgument);

   932 			TPtrC ptr(BufferTPtr((TText*)(pData.FindWindowGroupIdentifier+1),pData.FindWindowGroupIdentifier->length));

   933 			SetReply(CWsWindowGroup::FindWindowGroupL(this, pData.FindWindowGroupIdentifier->identifier,

   934 							pData.FindWindowGroupIdentifier->offset,&ptr,NULL)->Identifier());

   935 			}

   936 			break;

   937 		case EWsClOpFindWindowGroupIdentifierThread:

   938 			SetReply(CWsWindowGroup::FindWindowGroupL(this, pData.FindWindowGroupIdentifierThread->identifier,0,NULL,

   939 											&pData.FindWindowGroupIdentifierThread->threadId)->Identifier());

   940 			break;

   941 		case EWsClOpSetBackgroundColor:

   942 			for(TInt i=0;i<CWsTop::NumberOfScreens();i++)

   943 				{

   944 				CWsTop::Screen(i)->RootWindow()->SetColor(*pData.rgb);

   945 				}

   946 			break;

   947 		case EWsClOpGetBackgroundColor:

   948 			SetReply(iScreen->RootWindow()->BackColor().Internal());

   949 			break;

   950 		case EWsClOpClaimSystemPointerCursorList:

   951 			{

   952 			if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::ClaimSystemPointerCursorList API")))

   953 				{

   954 				User::Leave(KErrPermissionDenied);

   955 				}

   956 			ClaimSystemPointerCursorListL();

   957 			}

   958 			break;

   959 		case EWsClOpFreeSystemPointerCursorList:

   960 			FreeSystemPointerCursorList();

   961 			break;

   962 		case EWsClOpSetSystemPointerCursor:

   963 			{

   964 			CWsObject* pointercursor = NULL;

   965 			if ((pointercursor=HandleToObj(pData.SetSystemPointerCursor->handle, WS_HANDLE_POINTER_CURSOR))==NULL)

   966 				PPanic(EWservPanicSprite);

   967 			

   968 			SetSystemPointerCursorL(pData.SetSystemPointerCursor->number, (CWsPointerCursor* )pointercursor);

   969 			}

   970 			break;

   971 		case EWsClOpClearSystemPointerCursor:

   972 			ClearSystemPointerCursor(*pData.Int);

   973 			break;

   974 		case EWsClOpSetPointerCursorArea:

   975 			{

   976 			if(KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetPointerCursorArea API")))

   977 				{

   978 				if (!iScreen->IsValidScreenSizeMode(*pData.Int))

   979 					PPanic(EWservPanicScreenModeNumber);

   980 				iScreen->SetPointerCursorArea(pData.SetPointerCursorArea->mode,pData.SetPointerCursorArea->area);

   981 				}

   982 			}

   983 			break;

   984 		case EWsClOpPointerCursorArea:

   985 			if (!iScreen->IsValidScreenSizeMode(*pData.Int))

   986 				PPanic(EWservPanicScreenModeNumber);

   987 			

   988 			ReplyRect(iScreen->GetPointerCursorArea(*pData.Int));

   989 			break;

   990 		case EWsClOpSetPointerCursorMode:

   991 			{

   992 			CWsWindowGroup* focusWinGp=CWsTop::FocusWindowGroup();

   993 			if (focusWinGp && focusWinGp->WsOwner()==this)

   994 				{

   995 				TWsPointer::SetPointerCursorMode(*pData.Mode);

   996 				TWsPointer::UpdatePointerCursor();

   997 				}

   998 			}

   999 			break;

  1000 		case EWsClOpSetClientCursorMode :

  1001 			{

  1002 			if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetPointerCursorModeIfFocused API")))

  1003 				{

  1004 				User::Leave(KErrPermissionDenied);

  1005 				}

  1006 			TWsPointer::SetPointerCursorMode(*pData.Mode);

  1007 			TWsPointer::UpdatePointerCursor();

  1008 			}

  1009 			break;

  1010 		case EWsClOpPointerCursorMode:

  1011 			SetReply(TWsPointer::PointerCursorMode());

  1012 			break;

  1013 		case EWsClOpSetDefaultSystemPointerCursor:

  1014 			SetDefaultSystemPointerCursor(*pData.Int);

  1015 			break;

  1016 		case EWsClOpClearDefaultSystemPointerCursor:

  1017 			SetDefaultSystemPointerCursor(ENoDefaultSystemPointerCursor);

  1018 			break;

  1019 		case EWsClOpSetPointerCursorPosition:

  1020 			{

  1021 			CWsWindowGroup* focusWinGp=CWsTop::FocusWindowGroup();

  1022 			if ((!focusWinGp || focusWinGp->WsOwner()!=this)&&

  1023 				(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetPointerCursorPosition API"))))

  1024 				{

  1025 				User::Leave(KErrPermissionDenied);

  1026 				}

  1027 			TWsPointer::SetPointerCursorPos(*pData.Point);

  1028 			}

  1029 			break;

  1030 		case EWsClOpPointerCursorPosition:

  1031 			ReplyPoint(TWsPointer::PointerCursorPos());

  1032 			break;

  1033 		case EWsClOpSetModifierState:

  1034 			{

  1035 			if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SetModifierState API")))

  1036 				{

  1037 				User::Leave(KErrPermissionDenied);

  1038 				}

  1039 			TWindowServerEvent::SetModifierState(pData.SetModifierState->modifier,pData.SetModifierState->state);

  1040 			}

  1041 			break;

  1042 		case EWsClOpGetModifierState:

  1043 			SetReply(TWindowServerEvent::GetModifierState());

  1044 			break;

  1045 		case EWsClOpHeapCount:

  1046 			SetReply(CWsMemoryManager::Static()->Count());

  1047 			break;

  1048  		case EWsClOpDebugInfo:

  1049 			DebugInfoL(pData.DebugInfo->iFunction,pData.DebugInfo->iParam,EFalse);

  1050  			break;

  1051  		case EWsClOpDebugInfoReplyBuf:

  1052 			DebugInfoL(pData.DebugInfo->iFunction,pData.DebugInfo->iParam,ETrue);

  1053  			break;

  1054 		case EWsClOpResourceCount:

  1055 			SetReply(iObjectIndex->Count());

  1056 			break;

  1057 		case EWsClOpHeapSetFail:

  1058 			{

  1059 			if(!KSecurityPolicy_WriteDeviceData().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::HeapSetFail API")))

  1060 				{

  1061 				PPanic(EWservPanicPermissionDenied);

  1062 				}

  1063 #if !defined(_DEBUG)

  1064 			if (pData.HeapSetFail->type!=RHeap::ENone)

  1065 				TWindowServerEvent::NotifyOom();

  1066 #endif

  1067 			// if there is a memory manager and we are making the allocator fail next or 

  1068 			// deteministic we want to make sure we test both when the memory manager

  1069 			// succeeds and fails in allocating after freeing up memory. we do that by

  1070 			// remapping the rate and explicitly telling the memory manager to fail:

  1071 			// requested rate  | fail on retry, actual rate

  1072 			//        1        |    true      ,    1

  1073 			//        2        |    false     ,    1

  1074 			//        3        |    true      ,    2

  1075 			CWsMemoryManager* memoryManager = NULL;

  1076 			TInt rate = pData.HeapSetFail->value;

  1077 			TBool memoryManagerRetryFail = EFalse;

  1078 			if((pData.HeapSetFail->type == RAllocator::EFailNext || pData.HeapSetFail->type == RAllocator::EDeterministic))

  1079 				{

  1080 				memoryManager = CWsMemoryManager::Static();

  1081 				if(memoryManager)

  1082 					{

  1083 					memoryManagerRetryFail = (rate % 2 == 1);

  1084 					rate = rate / 2 + (memoryManagerRetryFail ? 1 : 0);

  1085 					}

  1086 				}

  1087 

  1088 			switch (pData.HeapSetFail->type)

  1089 				{	//This log message means you can safely ignore the allocation failures in between

  1090 					//see CWindowServer::ReleaseMemory()

  1091 				case RAllocator::ENone:

  1092 					RDebug::Printf("WSERV Heap: __DbgSetAllocFail() <<<ENone");

  1093 					break;

  1094 				case RAllocator::EReset:

  1095 					RDebug::Printf("WSERV Heap: __DbgSetAllocFail() <<<EReset");

  1096 					break;

  1097 				default:	

  1098 					if (memoryManagerRetryFail)

  1099 						RDebug::Printf("WSERV Heap: Memory Manager set to fail on retry");

  1100 					RDebug::Printf("WSERV Heap: __DbgSetAllocFail(EUser,%i,%i)>>>", pData.HeapSetFail->type, rate);

  1101 					break;

  1102 				}

  1103 

  1104 			if (memoryManager && memoryManagerRetryFail)

  1105 				memoryManager->SetFailNextRetry();

  1106 			

  1107 			if (pData.HeapSetFail->burst >= 0)

  1108 				User::__DbgSetBurstAllocFail(RHeap::EUser, pData.HeapSetFail->type, rate, pData.HeapSetFail->burst);

  1109 			else

  1110 				User::__DbgSetAllocFail(RHeap::EUser, pData.HeapSetFail->type, rate);

  1111 			break;

  1112 			}

  1113 		case EWsClOpRawEvent:

  1114 			{

  1115 			if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SimulateRawEvent API")))

  1116 				{

  1117 				PPanic(EWservPanicPermissionDenied);

  1118 				}

  1119 			TRawEvent event(*pData.RawEvent);

  1120 			if (TWsPointer::PreProcessDriverEvent(event))

  1121 				TWindowServerEvent::ProcessRawEvent(event);

  1122 			}

  1123 			break;

  1124 		case EWsClOpKeyEvent:

  1125 			{

  1126 			if(!KSecurityPolicy_SwEvent().CheckPolicy(ClientMessage(),__PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWsSession::SimulateKeyEvent API")))

  1127 				{

  1128 				PPanic(EWservPanicPermissionDenied);

  1129 				}

  1130 			TWindowServerEvent::ProcessKeyEvent(*pData.KeyEvent,0);

  1131 			}

  1132 			break;

  1133 		case EWsClOpLogMessage: