// KernLbxModel.cpp

// 

// Copyright (c) 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

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

// Accenture - Initial contribution

//

#include "KernLbxModel.h"

#include "Utils.h"

#include <fshell/memoryaccess.h>

#include "QResources3.hrh"

#include <HAL.h>

#include <fshell/common.mmh>

#include <fshell/clogger.h>

#ifdef FSHELL_APPARC_SUPPORT

#include <apgcli.h>

#include <APGWGNAM.H>

#include <APMREC.H>

#endif

#ifdef FSHELL_WSERV_SUPPPORT

#include <W32STD.H>

#endif

#include <fshell/ltkutils.h>

#include "sandbox.h"

using namespace LtkUtils;

CKernListBoxData::CKernListBoxData(CKernListBoxModel* aModel)

	: /*CQikListBoxData(),*/ iModel(aModel)

	{

	}

CKernListBoxData::~CKernListBoxData()

	{

	if (iDelegate)

		{

		iDelegate->DataObjectAboutToDestruct(this);

		}

	delete iInfo;

	}

CKernListBoxModel::CKernListBoxModel(RMemoryAccess& aMemoryAccess)

	: iSort(NULL), iMemAccess(aMemoryAccess)

	{

	}

void CKernListBoxModel::ConstructL()

	{

	iUnd = new(ELeave) CUndertaker(*this);

	iUnd->Register();

#ifdef FSHELL_WSERV_SUPPORT

	iWsSession = new (ELeave) RWsSession;

	TInt err = iWsSession->Connect();

	if (err != KErrNone)

		{

		delete iWsSession;

		iWsSession = NULL;

		// Null pointer is used to indicate wserv not present

		}

#endif

	iTempBuf1.CreateL(256);

	iTempBuf2.CreateL(256);

	}

TInt CKernListBoxModel::Count() const

	{

	return iItemData.Count();

	}

TInt CKernListBoxModel::ItemIdIndex(TInt aItemId) const

	{

	const TInt count = iItemData.Count();

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

		{

		if (iItemData[i]->ItemId() == aItemId)

			return i;

		}

	return KErrNotFound;

	}

CKernListBoxData* CKernListBoxModel::RetrieveDataL(TInt aItemIndex)

	{

	iItemData[aItemIndex]->Open();

	return iItemData[aItemIndex];

	}

CKernListBoxData* CKernListBoxModel::RetrieveDataLC(TInt aItemIndex)

	{

	CKernListBoxData* data = iItemData[aItemIndex];

	data->Open();

	CleanupClosePushL(*data);

	return data;

	}

void CKernListBoxModel::RemoveAllDataL()

	{

	const TInt count = iItemData.Count();

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

		{

		iItemData[i]->Close();

		}

	iItemData.Reset();

	}

void CKernListBoxModel::ModelBeginUpdateLC()

	{

	}

void CKernListBoxModel::ModelEndUpdateL()

	{

	}

void CKernListBoxModel::DataUpdatedL(TInt /*aIndex*/)

	{

	}

TInt CKernListBoxModel::Compare(TInt aLeft, TInt aRight) const

	{

	const CKernListBoxData* left = iItemData[aLeft];

	const CKernListBoxData* right = iItemData[aRight];

	return (*iSort)(left, right);

	}

void CKernListBoxModel::Swap(TInt aLeft,TInt aRight) const

	{

	const_cast<CKernListBoxModel*>(this)->WtfSwap(aLeft, aRight);

	}

void CKernListBoxModel::WtfSwap(TInt aLeft,TInt aRight)

	{

	CKernListBoxData* temp = iItemData[aLeft];

	iItemData[aLeft] = iItemData[aRight];

	iItemData[aRight] = temp;

	}

void CKernListBoxModel::RemoveDataL(TInt aItemIndex)

	{

	iItemData[aItemIndex]->Close();

	iItemData.Remove(aItemIndex);

	}

void CKernListBoxModel::SetCurrentListL(TInt aCurrentList)

	{

	if (iCurrentList != aCurrentList)

		{

		RemoveAllDataL();

		}

	iCurrentList = aCurrentList;

	}

TInt CKernListBoxModel::GetCurrentList() const

	{

	return iCurrentList;

	}

void CKernListBoxModel::NewKernDataL(TInt aType, TObjectKernelInfo* aInfo)

	{

	DoNewKernDataL(aType, aInfo, NULL);

	}

void CKernListBoxModel::DoNewKernDataL(TInt aType, TObjectKernelInfo* aInfo, MKernListBoxDataDelegate* aDelegate)

	{

	CKernListBoxData* data;

	switch (aType)

		{

	case EListOpenFiles:

		data = new(ELeave) COpenFilesListBoxData(this);

		break;

	case EListThread:

		data = new(ELeave) CThreadsListBoxData(this);

		break;

	case EListFeatureReg:

		data = new(ELeave) CFeatRegListBoxData(this);

		break;

	case EListServer:

		data = new(ELeave) CServerListBoxData(this);

		break;

	case EListHal:

		data = new(ELeave) CHalListBoxData(this);

		break;

	case EListWindowGroups:

		data = new(ELeave) CWindowGroupListBoxData(this);

#else

		data = NULL; // Compiler shutter upper

		User::Leave(KErrNotSupported);

#endif

		break;

	case EListMessageQueue:

		data = new(ELeave) CMsgQueListBoxData(this);

		break;

	case EListMutex:

		data = new(ELeave) CMutexListBoxData(this);

		break;

	case EListSemaphore:

		data = new(ELeave) CSemaphoreListBoxData(this);

		break;

	case EListTimer:

		data = new(ELeave) CTimerListBoxData(this);

		break;

	default:

		data = new(ELeave) CKernListBoxData(this);

		break;

		}

	data->SetDelegate(aDelegate);

	CleanupStack::PushL(data);

	data->iType = aType;

	data->ConstructL();

	data->FormatL(aInfo, iTempBuf1, iTempBuf2);

	iItemData.AppendL(data);

	CleanupStack::Pop(data);

	data->Open(); // open for model

	//data->Open(); // open for return

	data->iInfo = aInfo;

	//return data;

	}

// This function is used for the list box items

void CKernListBoxData::FormatL(TObjectKernelInfo* aInfo, RBuf& aTempBuf1, RBuf& aTempBuf2)

	{

	RBuf& name = aTempBuf1;

	RBuf& more = aTempBuf2;

	name.Zero();

	more.Zero();

	TInt itemId = (TInt)aInfo; // By default use the ptr unless the type can suggest anything better

	DoFormatL(aInfo, aTempBuf1, aTempBuf2, itemId);

	SetItemId(itemId);

	if (iDelegate)

		{

		iDelegate->FormatChangedL(this, name, more);

		}

	}

void CKernListBoxData::DoFormatL(TObjectKernelInfo* aInfo, RBuf& name, RBuf& more, TInt& itemId)

	{

	switch (iType)

		{

	case EListChunk:

		{

		TChunkKernelInfo& info = *(TChunkKernelInfo*)aInfo;

		name.Copy(info.iFullName);

		PrettyName(iType, name);

		TBuf<16> size, maxSize;

		HR(size, info.iSize);

		HR(maxSize, info.iMaxSize);

		more.Format(_L("Size %S / %S"), &size, &maxSize);

		break;

		}

	case EListProcess:

		{

		TProcessKernelInfo& info = *(TProcessKernelInfo*)aInfo;

		name.Copy(info.iFullName);

		PrettyName(iType, name);

		TUint pid = info.iProcessId;

		TUint sid = info.iProcessSecurityInfo.iSecureId;

		TExitType exitType = EExitPending;

		RProcess proc;

		if (proc.Open(pid) == KErrNone)

			{

			exitType = proc.ExitType();

			}

		if (exitType == EExitPending)

			{

			more.Format(_L("Pid %i Sid 0x%x"), pid, sid);

			}

		else

			{

			TExitCategoryName cat = proc.ExitCategory();

			more.Format(_L("Pid %i %S %i Sid 0x%x"), pid, &cat, proc.ExitReason(), sid);

			}

		proc.Close();

		itemId = pid;

		break;

		}

	case EListCodeSeg:

		{

		TCodeSegKernelInfo& info = *reinterpret_cast<TCodeSegKernelInfo*>(aInfo);

		name.Copy(info.iName);

		TBuf<16> size;

		HR(size, info.iSize);

		more.Format(_L("Size %S Ref count %i"), &size, info.iAccessCount);

		break;

		}

	case EListMimeTypes:

		{

		SDataType& info = *reinterpret_cast<SDataType*>(aInfo);

		name.Copy(info.iMime);

		more.Format(_L("From: %S"), &info.iRecog);

		break;

		}

	default:

		break;

		}

	}

void CKernListBoxModel::DumpToCloggerL(RClogger& clogger)

	{

	TInt count = Count();

#ifdef __WINS__

	clogger.Log("NOTE: This data is from a WINS[CW] build so is not representative of a real device!");

#endif

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

		{

		CKernListBoxData* data = static_cast<CKernListBoxData*>(RetrieveDataLC(i));

		data->DumpToCloggerL(clogger, i, count);

		CleanupStack::PopAndDestroy(data);

		}

	}

void CKernListBoxData::DumpToCloggerL(RClogger& clogger, TInt i, TInt count)

	{

	_LIT8(KChunkDesc,"Chunk;FullName;Size;(SizeHumanReadable);MaxSize;(MaxSizeHumanReadable);CreatorPid;BaseAddr");

	_LIT8(KChunkFmt,"Chunk;%S;%i;(%S);%i;(%S);%i;%08x");

	_LIT8(KProcessDesc,"Process;FullName;Pid;Priority;(PriorityHumanReadable);Sid;Vid;CreatorSid;CreatorName;Capabilities;(CapsHumanReadable);ExitStatus;ExitCategory;ExitReason;FixedProcess;DProcessAddr");

	_LIT8(KProcessFmt,"Process;%S;%i;%i;(%S);%x;%x;%x;%S;%x;(%S);%S;%S;%i;%S;%08x");

	_LIT8(KCodesegDesc,"CodeSeg;FileName;Size;(SizeHumanReadable);RefCount;DepCount");

	_LIT8(KCodesegFmt,"CodeSeg;%S;%i;%S;%i;%i");

	_LIT(KMimeDesc,"MimeType;Name;Recogniser;AppUid;AppName");

	_LIT(KMimeFmt, "MimeType;%S;%S;%x;%S");

	CKernListBoxData* data = this;

	TObjectKernelInfo* aInfo = data->iInfo;

	switch (iType)

		{

	case EListChunk:

		{

		if (i == 0) clogger.Log(KChunkDesc);

		if (i == 0)

			{

			// Also log free at the start, so we can tally up mem losses

			TInt freeRam = -1, totalRam = -1;

			TBuf8<16> free, total;

			HAL::Get(HAL::EMemoryRAMFree, freeRam);

			HAL::Get(HAL::EMemoryRAM, totalRam);

			HR(free, freeRam);

			HR(total, totalRam);

			_LIT8(KFree, "FREE");

			clogger.Log(KChunkFmt, &KFree, freeRam, &free, totalRam, &total, 0);

			}

		TChunkKernelInfo& info = *(TChunkKernelInfo*)aInfo;

		TBuf8<16> size, maxSize;

		HR(size, info.iSize);

		HR(maxSize, info.iMaxSize);

		clogger.Log(KChunkFmt, &info.iFullName, info.iSize, &size, info.iMaxSize, &maxSize, info.iControllingOwnerProcessId, info.iBase);

		if (i == count-1)

			{

			// Also print out free RAM at end, so we can see if mem usage changed much during

			TInt freeRam = -1, totalRam = -1;

			TBuf8<16> free, total;

			HAL::Get(HAL::EMemoryRAMFree, freeRam);

			HAL::Get(HAL::EMemoryRAM, totalRam);

			HR(free, freeRam);

			HR(total, totalRam);

			_LIT8(KFree, "FREE");

			clogger.Log(KChunkFmt, &KFree, freeRam, &free, totalRam, &total, 0);

			}

		break;

		}

	case EListProcess:

		{

		if (i == 0) clogger.Log(KProcessDesc);

		TProcessKernelInfo& info = *(TProcessKernelInfo*)aInfo;

		TBuf<16> priority16 = ToString((TProcessPriority)info.iPriority);

		TPtr8 priority = priority16.Collapse();

		HBufC* caps16 = ToStringL(info.iProcessSecurityInfo.iCaps);

		TPtr8 caps(caps16->Des().Collapse());

		TPtrC exitStatus;

		TInt exitReason = 0;

		TExitCategoryName exitCategory;

		RProcess handle;

		if (handle.Open(info.iProcessId) == KErrNone)

			{

			exitStatus.Set(ToString(handle.ExitType()));

			exitCategory = handle.ExitCategory();

			exitReason = handle.ExitReason();

			handle.Close();

			}

		TBuf8<16> exitStatus8;

		exitStatus8.Copy(exitStatus);

		TPtrC8 exitCategory8 = exitCategory.Collapse();

		RBuf creatorName;

		data->ExeNameForSid(info.iProcessCreatorSecurityInfo.iSecureId, creatorName);

		TPtrC8 creatorName8 = creatorName.Collapse();

		TBool fixed = info.iAttributes & 1; // TMemModelProcessAttributes::EFixedAddress

		_LIT8(KFixed, "FIXED");

		TPtrC8 fixedPtr = fixed ? KFixed() : KNullDesC8();

		clogger.Log(KProcessFmt, &info.iFullName, info.iProcessId, info.iPriority, &priority, info.iProcessSecurityInfo.iSecureId, info.iProcessSecurityInfo.iVendorId, info.iProcessCreatorSecurityInfo.iSecureId, &creatorName8, info.iProcessSecurityInfo.iCaps[0], &caps, &exitStatus8, &exitCategory8, exitReason, &fixedPtr, info.iAddressOfKernelObject);

		creatorName.Close();

		delete caps16;

		break;

		}

	case EListCodeSeg:

		{

		if (i == 0) clogger.Log(KCodesegDesc);

		TCodeSegKernelInfo& info = *reinterpret_cast<TCodeSegKernelInfo*>(aInfo);

		TBuf8<16> size;

		HR(size, info.iSize);

		clogger.Log(KCodesegFmt, &info.iName, info.iSize, &size, info.iAccessCount, info.iDepCount);

		break;

		}

	case EListMimeTypes:

		{

		if (i == 0) clogger.Log(KMimeDesc);

		SDataType& info = *reinterpret_cast<SDataType*>(aInfo);

		clogger.Log(KMimeFmt, &info.iMime, &info.iRecog, info.iAppUid, &info.iApp);

		break;

		}

	default:

		break;

		}

	}

void CKernListBoxData::InfoForDialogL(RBuf& aTitle, RBuf& aText, TBool aRefresh)

	{

	if (aRefresh)

		{

		// Figure out our index in the model

		TInt index = iModel->ItemIdIndex(ItemId());

		iModel->RefreshDataL(index);

		}

	aTitle.Zero();

	aText.Zero();

	if (aTitle.MaxLength() < 256)

		{

		aTitle.ReAllocL(256);

		}

	if (aText.MaxLength() < 1024)

		{

		aText.ReAllocL(1024);

		}

	RBuf& inf = aText;

	TBuf<256>* name = new(ELeave) TBuf<256>;

	CleanupStack::PushL(name);

	DoInfoForDialogL(aTitle, inf, name);

	CleanupStack::PopAndDestroy(name);

	}

void AppendProcessFlags(TDes& aBuf, TUint32 aFlags)

	{

	TInt len = aBuf.Length();

	// 9.1/9.2 doesn't have these, it's easier to redefine them to the correct value than make all the code conditional

	const TUint KThreadFlagRealtime = 0x00000040;

	const TUint KThreadFlagRealtimeTest = 0x00000080;

#define IF_MATCH(aBuf, aFlags, aFlag) if (aFlags&aFlag) { aBuf.Append(_L( #aFlag )); aBuf.Append('|'); }

	IF_MATCH(aBuf, aFlags, KThreadFlagProcessCritical)

	IF_MATCH(aBuf, aFlags, KThreadFlagProcessPermanent)

	IF_MATCH(aBuf, aFlags, KThreadFlagSystemCritical)

	IF_MATCH(aBuf, aFlags, KThreadFlagSystemPermanent)

	IF_MATCH(aBuf, aFlags, KThreadFlagOriginal)

	IF_MATCH(aBuf, aFlags, KThreadFlagLastChance)

	IF_MATCH(aBuf, aFlags, KThreadFlagRealtime)

	IF_MATCH(aBuf, aFlags, KThreadFlagRealtimeTest)

	IF_MATCH(aBuf, aFlags, KProcessFlagPriorityControl)

	IF_MATCH(aBuf, aFlags, KProcessFlagJustInTime)

	if (aBuf.Length() > len)

		{

		// Remove trailing |

		aBuf.SetLength(aBuf.Length() - 1);

		}

	}

void CKernListBoxData::DoInfoForDialogL(RBuf& aTitle, RBuf& inf, TDes* aTemp)

	{

	TDes* name = aTemp;

	switch (iType)

		{

		case EListProcess:

			{

			TProcessKernelInfo& info = *(TProcessKernelInfo*)iInfo;

			RProcess process;

			TInt err = process.Open(info.iProcessId);

			CleanupClosePushL(process);

			_LIT(KInfo, "Process info");

			aTitle.Copy(KInfo);

			inf.Copy(iInfo->iFullName);

			if (!err)

				{

				inf.Append(Klf);

				inf.Append(process.FileName());

				}

			if (info.iCommandLine.Length())

				{

				inf.Append(' ');

				//aTemp->Copy(info.iCommandLine);

				// Command line args are generally 16-bit descriptors even though they're represented in 8-bit kernel-side

				TPtrC widePtr((const TUint16*)info.iCommandLine.Ptr(), info.iCommandLine.Size()/2);

				inf.Append(widePtr);

				}

			//_LIT8(KProcessDesc, "Process\tFullName\tPid\tPriority\t(PriorityHumanReadable)\tSid\tVid\tCapabilities\t(CapsHumanReadable)\tExitStatus\tExitCategory\tExitReason");

			_LIT(KProcess, "\n\nPid: %i %S\nSid: 0x%x Vid: 0x%x");

			_LIT(KPriority, "\nPriority: %i (%S)");

			_LIT(KOtherStuff, "\nCreator Sid: 0x%x (%S)\n\nCapabilities: %S");

			_LIT(KKern, "\nKernel object address: 0x%08x");

			_LIT(KFlags, "\nFlags: 0x%x (");