// Copyright (c) 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:

 // t_shbuf_perfserver.cpp

 //

 //

 /**

  *  @file

  * 

  *  Test server used for Performance Testing of shared buffers.

  */

 #include <e32std.h>

 #include <e32debug.h>

 #include <e32msgqueue.h>

 #include <e32shbuf.h>

 #include "t_shbuf_perfserver.h"

 /**

  *  Second phase constructor for sessions. Called by the CServer2 framework

  *  when a session is created (e.g. a connection is made to the server).

  */

 void CShBufTestServerSession::CreateL()

 	{

 	Server().AddSessionL(this);

 	} // CShBufTestServerSession::CreateL()

 /**

  *  Destructor for session classes. When this is called it indicates that

  *  a session is closing its connection with the server.

  */

 CShBufTestServerSession::~CShBufTestServerSession()

 	{

 	Server().DropSession(this);

 	} // CShBufTestServerSession::~CShBufTestServerSession()

 /**

  *  Handle message requests for this session. Leaving is handled by

  *  CShBufTestServer::RunError() which reports the error code to the client.

  *

  *  @param aMessage  RMessage2 reference which encapsulates a client request.

  */

 void CShBufTestServerSession::ServiceL(const RMessage2& aMessage)

 	{

 	switch (aMessage.Function())

 		{

 		case EShBufServerShutdownServer:

 			{

 			ShutdownServerL(aMessage);

 			}

 			break;

 		case EShBufServerFromTPtr8ProcessAndReturn:

 			{

 			FromTPtr8ProcessAndReturnL(aMessage);

 			}

 			break;

 		case EShBufServerFromTPtr8ProcessAndRelease:

 			{

 			FromTPtr8ProcessAndReleaseL(aMessage);

 			}

 			break;

 		case EShBufServerOpenRShBufPool:

 			{

 			OpenRShBufPoolL(aMessage);

 			}

 			break;

 		case EShBufServerCloseRShBufPool:

 			{

 			CloseRShBufPoolL(aMessage);

 			}

 			break;

 		case EShBufServerFromRShBufProcessAndReturn:

 			{

 			FromRShBufProcessAndReturnL(aMessage);

 			}

 			break;

 		case EShBufServerFromRShBufProcessAndRelease:

 			{

 			FromRShBufProcessAndReleaseL(aMessage);

 			}

 			break;

 		case EShBufServerDbgMarkHeap:

 			{

 			DbgMarkHeapL(aMessage);

 			}

 			break;

 		case EShBufServerDbgCheckHeap:

 			{

 			DbgCheckHeapL(aMessage);

 			}

 			break;

 		case EShBufServerDbgMarkEnd:

 			{

 			DbgMarkEndL(aMessage);

 			}

 			break;

 		case EShBufServerDbgFailNext:

 			{

 			DbgFailNextL(aMessage);

 			}

 			break;

 		default:

 			{

 			aMessage.Panic(KRShBufTestServerName, 999);

 			}

 			break;

 		}

 	} // CShBufTestServerSession::ServiceL()

 /**

  *  Completes a client request. This function provides a single point of

  *  message completion which benefits debugging and maintenance.

  *

  *  @param aMessage  The RMessage2 client request.

  *  @param aResult   Result of the request.

  */

 void CShBufTestServerSession::CompleteRequest(const RMessage2& aMessage,

 										      TInt aResult) const

 	{

 	if (aMessage.IsNull() == EFalse)

 		{

 	    aMessage.Complete(aResult);

 		}

     } // CShBufTestServerSession::CompleteRequest()

 /**

  *  Takes a buffer from the client, sends to the driver and back to the client.

  *

  *  @param aMessage  RMessage2 client request.

  */

 void CShBufTestServerSession::FromTPtr8ProcessAndReturnL(const RMessage2& aMessage)

 	{

 	//

 	// Read the client buffer...

 	//

 	TPtr8  bufPtr(iSessionTempBuffer, sizeof(iSessionTempBuffer));

 	aMessage.ReadL(0, bufPtr); 

 	TUint bufSize;

 	bufSize = aMessage.Int1();

 	//

 	// Pass to the server to pass to the driver and back...

 	//

 	TInt  result;

 	result = Server().FromTPtr8ProcessAndReturn(bufPtr, bufSize);

 	//

 	// Write the client buffer back...

 	//

 	aMessage.WriteL(0, bufPtr); 

 	//

 	// Complete the request...

 	//

 	CompleteRequest(aMessage, result);

 	} // CShBufTestServerSession::FromTPtr8ProcessAndReturnL

 /**

  *  Takes a buffer from the client and sends to the driver.

  *

  *  @param aMessage  RMessage2 client request.

  */

 void CShBufTestServerSession::FromTPtr8ProcessAndReleaseL(const RMessage2& aMessage)

 	{

 	//

 	// Read the client buffer...

 	//

 	TPtr8  bufPtr(iSessionTempBuffer, sizeof(iSessionTempBuffer));

 	aMessage.ReadL(0, bufPtr); 

 	//

 	// Pass to the server to pass to the driver and back...

 	//

 	TInt  result;

 	result = Server().FromTPtr8ProcessAndRelease(bufPtr);

 	//

 	// Complete the request...

 	//

 	CompleteRequest(aMessage, result);

 	} // CShBufTestServerSession::FromTPtr8ProcessAndReleaseL

 /**

  *  Allows the client to ask the test server to open a buffer pool.

  *

  *  @param aMessage  RMessage2 client request.

  */

 void CShBufTestServerSession::OpenRShBufPoolL(const RMessage2& aMessage)

 	{

 	//

 	// Read the handle...

 	//

 	TInt  poolHandle = aMessage.Int0();

 	//

 	// Read the pool info...

 	//

 	TShPoolInfo  shPoolInfo;

 	TPckg<TShPoolInfo>  shPoolInfoPckg(shPoolInfo);

 	aMessage.ReadL(1, shPoolInfoPckg); 

 	//

 	// Pass to the server to open the pool...

 	//

 	TInt  result = Server().OpenRShBufPool(poolHandle, shPoolInfo);

 	//

 	// Complete the request...

 	//

 	CompleteRequest(aMessage, result);

 	} // CShBufTestServerSession::OpenRShBufPoolL

 /**

  *  Allows the client to ask the test server to close a buffer pool.

  *

  *  @param aMessage  RMessage2 client request.

  */

 void CShBufTestServerSession::CloseRShBufPoolL(const RMessage2& aMessage)

 	{

 	//

 	// Pass to the server to close the pool...

 	//

 	TInt  result = Server().CloseRShBufPool();

 	//

 	// Complete the request...

 	//

 	CompleteRequest(aMessage, result);

 	} // CShBufTestServerSession::CloseRShBufPoolL

 /**

  *  Takes a buffer from the client, sends to the driver and back to the client.

  *

  *  @param aMessage  RMessage2 client request.

  */

 void CShBufTestServerSession::FromRShBufProcessAndReturnL(const RMessage2& aMessage)

 	{

 	//

 	// Read the client handle buffer...

 	//

 	RShBuf shBuf;

 	TUint bufSize;

 	bufSize = aMessage.Int1();

 	//

 	// Pass to the server to pass to the driver and back...

 	//

 	TInt  result;

 	result = Server().FromRShBufProcessAndReturn(shBuf, bufSize);

 	//

 	// Write the client buffer handle back...

 	//

 #ifdef CAN_TRANSFER_SHBUF_TO_ANOTHER_PROCESS

 	// TDBD aMessage.Complete(shbuf->Handle());

 #else

 	TPckg<TInt> handlePckg(shBuf.Handle());

 	aMessage.WriteL(0, handlePckg);

 #endif

 	//

 	// Complete the request...

 	//

 	CompleteRequest(aMessage, result);

 	} // CShBufTestServerSession::FromRShBufProcessAndReturnL

 /**

  *  Takes a buffer from the client and sends to the driver.

  *

  *  @param aMessage  RMessage2 client request.

  */

 void CShBufTestServerSession::FromRShBufProcessAndReleaseL(const RMessage2& aMessage)

 	{

 	//

 	// Read the client buffer handle...

 	//

 	RShBuf  shBuf;

 #ifdef CAN_TRANSFER_SHBUF_TO_ANOTHER_PROCESS

 	// TBD RShBuf.Open(aMessage, 0);

 #else

 	shBuf.SetReturnedHandle(aMessage.Int0());

 #endif

 	//

 	// Pass to the server to pass to the driver and back...

 	//

 	TInt  result;

 	result = Server().FromRShBufProcessAndRelease(shBuf);

 	//

 	// Complete the request...

 	//

 	CompleteRequest(aMessage, result);

 	} // CShBufTestServerSession::FromRShBufProcessAndReleaseL

 /**

  *  Requests the server to mark the start of checking the server's heap.

  *  This function only works in debug releases and is a synchronous request

  *  which will be completed when the procedure returns.

  *

  *  @param aMessage  RMessage2 client request.

  */

 void CShBufTestServerSession::DbgMarkHeapL(const RMessage2& aMessage)

 	{

 	TInt  result;

 	result = Server().DbgMarkHeap();

 	//

 	// Complete the request...

 	//

 	CompleteRequest(aMessage, result);

 	} // CShBufTestServerSession::DbgMarkHeapL()

 /**

  *  Requests the server to check that the number of allocated cells at the

  *  current nested level on the server's heap is the same as the specified value.

  *  This function only works for debug builds and is a synchronous request

  *  which will be completed when the procedure returns.

  *

  *  @param aMessage  RMessage2 client request.

  */

 void CShBufTestServerSession::DbgCheckHeapL(const RMessage2& aMessage)

 	{

 	TInt  count = aMessage.Int0();

 	TInt  result;

 	result = Server().DbgCheckHeap(count);

 	//

 	// Complete the request...

 	//

 	CompleteRequest(aMessage, result);

 	} // CShBufTestServerSession::DbgCheckHeapL()

 /**

  *  Requests the server to mark the end of checking the server's heap. This

  *  function must match an earlier call to DbgMarkHeap() and only functions

  *  on debug releases. This is a synchronous request which will be completed

  *  when the procedure returns.

  *

  *  @param aMessage  RMessage2 client request.

  */

 void CShBufTestServerSession::DbgMarkEndL(const RMessage2& aMessage)

 	{

 	TInt  count = aMessage.Int0();

 	TInt  result;

 	result = Server().DbgMarkEnd(count);

 	//

 	// Complete the request...

 	//

 	CompleteRequest(aMessage, result);

 	} // CShBufTestServerSession::DbgMarkEndL()

 /**

  *  Simulates heap allocation failure for the sever. The failure occurs on

  *  the next call to new or any of the functions which allocate memory from

  *  the heap. This is defined only for debug builds and is a synchronous

  *  request which will be completed when the procedure returns.

  *

  *  @param aMessage  RMessage2 client request.

  */

 void CShBufTestServerSession::DbgFailNextL(const RMessage2& aMessage)

 	{

 	TInt  count = aMessage.Int0();

 	TInt  result;

 	result = Server().DbgFailNext(count);

 	//

 	// Complete the request...

 	//

 	CompleteRequest(aMessage, result);

 	} // CShBufTestServerSession::DbgFailNextL()

 /**

  *  Requests the server to shut down when it no longer has any connected

  *  sessions. This procedure is only premitted in debug builds for security

  *  reasons (e.g. to prevent a denial of service attack) and is provided

  *  for testing purposes. This is a synchronous request which will be

  *  completed when the procedure returns. The server will shutdown when the

  *  last session disconnects.

  *

  *  @param aMessage  RMessage2 client request.

  */

 void CShBufTestServerSession::ShutdownServerL(const RMessage2& aMessage)

 	{

 	TInt  result = Server().ShutdownServer();

 	//

 	// Complete the request...

 	//

 	CompleteRequest(aMessage, result);

 	} // CShBufTestServerSession::ShutdownServerL()

 /**

  *  Static factory method used to create a CShBufTestServer object.

  *

  *  @return  Pointer to the created CShBufTestServer object, or NULL.

  */

 CShBufTestServer* CShBufTestServer::NewL()

 	{

 	CShBufTestServer* self = new (ELeave) CShBufTestServer();

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	} // CShBufTestServer::NewL

 /**

  *  Standard constructor.

  */

 CShBufTestServer::CShBufTestServer()

 	: CServer2(EPriorityNormal),

 	iShouldShutdownServer(EFalse)

 	{

 	__DECLARE_NAME(_L("CShBufTestServer"));

 	} // CShBufTestServer::CShBufTestServer

 /**

  *  Second phase constructor. Ensures the server is created and ready to run.

  */

 void CShBufTestServer::ConstructL()

 	{

 	//

 	// Open the driver...

 	//

 	TInt  ret;

 	ret = User::LoadLogicalDevice(_L("D_SHBUF_CLIENT.LDD"));

 	if (ret != KErrAlreadyExists)

 		{

 		User::LeaveIfError(ret);

 		}

 	ret = User::LoadLogicalDevice(_L("D_SHBUF_OWN.LDD"));

 	if (ret != KErrAlreadyExists)

 		{

 		User::LeaveIfError(ret);

 		}

 	User::LeaveIfError(iShBufLdd.Open(RShBufTestChannel::EClientThread));

 	StartL(KRShBufTestServerName);

 	} // CShBufTestServer::ConstructL

 /**

  *  Destructor.

  */

 CShBufTestServer::~CShBufTestServer()

 	{

 	iSessionArray.Reset();

 	iShBufLdd.Close();

 	} // CShBufTestServer::~CShBufTestServer

 /**

  *  Create a new client session.

  */

 CSession2* CShBufTestServer::NewSessionL(const TVersion&, const RMessage2& /*aMessage*/) const

 	{

 	return new(ELeave) CShBufTestServerSession();

 	} // CShBufTestServer::NewSessionL

 /**

  *  Called by the session class when it is being created.

  *

  *  @param aSession  Server side session.

  */

 void CShBufTestServer::AddSessionL(CShBufTestServerSession* aSession)

 	{

 	//

 	// Store this session in the list of sessions...

 	//

 	iSessionArray.Append(aSession);

 	} // CShBufTestServer::AddSessionL

 /**

  *  Called by the session class when it is being destroyed.

  *

  *  @param aSession  Server side session.

  */

 void CShBufTestServer::DropSession(CShBufTestServerSession* aSession)

 	{

 	//

 	// Remove this session from the session array list...

 	//

 	TInt  position;

 	position = iSessionArray.Find(aSession);

  	if (position != KErrNotFound) 

 		{

  		iSessionArray.Remove(position);

 		}

 	//

 	// If we are shuting down then unconfigure and stop...

 	//

 	if (iSessionArray.Count() == 0  &&  iShouldShutdownServer)

 		{

 		CActiveScheduler::Stop();

 		}

 	} // CShBufTestServer::DropSession

 TInt CShBufTestServer::FromTPtr8ProcessAndReturn(TDes8& aBuf, TUint aBufSize)

 	{

 	// clear cache

 	memset(iClearCache, 0xFF, sizeof(iClearCache));

 	return iShBufLdd.FromTPtr8ProcessAndReturn(aBuf, aBufSize);

 	} // CShBufTestServer::FromTPtr8ProcessAndReturn

 TInt CShBufTestServer::FromTPtr8ProcessAndRelease(TDes8& aBuf)

 	{

 	return iShBufLdd.FromTPtr8ProcessAndRelease(aBuf);

 	} // CShBufTestServer::FromTPtr8ProcessAndRelease

 TInt CShBufTestServer::OpenRShBufPool(TInt aHandle, const TShPoolInfo& aPoolInfo)

 	{

 	return iShBufLdd.OpenUserPool(aHandle, aPoolInfo);

 	} // CShBufTestServer::OpenRShBufPool

 TInt CShBufTestServer::CloseRShBufPool()

 	{

 	return iShBufLdd.CloseUserPool();

 	} // CShBufTestServer::CloseRShBufPool

 TInt CShBufTestServer::FromRShBufProcessAndReturn(RShBuf& aShBuf, TUint aBufSize)

 	{

 	TInt ret;

 	// clear cache

 	memset(iClearCache, 0xFF, sizeof(iClearCache));

 	ret = iShBufLdd.FromRShBufProcessAndReturn(aBufSize);

 	if (ret > 0)

 		{

 		aShBuf.SetReturnedHandle(ret);

 		return KErrNone;

 		}

 	return ret;

 	} // CShBufTestServer::FromRShBufProcessAndReturn

 TInt CShBufTestServer::FromRShBufProcessAndRelease(RShBuf& aShBuf)

 	{

 	return iShBufLdd.FromRShBufProcessAndRelease(aShBuf.Handle());

 	} // CShBufTestServer::FromRShBufProcessAndRelease 

 /**

  *  Marks the start of checking the server's heap. This function only works

  *  in debug releases.

  *

  *  Calls to this function can be nested but each call must be matched by

  *  corresponding DbgMarkEnd().

  *

  *  @return  KErrNone.

  */

 TInt CShBufTestServer::DbgMarkHeap() const

 	{

 #ifdef _DEBUG

 	__UHEAP_MARK;

 #endif

 	return(KErrNone);

 	} // CShBufTestServer::DbgMarkHeap

 /**

  *  Checks that the number of allocated cells at the current nested level on

  *  the server's heap is the same as the specified value. This function only

  *  works for debug builds.

  *

  *  @param aCount  The number of heap cells expected to be allocated at

  *                 the current nest level.

  *

  *  @return  KErrNone.

  */

 TInt CShBufTestServer::DbgCheckHeap(TInt aCount) const

 	{

 #ifdef _DEBUG 

 	__UHEAP_CHECK(aCount);

 #else

 	(void) aCount;

 #endif

 	return(KErrNone);

 	} // CShBufTestServer::DbgCheckHeap

 /**

  *  Marks the end of checking the current server's heap. 

  *

  *  The function expects aCount heap cells to remain allocated at the

  *  current nest level. This function must match an earlier call to

  *  DbgMarkHeap() and only functions on debug releases.

  *

  *  @param aCount  The number of heap cells expected to remain allocated

  *                 at the current nest level.

  *

  *  @return  KErrNone.

  */

 TInt CShBufTestServer::DbgMarkEnd(TInt aCount) const

 	{

 #ifdef _DEBUG

 	__UHEAP_MARKENDC(aCount);

 #else

 	(void) aCount;

 #endif

 	return(KErrNone);

 	} // CShBufTestServer::DbgMarkEnd

 /**

  *  Simulates heap allocation failure for the server.

  *

  *  The failure occurs on the next call to new or any of the functions which 

  *  allocate memory from the heap. This is defined only for debug builds.

  *

  *  @param aCount  Determines when the allocation will fail.

  *

  *  @return  KErrNone.

  */

 TInt CShBufTestServer::DbgFailNext(TInt aCount) const

 	{

 #ifdef _DEBUG

 	if (aCount == 0)

 		{

 		__UHEAP_RESET;

 		}

 	else

 		{

 		__UHEAP_FAILNEXT(aCount);

 		}

 #else

 	(void) aCount;

 #endif

 	return(KErrNone);

 	} // CShBufTestServer::DbgFailNext

 /**

  *  Requests the server to shut down when it no longer has any connected

  *  sessions. This procedure is only premitted in debug builds and is provided

  *  for testing purposes.

  *

  *  The server will shutdown when the last session disconnects.

  *

  *  @return KErrNone if the shutdown request was accepted, otherwise returns

  *          an error.

  */

 TInt CShBufTestServer::ShutdownServer()

 	{

 	iShouldShutdownServer = ETrue;

 	return(KErrNone);

 	} // CShBufTestServer::ShutdownServer

 /**

  *  Standard Active Object RunError() method, called when the RunL() method

  *  leaves, which will be when the CShBufTestServerSession::ServiceL() leaves.

  *

  *  Find the current message and complete it before restarting the server.

  *

  *  @param aError  Leave code from CShBufTestServerSession::ServiceL().

  *

  *  @return KErrNone

  */

 TInt CShBufTestServer::RunError(TInt aError)

 	{

 	//

 	// Complete the request with the available error code.

 	//

 	if (Message().IsNull() == EFalse)

 		{

 		Message().Complete(aError);

 		}

 	//

 	// The leave will result in an early return from CServer::RunL(), skipping

 	// the call to request another message. So do that now in order to keep the

 	// server running.

 	//

 	ReStart();

 	return KErrNone;

 	} // CShBufTestServer::RunError

 /**

  *  Perform all server initialisation, in particular creation of the

  *  scheduler and server and then run the scheduler.

  */

 static void RunServerL()

 	{

 	//

 	// Naming the server thread after the server helps to debug panics.

 	//

 	User::LeaveIfError(User::RenameThread(KRShBufTestServerName));

 	//

 	// Increase priority so that requests are handled promptly...

 	//

 	RThread().SetPriority(EPriorityMuchMore);

 	//	

 	// Create a new Active Scheduler...

 	//

 	CActiveScheduler*  scheduler = new CActiveScheduler();

 	CleanupStack::PushL(scheduler);	

 	CActiveScheduler::Install(scheduler);

 	//

 	// Create a new PhoneBookServer...

 	//

 	CShBufTestServer*  server = CShBufTestServer::NewL();

 	CleanupStack::PushL(server);

 	//

 	// Initialisation complete, now signal the client thread...

 	//

 #ifdef CAN_TRANSFER_SHBUF_TO_ANOTHER_PROCESS

 	RProcess::Rendezvous(KErrNone);

 #else

 	RThread::Rendezvous(KErrNone);

 #endif

 	//

 	// Run the server...

 	//

 	CActiveScheduler::Start();

 	CleanupStack::PopAndDestroy(2, scheduler);

 	} // RunServerL

 /**

  *  Server process entry-point.

  *

  *  @return  KErrNone or a standard Symbian error code.

  */

 #ifdef CAN_TRANSFER_SHBUF_TO_ANOTHER_PROCESS

 TInt E32Main()

 #else

 TInt RShBufTestServerThread(TAny* /*aPtr*/)

 #endif

 	{

 	__UHEAP_MARK;

 	CTrapCleanup*  cleanup = CTrapCleanup::New();

 	TInt  ret(KErrNoMemory);

 	if (cleanup)

 		{

 		TRAP(ret, RunServerL());

 		delete cleanup;

 		}

 	__UHEAP_MARKEND;

 	return ret;

 	} // E32Main