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

// e32\kernel\sexec.cpp

// 

//

#include <kernel/kern_priv.h>

#include <e32uid.h>

#include <e32ver.h>

//#include <unicode.h>

#include "execs.h"

TInt ExecHandler::ObjectNext(TObjectType aType, TBuf8<KMaxFullName>& aName, TFindHandle& aFindHandle)

//

// Do the next find.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ObjectNext type %d",aType));

	if (aType<0 || aType>=ENumObjectTypes)

		K::PanicKernExec(EBadObjectType);

	DObjectCon* pC=K::Containers[aType];

	TFullName fn;

	TFullName match;

	TFindHandle h;

	Kern::KUDesGet(match,aName);

	kumemget32(&h,&aFindHandle,sizeof(h));

	__KTRACE_OPT(KEXEC,Kern::Printf("ObjN: %S %08x", &match, h.Handle()));

	NKern::ThreadEnterCS();

	TInt r=pC->FindByFullName(h, match, fn);

	NKern::ThreadLeaveCS();

	Kern::KUDesPut(aName,fn);

	kumemput32(&aFindHandle,&h,sizeof(h));

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ObjectNext ret %d",r));

	return r;

	}

TUint8 *ExecHandler::ChunkBase(DChunk* aChunk)

//

// Return the address of the base of the Chunk.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ChunkBase"));

	return (TUint8*)aChunk->Base(&Kern::CurrentProcess());

	}

TInt ExecHandler::ChunkSize(DChunk* aChunk)

//

// Return the current size of the Chunk.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ChunkSize"));

	return aChunk->Size();

	}

TInt ExecHandler::ChunkMaxSize(DChunk* aChunk)

//

// Return the maximum size of the Chunk.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ChunkMaxSize")); 	

	return aChunk->MaxSize();

	}

TInt ExecHandler::ChunkBottom(DChunk* aChunk)

//

// Return the position of the bottom of the chunk

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ChunkBottom"));

	return aChunk->Bottom();

	}

TInt ExecHandler::ChunkTop(DChunk* aChunk)

//

// Return the position of the top of the chunk

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ChunkTop"));

	return aChunk->Top();

	}

TInt ExecHandler::MutexWait(DMutex* aMutex, TInt aTimeout)

//

// Wait for the mutex.

//

	{

	if (aTimeout)	// 0 means wait forever, -1 means poll

		{

		if (aTimeout<-1)

			{

			return KErrArgument;

			}

		if (aTimeout>0)

			{

			// Convert microseconds to NTimer ticks, rounding up

			TInt ntp = NKern::TickPeriod();

			aTimeout += ntp-1;

			aTimeout /= ntp;

			}

		}

	return aMutex->Wait(aTimeout);

	}

void ExecHandler::MutexSignal(DMutex* aMutex)

//

// Signal the mutex.

//

	{

//	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::MutexSignal"));

	if (TheCurrentThread==aMutex->iCleanup.iThread)

		{

		aMutex->Signal();

		return;

		}

	K::PanicCurrentThread(EAccessDenied);

	}

/**

Test if mutex is held by the current thread.

@return True if the current thread has waited on the mutex, false otherwise.

*/

TBool ExecHandler::MutexIsHeld(DMutex* aMutex)

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::MutexIsHeld"));

	return TheCurrentThread==aMutex->iCleanup.iThread;

	}

void ExecHandler::ProcessType(DProcess* aProcess, TUidType& aUids)

//

// Get process' UIDs.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessType"));

	TUidType uids(aProcess->iUids);

	NKern::UnlockSystem();

	kumemput32(&aUids,&uids,sizeof(TUidType));

	}

TInt ExecHandler::ProcessId(DProcess* aProcess)

//

// Get process ID.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessId")); 	

	return (TInt)aProcess->iId;

	}

void ExecHandler::ProcessSecurityInfo(DProcess* aProcess,SSecurityInfo& aInfo)

//

// Get process security info.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessSecurityInfo"));

	SSecurityInfo info(aProcess->iS);

	NKern::UnlockSystem();

	kumemput32(&aInfo,&info,sizeof(info));

	}

void ExecHandler::ThreadSecurityInfo(DThread* aThread,SSecurityInfo& aInfo)

//

// Get threads security info.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadSecurityInfo"));

	SSecurityInfo info(aThread->iOwningProcess->iS);

	NKern::UnlockSystem();

	kumemput32(&aInfo,&info,sizeof(info));

	}

void ExecHandler::MessageSecurityInfo(DThread* aClient,SSecurityInfo& aInfo)

//

// Get clients security info.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::MessageSecurityInfo"));

	SSecurityInfo info(aClient->iOwningProcess->iS);

	NKern::UnlockSystem();

	kumemput32(&aInfo,&info,sizeof(info));

	}

TInt ExecHandler::SessionSecurityInfo(TInt aSession,SSecurityInfo& aInfo)

//

// Get session security info.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::SessionSecurityInfo"));

	TInt r = KErrBadHandle;

	SSecurityInfo info;

	NKern::LockSystem();

	DSession* s = (DSession*)TheCurrentThread->ObjectFromHandle(aSession,ESession);

	if (s)

		{

		if (s->iServer && s->iServer->iOwningThread)

			{

			// session is connected, and server is alive

			info = s->iServer->iOwningThread->iOwningProcess->iS;

			r = KErrNone;

			}

		else

			{

			r = KErrServerTerminated;

			}

		}

	NKern::UnlockSystem();

	if (r==KErrNone)

		kumemput32(&aInfo,&info,sizeof(info));

	return r;

	}

void ExecHandler::CreatorSecurityInfo(SSecurityInfo& aInfo)

//

// Get creator's security info.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::CreatorSecurityInfo"));

	kumemput32(&aInfo,&TheCurrentThread->iOwningProcess->iCreatorInfo,sizeof(aInfo));

	}

void ExecHandler::DisabledCapabilities(SCapabilitySet& aCaps)

//

// Get the set of capabilities which are not to be checked (implemented by effectively

// setting them for all executables).

//

	{

	__KTRACE_OPT(KEXEC, Kern::Printf("Exec::DisabledCapabilities"));

#ifdef __PLATSEC_UNLOCKED__

	kumemput32(&aCaps, &TheSuperPage().iDisabledCapabilities, sizeof(aCaps));

#else

	kumemset(&aCaps, 0, sizeof(aCaps));

#endif	// __PLATSEC_UNLOCKED__

	}

void ExecHandler::ProcessResume(DProcess* aProcess)

//

// Resume the first thread in the process.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessResume"));

	if (aProcess->iCreatorId!=TheCurrentThread->iOwningProcess->iId) // Not creator...

		K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Checked by RProcess::Resume"));

	aProcess->Resume();

	}

void ExecHandler::ProcessFileName(DProcess* aProcess, TDes8& aName)

//

// Return the process file name.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessFileName"));

	TFileName fn;

	DCodeSeg* pS=aProcess->iCodeSeg;

	if (pS)

		pS->AppendFullFileName(fn);

	NKern::UnlockSystem();

	if (pS)

		P::NormalizeExecutableFileName(fn);

	Kern::KUDesPut(aName, fn);

	}

TInt ExecHandler::ProcessCommandLineLength(DProcess* aProcess)

//

// Return the process command line length.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessCommandLineLength"));

	if (aProcess->iSecurityZone!=TheCurrentThread->iOwningProcess->iSecurityZone)

		K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Checked by RProcess::CommandLineLength"));

	const TDesC* pC=aProcess->iCommandLine;

#ifdef _UNICODE

	return pC?(pC->Length()>>1):0;

#else

	return pC?(pC->Length()):0;

#endif

	}

void ExecHandler::ProcessCommandLine(DProcess* aProcess, TDes8& aCommandLine)

//

// Return the process command line.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessCommandLine"));

	if (aProcess->iSecurityZone!=TheCurrentThread->iOwningProcess->iSecurityZone)

		K::ProcessIsolationFailure(__PLATSEC_DIAGNOSTIC_STRING("Checked by RProcess::CommandLine"));

	aProcess->CheckedOpen();

	DThread& t=*TheCurrentThread;

	t.iTempObj=aProcess;

	NKern::UnlockSystem();

	const TDesC* pC=aProcess->iCommandLine;

	if (!pC)

		pC=&KNullDesC;

	Kern::KUDesPut(aCommandLine,*pC);

	NKern::ThreadEnterCS();

	t.iTempObj=NULL;

	aProcess->Close(NULL);

	NKern::ThreadLeaveCS();

	}

TExitType ExecHandler::ProcessExitType(DProcess* aProcess)

//

// Return the exit type.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessExitType")); 	

	return (TExitType)aProcess->iExitType;

	}

TInt ExecHandler::ProcessExitReason(DProcess* aProcess)

//

// Return the exit reason.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessExitReason"));

	return aProcess->iExitReason;

	}

void ExecHandler::ProcessExitCategory(DProcess* aProcess, TDes8& aName)

//

// Return the category of the exit type.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessExitCategory"));

	TBufC<KMaxExitCategoryName> exitCat(aProcess->iExitCategory);

	NKern::UnlockSystem();

	Kern::KUDesPut(aName,exitCat);

	}

LOCAL_D const TProcessPriority procPriorityConvertTable[8]=

	{

	EPriorityLow,			EPriorityBackground,	EPriorityForeground,	EPriorityHigh,

	EPriorityWindowServer,	EPriorityFileServer,	EPrioritySupervisor,	EPriorityRealTimeServer

	};

LOCAL_D const TThreadPriority thrdPriorityConvertTable[8]=

	{

	EPriorityMuchLess,	EPriorityMuchLess,	EPriorityLess,		EPriorityNormal,

	EPriorityMore,		EPriorityMuchMore,	EPriorityRealTime,	EPriorityRealTime

	};

LOCAL_C TThreadPriority ConvertThreadPriority(TInt p)

	{

	switch(p)

		{

		case EThrdPriorityAbsoluteVeryLow:

			return EPriorityAbsoluteVeryLow;

		case EThrdPriorityAbsoluteLowNormal:

			return EPriorityAbsoluteLowNormal;

		case EThrdPriorityAbsoluteLow:

			return EPriorityAbsoluteLow;

		case EThrdPriorityAbsoluteBackgroundNormal:

			return EPriorityAbsoluteBackgroundNormal;

		case EThrdPriorityAbsoluteBackground:

			return EPriorityAbsoluteBackground;

		case EThrdPriorityAbsoluteForegroundNormal:

			return EPriorityAbsoluteForegroundNormal;

		case EThrdPriorityAbsoluteForeground:

			return EPriorityAbsoluteForeground;

		case EThrdPriorityAbsoluteHighNormal:

			return EPriorityAbsoluteHighNormal;

		case EThrdPriorityAbsoluteHigh:

			return EPriorityAbsoluteHigh;

		case EThrdPriorityAbsoluteRealTime1:

			return EPriorityAbsoluteRealTime1;

		case EThrdPriorityAbsoluteRealTime2:

			return EPriorityAbsoluteRealTime2;

		case EThrdPriorityAbsoluteRealTime3:

			return EPriorityAbsoluteRealTime3;

		case EThrdPriorityAbsoluteRealTime4:

			return EPriorityAbsoluteRealTime4;

		case EThrdPriorityAbsoluteRealTime5:

			return EPriorityAbsoluteRealTime5;

		case EThrdPriorityAbsoluteRealTime6:

			return EPriorityAbsoluteRealTime6;

		case EThrdPriorityAbsoluteRealTime7:

			return EPriorityAbsoluteRealTime7;

		case EThrdPriorityAbsoluteRealTime8:

			return EPriorityAbsoluteRealTime8;

		default:

			if (p>=-8 && p<0)

				return thrdPriorityConvertTable[p+8];

		}

	return EPriorityNormal;

	}

LOCAL_C TBool ProcessPriorityValid(TProcessPriority p)

	{

	switch(p)

		{

		case EPriorityLow:

		case EPriorityBackground:

		case EPriorityForeground:

		case EPriorityHigh:

			return ETrue;

		default:

			return EFalse;

		}

	}

TProcessPriority ExecHandler::ProcessPriority(DProcess* aProcess)

//

// Get the process base priority.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessPriority"));

	return procPriorityConvertTable[aProcess->iPriority];

	}

TInt ExecHandler::ProcessSetPriority(DProcess* aProcess, TProcessPriority aPriority)

//

// Set the process base priority.

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessSetPriority"));

	aProcess->CheckedOpen();

	DThread& t=*TheCurrentThread;

	t.iTempObj=aProcess;

	NKern::UnlockSystem();

	if (!ProcessPriorityValid(aPriority))

		K::PanicKernExec(EBadPriority);

	TBool allowed=ETrue;

	DProcess* currentProcess=TheCurrentThread->iOwningProcess;

	if (aProcess->iSecurityZone!=currentProcess->iSecurityZone)  // Not self...

		if (aProcess->iCreatorId!=currentProcess->iId)  // Not creator

			{

			TInt processPriority=aProcess->iPriority;

			if (!(aProcess->iFlags&KProcessFlagPriorityControl)  // No remote control...

 				|| (processPriority!=EProcPriorityBackground && processPriority!=EProcPriorityForeground && processPriority!=EProcPriorityHigh)

				|| (aPriority!=EPriorityBackground && aPriority!=EPriorityForeground && aPriority!=EPriorityHigh) )  // Or not foreground/background/high

					allowed=!(TheSuperPage().KernelConfigFlags() & EKernelConfigPlatSecProcessIsolation);

			}

	NKern::ThreadEnterCS();

	t.iTempObj=NULL;

	if(allowed)

		aProcess->SetPriority(aPriority);

	aProcess->Close(NULL);

	NKern::ThreadLeaveCS();

	if (allowed)

		{

		return KErrNone;

		}

	else

		{

		return KErrPermissionDenied;

		}

	}

const TUint32 KDefinedProcessFlags=

	KProcessFlagSystemCritical|

	KProcessFlagSystemPermanent|

	KProcessFlagJustInTime|

	KProcessFlagPriorityControl|

	KThreadFlagProcessCritical;

const TUint32 KRestrictedProcessFlags =

		~(KProcessFlagJustInTime|KProcessFlagPriorityControl|KThreadFlagProcessCritical); // All but these are restricted

const TUint32 KSelfOnlyProcessFlags =

		~0u; // (KProcessFlagJustInTime|KProcessFlagPriorityControl); // Only self can change these

const TUint32 KDefinedThreadFlags=

	KThreadFlagProcessCritical|

	KThreadFlagProcessPermanent|

	KThreadFlagSystemCritical|

	KThreadFlagSystemPermanent|

	KThreadFlagLastChance|

	KThreadFlagRealtime|

	KThreadFlagRealtimeTest;

const TUint32 KRestrictedThreadFlags =

		~(KThreadFlagProcessCritical|KThreadFlagProcessPermanent|KThreadFlagLastChance|

			KThreadFlagRealtime|KThreadFlagRealtimeTest); // All but these are restricted

const TUint32 KSelfOnlyThreadFlags =

		~0u; // (KThreadFlagProcessCritical|KThreadFlagProcessPermanent|KThreadFlagLastChance); // Only owning process can change these

TUint ExecHandler::ProcessFlags(DProcess* aProcess)

//

// Get the process flags

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ProcessFlags"));

	return aProcess->iFlags;

	}

TUint ExecHandler::ThreadProcessFlags(DThread* aThread)

//

// Get the process flags

//

	{

	__KTRACE_OPT(KEXEC,Kern::Printf("Exec::ThreadProcessFlags"));