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

// e32test\system\t_env.cpp

// Overview:

// Test RProcess parameters

// API Information:

// RProcess

// Details:

// - Create a thread that causes a variety of panics. Verify that the exit

// reason is as expected.

// - Create a process that causes a variety of panics. Verify that the results

// are as expected.

// - Test passing 16 bit and 8 bit descriptors to another process. Verify the 

// text and other results are as expected.

// - Verify that an invalid read of a descriptor by a process causes a panic.

// - Test passing zero length data to a separate process works as expected.

// - Test that passing each of a mutex, semaphore, file handle and chunk to a 

// separate process works as expected.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32std.h>

#include <e32std_private.h>

#include <e32test.h>

#include <e32panic.h>

#include <e32msgqueue.h>

#include <d32comm.h>

#include <f32file.h>

#if defined (__WINS__)

#define PDD_NAME _L("ECDRV.PDD")

#define LDD_NAME _L("ECOMM.LDD")

#else

#define PDD_NAME _L("EUART")

#define LDD_NAME _L("ECOMM")

#endif

LOCAL_D RTest test(_L("T_ENV"));

_LIT(KProcName, "t_env_child.exe");

_LIT(KThreadName, "t_env_panic_thread");

_LIT(KQueueName, "testqueue");

_LIT(KMutexName, "testmutex");

_LIT(KSemName, "testsemaphore");

_LIT(KChunkName, "testchunk");

_LIT(KFileName, "c:\\testfile");

const TInt KHeapSize=0x2000;

class TData 

	{

public:

	TData(TInt aTest, RProcess& aProcess);

	TInt iTest;

	RProcess& iProcess;

	};

TData::TData(TInt aTest, RProcess&  aProcess) :	iTest(aTest), iProcess(aProcess)

	{

	//empty

	};

class Handles

	{

	public:

	void SetupParameters(RProcess& aNewProcess);

	Handles();

	~Handles();

	void Command(TInt aCommand);

	public:

	RMsgQueue<TInt> iCommandQueue;

	RMsgQueue<TInt> iIntQueue;

	RMutex iMutex;

	RSemaphore iSem;

	RChunk iChunk;

	RFile iFile;

	RFs iSession;

	};

void Handles::Command(TInt aC)

	{

	iCommandQueue.SendBlocking(aC);

	}

void Handles::SetupParameters(RProcess& aNewProcess)

	{

	aNewProcess.SetParameter(1, iCommandQueue);

	aNewProcess.SetParameter(2, iIntQueue);

	aNewProcess.SetParameter(3, iMutex);

	aNewProcess.SetParameter(4, iSem);

	aNewProcess.SetParameter(5, iChunk);

	aNewProcess.SetParameter(7, iSession);

	aNewProcess.SetParameter(8, iFile);

	}

_LIT8(KTestData,"test data");

Handles::Handles()

	{

	TInt ret = iCommandQueue.CreateGlobal(KNullDesC, 10, EOwnerProcess);

	test(ret == KErrNone);

	ret = iIntQueue.CreateGlobal(KQueueName,1);

	test(ret == KErrNone);

	ret = iMutex.CreateGlobal(KMutexName);

	test(ret == KErrNone);

	ret = iSem.CreateGlobal(KSemName,0);

	test(ret == KErrNone);

	ret = iChunk.CreateGlobal(KChunkName, 1024, 2048);

	test(ret == KErrNone);

	ret = iSession.Connect();

	test(ret == KErrNone);

	ret = iSession.ShareProtected();

	test(ret == KErrNone);

	ret = iFile.Open(iSession, KFileName, EFileStreamText|EFileWrite|EFileShareAny); 

	if (ret == KErrNotFound) // file does not exist - create it 

		ret = iFile.Create(iSession, KFileName, EFileStreamText|EFileWrite|EFileShareAny);

	test(ret == KErrNone);

	ret = iFile.Write(0, KTestData);

	test(ret == KErrNone);

	}

Handles::~Handles()

	{

	iCommandQueue.Close();

	iIntQueue.Close();

	iMutex.Close();

	iSem.Close();

	iChunk.Close();

	iSession.Close();

	}

LOCAL_C TInt testSetParameterPanics(TAny* aData)

	{

	const TData* data = (const TData*)aData;

	switch (data->iTest)

		{

		case 0:	//try and pass a non local handle

			{

			RMsgQueue<TInt> localMsgQueue;

			localMsgQueue.CreateLocal(1);

			data->iProcess.SetParameter(1, localMsgQueue);	//should panic with plat security panic

			break;

			}

		case 1:	//out of range slot

			{

			RMsgQueue<TInt> globalMsgQueue;

			globalMsgQueue.CreateGlobal(KNullDesC, 1);

			data->iProcess.SetParameter(-1, globalMsgQueue);	//should panic with range error

			break;

			}

		case 2:

			{

			RMsgQueue<TInt> globalMsgQueue;

			globalMsgQueue.CreateGlobal(KNullDesC, 1);

			data->iProcess.SetParameter(1234, globalMsgQueue);	//should panic with range error

			break;

			}

		case 3:	//in use 

			{

			RMsgQueue<TInt> globalMsgQueue;

			globalMsgQueue.CreateGlobal(KNullDesC, 1);

			data->iProcess.SetParameter(1, globalMsgQueue);

			data->iProcess.SetParameter(1, globalMsgQueue);	//panic, in use

			break;

			}

		case 4:

			{

			TPtrC8 bad((const TUint8*)0xfeed,4);

			data->iProcess.SetParameter(1, bad);

			break;

			}

		case 5:	//slot 0 is for the command line

			{

			RMsgQueue<TInt> globalMsgQueue;

			globalMsgQueue.CreateGlobal(KNullDesC, 1);

			data->iProcess.SetParameter(0, globalMsgQueue);	//panic, in use

			break;

			}

		}

	return KErrNone;

	}

GLDEF_C TInt E32Main()

    {

	test.Title();

	test.Start(_L("Process Parameters"));

	test.Next(_L("Test Panics on a set"));

	TBool jit = User::JustInTime();

	User::SetJustInTime(EFalse);

	TInt i;

	RProcess p;

	TInt ret = p.Create(KProcName, KProcName);

	test(ret == KErrNone);

	for (i = 0; i < 6; i++)

		{

		test.Printf(_L("panic test number %d\n"), i);

		TData data(i, p);

		RThread thread;

		ret = thread.Create(KThreadName, testSetParameterPanics, KDefaultStackSize, KHeapSize, KHeapSize, &data);

		test(KErrNone == ret);

		TRequestStatus stat;

		thread.Logon(stat);

		thread.Resume();

		User::WaitForRequest(stat);

		test.Printf(_L("exit type is %d, stat is %d"), thread.ExitType(), stat.Int());

		test (thread.ExitType() == EExitPanic);

		switch (i)

			{

			case 0:

			test (thread.ExitReason() == EPlatformSecurityTrap);

			break;

			case 1:

			case 2:

			test (thread.ExitReason() == EParameterSlotRange);

			break;

			case 3:

			case 5:

			test (thread.ExitReason() == EParameterSlotInUse);

			break;

			case 4:

			test (thread.ExitReason() == ECausedException);

			break;

			}

		CLOSE_AND_WAIT(thread);

		}

	p.Kill(0);	

	CLOSE_AND_WAIT(p);

	test.Next(_L("launch panicing process"));

	Handles h;	

	TRequestStatus stat;

	for (i = 0; i < 1; i++)

		{

		h.Command(i);

		ret = p.Create(KProcName, KNullDesC);

		test(ret == KErrNone);

		p.Logon(stat);

		h.SetupParameters(p);

		p.Resume();

		User::WaitForRequest(stat);

		test(p.ExitType()==EExitPanic);

		test(p.ExitReason()==EParameterSlotRange);

		CLOSE_AND_WAIT(p);

		}

	User::SetJustInTime(jit);

	test.Next(_L("test 16 bit descriptor"));

	h.Command(8);

	ret = p.Create(KProcName, KNullDesC);

	test(ret == KErrNone);

	p.Logon(stat);

	h.SetupParameters(p);

	p.SetParameter(15, _L("16 bit text"));

	p.Resume();

	User::WaitForRequest(stat);

	test(p.ExitType()==EExitKill);

	test(p.ExitReason()==KErrNone);

	CLOSE_AND_WAIT(p);

	test.Next(_L("test 8 bit descriptor"));

	h.Command(9);

	ret = p.Create(KProcName, KNullDesC);

	test(ret == KErrNone);

	p.Logon(stat);

	h.SetupParameters(p);

	p.SetParameter(15, _L8("8 bit text"));

	p.Resume();

	User::WaitForRequest(stat);

	test(p.ExitType()==EExitKill);

	test(p.ExitReason()==KErrNone);

	CLOSE_AND_WAIT(p);

	test.Next(_L("test bad read of descriptor"));

	h.Command(10);

	ret = p.Create(KProcName, KNullDesC);

	test(ret == KErrNone);

	p.Logon(stat);

	h.SetupParameters(p);

	p.SetParameter(15, _L8("aa"));

	p.Resume();

	User::WaitForRequest(stat);

	test(p.ExitType()==EExitPanic);

	test(p.ExitReason()==ECausedException);

	CLOSE_AND_WAIT(p);

	test.Next(_L("test zero length data"));

	h.Command(11);

	ret = p.Create(KProcName, KNullDesC);

	test(ret == KErrNone);

	p.Logon(stat);

	h.SetupParameters(p);

	p.SetParameter(15, KNullDesC);

	p.Resume();

	User::WaitForRequest(stat);

	test(p.ExitType()==EExitKill);

	test(p.ExitReason()==KErrNone);

	CLOSE_AND_WAIT(p);

	test.Next(_L("test reserved command line"));

	h.Command(12);

	ret = p.Create(KProcName, KNullDesC);

	test(ret == KErrNone);

	p.Logon(stat);

	h.SetupParameters(p);

	p.Resume();

	User::WaitForRequest(stat);

	test(p.ExitType()==EExitKill);

	test(p.ExitReason()==KErrNone);

	CLOSE_AND_WAIT(p);

	test.Next(_L("test mutex"));

	h.Command(4);

	ret = p.Create(KProcName, KNullDesC);

	test(ret == KErrNone);

	p.Logon(stat);

	h.SetupParameters(p);

	p.Resume();

	User::WaitForRequest(stat);

	test(p.ExitType()==EExitKill);

	test(p.ExitReason()==KErrNone);

	CLOSE_AND_WAIT(p);

	test.Next(_L("test semaphore"));

	h.Command(5);

	ret = p.Create(KProcName, KNullDesC);

	test(ret == KErrNone);

	p.Logon(stat);

	h.SetupParameters(p);

	p.Resume();

	User::WaitForRequest(stat);

	test(p.ExitType()==EExitKill);

	test(p.ExitReason()==KErrNone);

	CLOSE_AND_WAIT(p);

	test.Next(_L("test file handle"));

	h.Command(6);

	ret = p.Create(KProcName, KNullDesC);

	test(ret == KErrNone);

	p.Logon(stat);

	h.SetupParameters(p);

	p.Resume();

	User::WaitForRequest(stat);

	test(p.ExitType()==EExitKill);

	test(p.ExitReason()==KErrNone);

	CLOSE_AND_WAIT(p);

	test.Next(_L("test chunk"));

	h.Command(7);

	ret = p.Create(KProcName, KNullDesC);

	test(ret == KErrNone);

	p.Logon(stat);

	h.SetupParameters(p);

	p.Resume();

	User::WaitForRequest(stat);

	test(p.ExitType()==EExitKill);

	test(p.ExitReason()==KErrNone);

	CLOSE_AND_WAIT(p);

	test.End();

	return 0;

    }