sl@0: // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include <e32test.h>
sl@0: #include <bautils.h>
sl@0: #include <e32math.h>
sl@0: #include "LogServShared.h"
sl@0: #include "logservcli.h"
sl@0: #include "t_logutil.h"
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: RTest TheTest(_L("t_logbadclient test"));
sl@0: 
sl@0: const TInt KTestIterCount = 5000;
sl@0: const TInt KMaxDesArgLen = 1000;
sl@0: enum TArgType 
sl@0: 	{
sl@0: 	EIntArgType, 
sl@0: 	ETextArgType, 
sl@0: 	EBinArgType, 
sl@0: 	ELastArgType
sl@0: 	};
sl@0: 
sl@0: const TLogServFunction KLogIpcMsgCodes[] = 
sl@0: 	{
sl@0: 	ELogOperationCancel, ELogOperationGetResult, ELogOperationInitiate, ELogNotify, ELogNotifyCancel, ELogViewCreate,
sl@0: 	ELogViewDelete, ELogViewCount, ELogViewOperationInitiate, ELogViewChangeNotificationsRequest,
sl@0: 	ELogViewChangeNotificationsCancel, ELogViewFetchChanges, ELogViewNotifyLockStatusChange, 
sl@0: 	ELogViewNotifyLockStatusChangeCancel, ELogNotifyExtended, ELogNotifyExtendedCancel, ELogNOTUSED   
sl@0: 	};
sl@0: 
sl@0: const TLogOperationType KLogOpTypes[] =
sl@0: 	{
sl@0: 	ELogOperationEventAdd, ELogOperationEventGet, ELogOperationEventChange, ELogOperationEventDelete,
sl@0: 	ELogOperationTypeAdd, ELogOperationTypeGet, ELogOperationTypeChange, ELogOperationTypeDelete,
sl@0: 	ELogOperationClearLog,  ELogOperationClearRecent, ELogOperationConfigGet,  ELogOperationConfigChange,
sl@0: 	ELogOperationMaintain, ELogOperationViewSetup, ELogOperationViewRemoveEvent, ELogOperationViewClearDuplicates,
sl@0: 	ELogOperationViewSetFlags, ELogOperationViewWindowFetch, (TLogOperationType)-100
sl@0: 	};
sl@0: 
sl@0: //////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //If the LogEng server crashes and the test receives KErrServerTerminated error, then the 
sl@0: //next set will contain the last:
sl@0: // - iteration number;
sl@0: // - function code;
sl@0: // - IPC arguments values;
sl@0: struct TThreadData
sl@0: 	{
sl@0: 	TInt				iIteration;
sl@0: 	TInt 				iFunction;
sl@0: 	TArgType 			iArgType[KMaxMessageArguments];
sl@0: 	TInt 				iIntArg[KMaxMessageArguments];
sl@0: 	TBuf<KMaxDesArgLen> iTextArg[KMaxMessageArguments];
sl@0: 	TBuf8<KMaxDesArgLen> iBinArg[KMaxMessageArguments];
sl@0: 	TInt64 				iSeed;
sl@0: 	};
sl@0: //////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: _LIT(KPanicCategory, "SrvTerm");
sl@0: _LIT(KPanicCategory2, "InvArg");
sl@0: const TInt KPanicCode = 1111;
sl@0: const TInt KPanicCode2 = 2222;
sl@0: 
sl@0: static TLogClientServerData TheLogIpcData;
sl@0: static TPtrC8 TheLogIpcDataPtr((const TUint8*)&TheLogIpcData, sizeof(TheLogIpcData));
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: void PrintIterationCount(TInt aIteration)
sl@0: 	{
sl@0: 	if((aIteration % 100) == 0)
sl@0: 		{
sl@0: 		TTime time;
sl@0: 		time.HomeTime();
sl@0: 		TDateTime dt = time.DateTime();
sl@0: 		TBuf<16> tbuf;
sl@0: 		tbuf.Format(_L("%02d:%02d:%02d.%06d"), dt.Hour(), dt.Minute(), dt.Second(), dt.MicroSecond());
sl@0: 		TheTest.Printf(_L("-----[%S] Test iterations: %d\r\n"), &tbuf, aIteration);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //Worker thread function.
sl@0: //It behaves as a malicious client. Connects to the LogEng server. In each test iteration generates some random values
sl@0: //for the function number, handle, handle type, IPC arguments. Then sends a command to the server using these
sl@0: //randomly generated values. If the server crashes and the thread function receives KErrServerTerminated error,
sl@0: //then the thread kills itself and the main thread will get KPanicCategory and KPanicCode as a reason for the
sl@0: //worker thread's death. The last set of randomly generated values will be stored in the memory, pointed by aData argument.
sl@0: TInt ThreadFunc1(void* aData)
sl@0: 	{
sl@0: 	__UHEAP_MARK;
sl@0: 	
sl@0: 	CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 	TTEST(tc != NULL);
sl@0: 
sl@0: 	TThreadData* p = static_cast <TThreadData*> (aData);
sl@0: 	TTEST(p != NULL);
sl@0: 	TThreadData& data = *p;
sl@0: 	
sl@0: 	RLogSession sess;
sl@0: 	TInt err = sess.Connect();
sl@0: 	TTEST2(err, KErrNone);
sl@0: 
sl@0: 	while(++data.iIteration <= KTestIterCount)
sl@0: 		{
sl@0: 		TIpcArgs args;
sl@0: 		const TInt KFnCnt = sizeof(KLogIpcMsgCodes) / sizeof(KLogIpcMsgCodes[0]);
sl@0: 		TInt fnIdx = Math::Rand(data.iSeed) % KFnCnt;
sl@0: 		data.iFunction = KLogIpcMsgCodes[fnIdx];
sl@0: 		PrintIterationCount(data.iIteration);
sl@0: 		for(TInt argIdx=0;argIdx<KMaxMessageArguments;++argIdx)
sl@0: 			{
sl@0: 			//Initialize arguments
sl@0: 			data.iArgType[argIdx] = EBinArgType;
sl@0: 			if(argIdx > 0)
sl@0: 				{
sl@0: 				data.iArgType[argIdx] = static_cast <TArgType> (Math::Rand(data.iSeed) % ELastArgType);
sl@0: 				}
sl@0: 			switch(data.iArgType[argIdx])
sl@0: 				{
sl@0: 				case EIntArgType:
sl@0: 					data.iIntArg[argIdx] = Math::Rand(data.iSeed) % 9711;
sl@0: 					args.Set(argIdx, data.iIntArg[argIdx]);
sl@0: 					break;
sl@0: 				case ETextArgType:
sl@0: 					{
sl@0: 					TInt len = Math::Rand(data.iSeed) % KMaxDesArgLen;	
sl@0: 					data.iTextArg[argIdx].SetLength(len);
sl@0: 					args.Set(argIdx, &data.iTextArg[argIdx]);
sl@0: 					}
sl@0: 					break;
sl@0: 				case EBinArgType:
sl@0: 					{
sl@0: 					if(argIdx == 0)
sl@0: 						{
sl@0: 						//The operations ids are guaranteed to be sequential by logeng.dll implementation.
sl@0: 						TheLogIpcData.iOperationId = data.iIteration;
sl@0: 						//if(Math::Rand(data.iSeed) & 1)
sl@0: 						//	{
sl@0: 						//	TheLogIpcData.iOperationId = 0;
sl@0: 						//	}
sl@0: 						const TInt KTypeCnt = sizeof(KLogOpTypes) / sizeof(KLogOpTypes[0]);
sl@0: 						TInt typeIdx = Math::Rand(data.iSeed) % KTypeCnt;
sl@0: 						TheLogIpcData.iOperationType = KLogOpTypes[typeIdx];
sl@0: 						TheLogIpcData.iDataSlot1 = Math::Rand(data.iSeed);
sl@0: 						TheLogIpcData.iDataSlot2 = Math::Rand(data.iSeed);
sl@0: 						args.Set(argIdx, &TheLogIpcDataPtr);
sl@0: 						}
sl@0: 					else
sl@0: 						{
sl@0: 						TInt len = Math::Rand(data.iSeed) % KMaxDesArgLen;	
sl@0: 						data.iBinArg[argIdx].SetLength(len);
sl@0: 						args.Set(argIdx, &data.iBinArg[argIdx]);
sl@0: 						}
sl@0: 					}
sl@0: 					break;
sl@0: 				default:
sl@0: 					User::Panic(KPanicCategory2, KPanicCode2);
sl@0: 					break;
sl@0: 				}
sl@0: 			}
sl@0: 		//Send arguments
sl@0: 		//RDebug::Print(_L("##data.iFunction=%d\r\n"), data.iFunction);
sl@0: 		TRequestStatus stat;
sl@0: 		sess.Send(data.iFunction, args, stat);
sl@0: 		if(stat.Int() == KErrServerTerminated)
sl@0: 			{
sl@0: 			User::Panic(KPanicCategory, KPanicCode);
sl@0: 			}
sl@0: 		else if(stat.Int() == KRequestPending)
sl@0: 			{
sl@0: 			if(data.iFunction == ELogOperationInitiate)
sl@0: 				{
sl@0: 				//RDebug::Print(_L("##ELogOperationGetResult\r\n"));
sl@0: 				err = sess.Send(ELogOperationGetResult, args);
sl@0: 				if(err == KErrServerTerminated)
sl@0: 					{
sl@0: 					User::Panic(KPanicCategory, KPanicCode);
sl@0: 					}
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				//Give some time to the LogEng server to do something with that async request, then cancel it.
sl@0: 				//Otherwise, on a multi-core hardware, the LogEnd server will end up with a long queue of
sl@0: 				//pending requests, not cleared if the client side thread is panic'd. It will be a complete chaos.
sl@0: 				//RDebug::Print(_L("##data.iFunction=%d, wait and cancel async request\r\n"), data.iFunction);
sl@0: 				User::After(100000);
sl@0: 				TRequestStatus* s = &stat;
sl@0: 				User::RequestComplete(s, KErrCancel);
sl@0: 				}
sl@0: 			//RDebug::Print(_L("##---err=%d\r\n"), err);
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	sess.Close();
sl@0: 
sl@0: 	delete tc;	
sl@0: 	
sl@0: 	__UHEAP_MARKEND;
sl@0: 	
sl@0: 	return KErrNone;		
sl@0: 	}
sl@0: 
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //Thread function to detect a crash in the server.
sl@0: //The server should run for the duration of the test.
sl@0: // return KErrAbort: If failure to start server
sl@0: // return KErrServerTerminated: If server process is terminated 
sl@0: 
sl@0: TInt ServerWatcherFunc(TAny* /*aData*/)
sl@0: 	{
sl@0: 	__UHEAP_MARK;
sl@0: 
sl@0: 	_LIT(KLogEngServerName,"LogServ*");
sl@0: 
sl@0: 	TInt err;
sl@0: 
sl@0: 	// Start the server if not already running
sl@0: 	RLogSession sess;
sl@0: 	err = sess.Connect();
sl@0: 	if (err != KErrNone)
sl@0: 		return KErrAbort;
sl@0: 	sess.Close();
sl@0: 
sl@0: 	TFindProcess findProcess(KLogEngServerName);
sl@0: 	TFullName result;
sl@0: 	if ( findProcess.Next(result) != KErrNone )
sl@0: 		return KErrAbort;
sl@0: 	
sl@0: 	RProcess server;
sl@0: 	if( server.Open(findProcess, EOwnerProcess) != KErrNone)
sl@0: 		return KErrAbort;
sl@0: 
sl@0: 	TRequestStatus status;
sl@0: 	server.Logon(status);	
sl@0:  	User::WaitForRequest(status);
sl@0: 	
sl@0: 	server.Close();
sl@0: 	
sl@0: 	__UHEAP_MARKEND;
sl@0: 
sl@0: 	return KErrServerTerminated;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-LOGENG-UT-4045
sl@0: @SYMTestCaseDesc		In a loop, where the loop iterations are less than KTestIterCount (5000 at the moment), 
sl@0: 						the test creates a worker thread, which will behave as a malicious client. 
sl@0: 						If the worker thread crashes the LogEng server, then the worker thread
sl@0: 						dies notifying the main thread about the LogEng server crash. The main thread prints the 
sl@0: 						values used in the last IPC call and crashes the test.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			LogEng, Malicious client simulation test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ12746
sl@0: */	
sl@0: void BadClientTest()
sl@0: 	{
sl@0: 	// Start a thread to watch the server process
sl@0: 	RThread serverWatcher;
sl@0: 	TInt err = serverWatcher.Create(_L("ServerWatcher"), &ServerWatcherFunc, 0x2000, 0x1000, 0x10000, NULL, EOwnerProcess);
sl@0: 	TRequestStatus serverStatus;
sl@0: 	serverWatcher.Logon(serverStatus);
sl@0: 	serverWatcher.Resume();
sl@0: 
sl@0: 	TThreadData* p = new TThreadData;
sl@0: 	TEST(p != NULL);
sl@0: 	TThreadData& data = *p;
sl@0: 	data.iFunction = 0;
sl@0: 	TTime now;
sl@0: 	now.UniversalTime();
sl@0: 	data.iSeed = now.Int64();
sl@0: 
sl@0: 	for(data.iIteration=0;data.iIteration<KTestIterCount;++data.iIteration)
sl@0: 		{
sl@0: 		PrintIterationCount(data.iIteration);
sl@0: 		
sl@0: 		//Run the malicious client (one test thread which will try to crash the LogEng server)
sl@0: 		User::After(200000);
sl@0: 		_LIT(KTestThreadName, "TLBCThr");
sl@0: 		RThread thread;
sl@0: 		err = thread.Create(KTestThreadName, &ThreadFunc1, 0x2000, 0x1000, 0x10000, &data, EOwnerProcess);
sl@0: 		if(err == KErrAlreadyExists)
sl@0: 			{
sl@0: 			TheTest.Printf(_L("##Iteration %d. Function %d. Thread \"%S\" already exists!\r\n"), data.iIteration, data.iFunction, &KTestThreadName);
sl@0: 			for(TInt i=0;i<KMaxMessageArguments;++i)
sl@0: 				{
sl@0: 				TheTest.Printf(_L("##Arg %d, Type %d\r\n"), i + 1, data.iArgType[i]);
sl@0: 				switch(data.iArgType[i])
sl@0: 					{
sl@0: 					case EIntArgType:
sl@0: 					    TheTest.Printf(_L("Integer, value=%d\r\n"), data.iIntArg[i]);
sl@0: 						break;
sl@0: 					case ETextArgType:
sl@0: 					    TheTest.Printf(_L("Text, length=%d\r\n"), data.iTextArg[i].Length());
sl@0: 						break;
sl@0: 					case EBinArgType:
sl@0: 					    TheTest.Printf(_L("Binary, length=%d\r\n"), data.iBinArg[i].Length());
sl@0: 						break;
sl@0: 					default:
sl@0: 					    TheTest.Printf(_L("Invalid argument type: %d\r\n"), data.iArgType[i]);
sl@0: 						break;
sl@0: 					}
sl@0: 				}
sl@0: 			break;
sl@0: 			}
sl@0: 		TEST2(err, KErrNone);
sl@0: 		User::SetJustInTime(EFalse);		
sl@0: 		TRequestStatus status;
sl@0: 		thread.Logon(status);
sl@0: 		TEST2(status.Int(), KRequestPending);
sl@0: 		thread.Resume();
sl@0: 		User::WaitForRequest(status, serverStatus);
sl@0: 
sl@0: 		// If the Server has crashed then we must fail		
sl@0: 		if (serverStatus != KRequestPending) 
sl@0: 			{
sl@0: 			TheTest.Printf(_L("##Iteration=%d, Function=%d, Status=%d, Server Status=%d\r\n"), data.iIteration, data.iFunction, status.Int(), serverStatus.Int());
sl@0: 			}
sl@0: 
sl@0: 		TExitType exitType = thread.ExitType();
sl@0: 		TInt exitReason = thread.ExitReason();
sl@0: 		thread.Close();
sl@0: 		User::SetJustInTime(ETrue);
sl@0: 		
sl@0: 		if(exitType == EExitPanic || serverStatus != KRequestPending)
sl@0: 			{
sl@0: 			if(exitReason == KPanicCode || serverStatus != KRequestPending)
sl@0: 				{
sl@0: 				TheTest.Printf(_L("##Server terminated!\r\n"));
sl@0: 				TheTest.Printf(_L("##Iteration=%d, Function=%d, iOperationType=%d, iDataSlot1=%d, iDataSlot2=%d\r\n"), 
sl@0: 						data.iIteration, data.iFunction,
sl@0: 						TheLogIpcData.iOperationType,
sl@0: 						TheLogIpcData.iDataSlot1,
sl@0: 						TheLogIpcData.iDataSlot2);
sl@0: 				for(TInt i=0;i<KMaxMessageArguments;++i)
sl@0: 					{
sl@0: 					TheTest.Printf(_L("##Arg %d, Type %d\r\n"), i + 1, data.iArgType[i]);
sl@0: 					switch(data.iArgType[i])
sl@0: 						{
sl@0: 						case EIntArgType:
sl@0: 						    TheTest.Printf(_L("Integer, value=%d\r\n"), data.iIntArg[i]);
sl@0: 							break;
sl@0: 						case ETextArgType:
sl@0: 						    TheTest.Printf(_L("Text, length=%d\r\n"), data.iTextArg[i].Length());
sl@0: 							break;
sl@0: 						case EBinArgType:
sl@0: 						    TheTest.Printf(_L("Binary, length=%d\r\n"), data.iBinArg[i].Length());
sl@0: 							break;
sl@0: 						default:
sl@0: 						    TheTest.Printf(_L("Invalid argument type: %d\r\n"), data.iArgType[i]);
sl@0: 							break;
sl@0: 						}
sl@0: 					}
sl@0: 				TEST(0);
sl@0: 				}
sl@0: 			}
sl@0: 		}//for
sl@0: 	delete p;
sl@0: 
sl@0: 	// Check to see if the server crashed and not detected by client
sl@0: 	TEST(serverStatus.Int() == KRequestPending);
sl@0: 	serverWatcher.Kill(KErrCancel);
sl@0: 	serverWatcher.Close();
sl@0: 		
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-LOGENG-UT-4044
sl@0: @SYMTestCaseDesc		LogEng server startup - file I/O error simulation test.
sl@0: 						The test case shuts down the LogEng server in debug mode.
sl@0: 						Then attempts to connect to the server in a file I/O error simulation
sl@0: 						loop.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			LogEng server startup - file I/O error simulation test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ12746
sl@0: */	
sl@0: void LogEngSrvStartupFileIoErrTest()
sl@0: 	{
sl@0: 	//Shut down the server if it is running
sl@0: 	RLogSession sess;
sl@0: 	TInt err = sess.Connect();
sl@0: 	TEST2(err, KErrNone);
sl@0: 
sl@0: 	err = sess.Send(ELogMakeTransient, TIpcArgs(1));
sl@0: 	TEST2(err, KErrNone);
sl@0: 	sess.Close();
sl@0: 	
sl@0: 	//The shutdown delay is 2 seconds (defined in LogServShutdownTimer.h file). In this csase 5 seconds is more than enough.
sl@0: 	User::After(5000000);
sl@0: 	
sl@0: 	RFs fs;
sl@0: 	err = fs.Connect();
sl@0: 	TEST2(err, KErrNone);
sl@0: 
sl@0: 	TBool finished = EFalse;
sl@0: 	TInt failCount = 0;
sl@0: 
sl@0: 	while(!finished)
sl@0: 		{
sl@0: 		fs.SetErrorCondition(KErrCorrupt, ++failCount);
sl@0: 		TInt err = sess.Connect();
sl@0: 		fs.SetErrorCondition(KErrNone, 0);
sl@0: 		sess.Close();
sl@0: 		if(err == KErrNone)
sl@0: 			{
sl@0: 			finished = ETrue;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			TEST2(err, KErrCorrupt);
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	fs.Close();
sl@0: 	TheTest.Printf(_L("===LogEng Server Startup File I/O error simularion test succeeded at iteration %d\n"), failCount);
sl@0: 	}
sl@0: 
sl@0: void DoTests()
sl@0: 	{
sl@0: 	TheTest.Start(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4045: Bad client test"));
sl@0: 	BadClientTest();
sl@0: #ifdef _DEBUG	
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4044: LogEng Server Startup - File I/O error simulation test"));
sl@0: 	LogEngSrvStartupFileIoErrTest();
sl@0: #endif	
sl@0: 	}
sl@0: 
sl@0: TInt E32Main()
sl@0: 	{
sl@0: 	TheTest.Title();
sl@0: 	
sl@0: 	CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 	
sl@0: 	__UHEAP_MARK;
sl@0: 	
sl@0: 	DoTests();
sl@0: 
sl@0: 	__UHEAP_MARKEND;
sl@0: 	
sl@0: 	TheTest.End();
sl@0: 	TheTest.Close();
sl@0: 	
sl@0: 	delete tc;
sl@0: 
sl@0: 	User::Heap().Check();
sl@0: 	return KErrNone;
sl@0: 	}