// 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)