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