// 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 <bautils.h>

#include <e32math.h>

#include <sqldb.h>

#include "SqlUtil.h"

///////////////////////////////////////////////////////////////////////////////////////

static RFs TheFs;

RTest TheTest(_L("t_sqlbadclient test"));

_LIT(KTestDir, "c:\\test\\");

_LIT(KTestDbName1, "c:\\test\\t_sqlbadclient.db");

_LIT(KTestDbName2, "c:[1111D1C1]t_sqlbadclient.db");

#if defined __WINS__ || defined __WINSCW__

const TInt KTestIterCount = 5000;

#else

const TInt KTestIterCount = 4000;

#endif

const TInt KMaxDesArgLen = 1000;

enum TArgType 

	{

	EIntArgType, 

	ETextArgType, 

	EBinArgType, 

	ELastArgType

	};

//////////////////////////////////////////////////////////////////////////////////////

//If the SQL server crashes and the test receives KErrServerTerminated error, then the 

//next set will contain the last:

// - iteration number;

// - handle type;

// - function code;

// - handle;

// - IPC arguments values;

struct TThreadData

	{

	TInt				iIteration;

	TSqlSrvHandleType 	iHandleType;

	TInt 				iFunction;

	TInt 				iHandle;

	TArgType 			iArgType[KMaxMessageArguments];

	TInt 				iIntArg[KMaxMessageArguments];

	TBuf<KMaxDesArgLen> iTextArg[KMaxMessageArguments];

	TBuf8<KMaxDesArgLen> iBinArg[KMaxMessageArguments];

	TInt64 				iSeed;

	};

//////////////////////////////////////////////////////////////////////////////////////

_LIT(KPanicCategory, "SrvTerm");

_LIT(KPanicCategory2, "InvArg");

const TInt KPanicCode = 1111;

const TInt KPanicCode2 = 2222;

///////////////////////////////////////////////////////////////////////////////////////

//Deletes all created test files.

void DeleteTestFiles()

	{

	RSqlDatabase::Delete(KTestDbName1);

	}

///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

//Test macros and functions

void Check1(TInt aValue, TInt aLine, TBool aPrintThreadName = EFalse)

	{

	if(!aValue)

		{

		DeleteTestFiles();

		if(aPrintThreadName)

			{

			RThread th;

			TName name = th.Name();

			RDebug::Print(_L("*** Thread %S, Line %d\r\n"), &name, aLine);

			}

		else

			{

			RDebug::Print(_L("*** Line %d\r\n"), aLine);

			}

		TheTest(EFalse, aLine);

		}

	}

void Check2(TInt aValue, TInt aExpected, TInt aLine, TBool aPrintThreadName = EFalse)

	{

	if(aValue != aExpected)

		{

		DeleteTestFiles();

		if(aPrintThreadName)

			{

			RThread th;

			TName name = th.Name();

			RDebug::Print(_L("*** Thread %S, Line %d Expected error: %d, got: %d\r\n"), &name, aLine, aExpected, aValue);

			}

		else

			{

			RDebug::Print(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);

			}

		TheTest(EFalse, aLine);

		}

	}

#define TEST(arg) ::Check1((arg), __LINE__)

#define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)

#define TTEST(arg) ::Check1((arg), __LINE__, ETrue)

#define TTEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__, ETrue)

///////////////////////////////////////////////////////////////////////////////////////

//Creates file session instance and the test directory

void CreateTestEnv()

    {

	TInt err = TheFs.Connect();

	TEST2(err, KErrNone);

	err = TheFs.MkDir(KTestDir);

	TEST(err == KErrNone || err == KErrAlreadyExists);

	}

//Starts the SQL server process.

TInt StartSqlServer()

	{

	const TUid KSqlSrvUid3 = {0x10281E17};//The same UID is in SqlSrv.mmp file

	const TUidType serverUid(KNullUid, KNullUid, KSqlSrvUid3);

	_LIT(KSqlSrvImg, "SqlSrv");//SQL server image name

	RProcess server;

	TInt err = server.Create(KSqlSrvImg, KNullDesC, serverUid);

	if(err != KErrNone)

		{

		return err;

		}

	TRequestStatus stat;

	server.Rendezvous(stat);

	if(stat != KRequestPending)

		{

		server.Kill(0);		// abort startup

		}

	else

		{

		server.Resume();	// logon OK - start the server

		}

	User::WaitForRequest(stat);		// wait for start or death

	// we can't use the 'exit reason' if the server panicked as this

	// is the panic 'reason' and may be '0' which cannot be distinguished

	// from KErrNone

	err = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int();

	server.Close();

	return err;

	}

//////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////        RTestSqlDbSession          //////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////

//Test client SQL session class

class RTestSqlDbSession : public RSessionBase

	{

public:	

	void Close();

	TInt SendReceive(TInt aFunction);

	TInt SendReceive(TInt aFunction, const TIpcArgs& aArgs);

private:

	};

	{

	if(err == KErrNone)

		{

		TIpcArgs ipcArgs(KTestDbName1().Length(), &KTestDbName1(), 0, 0);

		err = SendReceive(ESqlSrvDbOpen, ipcArgs);

		}

	if(err != KErrNone && err != KErrAlreadyExists)

		{

		Close();	

		}

	return err;

	}

void RTestSqlDbSession::Close()

	{

	if(Handle())

		{

		(void)SendReceive(ESqlSrvDbClose);

		}

	RSessionBase::Close();

	}

TInt RTestSqlDbSession::SendReceive(TInt aFunction)

	{

	return RSessionBase::SendReceive(aFunction);	

	}

TInt RTestSqlDbSession::SendReceive(TInt aFunction, const TIpcArgs& aArgs)

	{

	return RSessionBase::SendReceive(aFunction, aArgs);	

	}

	{

	const TInt KTimesToRetryConnection = 2;

	TInt retry = KTimesToRetryConnection;

	_LIT(KSqlSrvName, "!SQL Server");//SqlDb server name

	for(;;)

		{

		if(err != KErrNotFound && err != KErrServerTerminated)

			{

			return err;

			}

		if(--retry == 0)

			{

			return err;

			}

		err = ::StartSqlServer();

		if(err != KErrNone && err != KErrAlreadyExists)

			{

			return err;

			}

		}

	}

//////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////

TInt SendReceive(RTestSqlDbSession aSession, TSqlSrvHandleType aHandleType, TInt aFunction, TInt aHandle, TIpcArgs& aArgs)

	{

	return aSession.SendReceive(::MakeMsgCode(static_cast <TSqlSrvFunction> (aFunction), aHandleType, aHandle), aArgs);

	}

TInt SendReceive(RTestSqlDbSession aSession, TInt aFunction, TIpcArgs& aArgs)

	{

	return aSession.SendReceive(aFunction, aArgs);

	}

void PrintIterationCount(TInt aIteration)

	{

	if((aIteration % 100) == 0)

		{

		TTime time;

		time.HomeTime();

		TDateTime dt = time.DateTime();

		TBuf<16> tbuf;

		tbuf.Format(_L("%02d:%02d:%02d.%06d"), dt.Hour(), dt.Minute(), dt.Second(), dt.MicroSecond());

		RDebug::Print(_L("-----[%S] Test iterations: %d\r\n"), &tbuf, aIteration);

		}

	}

//Worker thread function.

//It behaves as a malicious client. Connects to the SQL server. In each test iteration generates some random values

//for the function number, handle, handle type, IPC arguments. Then sends a command to the server using these

//randomly generated values. If the server crashes and the thread function receives KErrServerTerminated error,

//then the thread kills itself and the main thread will get KPanicCategory and KPanicCode as a reason for the

//worker thread's death. The last set of randomly generated values will be stored in the memory, pointed by aData argument.

TInt ThreadFunc1(void* aData)

	{

	__UHEAP_MARK;

	CTrapCleanup* tc = CTrapCleanup::New();

	TTEST(tc != NULL);

	TThreadData* p = static_cast <TThreadData*> (aData);

	TTEST(p != NULL);

	TThreadData& data = *p;

	RTestSqlDbSession sess;

	TTEST2(err, KErrNone);

	while(++data.iIteration <= KTestIterCount)

		{

		PrintIterationCount(data.iIteration);

		TIpcArgs args;

		do

			{

			data.iFunction = Math::Rand(data.iSeed) % (ESqlSrvStreamClose + 1);//ESqlSrvStreamClose - the last server message number)

			}

		while(data.iFunction >= ESqlSrvResourceMark && data.iFunction <= ESqlSrvSetHeapFailure);

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

			{

			//Initialize arguments

			data.iArgType[i] = static_cast <TArgType> (Math::Rand(data.iSeed) % ELastArgType);

			switch(data.iArgType[i])

				{

				case EIntArgType:

					data.iIntArg[i] = Math::Rand(data.iSeed) % 9711;

					args.Set(i, data.iIntArg[i]);

					break;

				case ETextArgType:

					{

					TInt len = Math::Rand(data.iSeed) % KMaxDesArgLen;	

					data.iTextArg[i].SetLength(len);

					args.Set(i, &data.iTextArg[i]);

					}

					break;

				case EBinArgType:

					{

					TInt len = Math::Rand(data.iSeed) % KMaxDesArgLen;	

					data.iBinArg[i].SetLength(len);

					args.Set(i, &data.iBinArg[i]);

					}

					break;

				default:

					User::Panic(KPanicCategory2, KPanicCode2);

					break;

				}

			}

		//Send arguments

		User::SetJustInTime(EFalse);

		TInt err = KErrNone;

		if((Math::Rand(data.iSeed) % 5) == 0)	//Pass a handle (statement or stream)

			{

			data.iHandleType = (Math::Rand(data.iSeed) % 2) ? ESqlSrvStatementHandle : ESqlSrvStreamHandle;

			data.iHandle = Math::Rand(data.iSeed) % 64;

			err = ::SendReceive(sess, data.iHandleType, data.iFunction, data.iHandle, args);

			}

		else

			{

			err = ::SendReceive(sess, data.iFunction, args);

			}

		if(err == KErrServerTerminated)

			{

			User::Panic(KPanicCategory, KPanicCode);

			}

		User::SetJustInTime(ETrue);

		}

	sess.Close();

	delete tc;	

	__UHEAP_MARKEND;

	return KErrNone;		

	}

/**

@SYMTestCaseID			SYSLIB-SQL-CT-1769

@SYMTestCaseDesc		In a loop, where the loop iterations are less than KTestIterCount (5000 at the moment), 

						the test creates a public shared database and a worker thread, which will behave as 

						malicious client. If the worker thread crashes the SQL server, then the worker thread

						dies notifying the main thread about the SQL server crash. The main thread prints the 

						values used in the last IPC call and crashes the test.

@SYMTestPriority		High

@SYMTestActions			SQL, Malicious client simulation test.

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ5792

                        REQ5793

						REQ10405

						REQ10407

*/	

void BadClientTest()

	{

	TThreadData* p = new TThreadData;

	TEST(p != NULL);

	TThreadData& data = *p;

	data.iFunction = 0;

	TTime now;

	now.UniversalTime();

	data.iSeed = now.Int64();

	_LIT(KThreadName, "WorkThrd");

	for(data.iIteration=0;data.iIteration<KTestIterCount;++data.iIteration)

		{

		PrintIterationCount(data.iIteration);

		//Create/open the test database

		RSqlDatabase db;

		TInt err = db.Create(KTestDbName1);

		TEST(err == KErrNone || err == KErrAlreadyExists);

		if(err == KErrNone)

			{

			err = db.Exec(_L8("CREATE TABLE A(Id INTEGER); INSERT INTO A(Id) VALUES(1); INSERT INTO A(Id) VALUES(2);"));	

			TEST(err >= 0);

			}

		db.Close();

		//Run the malicious client (one worker theread which will try to crash the SQL server)

		RThread thread;

		TEST2(thread.Create(KThreadName, &ThreadFunc1, 0x2000, 0x1000, 0x10000, &data, EOwnerProcess), KErrNone);

		TRequestStatus status;

		thread.Logon(status);

		TEST2(status.Int(), KRequestPending);

		thread.Resume();

		User::WaitForRequest(status);

		User::SetJustInTime(ETrue);	// enable debugger panic handling

		if(thread.ExitType() == EExitPanic)

			{

			if(thread.ExitReason() == KPanicCode)

				{

				TheTest.Printf(_L("##Server terminated!\r\n"));

				TheTest.Printf(_L("##Iteration=%d, Handle type(hex)=%X, Function(hex)=%X, Handle=%d\r\n"), data.iIteration, data.iHandleType, data.iFunction, data.iHandle);

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

					{

					switch(data.iArgType[i])

						{

						case EIntArgType:

							TheTest.Printf(_L("##Arg %d, Integer, value=%d\r\n"), i, data.iIntArg[i]);

							break;

						case ETextArgType:

							TheTest.Printf(_L("##Arg %d, Text,    length=%d\r\n"), i, data.iTextArg[i].Length());

							break;

						case EBinArgType:

							TheTest.Printf(_L("##Arg %d, Binary,  length=%d\r\n"), i, data.iBinArg[i].Length());

							break;

						default:

							TheTest.Printf(_L("##Arg %d, Invalid argument type: %d\r\n"), i, data.iArgType[i]);

							break;

						}

					}

				TEST(0);

				}

			}

		thread.Close();

		}

	User::SetJustInTime(ETrue);	// enable debugger panic handling

	delete p;

	}

RSqlSecurityPolicy CreateSecurityPolicy()

	{

	RSqlSecurityPolicy securityPolicy;

	const TSecurityPolicy KDefaultPolicy(TSecurityPolicy::EAlwaysPass);

	TInt err = securityPolicy.Create(KDefaultPolicy);

	TEST2(err, KErrNone);

	return securityPolicy;

	}

void DoBadNameTest(RSqlDatabase& aDb)

	{

	TFileName invalidFileName1;

	invalidFileName1.SetLength(KMaxFileName);

	//Initialise the first character so that it is not treated as an empty descriptor by the sever

	invalidFileName1[0] = TChar(204); //0xCC

	TFileName invalidFileName2;

	invalidFileName2.SetLength(KMaxFileName);

	invalidFileName2.Fill(TChar(204));//0xCC

	TInt err = aDb.Attach(invalidFileName1, invalidFileName2);

	TheTest.Printf(_L("Attach, invalid database name-1, err=%d\r\n"), err);

	TEST(err != KErrNone);

	err = aDb.Attach(invalidFileName2, invalidFileName1);

	TheTest.Printf(_L("Attach, invalid database name-2, err=%d\r\n"), err);

	TEST(err != KErrNone);

	err = aDb.Attach(KTestDbName2, invalidFileName2);

	TheTest.Printf(_L("Attach, invalid database name-3, err=%d\r\n"), err);

	TEST(err != KErrDied);

	if(err == KErrNone)

		{

		err = aDb.Detach(invalidFileName2);

		TheTest.Printf(_L("Detach, invalid database name-3, err=%d\r\n"), err);

		TEST2(err, KErrNone);

		}

	err = aDb.Attach(KTestDbName2, invalidFileName1);

	TheTest.Printf(_L("Attach, invalid database name-4, err=%d\r\n"), err);

	TEST(err != KErrDied);

	if(err == KErrNone)

		{

		err = aDb.Detach(invalidFileName1);

		TheTest.Printf(_L("Detach, invalid database name-4, err=%d\r\n"), err);

		TEST2(err, KErrNone);

		}

	RSqlDatabase::TSize size;

	err = aDb.Size(size, invalidFileName1);

	TheTest.Printf(_L("Size, invalid database name-1, err=%d\r\n"), err);

	TEST(err != KErrNone);

	err = aDb.Size(size, invalidFileName2);

	TheTest.Printf(_L("Size, invalid database name-2, err=%d\r\n"), err);

	TEST(err != KErrNone);

	err = aDb.Compact(RSqlDatabase::EMaxCompaction, invalidFileName1);

	TheTest.Printf(_L("Compact, invalid database name-1, err=%d\r\n"), err);

	TEST(err != KErrNone);

	err = aDb.Compact(RSqlDatabase::EMaxCompaction, invalidFileName2);

	TheTest.Printf(_L("Compact, invalid database name-2, err=%d\r\n"), err);

	TEST(err != KErrNone);

	RSqlStatement stmt;

	err = stmt.Prepare(aDb, _L("SELECT * FROM A"));

	TEST2(err, KErrNone);

	err = stmt.ColumnIndex(invalidFileName1);

	TheTest.Printf(_L("ColumnIndex, invalid column name-1, err=%d\r\n"), err);

	TEST(err != KErrNone);

	err = stmt.ColumnIndex(invalidFileName2);

	TheTest.Printf(_L("ColumnIndex, invalid column name-2, err=%d\r\n"), err);

	TEST(err != KErrNone);

	err = stmt.ParameterIndex(invalidFileName1);

	TheTest.Printf(_L("ParameterIndex, invalid parameter name-1, err=%d\r\n"), err);

	TEST(err != KErrNone);

	err = stmt.ParameterIndex(invalidFileName2);

	TheTest.Printf(_L("ParameterIndex, invalid parameter name-2, err=%d\r\n"), err);

	TEST(err != KErrNone);

	stmt.Close();

	}

/**

@SYMTestCaseID			SYSLIB-SQL-UT-4048

@SYMTestCaseDesc		Bad database names - robustness test.

						The test defines file names with invalid content and attempts to use 

						these file names with the SQL API. The test should not cause crashes 

						in the SQL server.

@SYMTestPriority		High