sl@0: // Copyright (c) 2009-2010 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 <e32math.h>
sl@0: #include <featmgr.h>
sl@0: #include <featureuids.h>
sl@0: #include "featurepanics.h"
sl@0: #include <featurecontrol.h>
sl@0: #include <featurenotifier.h>
sl@0: #include "../src/inc/featmgrconfiguration.h"
sl@0: #include "../src/inc/featmgrclientserver.h"
sl@0: 
sl@0: using namespace NFeature;
sl@0: 
sl@0: static RTest TheTest(_L("t_fmgrbadclient"));
sl@0: 
sl@0: const TInt KTestIterCount = 5000;
sl@0: 
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 TInt KMaxDesArgLen = 1000;
sl@0: 
sl@0: //If the FeatMgr server crashes and the test receives KErrServerTerminated error, then the 
sl@0: //next set will contain the last:
sl@0: // - iteration number;
sl@0: // - handle type;
sl@0: // - function code;
sl@0: // - handle;
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: _LIT(KPanicCategory, "SrvTerm");
sl@0: _LIT(KPanicCategory2, "InvArg");
sl@0: const TInt KPanicCode = 1111;
sl@0: const TInt KPanicCode2 = 2222;
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //Deletes all created test files.
sl@0: void DestroyTestEnv()
sl@0:     {
sl@0:     }
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: //Test macros and functions
sl@0: void Check1(TInt aValue, TInt aLine, TBool aPrintThreadName = EFalse)
sl@0:     {
sl@0:     if(!aValue)
sl@0:         {
sl@0:         DestroyTestEnv();
sl@0:         if(aPrintThreadName)
sl@0:             {
sl@0:             RThread th;
sl@0:             TName name = th.Name();
sl@0:             RDebug::Print(_L("*** Expression evaluated to false. Thread %S, Line %d\r\n"), &name, aLine);
sl@0:             }
sl@0:         else
sl@0:             {
sl@0:             TheTest.Printf(_L("*** Expression evaluated to false. Line %d\r\n"), aLine);
sl@0:             }
sl@0:         TheTest(EFalse, aLine);
sl@0:         }
sl@0:     }
sl@0: void Check2(TInt aValue, TInt aExpected, TInt aLine, TBool aPrintThreadName = EFalse)
sl@0:     {
sl@0:     if(aValue != aExpected)
sl@0:         {
sl@0:         DestroyTestEnv();
sl@0:         if(aPrintThreadName)
sl@0:             {
sl@0:             RThread th;
sl@0:             TName name = th.Name();
sl@0:             RDebug::Print(_L("*** Thread %S, Line %d Expected error: %d, got: %d\r\n"), &name, aLine, aExpected, aValue);
sl@0:             }
sl@0:         else
sl@0:             {
sl@0:             RDebug::Print(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);
sl@0:             }
sl@0:         TheTest(EFalse, aLine);
sl@0:         }
sl@0:     }
sl@0: #define TEST(arg) ::Check1((arg), __LINE__)
sl@0: #define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)
sl@0: #define TTEST(arg) ::Check1((arg), __LINE__, ETrue)
sl@0: #define TTEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__, ETrue)
sl@0: 
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: static TInt StartFeatMgrServer()
sl@0:     {
sl@0:     RProcess server;
sl@0:     const TUidType serverUid( KNullUid, KServerUid2, KNullUid );
sl@0:     TInt err = server.Create( KServerExeName, // FeatMgrServer.exe
sl@0:                            KNullDesC, // A descriptor containing data passed as 
sl@0:                                       // an argument to the thread function of 
sl@0:                                       // the new process's main thread, when it 
sl@0:                                       // is first scheduled.
sl@0:                            serverUid, // FeatMgr server UID
sl@0:                            EOwnerProcess ); // Ownership of this process handle 
sl@0: 
sl@0:     // Return error code if we couldn't create a process
sl@0:     if ( err == KErrNone )
sl@0:         {
sl@0:         // Rendezvous is used to detect server start
sl@0:         TRequestStatus stat;
sl@0:         server.Rendezvous( stat );
sl@0: 
sl@0:         if ( stat != KRequestPending )
sl@0:             {
sl@0:             server.Kill( KErrNone ); // Abort startup
sl@0:             }
sl@0:         else
sl@0:             {
sl@0:             server.Resume();  // Logon OK - start the server
sl@0:             }
sl@0: 
sl@0:         User::WaitForRequest( stat ); // Wait for start or death
sl@0: 
sl@0:         // We can't use the 'exit reason' if the server paniced as this
sl@0:         // is the panic 'reason' and may be '0' which cannot be distinguished
sl@0:         // from KErrNone
sl@0:         err = (server.ExitType() == EExitPanic)? KErrGeneral : stat.Int();
sl@0: 
sl@0:         // We can close the handle now
sl@0:         server.Close();        
sl@0:         }
sl@0: 
sl@0:     return err;
sl@0:     }
sl@0: 
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: /////////////////////////////        RTestFeatMgrSession          ////////////////////////////////
sl@0: //////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: class RTestFeatMgrSession : public RSessionBase
sl@0:     {
sl@0: public: 
sl@0:     TInt Connect();
sl@0:     void Close();
sl@0:     TInt SendReceive(TInt aFunction);
sl@0:     TInt SendReceive(TInt aFunction, const TIpcArgs& aArgs);
sl@0:     void SendReceive(TInt aFunction, const TIpcArgs& aArgs, TRequestStatus& aStatus);
sl@0: 
sl@0: private:
sl@0:     TInt DoCreateSession();
sl@0:     };
sl@0:     
sl@0: TInt RTestFeatMgrSession::Connect()
sl@0:     {
sl@0:     TInt err = DoCreateSession();
sl@0:     if(err != KErrNone && err != KErrAlreadyExists)
sl@0:         {
sl@0:         Close();
sl@0:         }
sl@0:     return err;
sl@0:     }
sl@0: 
sl@0: void RTestFeatMgrSession::Close()
sl@0:     {
sl@0:     RSessionBase::Close();
sl@0:     }
sl@0: 
sl@0: TInt RTestFeatMgrSession::SendReceive(TInt aFunction)
sl@0:     {
sl@0:     return RSessionBase::SendReceive(aFunction);    
sl@0:     }
sl@0:     
sl@0: TInt RTestFeatMgrSession::SendReceive(TInt aFunction, const TIpcArgs& aArgs)
sl@0:     {
sl@0:     return RSessionBase::SendReceive(aFunction, aArgs); 
sl@0:     }
sl@0: 
sl@0: void RTestFeatMgrSession::SendReceive(TInt aFunction, const TIpcArgs& aArgs, TRequestStatus& aStatus)
sl@0:     {
sl@0:     RSessionBase::SendReceive(aFunction, aArgs, aStatus); 
sl@0:     }
sl@0: 
sl@0: TInt RTestFeatMgrSession::DoCreateSession()
sl@0:     {
sl@0:     const TInt KRetry( 2 );
sl@0:     // Try this twice
sl@0:     TInt retry( KRetry );
sl@0:     TInt err( KErrNone );
sl@0: 
sl@0:     while ( retry > 0 )
sl@0:         {
sl@0:         // Try to create a FeatMgr Server session
sl@0:         err = CreateSession(KServerProcessName, 
sl@0:                             TVersion(KServerVersionMajor, KServerVersionMinor, KServerVersionBuild), 
sl@0:                             KDefaultAsyncSlots);
sl@0: 
sl@0:         if ( err != KErrNotFound && err != KErrServerTerminated )
sl@0:             {
sl@0:             // KErrNone or unrecoverable error
sl@0:             retry = 0;
sl@0:             }
sl@0:         else
sl@0:             {
sl@0:             // Return code was KErrNotFound or KErrServerTerminated.
sl@0:             // Try to start a new FeatMgr Server
sl@0:             err = StartFeatMgrServer();
sl@0: 
sl@0:             if ( err != KErrNone && err != KErrAlreadyExists )
sl@0:                 {
sl@0:                 // Unrecoverable error
sl@0:                 retry = 0;
sl@0:                 }
sl@0:             }
sl@0:             
sl@0:         retry--;
sl@0:         }
sl@0:             
sl@0:     return err;
sl@0:     }
sl@0:     
sl@0: void PrintIterationCount(TInt aIteration, TBool aFromThread = EFalse)
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:         if(aFromThread)
sl@0:             {
sl@0:             RDebug::Print(_L("-----[%S] Test iterations: %d\r\n"), &tbuf, aIteration);
sl@0:             }
sl@0:         else
sl@0:             {
sl@0:             TheTest.Printf(_L("-----[%S] Test iterations: %d\r\n"), &tbuf, aIteration);
sl@0:             }
sl@0:         }
sl@0:     }
sl@0: 
sl@0: //Worker thread function.
sl@0: //It behaves as a malicious client. Connects to the FeatMgr server. In each test iteration generates some random values
sl@0: //for the function number, handle, 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:     RTestFeatMgrSession sess;
sl@0:     TInt err = sess.Connect();
sl@0:     TTEST2(err, KErrNone);
sl@0: 
sl@0:     while(++data.iIteration <= KTestIterCount)
sl@0:         {
sl@0:         PrintIterationCount(data.iIteration, ETrue);
sl@0:         TIpcArgs args;
sl@0:         data.iFunction = Math::Rand(data.iSeed) % (EFeatMgrSWIEnd + 1);//EFeatMgrSWIEnd - the last server message number (without resource checking IPCs))
sl@0:         for(TInt i=0;i<KMaxMessageArguments;++i)
sl@0:             {
sl@0:             //Initialize arguments
sl@0:             data.iArgType[i] = static_cast <TArgType> (Math::Rand(data.iSeed) % ELastArgType);
sl@0:             switch(data.iArgType[i])
sl@0:                 {
sl@0:                 case EIntArgType:
sl@0:                     data.iIntArg[i] = Math::Rand(data.iSeed) % 9711;
sl@0:                     args.Set(i, data.iIntArg[i]);
sl@0:                     break;
sl@0:                 case ETextArgType:
sl@0:                     {
sl@0:                     TInt len = Math::Rand(data.iSeed) % KMaxDesArgLen;  
sl@0:                     data.iTextArg[i].SetLength(len);
sl@0:                     args.Set(i, &data.iTextArg[i]);
sl@0:                     }
sl@0:                     break;
sl@0:                 case EBinArgType:
sl@0:                     {
sl@0:                     TInt len = Math::Rand(data.iSeed) % KMaxDesArgLen;  
sl@0:                     data.iBinArg[i].SetLength(len);
sl@0:                     args.Set(i, &data.iBinArg[i]);
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:         User::SetJustInTime(EFalse);
sl@0:         TInt err = KErrNone;
sl@0:         if(data.iFunction == EFeatMgrReqNotify)
sl@0:             {
sl@0:             TRequestStatus status;
sl@0:             sess.SendReceive(data.iFunction, args, status);
sl@0:             if(status == KRequestPending)
sl@0:                 {
sl@0:                 err = sess.SendReceive(EFeatMgrReqNotifyCancelAll);
sl@0:                 }
sl@0:             else
sl@0:                 {
sl@0:                 err = status.Int();
sl@0:                 }
sl@0:             }
sl@0:         else
sl@0:             {
sl@0:             err = sess.SendReceive(data.iFunction, args);
sl@0:             }
sl@0:         if(err == KErrServerTerminated)
sl@0:             {
sl@0:             User::Panic(KPanicCategory, KPanicCode);
sl@0:             }
sl@0:         User::SetJustInTime(ETrue);
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: @SYMTestCaseID          PDS-EFM-CT-4065
sl@0: @SYMTestCaseDesc        
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMDEF                 DEF144262
sl@0: */
sl@0: void BadClientTest()
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:     _LIT(KThreadName, "WorkThrd");
sl@0:     
sl@0:     for(data.iIteration=0;data.iIteration<KTestIterCount;++data.iIteration)
sl@0:         {
sl@0:         PrintIterationCount(data.iIteration);
sl@0:         //Run the malicious client (one worker theread which will try to crash the FeatMgr server)
sl@0:         RThread thread;
sl@0:         TEST2(thread.Create(KThreadName, &ThreadFunc1, 0x2000, 0x1000, 0x10000, &data, EOwnerProcess), KErrNone);
sl@0:         TRequestStatus status;
sl@0:         thread.Logon(status);
sl@0:         TEST2(status.Int(), KRequestPending);
sl@0:         thread.Resume();
sl@0:         User::WaitForRequest(status);
sl@0:         User::SetJustInTime(ETrue); // enable debugger panic handling
sl@0:         if(thread.ExitType() == EExitPanic)
sl@0:             {
sl@0:             if(thread.ExitReason() == KPanicCode)
sl@0:                 {
sl@0:                 TheTest.Printf(_L("##Server terminated!\r\n"));
sl@0:                 TheTest.Printf(_L("##Iteration=%d, Function(hex)=%X, Handle=%d\r\n"), data.iIteration, data.iFunction);
sl@0:                 for(TInt i=0;i<KMaxMessageArguments;++i)
sl@0:                     {
sl@0:                     switch(data.iArgType[i])
sl@0:                         {
sl@0:                         case EIntArgType:
sl@0:                             TheTest.Printf(_L("##Arg %d, Integer, value=%d\r\n"), i, data.iIntArg[i]);
sl@0:                             break;
sl@0:                         case ETextArgType:
sl@0:                             TheTest.Printf(_L("##Arg %d, Text,    length=%d\r\n"), i, data.iTextArg[i].Length());
sl@0:                             break;
sl@0:                         case EBinArgType:
sl@0:                             TheTest.Printf(_L("##Arg %d, Binary,  length=%d\r\n"), i, data.iBinArg[i].Length());
sl@0:                             break;
sl@0:                         default:
sl@0:                             TheTest.Printf(_L("##Arg %d, Invalid argument type: %d\r\n"), i, data.iArgType[i]);
sl@0:                             break;
sl@0:                         }
sl@0:                     }
sl@0:                 TEST(0);
sl@0:                 }
sl@0:             }
sl@0:         thread.Close();
sl@0:         }
sl@0:     User::SetJustInTime(ETrue); // enable debugger panic handling
sl@0:     delete p;
sl@0:     }
sl@0: 
sl@0: void DoTestsL()
sl@0:     {
sl@0:     //This test won't pass
sl@0:     TheTest.Start(_L("@SYMTestCaseID:PDS-EFM-CT-4065 Bad client test"));
sl@0:     BadClientTest();
sl@0:     }
sl@0: 
sl@0: TInt E32Main()
sl@0:     {
sl@0:     TheTest.Title();
sl@0:     
sl@0:     CTrapCleanup* tc = CTrapCleanup::New();
sl@0:     TheTest(tc != NULL);
sl@0:     
sl@0:     __UHEAP_MARK;
sl@0:     
sl@0:     TRAPD(err, DoTestsL());
sl@0:     DestroyTestEnv();
sl@0:     TEST2(err, KErrNone);
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:     }