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

// All rights reserved.

// This component and the accompanying materials are made available

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

//

#include <e32debug.h>

#include <e32btrace.h> 

#include <d32btrace.h>

#include "servercrashdatasource.h"

// Required for interface to Debug Security Server via RSecuritySvrSession

#include "coredumpsession.h"

CServerCrashDataSource::CServerCrashDataSource(RSecuritySvrSession &aSource)

    : iSecSess(aSource)

{

//no implementation

}

CServerCrashDataSource* CServerCrashDataSource::NewL(RSecuritySvrSession &aSource)

{

    CServerCrashDataSource *self = new(ELeave) CServerCrashDataSource(aSource);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

}

TTag* CServerCrashDataSource::GetTag(const TTagHeader* aTagHdr, const TInt aElement)

	{

	TUint8* ptr = (TUint8*)aTagHdr + sizeof(TTagHeader);

	TUint8* blockEnd = ptr + (aTagHdr->iNumTags * sizeof(TTag));

	while(ptr < blockEnd)

		{

		TTag* tag = (TTag*)ptr;

		if(tag->iTagId == aElement)

			{

			return tag;

			}

		ptr += sizeof(TTag);

		}

	return NULL;

	}

// second-phase constructor

void CServerCrashDataSource::ConstructL()

    {

	LOG_MSG("->CServerCrashDataSource::ConstructL()\n" );

	// Get the debug func block and make appropriate changes to our structures

    TInt err;

	TUint32 bufsize = 0;

	LOG_MSG( "  -> iSecSess->GetDebugFunctionalityBufSize( &bufsize )\n" );

    err = iSecSess.GetDebugFunctionalityBufSize( &bufsize );

	if( (err != KErrNone) || (0 == bufsize) )

		{

		// No debug functionality block, cannot do much without that.

		LOG_MSG2("CServerCrashDataSource::ConstructL() - unable to get debug functionality block! err:%d\n", err);

		User::Leave( KErrNotSupported );

		}

    RBuf8 DFBlock;

    DFBlock.CreateL(bufsize);

    DFBlock.CleanupClosePushL();

	LOG_MSG2( "  -> HBufC8::NewLC( bufsize=%d )\n", bufsize );

	LOG_MSG("CServerCrashDataSource::ConstrucL -> GetDebugFunctionality()\n" );

    err = iSecSess.GetDebugFunctionality(DFBlock);

	if( KErrNone != err )

		{

		LOG_MSG( "CServerCrashDataSource::ConstructL() : ERROR !* : Could not retrieve debug functionality block\n" );

		User::Leave( KErrNotSupported );

		}

	LOG_MSG( "  -> GetDebugHeader( EDF_TagHdrId_RegistersCore )\n" );

	TTagHeader * hdr = GetDebugHeader( ETagHeaderIdRegistersCore, DFBlock );

	if( hdr == NULL )

		{

		LOG_MSG( "Could not retrieve ETagHeaderIdRegistersCore register debug block\n" );

		}

	else if( 0 == hdr->iNumTags )

		{

		LOG_MSG( "Zero tags found for ETagHeaderIdRegistersCore register debug block\n" );

		}

	else

		{

		iRegisterList.ReserveL( (TInt)hdr->iNumTags );

		// Skip the header to get to the tags

		TUint8 * ptr = ((TUint8 *) hdr) + sizeof( TTagHeader );

		TTag * tag = (TTag *) ptr;

		TRegisterData regData;

		TRegisterData * reg = &regData;

		// Process all the register tags

		for( TInt regIdx = 0; regIdx < hdr->iNumTags; regIdx ++ )

			{

			reg->iRegClass  = 0;			// Core = 0

			reg->iId        = tag->iTagId;	//

			reg->iSubId     = 0;			//

			reg->iSize      = 2;			// Should all be 32 bits == 2.

			reg->iAvailable = ETrue;

			reg->iValue64	= 0;

			iRegisterList.Append( *reg );

			tag++;

			}

		}

	hdr = GetDebugHeader( ETagHeaderIdMemory, DFBlock );

	if( hdr == NULL )

		{

		LOG_MSG( "Could not retrieve ETagHeaderIdMemory. Cannot read memory\n" );

		iMaxMemReadSize = 0;

		}

	else if( 0 == hdr->iNumTags )

		{

		LOG_MSG( "Zero tags found for ETagHeaderIdMemory register debug block\n" );

		iMaxMemReadSize = 0;

		}

	else

		{

		TTag* tag = GetTag( hdr, EMemoryMaxBlockSize );

		if( tag )

			{

			//LOG_MSG2( " EMemoryMaxBlockSize =0x%X\n", tag->iValue );

			iMaxMemReadSize = tag->iValue;

			}

		}

	iLastThreadListSize = 1;

	iLastProcListSize = 1;

	iLastRegListSize = 1;

	CleanupStack::PopAndDestroy(&DFBlock);

    }

//

// Returns the start of the sub block for this TTagHdrId_e 

//

TTagHeader * CServerCrashDataSource::GetDebugHeader( const TTagHeaderId aTagHdrId, const TDesC8 &aDFBlock )

	{

	TInt DFBlockSize = aDFBlock.Size();

	TTagHeader* headerPtr = (TTagHeader*) aDFBlock.Ptr();

	TUint8 * ptr = (TUint8 * ) aDFBlock.Ptr();

	while( headerPtr < ( (TTagHeader*)aDFBlock.Ptr() + DFBlockSize ) )

		{

		if( headerPtr->iTagHdrId != aTagHdrId )

			{

			ptr += sizeof(TTagHeader) + ( headerPtr->iNumTags * sizeof(TTag) );

			headerPtr = (TTagHeader*) ptr;

			}

		else

			{

			return ( headerPtr );

			}

		}

	return NULL;

	}

// destructor

CServerCrashDataSource::~CServerCrashDataSource()

    {

	LOG_MSG( "server_crashdatasource.cpp::CServerCrashDataSource::~CServerCrashDataSource()\n" );

	iRegisterList.Reset();

    iThreadListBuffer.Close();

    iProcListBuffer.Close();

    iExecutableListBuffer.Close();

    }

void CServerCrashDataSource::SetRegValuesL( const TUint64 aThreadId, RRegisterList &aRegisterList )

	{

	LOG_MSG2("->CServerCrashDataSource::SetRegValuesL(aThreadId=%Lu)\n", aThreadId); 

	TInt numberOfRegisters = aRegisterList.Count();

	RBuf8 ids;

	ids.CreateL( numberOfRegisters * sizeof(TFunctionalityRegister) );

    ids.CleanupClosePushL();

	TInt totalByteSize = 0; // Keeps track of the number of bytes that we are requesting

	for( TInt i=0; i < numberOfRegisters; i++ )

		{

		TRegisterInfo reg = (TRegisterInfo)( aRegisterList[i].iId ); 

		// iSize = (0 == 1 byte); (3 == 8 bytes)

		TInt byteSize = (aRegisterList[i].iSize) << 1;

		totalByteSize += byteSize;

		ids.Append( reinterpret_cast<const TUint8*>(&reg), sizeof(TRegisterInfo) );

		}

	RBuf8 registerValues;

	registerValues.CreateL( totalByteSize );

    registerValues.CleanupClosePushL();

	RBuf8 registerFlags;

	registerFlags.CreateL( numberOfRegisters );

    registerFlags.CleanupClosePushL();

    LOG_MSG("CServerCrashDataSource::SetRegValuesL - reading registers\n");

    User::LeaveIfError(iSecSess.ReadRegisters( aThreadId, ids, registerValues, registerFlags ));

	// Now copy the values back to the array and mark the availability from the flags

	TUint8* valuePtr = (TUint8*) registerValues.Ptr();

	for( TInt i=0; i < numberOfRegisters; i++ )

		{

		TRegisterData & reg = aRegisterList[i];

		switch( reg.iSize )

			{

			case 0:

				reg.iValue8 = *((TUint8 *)valuePtr);

				valuePtr += 1;

				break;

			case 1:

				reg.iValue16 = *((TUint16 *)valuePtr);

				valuePtr += 2;

				break;

			case 2:

				reg.iValue32 = *((TUint32 *)valuePtr);

				valuePtr += 4;

				break;

			case 3:

				reg.iValue64 = *((TUint64 *)valuePtr);

				valuePtr += 8;

				break;

			}

		if( EValid == registerFlags[i] ) 

			{

			reg.iAvailable = ETrue;

			}

		else

			{

			reg.iAvailable = EFalse;

			}

		}

    CleanupStack::PopAndDestroy(&registerFlags);

    CleanupStack::PopAndDestroy(&registerValues);

    CleanupStack::PopAndDestroy(&ids);

	}

void CServerCrashDataSource::PrintRegs( RRegisterList & aRegisterList )

	{

	LOG_MSG( "CServerCrashDataSource::PrintRegs()\n" );

	if( aRegisterList.Count() > 0 )

		{

		for( TInt i = 0; i < aRegisterList.Count(); i ++ )

			{

			TRegisterData & reg = aRegisterList[i];

			RDebug::Printf( " reg[%d] iRegClass=%d, iId=%d, iSubId=%d, iSize=%d, iAvailable=%d\n", 

				i, reg.iRegClass, reg.iId, reg.iSubId, reg.iSize, reg.iAvailable );

			switch ( reg.iSize )

				{

				case 0:

					RDebug::Printf( "  iValue8=0x%X\n", reg.iValue8 ); break;

				case 1:

					RDebug::Printf( "  iValue16=0x%X\n", reg.iValue16 ); break;

				case 2:

					RDebug::Printf( "  iValue32=0x%X\n", reg.iValue32 ); break;

				case 3:

					RDebug::Printf( "  iValue64=0x%X%X\n", 

						I64HIGH(reg.iValue64), I64LOW(reg.iValue64) ); 

					break;

				}

			}

		}

	else

		{

		RDebug::Printf( " No registers to print\n" );

		}

	}

void CServerCrashDataSource::GetRegisterListL( RRegisterList & aRegisterList )

	{

	LOG_MSG("CServerCrashDataSource::GetRegisterListL()\n");

	/* Copy the registers that were returned in the debug functionality block */

	aRegisterList.Reset();

    TInt count = iRegisterList.Count();

	for(TInt i = 0; i < count; ++i)

		{

		aRegisterList.AppendL( iRegisterList[i] );

		}

	}

void CServerCrashDataSource::ReadRegistersL( const TUint64 aThreadId, RRegisterList  & aRegisterList )

	{

	LOG_MSG2("CServerCrashDataSource::ReadRegistersL(aThreadId=%Lu)\n", aThreadId);

	if( aRegisterList.Count() )

		{

		LOG_MSG("CServerCrashDataSource::ReadRegistersL - register list already supplied\n" );

		SetRegValuesL( aThreadId, aRegisterList );

		}

	else

		{

		LOG_MSG("CServerCrashDataSource::ReadRegistersL - suppliying register list\n" );

		GetRegisterListL( aRegisterList );

		SetRegValuesL( aThreadId, aRegisterList );

		}

	//PrintRegs( aRegisterList );

	}

/**

Purpose:

Read memory from the security server. If the length of the data is greater

than the maximum length supported by the security server (as reported debug

functionality block tag EMemoryMaxBlockSize), break up the read into reads 

of this maximum size.

@pre Must be connected to the debug security server

@pre Must be attached to the process that owns aThreadId

@param aThreadId - The id of the thread relative to which the read should take place

@param aAddress - The virtual address to read from

@param aLength - The number of bytes to read

@param aData - The buffer to read into

@return Any error which may be returned by Security Server::ReadMemory()

*/

void CServerCrashDataSource::ReadMemoryL(

                   const TUint64    aThreadId,

                   const TUint32    aAddress,

                   const TUint32    aLength,

                   TDes8          & aData )

	{

    LOG_MSG4("->CServerCrashDataSource::ReadMemoryL(aThreadId=0x%X, aAddress=0x%X, aLength=%d)\n",

            I64LOW(aThreadId), aAddress, aLength);	

    TInt err;

	if( aLength <= iMaxMemReadSize )

		{

		err = iSecSess.ReadMemory( aThreadId, aAddress, aLength, aData, EAccess32, EEndLE8);

		}

    else

        {

        // If aLength is greater than iMaxMemReadSize, then break up the read into 

        // smaller packets and append them to aData

        RBuf8 readData;

        readData.CreateL( iMaxMemReadSize );

        TInt readLength = iMaxMemReadSize;

        TInt readSoFar = 0;

        do

            {

            LOG_MSG3( "  iSecSess->ReadMemory(addr=0x%X, length=%d)\n", aAddress+readSoFar, readLength );

            err = iSecSess.ReadMemory( aThreadId, aAddress+readSoFar, readLength, readData, EAccess32, EEndLE8 );

            if(err != KErrNone)

                break;

            readSoFar += readLength;

            aData.Append( readData );

            if( (aLength - readSoFar) < iMaxMemReadSize )

                {

                readLength = aLength - readSoFar;

                }

            }

        while( readSoFar < aLength );

        readData.Close();

        }

    User::LeaveIfError(err);

	}

void CServerCrashDataSource::GetProcessListL( RProcessPointerList & aProcessList,

											  TUint & aTotalProcessListDescSize )

    {

	//LOG_MSG( "CServerCrashDataSource::GetProcessListL()\n" );

	// Delete any objects in the array, since we will replace them. 

	aProcessList.ResetAndDestroy();

	aTotalProcessListDescSize = 0;

	if( iProcListBuffer.Size() != iLastProcListSize )

		{

		LOG_MSG2( "  iProcListBuffer.ReAlloc( %d)\n", iLastProcListSize );

		iProcListBuffer.ReAllocL( iLastProcListSize );

		}

	DoGetListL( EProcesses, (TUint)(-1), (TUint)(-1), iProcListBuffer, iLastProcListSize );

	iLastProcListSize = iProcListBuffer.Size();

	TUint8* ptr = (TUint8*)( iProcListBuffer.Ptr() );

	const TUint8* ptrEnd = ptr + iLastProcListSize;

	//LOG_MSG3( "  Data start,end=(0x%x, 0x%x)\n", ptr, ptrEnd );

	while( ptr < ptrEnd ) 

		{

	    TProcessListEntry *entry = (TProcessListEntry*)ptr;

		if( !entry )

			{

			LOG_MSG( "  ERROR !* : TProcessListEntry is NULL\n" );

			User::Leave(KErrBadHandle);

			}

		TUint64 id = entry->iProcessId;

		if( entry->iFileNameLength == 0 )

			{

			LOG_MSG4( "  Skipping process 0x%X%X : entry->iFileNameLength=%d", 

				I64HIGH(entry->iProcessId), I64LOW(entry->iProcessId), entry->iFileNameLength );

			ptr += Align4( entry->GetSize() );

			continue;

			}

		/*

		LOG_MSG4( "  process 0x%X%X has iFileNameLength=%d", 

			I64HIGH(entry->iProcessId), I64LOW(entry->iProcessId), entry->iFileNameLength );

		*/

        TPtrC entryName(&(entry->iNames[0]), entry->iFileNameLength);

        CProcessInfo *procInfoPtr = CProcessInfo::NewL(id, entryName );

		TInt err = aProcessList.Append( procInfoPtr );

        if(err != KErrNone)

            {

            delete procInfoPtr;

            User::Leave(err);

            }

		aTotalProcessListDescSize += procInfoPtr->Size();

		ptr += Align4( entry->GetSize() );

		}

	}

void CServerCrashDataSource::GetExecutableListL( RExecutablePointerList & aExecutableList,

											  TUint & aTotalExecutableListDescSize )

    {

	LOG_MSG( "CServerCrashDataSource::GetExecutableListL()\n" );

	// Delete any objects in the array, since we will replace them. 

	aExecutableList.ResetAndDestroy();

	aTotalExecutableListDescSize = 0;

	if( iExecutableListBuffer.Size() != iLastExecutableListSize )

		{

		LOG_MSG2( "  iExecutableListBuffer.ReAlloc( %d)\n", iLastExecutableListSize );

		iExecutableListBuffer.ReAllocL( iLastExecutableListSize );

		}

	DoGetListL( EExecutables, (TUint)(-1), (TUint)(-1), iExecutableListBuffer, iLastExecutableListSize );

	iLastExecutableListSize = iExecutableListBuffer.Size();

	TUint8* ptr = (TUint8*)( iExecutableListBuffer.Ptr() );

	const TUint8* ptrEnd = ptr + iLastExecutableListSize;

	//LOG_MSG3( "  Data start,end=(0x%x, 0x%x)\n", ptr, ptrEnd );

	while( ptr < ptrEnd ) 

		{

	    TExecutablesListEntry *entry = (TExecutablesListEntry*)ptr;

		if( !entry )

			{

			LOG_MSG( "  ERROR !* : TExecutablesListEntry is NULL\n" );

			User::Leave(KErrBadHandle);

			}

		if( entry->iNameLength == 0 )

			{

			LOG_MSG( "  Skipping executable : entry->iNameLength=0" );

			ptr += Align4( entry->GetSize() );

			continue;

			}

        TPtrC entryName(&(entry->iName[0]), entry->iNameLength);

        CExecutableInfo *executableInfoPtr = 

			CExecutableInfo::NewL(entryName, entry->iIsActivelyDebugged, entry->iIsPassivelyDebugged );

		TInt err = aExecutableList.Append( executableInfoPtr );

        if(err != KErrNone)

            {

            delete executableInfoPtr;

            User::Leave(err);

            }

		aTotalExecutableListDescSize += executableInfoPtr->Size();

		ptr += Align4( entry->GetSize() );