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

// Provides the debug security server session implementation.

// 

//

/**

 @file

 @internalTechnology

 @released

*/

// Needed so we get the text strings for capabilities

#define __INCLUDE_CAPABILITY_NAMES__

#include <e32std.h>

#include <e32std_private.h>

#include <e32btrace.h>

#include <d32btrace.h>

#include <e32base.h>

#include <e32base_private.h>

#include <e32uid.h>

#include <f32file.h>

#include <e32capability.h>

#include <rm_debug_api.h>

// required for direct parsing of e32image/tromimage headers

#include <f32image.h>

#include <e32rom.h>

//added for direct access to media driver

#include <partitions.h>

#include <ftlcontrolio.h>

#include "c_security_svr_session.h"

#include "c_security_svr_server.h"

#include "c_security_svr_async.h"

#include "rm_debug_logging.h"

#ifdef _DEBUG

#include "low_mem_requests.h"

#endif

using namespace Debug;

CSecuritySvrSession::CSecuritySvrSession()

	: iDebugAgentProcessIdStored(EFalse),

	  iDebugAgentProcessId(0),

	  iServerNotified(EFalse),

	  iCrashConnected(EFalse)

	{

	// Ensure that this debug agent has no target capability override

	// by default

	iOEMDebugCapabilities.SetEmpty();

	}

void CSecuritySvrSession::ServiceError(const RMessage2 &aMessage, TInt aError)

	{

	LOG_MSG2("CSecuritySvrSession::ServiceError(), aError: %d\n", aError);

	//insert ending heap markers

	HeapWatcher(aMessage.Function(), EFalse);

	aMessage.Complete(aError);

	}

/**

Called by the client/server framework as part of session creation.

Notifies the server that a session is being created

*/

void CSecuritySvrSession::CreateL()

	{

	LOG_MSG("CSecuritySvrSession::CreateL()\n");

	//notify the server that the session has been opened

	Server().SessionOpened();

	iServerNotified = ETrue;

	}

/**

  Returns a reference to the DSS

  @return a reference to the DSS

  */

CSecuritySvrServer& CSecuritySvrSession::Server() const

    {

    return *static_cast<CSecuritySvrServer*>(const_cast<CServer2*>(CSession2::Server()));

    }

/**

Session destructor. Performs necessary cleanup and notifies the server that the

session is being closed

*/

CSecuritySvrSession::~CSecuritySvrSession()

	{

	LOG_MSG("CSecuritySvrSession::~CSecuritySvrSession!()\n");

	//forced detachment if attached to processes

	if(iDebugAgentProcessIdStored)

		{

		// Cancel any outstanding async objects.

		iAsyncHandlers.ResetAndDestroy();

		// Inform the device driver of the agent detach.

		Server().iKernelDriver.DetachAgent(iDebugAgentProcessId.Id());

		LOG_MSG( "CSecuritySvrSession::~CSecuritySvrSession() : -> securityServer.DetachAllProcesses()\n" );

		Server().DetachAllProcesses(iDebugAgentProcessId);

		}

	//notify the server that the session has closed

	if(iServerNotified)

		{

		Server().SessionClosed();

		}

	}

void CSecuritySvrSession::ConstructL()

	{

	// nothing to do

	}

/**

  Used to insert heap checking markers.

  @param aFunction The function that heap markers should be added for

  @param aEntry if ETrue indicates that heap checking is starting, if EFalse

  that heap checking is ending.

  */

void CSecuritySvrSession::HeapWatcher(const TUint32 aFunction, const TBool aEntry) const

	{

	switch(aFunction)

		{

		case EDebugServAttachExecutable:

			return;

		case EDebugServDetachExecutable:

			return;

		case EDebugServSuspendThread:

			return;

		case EDebugServResumeThread:

			return;

// used for out-of-memory testing in debug mode

#ifdef _DEBUG

		// start heap marking in on entry, do nothing on exit

		case EDebugServMarkHeap:

			{

			if(aEntry)

				{

				__UHEAP_MARK;

				}

			return;

			}

		// stop heap marking on exit, do nothing on entry

		case EDebugServMarkEnd:

			{

			if(!aEntry)

				{

				__UHEAP_MARKEND;

				}

			return;

			}

#endif

		default:

			if(aEntry)

				{

				__UHEAP_MARK;

				}

			else

				{

				__UHEAP_MARKEND;

				}

			return;

		}

	}

void CSecuritySvrSession::ServiceL(const RMessage2& aMessage)

//

// Session service handler

//

	{

	//insert starting heap markers

	HeapWatcher(aMessage.Function(), ETrue);

	switch(aMessage.Function())

		{

		case EDebugServResumeThread:

			LOG_MSG( "CSecuritySvrSession::ServiceL() EDebugServResumeThread\n" );

			ResumeThreadL(aMessage);

			break;

		case EDebugServSuspendThread:

			LOG_MSG( "CSecuritySvrSession::ServiceL() EDebugServSuspendThread\n" );

			SuspendThreadL(aMessage);

			break;

		case EDebugServReadMemory:

			LOG_MSG( "CSecuritySvrSession::ServiceL() EDebugServReadMemory\n" );

			ReadMemoryL(aMessage);

			break;

		case EDebugServWriteMemory:

			LOG_MSG( "CSecuritySvrSession::ServiceL() EDebugServWriteMemory\n" );

			WriteMemoryL(aMessage);

			break;

		case EDebugServSetBreak:

			LOG_MSG( "CSecuritySvrSession::ServiceL() EDebugServSetBreak\n" );

			SetBreakL(aMessage);

			break;

		case EDebugServClearBreak:

			LOG_MSG( "CSecuritySvrSession::ServiceL() EDebugServClearBreak\n" );

			ClearBreakL(aMessage);

			break;

		case EDebugServModifyBreak:

			LOG_MSG( "CSecuritySvrSession::ServiceL() EDebugServModifyBreak\n" );

			ModifyBreakL(aMessage);

			break;

		case EDebugServModifyProcessBreak:

			LOG_MSG( "CSecuritySvrSession::ServiceL() EDebugServModifyProcessBreak\n" );

			ModifyProcessBreakL(aMessage);

			break;

		case EDebugServBreakInfo:

			LOG_MSG( "CSecuritySvrSession::ServiceL() EDebugServBreakInfo\n" );

			BreakInfoL(aMessage);

			break;

		case EDebugServReadRegisters:

			LOG_MSG( "CSecuritySvrSession::ServiceL() EDebugServReadRegisters\n" );

			ReadRegistersL(aMessage);

			break;

		case EDebugServWriteRegisters:

			LOG_MSG( "CSecuritySvrSession::ServiceL() EDebugServWriteRegisters\n" );

			WriteRegistersL(aMessage);

			break;

		case EDebugServGetEvent:

			LOG_MSG( "CSecuritySvrSession::ServiceL() EDebugServGetEvent\n" );

			GetEventL(aMessage);

			break;

		case EDebugServCancelGetEvent:

			CancelGetEventL(aMessage);

			break;

		case EDebugServAttachExecutable:

			LOG_MSG( "CSecuritySvrSession::ServiceL() EDebugServAttachExecutable\n" );

			AttachProcessL(aMessage);

			break;

		case EDebugServDetachExecutable:

			LOG_MSG( "CSecuritySvrSession::ServiceL() EDebugServDetachExecutable\n" );

			DetachProcessL(aMessage);

			break;

		case EDebugServGetDebugFunctionalityBufSize:

			LOG_MSG( "CSecuritySvrSession::ServiceL() EDebugServGetDebugFunctionalityBufSize\n" );

			GetDebugFunctionalityBufSizeL(aMessage);

			break;

		case EDebugServGetDebugFunctionality:

			LOG_MSG( "CSecuritySvrSession::ServiceL() EDebugServGetDebugFunctionality\n" );

			GetDebugFunctionalityL(aMessage);

			break;

		case EDebugServSetEventAction:

			LOG_MSG( "CSecuritySvrSession::ServiceL() EDebugServSetEventAction\n" );

			SetEventActionL(aMessage);

			break;

		case EDebugServGetList:

			LOG_MSG( "CSecuritySvrSession::ServiceL() EDebugServGetList\n" );

			GetListL(aMessage);

			break;

		case EDebugServStep:

			LOG_MSG("CSecuritySvrSession::ServiceL() EDebugServStep\n");

			StepL(aMessage);

			break;

		case EDebugServSetProcessBreak:

			LOG_MSG("CSecuritySvrSession::ServiceL() EDebugServSetProcessBreak\n");

			SetProcessBreakL(aMessage);

			break;

		case EDebugServProcessBreakInfo:

			LOG_MSG("CSecuritySvrSession::ServiceL() EDebugServProcessBreakInfo\n");

			ProcessBreakInfoL(aMessage);

			break;

		case EDebugServKillProcess:

			LOG_MSG("CSecuritySvrSession::ServiceL() EDebugServKillProcess\n");

			KillProcessL(aMessage);

			break;

#ifdef _DEBUG

		case EDebugServMarkHeap:

			LOG_MSG("CSecuritySvrSession::ServiceL() EDebugServMarkHeap\n");

			// all taken care of in HeapWatcher

			aMessage.Complete(KErrNone);

			break;

		case EDebugServMarkEnd:

			LOG_MSG("CSecuritySvrSession::ServiceL() EDebugServMarkEnd\n");

			// all taken care of in HeapWatcher

			aMessage.Complete(KErrNone);

			break;

		case EDebugServFailAlloc:

			LOG_MSG("CSecuritySvrSession::ServiceL() EDebugServFailAlloc\n");

			DoFailAlloc(aMessage);

			break;

#endif

		case EDebugServReadCrashFlash:

			ReadCrashLogL(aMessage);

			break;		

		case EDebugServWriteCrashFlash:

			LOG_MSG("CSecuritySvrSession::ServiceL() EDebugServWriteCrashFlash\n");

			WriteCrashConfigL(aMessage);

			break;

		case EDebugServEraseCrashFlash:

			LOG_MSG("CSecuritySvrSession::ServiceL() EDebugServEraseCrashFlash\n");

			EraseCrashLogL(aMessage);

			break;

		case EDebugServEraseEntireCrashFlash:

			LOG_MSG("CSecuritySvrSession::ServiceL() EDebugServEraseEntireCrashFlash\n");

			EraseEntireCrashLogL(aMessage);

			break;

		default:

			LOG_MSG( "CSecuritySvrSession::ServiceL() Unknown request, calling User::Leave(KErrNotSupported);\n" );

			User::Leave(KErrNotSupported);

			break;

		}

	//insert ending heap markers

	HeapWatcher(aMessage.Function(), EFalse);

	}

#ifdef _DEBUG

/**

  Used to control heap failure in debug mode.

  @param aMessage If aMessage.Int0 is non-zero then heap will be set to fail on that allocation.

  If aMessage.Int0 is zero then the heap failure count is reset

  */

void CSecuritySvrSession::DoFailAlloc(const RMessage2& aMessage)

	{

	TInt count = aMessage.Int0();

	if(count == 0)

		{

		__UHEAP_RESET;

		}

	else

		{

		__UHEAP_FAILNEXT(count);

		}

	aMessage.Complete(KErrNone);

	}

#endif

/**

Suspends execution of the specified thread.

@param aMessage contains an integer representation of the target thread's

       thread ID at offset 0.

@leave KErrPermissionDenied if security check fails or KErrArgument if the

       thread does not exist

*/

void CSecuritySvrSession::SuspendThreadL(const RMessage2& aMessage)

	{

	LOG_MSG( "CSecuritySvrSession::SuspendThreadL()\n" );

	//get thread ID

	TThreadId threadId = ReadTThreadIdL(aMessage, 0);

	//check attached

	CheckAttachedL(threadId, aMessage, EFalse);

	//security check passed so can perform actions

	User::LeaveIfError(Server().iKernelDriver.SuspendThread(threadId));

	aMessage.Complete(KErrNone);

	}

/**

Resumes execution of the specified thread.

@param aMessage contains an integer representation of the target thread's

       thread ID at offset 0.

@leave KErrPermissionDenied if security check fails or KErrArgument if the

       thread does not exist

*/

void CSecuritySvrSession::ResumeThreadL(const RMessage2& aMessage)

	{

	LOG_MSG( "CSecuritySvrSession::ResumeThreadL()\n" );

	//get thread ID

	TThreadId threadId = ReadTThreadIdL(aMessage, 0);

	//check attached

	CheckAttachedL(threadId, aMessage, EFalse);

	//security check passed so can perform actions

	TInt err = Server().iKernelDriver.ResumeThread(threadId);

	aMessage.Complete(err);

	}

void CSecuritySvrSession::GetDebugFunctionalityBufSizeL(const RMessage2& aMessage)

//

// Retrieve size of functionality data buffer in bytes which must be allocated

// by the client

//

	{

	LOG_MSG( "CSecuritySvrSession::GetDebugFunctionalityBufSizeL()\n" );

	TUint32 result = 0;

	// Get Buffer size from the kernel driver

	User::LeaveIfError(Server().iKernelDriver.GetDebugFunctionalityBufSize(result));

	TPtr8 stuff((TUint8*)&result,4, 4);

	aMessage.WriteL(0,stuff);

	aMessage.Complete(KErrNone);

	}

void CSecuritySvrSession::GetDebugFunctionalityL(const RMessage2& aMessage)

//

// Retrieve the functionality data and place it in a buffer

// allocated by the client.

//

	{

	LOG_MSG( "CSecuritySvrSession::GetDebugFunctionalityL()\n" );

	TUint32 dfsize = 0;

	// Get Buffer size from the kernel driver

	User::LeaveIfError(Server().iKernelDriver.GetDebugFunctionalityBufSize(dfsize));

	// Allocate space for the functionality data

	HBufC8* dftext = HBufC8::NewLC(dfsize);

	const TPtr8& dfPtr = dftext->Des();

	// Extract said data from the device driver

	User::LeaveIfError(Server().iKernelDriver.GetDebugFunctionality((TDes8&)dfPtr));

	// Return data to client

	aMessage.WriteL(0,dfPtr);

	// Free buffer

	CleanupStack::PopAndDestroy(dftext);

	aMessage.Complete(KErrNone);

	}

/**

Reads memory from a specified thread using the passed parameters. The user 

should ensure that the TPtr8 that is passed in has size greater than or equal

to the size of the memory that is trying to be read.

@param aMessage The RMessage2 object should be constructed as follows:

    * aMessage.Int0() is the thread ID of the target debug app

    * aMessage.Ptr1() is a TMemoryInfo object which contains the following:

        * the address of the memory to be read from the target debug thread

        * the size of the memory block to be read from the target debug thread

	* the access size to use

	* the endianess to interpret the data as

    * aMessage.Ptr2() is the address of the buffer in the debug agent thread 

      that the data from the target debug app should be written into 

@leave KErrPermissionDenied if client is not attached to the target

       thread's process,

       KErrNoMemory if memory could not be allocated,

       KErrArgument if there are problems with the aMessage object,

       KErrBadHandle if the thread represented by aMessage.Ptr0() is invalid,

       an error value from CSecuritySvrSession::ValidateMemoryInfo if checking

       the memory attributes failed,

       or another of the system wide error codes

*/

void CSecuritySvrSession::ReadMemoryL(const RMessage2& aMessage)

	{

	LOG_MSG( "CSecuritySvrSession::ReadMemoryL()\n" );

	//get debug app thread ID

	TThreadId threadId = ReadTThreadIdL(aMessage, 0);

	CheckAttachedL(threadId, aMessage, ETrue);

	//create and initialise the memory info object

	TMemoryInfo targetMemory;

	TPtr8 targetMemoryPtr( (TUint8 *)&targetMemory, sizeof(TMemoryInfo) );

	aMessage.ReadL(1,targetMemoryPtr);

	//check memory info is acceptable

	ValidateMemoryInfoL(threadId, targetMemory, ETrue);

	RBuf8 data;

	data.CreateL(targetMemory.iSize);

	data.CleanupClosePushL();

	//fill buffer with data from target debug thread

	User::LeaveIfError(Server().iKernelDriver.ReadMemory(threadId, targetMemory.iAddress, targetMemory.iSize, data));

	//attempt to write the data from the target debug thread back to the agent

	aMessage.WriteL(2, data);

	//delete temporary buffer

	CleanupStack::PopAndDestroy(&data);

	aMessage.Complete(KErrNone);