// Copyright (c) 2009-2010 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
            {
            TheTest.Printf(_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);
    void SendReceive(TInt aFunction, const TIpcArgs& aArgs, TRequestStatus& aStatus);

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

void RTestFeatMgrSession::SendReceive(TInt aFunction, const TIpcArgs& aArgs, TRequestStatus& aStatus)
    {
    RSessionBase::SendReceive(aFunction, aArgs, aStatus); 
    }

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, TBool aFromThread = EFalse)
    {
    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());
        if(aFromThread)
            {
            RDebug::Print(_L("-----[%S] Test iterations: %d\r\n"), &tbuf, aIteration);
            }
        else
            {
            TheTest.Printf(_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)
        {
        PrintIterationCount(data.iIteration, ETrue);
        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;
        if(data.iFunction == EFeatMgrReqNotify)
            {
            TRequestStatus status;
            sess.SendReceive(data.iFunction, args, status);
            if(status == KRequestPending)
                {
                err = sess.SendReceive(EFeatMgrReqNotifyCancelAll);
                }
            else
                {
                err = status.Int();
                }
            }
        else
            {
            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()
    {
    //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;
    }