diff -r 5ffdb8f2067f -r fa9941cf3867 featuremgmt/featuremgr/test/rtest/src/t_fmgrbadclient.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/featuremgmt/featuremgr/test/rtest/src/t_fmgrbadclient.cpp	Fri Mar 12 15:51:02 2010 +0200
@@ -0,0 +1,425 @@
+// Copyright (c) 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 <featmgr.h>
+#include <featureuids.h>
+#include "featurepanics.h"
+#include <featurecontrol.h>
+#include <featurenotifier.h>
+#include "..\src\inc\featmgrconfiguration.h"
+#include "..\src\inc\featmgrclientserver.h"
+
+using namespace NFeature;
+
+static RTest TheTest(_L("t_fmgrbadclient"));
+
+const TInt KTestIterCount = 5000;
+
+enum TArgType 
+    {
+    EIntArgType, 
+    ETextArgType, 
+    EBinArgType, 
+    ELastArgType
+    };
+
+const TInt KMaxDesArgLen = 1000;
+
+//If the FeatMgr 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;
+    TInt                iFunction;
+    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 DestroyTestEnv()
+    {
+    }
+
+///////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////
+//Test macros and functions
+void Check1(TInt aValue, TInt aLine, TBool aPrintThreadName = EFalse)
+    {
+    if(!aValue)
+        {
+        DestroyTestEnv();
+        if(aPrintThreadName)
+            {
+            RThread th;
+            TName name = th.Name();
+            RDebug::Print(_L("*** Expression evaluated to false. Thread %S, Line %d\r\n"), &name, aLine);
+            }
+        else
+            {
+            RDebug::Print(_L("*** Expression evaluated to false. Line %d\r\n"), aLine);
+            }
+        TheTest(EFalse, aLine);
+        }
+    }
+void Check2(TInt aValue, TInt aExpected, TInt aLine, TBool aPrintThreadName = EFalse)
+    {
+    if(aValue != aExpected)
+        {
+        DestroyTestEnv();
+        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)
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+static TInt StartFeatMgrServer()
+    {
+    RProcess server;
+    const TUidType serverUid( KNullUid, KServerUid2, KNullUid );
+    TInt err = server.Create( KServerExeName, // FeatMgrServer.exe
+                           KNullDesC, // A descriptor containing data passed as 
+                                      // an argument to the thread function of 
+                                      // the new process's main thread, when it 
+                                      // is first scheduled.
+                           serverUid, // FeatMgr server UID
+                           EOwnerProcess ); // Ownership of this process handle 
+
+    // Return error code if we couldn't create a process
+    if ( err == KErrNone )
+        {
+        // Rendezvous is used to detect server start
+        TRequestStatus stat;
+        server.Rendezvous( stat );
+
+        if ( stat != KRequestPending )
+            {
+            server.Kill( KErrNone ); // 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 paniced as this
+        // is the panic 'reason' and may be '0' which cannot be distinguished
+        // from KErrNone
+        err = (server.ExitType() == EExitPanic)? KErrGeneral : stat.Int();
+
+        // We can close the handle now
+        server.Close();        
+        }
+
+    return err;
+    }
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////        RTestFeatMgrSession          ////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+class RTestFeatMgrSession : public RSessionBase
+    {
+public: 
+    TInt Connect();
+    void Close();
+    TInt SendReceive(TInt aFunction);
+    TInt SendReceive(TInt aFunction, const TIpcArgs& aArgs);
+
+private:
+    TInt DoCreateSession();
+    };
+    
+TInt RTestFeatMgrSession::Connect()
+    {
+    TInt err = DoCreateSession();
+    if(err != KErrNone && err != KErrAlreadyExists)
+        {
+        Close();
+        }
+    return err;
+    }
+
+void RTestFeatMgrSession::Close()
+    {
+    RSessionBase::Close();
+    }
+
+TInt RTestFeatMgrSession::SendReceive(TInt aFunction)
+    {
+    return RSessionBase::SendReceive(aFunction);    
+    }
+    
+TInt RTestFeatMgrSession::SendReceive(TInt aFunction, const TIpcArgs& aArgs)
+    {
+    return RSessionBase::SendReceive(aFunction, aArgs); 
+    }
+
+TInt RTestFeatMgrSession::DoCreateSession()
+    {
+    const TInt KRetry( 2 );
+    // Try this twice
+    TInt retry( KRetry );
+    TInt err( KErrNone );
+
+    while ( retry > 0 )
+        {
+        // Try to create a FeatMgr Server session
+        err = CreateSession(KServerProcessName, 
+                            TVersion(KServerVersionMajor, KServerVersionMinor, KServerVersionBuild), 
+                            KDefaultAsyncSlots);
+
+        if ( err != KErrNotFound && err != KErrServerTerminated )
+            {
+            // KErrNone or unrecoverable error
+            retry = 0;
+            }
+        else
+            {
+            // Return code was KErrNotFound or KErrServerTerminated.
+            // Try to start a new FeatMgr Server
+            err = StartFeatMgrServer();
+
+            if ( err != KErrNone && err != KErrAlreadyExists )
+                {
+                // Unrecoverable error
+                retry = 0;
+                }
+            }
+            
+        retry--;
+        }
+            
+    return err;
+    }
+    
+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 FeatMgr server. In each test iteration generates some random values
+//for the function number, handle, 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;
+
+    RTestFeatMgrSession sess;
+    TInt err = sess.Connect();
+    TTEST2(err, KErrNone);
+
+    while(++data.iIteration <= KTestIterCount)
+        {
+        RDebug::Print(_L("++++ %d\r\n"), data.iIteration);
+        
+        PrintIterationCount(data.iIteration);
+        TIpcArgs args;
+        data.iFunction = Math::Rand(data.iSeed) % (EFeatMgrSWIEnd + 1);//EFeatMgrSWIEnd - the last server message number (without resource checking IPCs))
+        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;
+        err = sess.SendReceive(data.iFunction, args);
+        if(err == KErrServerTerminated)
+            {
+            User::Panic(KPanicCategory, KPanicCode);
+            }
+        User::SetJustInTime(ETrue);
+        }
+
+    sess.Close();
+
+    delete tc;  
+    
+    __UHEAP_MARKEND;
+    
+    return KErrNone;        
+    }
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/**
+@SYMTestCaseID          PDS-EFM-CT-4065
+@SYMTestCaseDesc        
+@SYMTestPriority        High
+@SYMTestActions         
+@SYMTestExpectedResults Test must not fail
+@SYMDEF                 DEF144262
+*/
+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);
+        //Run the malicious client (one worker theread which will try to crash the FeatMgr 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, Function(hex)=%X, Handle=%d\r\n"), data.iIteration, data.iFunction);
+                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;
+    }
+
+void DoTestsL()
+    {
+    //TODO: this test won't pass
+    TheTest.Start(_L("@SYMTestCaseID:PDS-EFM-CT-4065 Bad client test"));
+    BadClientTest();
+    }
+
+TInt E32Main()
+    {
+    TheTest.Title();
+    
+    CTrapCleanup* tc = CTrapCleanup::New();
+    TheTest(tc != NULL);
+    
+    __UHEAP_MARK;
+    
+    TRAPD(err, DoTestsL());
+    DestroyTestEnv();
+    TEST2(err, KErrNone);
+
+    __UHEAP_MARKEND;
+    
+    TheTest.End();
+    TheTest.Close();
+    
+    delete tc;
+
+    User::Heap().Check();
+    return KErrNone;
+    }