// Copyright (c) 2008-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 <e32test.h>

#include <e32math.h>

#include <e32debug.h>

#include "backup_std.h"

LOCAL_D RTest				TheTest (_L("T_BackupServerIPC"));

LOCAL_D CActiveScheduler*	TheScheduler;

_LIT(KServerLauncherProcess, "T_BackupServerLauncher");

_LIT(KServerStartProcess, "baksrvs");

_LIT(KServerName, "!BackupServer");

struct TTestInfo

	{

	TInt iFunction;

	TInt iType;

	TInt iArgCount;

	};

struct TExitDetails

	{

	TExitCategoryName iCategory;

	TExitType iExitType;

	TInt iReason;

	};

const TInt KAsynchDelay = 500000;

//===============================================================================

TBool IsFunctionAsynchronous(TInt aFunc)

	{

	TBool asynch = EFalse;

	switch(aFunc)

		{

		case EBakOpCodeEventReady:

		case EBakOpCodeCloseAllFiles:

		case EBakOpCodeCloseServer:

		case EBakOpCodeBackupOperationEventReady:

			asynch = ETrue;

			break;

		default:

			break;

		}

	return asynch;

	}

class RIpcFuzzTest : public RSessionBase

{

public: // Constructors and destructor

	/**

		* Constructor for performing 1st stage construction

		*/

	RIpcFuzzTest();

	/**

		* Destructor.

		*/

	~RIpcFuzzTest();

	/**

		* Performs test steps

		*/

	void RunTestL(const TDesC& aTargetSrvName, TInt aFunc,

				TInt aTestType, TInt aArgCount);

private:

	TInt Fuzz(TInt aMsg, TInt aArgCount);

	TInt FuzzL(TInt aMsg, TInt aArgCount);

	TInt Fuzz8L(TInt aMsg, TInt aArgCount);

};

RIpcFuzzTest::RIpcFuzzTest()

	{

	// No implementation required

	}

RIpcFuzzTest::~RIpcFuzzTest()

	{

	Close();

	}

TInt RIpcFuzzTest::Fuzz(TInt aMsg, TInt aArgCount)

	{

	TIpcArgs args;

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

		{

		args.Set(i,Math::Random());

		}

	TInt ret;

	if(IsFunctionAsynchronous(aMsg))

		{

		ret = Send(aMsg, args);

		User::After(KAsynchDelay);

		}

	else

		{

		ret = SendReceive(aMsg, args);

		}

	return ret;

	}

TInt RIpcFuzzTest::Fuzz8L(TInt aMsg, TInt aArgCount)

	{

	HBufC8* buf = HBufC8::NewLC(255);

	TPtr8 ptr = buf->Des();

	ptr.Fill(Math::Random(),255);

	TIpcArgs args;

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

		{

		args.Set(i,&ptr);

		}

	TInt ret;

	if(IsFunctionAsynchronous(aMsg))

		{

		ret = Send(aMsg, args);

		User::After(KAsynchDelay);

		}

	else

		{

		ret = SendReceive(aMsg, args);

		}

	CleanupStack::PopAndDestroy(buf);

	return ret;

	}

TInt RIpcFuzzTest::FuzzL(TInt aMsg, TInt aArgCount)

	{

	HBufC* buf = HBufC::NewLC(255);

	TPtr ptr = buf->Des();

	ptr.Fill(Math::Random(),255);

	TIpcArgs args;

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

		{

		args.Set(i,&ptr);

		}

	TInt ret;

	if(IsFunctionAsynchronous(aMsg))

		{

		ret = Send(aMsg, args);

		User::After(KAsynchDelay);

		}

	else

		{

		ret = SendReceive(aMsg, args);

		}

	CleanupStack::PopAndDestroy(buf);

	return ret;

	}

void RIpcFuzzTest::RunTestL(const TDesC& aTargetSrvName,

							TInt aFunc, TInt aTestType, TInt aArgCount)

	{

		TVersion version(0,0,0);

		User::LeaveIfError(CreateSession(aTargetSrvName, version, 200));

		switch(aTestType)

			{

			case 0:

				Fuzz(aFunc,aArgCount);

				break;

			case 1:

				Fuzz8L(aFunc,aArgCount);

				break;

			case 2:

				FuzzL(aFunc,aArgCount);

				break;

			}

	}

TInt KillProcess(const TDesC& aProcessName)

	{

	TFullName name;

	RDebug::Print(_L("Find and kill \"%S\" process.\n"), &aProcessName);

	TBuf<64> pattern(aProcessName);

	TInt length = pattern.Length();

	pattern += _L("*");

	TFindProcess procFinder(pattern);

	while (procFinder.Next(name) == KErrNone)

		{

		if (name.Length() > length)

			{//If found name is a string containing aProcessName string.

			TChar c(name[length]);

			if (c.IsAlphaDigit() ||

				c == TChar('_') ||

				c == TChar('-'))

				{

				// If the found name is other valid application name

				// starting with aProcessName string.

				RDebug::Print(_L(":: Process name: \"%S\".\n"), &name);

				continue;

				}

			}

		RProcess proc;

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

			{

			proc.Kill(0);

			RDebug::Print(_L("\"%S\" process killed.\n"), &name);

			}

		proc.Close();

		}

	return KErrNone;

	}

TInt FuzzServerL(TAny* aTestInfo)

	{

   	CTrapCleanup* cleanup=CTrapCleanup::New();

   	TInt err=KErrNoMemory;

   	if (cleanup)

   		{

		TTestInfo* info = (TTestInfo*)aTestInfo;

		RIpcFuzzTest fuzzer;

		TRAP(err,fuzzer.RunTestL(KServerName,info->iFunction

				,info->iType, info->iArgCount));

		fuzzer.Close();

   		delete cleanup;

   		}

   	return err;

	}

void TestServerApi(TInt aFunctionNumber,

			TInt aTestType,TInt aArgCount, TExitDetails& aExitDetails)

	{

    TTestInfo testInfo;

	testInfo.iFunction = aFunctionNumber;

	testInfo.iType = aTestType;

	testInfo.iArgCount = aArgCount;

    RThread thread;

    _LIT(KThreadName,"FuzzerThread" );

	thread.Create(KThreadName,&FuzzServerL, KDefaultStackSize, NULL,&testInfo);

	TRequestStatus threadStat;

	thread.Logon(threadStat);

	TBool jit = User::JustInTime();

	User::SetJustInTime(EFalse);

	thread.Resume();

	User::WaitForRequest(threadStat);

	User::SetJustInTime(jit);

	aExitDetails.iCategory = thread.ExitCategory();

	aExitDetails.iReason = thread.ExitReason();

	aExitDetails.iExitType = thread.ExitType();

	thread.Close();

	}

TInt LaunchServer(RProcess& aServer)

	{

	TheTest.Printf(_L("Launching BackupServer...\n"));

	TInt err = aServer.Create(KServerLauncherProcess, _L(""));

	 if(err == KErrNone)

		 {

		 //Start server and wait until it is running

		 TRequestStatus serverStat;

		 aServer.SetJustInTime(false);

		 aServer.Resume();

		 aServer.Rendezvous(serverStat);

		 User::WaitForRequest(serverStat);

		 }

	 return err;

	}

void PrintTestMessage(TInt iFunc, TInt iType, TInt iArgCount)

	{

	switch(iType)

		{

		case 0:

			TheTest.Printf(_L("\nFuzz Test on function number %d using random Int data. Number of Args = %d\n"), iFunc, iArgCount);

			break;

		case 1:

			TheTest.Printf(_L("\nFuzz Test on function number %d using random Des8 data. Number of Args = %d\n"), iFunc, iArgCount);

			break;

		case 2:

			TheTest.Printf(_L("\nFuzz Test on function number %d using random Des data. Number of Args = %d\n"), iFunc, iArgCount);

			break;

		}

	}

/**

Invoke the tests

*/

/**

@SYMTestCaseID          SYSLIB-BAFL-CT-4039

@SYMTestCaseDesc	    Tests Bafl Backup Server APIs for IPC Robustness

@SYMTestPriority 	    High

@SYMTestActions  	    The function calls each of the Bafl Backup Server APIs through a

						custom session object passing random TInt, Des8 and Des16 data .

@SYMTestExpectedResults The server should be robust to all malformed messages and should not

						hang or panic.

@SYMDEF                	INC113760

*/

LOCAL_C void DoTestsL ()

    {

    RProcess server;

    const TInt KMinFuncNumber = 20;

    const TInt KMaxFuncNumber = 35;

    TInt err = LaunchServer(server);

    TheTest(err == 0);

    TExitDetails exitDetails;

    for(TInt i = KMinFuncNumber;i<= KMaxFuncNumber;i++)

    	{

    	//Carry out each type of test

    	for(TInt testType = 0; testType < 3;testType++)

    		{

       		//Carry out each test with number of arguments 1 - 4

    		for(TInt argCount = 1;argCount <= 4;argCount++)

    			{

    			PrintTestMessage(i, testType, argCount);

    			TestServerApi(i, testType, argCount, exitDetails);

		    	//Kill the server process and verify that it was still running

		    	//If the server was already dead it would return the reason it exited

	    		if(server.ExitType() != EExitPending)

	    			{

	    			server.Kill(0);

	    			TInt exitReason = server.ExitReason();

	    			server.Close();

	    			TheTest(exitReason == 0);

	    			User::LeaveIfError(LaunchServer(server));

	    			}

    			}

	    	TheTest.Printf(_L("\nFuzz Test Successful\n"));

    		}

    	}

    }

void SetupTestL()

	{

	TheScheduler = new (ELeave) CActiveScheduler;

   	CActiveScheduler::Install (TheScheduler);

	}

GLDEF_C TInt E32Main ()

	{

	TheTest.Printf (_L ("\n"));

	TheTest.Title ();

	TheTest.Start (_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-4039 IPC Fuzz Tests "));

   	CTrapCleanup* cleanup=CTrapCleanup::New();

   	TInt err=KErrNoMemory;

   	if (cleanup)

   		{

   		// Construct and install the active scheduler

   		TRAP(err, SetupTestL());

   		//Kill baksrvs which may have already been launched by another test

   		KillProcess(KServerStartProcess);

   		KillProcess(KServerLauncherProcess);

   		TRAP (err, DoTestsL ());

   		TheTest (err == KErrNone);

   		TheTest.End ();

   		TheTest.Close ();

   		delete TheScheduler;

   		delete cleanup;

   		}

	return err;

	}