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

 	}