/*

* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

#ifndef TAUTHCLISERVSTEP_H

#define TAUTHCLISERVSTEP_H

#include <e32cmn.h>

#include <ct/rcpointerarray.h>

#include <ecom/ecom.h>

#include <test/testexecutestepbase.h>

#include <test/testexecutelog.h>

#include "tauthcliserv.h"

#ifndef __INIPARSER_H__

#include <cinidata.h>

#endif // __INIPARSER_H__

// publicly available include file

#include "authserver_client.h"

#include <authserver/authplugininterface.h>

// these tests use some information which is normally

// only visible to the server, or to the client DLL.

#include "authserveripc.h"

#include "authdb.h"

#include "transientkey.h"

#include "transientkeyinfo.h"

#include "evaluator.h"

// load test plugin data

#include "../tauthplugins/consts.h"

using AuthServer::TIdentityId;

using AuthServer::TPluginId;

using AuthServer::TAuthPluginType;

using AuthServer::TAuthTrainingStatus;

using AuthServer::CAuthExpression;

using AuthServer::CAuthExpressionImpl;

using AuthServer::TAuthExpressionWrapper;

using AuthServer::CEvaluator;

using AuthServer::CPluginDesc;

using AuthServer::RAuthClient;

// Authserver name

_LIT(KAuthServerName, "!AuthServer");

_LIT(KTStepCreateDb,"CREATEDB");

_LIT(KTStepClient,	"CLIENT");

_LIT(KTStepMgrClient,	"MGRCLIENT");

_LIT(KTStepFirstStart,	"FIRSTSTART");

_LIT(KTStepAuthExprBuild, "AuthExprBuild");

_LIT(KTStepBadExtAuthExpr, "AuthExprBadAuthExt");

_LIT(KTStepAuthExprHighVer, "AuthExprHighVer");

_LIT(KTStepAuthExprEval, "AuthExprEval");

// debug-mode tests for client-side panicks

_LIT(KTStepAuthExprTypePnc, "AuthExprTypePanic");

_LIT(KTStepAuthExprTypePncBadLeft, "AuthExprTypePanicBadLeft");

_LIT(KTStepAuthExprTypePncBadRight, "AuthExprTypePanicBadRight");

// These are used in the RemoveExistingDbL() function

// applying to DBs used by tPinAuthPlugin

_LIT(KPlugin3100File,		"\\tAuth\\tAuthSvr\\testdata\\Pin11113100Db.ini");

_LIT(KPlugin3101File,		"\\tAuth\\tAuthSvr\\testdata\\Pin11113101Db.ini");

_LIT(KPlugin3102File,		"\\tAuth\\tAuthSvr\\testdata\\Pin11113102Db.ini");

_LIT(KAuthSvrPolicyFile, 	"\\tAuth\\tAuthSvr\\testdata\\AuthSvrPolicy.ini");

_LIT(KPinDbTag,				"Identity&PinValues");

_LIT(KTotalDbTag,			"AllUserID&PinValues");

_LIT(KInitPinDatabaseValue,	",");

_LIT(KDisplayMessage,		"DisplayMessage");

#define KNumPlugins 8

const TInt KTestPluginId22       = 0x10274104;

const TInt KTestPluginBlocking   = 0x10274105;

const TInt KTestPluginIdInactive = 0x10274106;

const TInt KTestPluginIdUnknown  = 0x10274107;

class CTAuthcliservStepBase : public CTestStep

	{

protected:

	CTAuthcliservStepBase() {}

	virtual ~CTAuthcliservStepBase();

	virtual TVerdict doTestStepPreambleL()

	   {

	   iFs.Connect();

	   CreatePlugins();

	   CreateKeyInfo();

	   return TestStepResult();

	   }

	virtual TVerdict doTestStepPostambleL()

    	{

		iFs.Close();

		return TestStepResult();

		}

	inline void CreatePlugins();

	inline void CreateKeyInfo();

	HBufC* GetNameLC(TInt i);

	void PluginData(AuthServer::TIdentityId aId,

					AuthServer::TPluginId aPlugin,

					TPtr8 aDes) 

	{

	aDes.Fill(aId*aPlugin);

	}

	void WaitForServerToReleaseDb();

	void RemoveExistingDbL();

	//Utility function allowing text INI file parsing abilities	

	//Section name unspecified

	TInt writeToNamedConfig(const TDesC &aFileName, const TDesC &aKeyName,const TPtrC &aResult);

protected:

	RFs		iFs;

	AuthServer::CPluginDesc*       iPlugins[KNumPlugins];

	AuthServer::CTransientKeyInfo* iId1Keys[KNumPlugins];

	AuthServer::CTransientKeyInfo* iId2Keys[KNumPlugins];

	AuthServer::CTransientKeyInfo* iId3Keys[KNumPlugins];

  };

inline CTAuthcliservStepBase::~CTAuthcliservStepBase() 

    {

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

        {

        delete iPlugins[i];

        delete iId1Keys[i];

        delete iId2Keys[i];

        delete iId3Keys[i];

        }

    }

class CTStepActSch : public CTAuthcliservStepBase

/**

	This abstract subclass of CTAuthcliservStepBase

	overrides the doTestStep(Pre|Post)ambleL functions

	from CTestBase to allocate and free an active

	scheduler.

	The scheduler is stored in the protected iActSchd

	variable.  This class does not start or stop the

	scheduler.

 */

	{

private:

	// override CTestStep

	inline virtual TVerdict doTestStepPreambleL();

	inline virtual TVerdict doTestStepPostambleL();

protected:

	/** The active scheduler which subclasses can use. */

	CActiveScheduler* iActSchd;

	};

inline TVerdict CTStepActSch::doTestStepPreambleL()

/**

	Override CTestStep by allocating an active

	scheduler which is available to the subclass.

	@return					This test step's result,

							which isn't actually used

							by ThreadStepExecutionL.

 */

	{

	CTAuthcliservStepBase::doTestStepPreambleL();

	iActSchd = new(ELeave) CActiveScheduler;

	return TestStepResult();

	}

inline TVerdict CTStepActSch::doTestStepPostambleL()

/**

	Override CTestStep by deleting the active

	scheduler which allocated in doTestStepPreambleL.

	@return					This test step's result,

							which isn't actually used

							by ThreadStepExecutionL.

 */

	{

	CTAuthcliservStepBase::doTestStepPostambleL();

	delete iActSchd;

	return TestStepResult();

	}

class CTStepClient : public CTStepActSch

	{

public:

	CTStepClient();

	virtual TVerdict doTestStepL();

	TBool TestAuthenticate(AuthServer::RAuthClient& client);

	TBool TestAuthenticate2(AuthServer::RAuthClient& client);

	TBool TestAuthenticate3(AuthServer::RAuthClient& client);

	TBool TestAuthenticateFail(AuthServer::RAuthClient& client);

private:

	void GetDescriptionsFromEComL(RPointerArray<CPluginDesc>& aDescs);

	void TestIdentitiesL();

	void GetIdentitiesLC(RArray<TIdentityId>& aIds);

	void AddIdentityL(TIdentityId aIdentityId, const TDesC& aDesc);

	void TestIdentityL(TIdentityId aIdentityId, const TDesC& aExpDesc);

	void TestSetIdentityStrL();

	void TestClientPluginListsL();

	void SetSeenCountsL(const RCPointerArray<const CPluginDesc>& aPlugins);

	void TestTypedPluginsL(RAuthClient& aClient, TAuthPluginType aPluginType);

	void TestTrainedPluginsL();

	void PrepareTrainedPluginsL();

	void TestActivePluginsL(RAuthClient& aClient);

	TBool TestAuthenticateL();

	TBool TestMultiAuthL();

private:

	RArray<TUid> iPluginIds;

	};

class CTStepMgrClient : public CTStepActSch

	{

public:

	CTStepMgrClient();

	virtual TVerdict doTestStepL();

	TBool TestRegister(AuthServer::RAuthMgrClient& client);

	TBool TestMultiRegisterL(AuthServer::RAuthMgrClient& client);

	TBool TestMultiTrainL(AuthServer::RAuthMgrClient& client);

	TBool TestTrain(AuthServer::RAuthMgrClient& client);

	TBool TestCancellation(AuthServer::RAuthMgrClient& client);

	};

class CTStepFirstStart : public CTAuthcliservStepBase

	{

public:

	CTStepFirstStart();

	virtual TVerdict doTestStepL();

	};

inline HBufC* CTAuthcliservStepBase::GetNameLC(TInt id)

    {

    _LIT(nameTmpl, "Plugin_%d");

	HBufC* name = HBufC::NewLC(15);

	name->Des().Format(nameTmpl, id);

	return name;

    }

inline void CTAuthcliservStepBase::CreatePlugins()

	{

	using namespace AuthServer;

	const TAuthPluginType   types[KNumPlugins]

		= { EAuthBiometric, EAuthToken, EAuthKnowledge,

			EAuthBiometric, EAuthToken, EAuthKnowledge,

			EAuthToken, EAuthKnowledge

		};

	const TAuthTrainingStatus   training[KNumPlugins]

		= { EAuthUntrained, EAuthTrained, EAuthFullyTrained,

			EAuthUntrained, EAuthTrained, EAuthFullyTrained,

			EAuthTrained, EAuthFullyTrained

		  };

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

		{

			HBufC* name = GetNameLC(i);

			iPlugins[i] = CPluginDesc::NewL(i,

											*name,

											types[i],

											training[i],

											i*10000,

											i,

											i*4);

		    CleanupStack::PopAndDestroy(name);									

		}

	}

inline void CTAuthcliservStepBase::CreateKeyInfo()

	{

	using namespace AuthServer;

	CProtectionKey* protKey1 = CProtectionKey::NewLC(8);

	CProtectionKey* protKey2 = CProtectionKey::NewLC(8);

	CProtectionKey* protKey3 = CProtectionKey::NewLC(8);

	HBufC8* data = HBufC8::NewLC(4);

	for (TInt plugin = 0 ; plugin < KNumPlugins ; ++plugin)

		{

			CTransientKey* transient = 0;

			// id 1

			iId1Keys[plugin] = CTransientKeyInfo::NewL(plugin);

			PluginData(1, plugin, data->Des());

			transient = iId1Keys[plugin]->CreateTransientKeyL(data->Des());

			CEncryptedProtectionKey* epKey1 =

				transient->EncryptL(*protKey1);

			delete transient;

			iId1Keys[plugin]->SetEncryptedProtectionKeyL(epKey1);

			// id 2

			PluginData(2, plugin, data->Des());

			iId2Keys[plugin] = CTransientKeyInfo::NewL(plugin);

			transient = iId2Keys[plugin]->CreateTransientKeyL(data->Des());

			CEncryptedProtectionKey* epKey2 =

				transient->EncryptL(*protKey2);

			delete transient;

			iId2Keys[plugin]->SetEncryptedProtectionKeyL(epKey2);

			// id 3

			PluginData(3, plugin, data->Des());

			iId3Keys[plugin] = CTransientKeyInfo::NewL(plugin);

			transient = iId3Keys[plugin]->CreateTransientKeyL(data->Des());

			CEncryptedProtectionKey* epKey3 =

				transient->EncryptL(*protKey3);

			delete transient;

			iId3Keys[plugin]->SetEncryptedProtectionKeyL(epKey3);

		}

	CleanupStack::Pop(4, protKey1);

	}

// -------- Authentication expression tests --------

class CTStepAuthExprBuild : public CTAuthcliservStepBase

/**

	This test step ensures that complex authentication

	expressions can be constructed, or fail cleanly in OOM.

 */

	{

public:

	CTStepAuthExprBuild();

	// implement CTestStep

	virtual TVerdict doTestStepL();

private:

	void RunTestsL();

	void TestExprLD(

		void (CTStepAuthExprBuild::*aTestFuncL)(AuthServer::CAuthExpression*),

		AuthServer::CAuthExpression* aExpr);

#ifdef AUTH_EXPR_BINARY_OPS

	inline void OpTestExprLD(

		void (CTStepAuthExprBuild::*aTestFuncL)(AuthServer::CAuthExpression*),

		AuthServer::CAuthExpression* aExpr)

		{

		TestExprLD(aTestFuncL, aExpr);

		}

#else

	// this isn't an empty inline because don't want compiler

	// to build expression with binary operators.

	#define OpTestExprLD(___f, ___expr)

#endif

	void TestSimpleExprL();

	void TestPluginIdL(AuthServer::CAuthExpression* aExpr);

	void TestPluginTypeL(AuthServer::CAuthExpression* aExpr);

	void TestSimpleExprCombsConsL();

	void TestTypeAndTypeL(AuthServer::CAuthExpression* aExpr);

	void TestTypeOrTypeL(AuthServer::CAuthExpression* aExpr);

	void TestIdAndTypeL(AuthServer::CAuthExpression* aExpr);

	void TestTypeAndIdL(AuthServer::CAuthExpression* aExpr);

	void TestIdAndIdL(AuthServer::CAuthExpression* aExpr);

	void TestComplexExprCombsConsL();

	void TestAndAndL(AuthServer::CAuthExpression* aExpr);

	void TestAndOrL(AuthServer::CAuthExpression* aExpr);

	void TestOrAndL(AuthServer::CAuthExpression* aExpr);

	void TestOrOrL(AuthServer::CAuthExpression* aExpr);

	void TestFailedCombsL();

	void TestCorruptPersistL();

	};

class CTStepAuthExprTypePnc : public CTAuthcliservStepBase

/**

	This test step ensures the client is panicked when

	they attempt to retrieve the type of a corrupt expression.

 */

	{

public:

	CTStepAuthExprTypePnc();

	// implement CTestStep

	virtual TVerdict doTestStepL();

	};

class CTStepAuthExprTypePncBadLeft : public CTAuthcliservStepBase

/**

	This test step ensures the client is panicked when

	they attempt to retrieve the type of a expression,

	where the left subtree is corrupt.

 */

	{

public:

	CTStepAuthExprTypePncBadLeft();

	// implement CTestStep

	virtual TVerdict doTestStepL();

	};

class CTStepAuthExprTypePncBadRight : public CTAuthcliservStepBase

/**

	This test step ensures the client is panicked when

	they attempt to retrieve the type of a expression,

	where the right subtree is corrupt.

 */

	{

public:

	CTStepAuthExprTypePncBadRight();

	// implement CTestStep

	virtual TVerdict doTestStepL();

	};

class CTStepAuthExprHighVer : public CTAuthcliservStepBase

/**

	This step tests sending an unsupported authentication

	expression to the server.

	The server should fail the request.

 */

	{

public:

	CTStepAuthExprHighVer();

	// implement CTestStep

	virtual TVerdict doTestStepL();

	};

class CTStepBadExtAuthExpr : public CTAuthcliservStepBase

/**

	This step tests trying to authenticate a server with

	an invalid authentication expression.

	The client code should be panicked.

 */

	{

public:

	CTStepBadExtAuthExpr();

	// implement CTestStep

	virtual TVerdict doTestStepL();

	};

class TTestPluginInterface : public AuthServer::MEvaluatorPluginInterface

/**

	This implementation records which calls were made

	to the interface, so the test code can test the

	evaluator made the right calls in the right order.

 */

	{

public:

	virtual void Evaluate(TPluginId aPluginId, TIdentityId& aIdentity,

			   CAuthExpressionImpl::TType aType, TRequestStatus& aStatus);

	virtual void Evaluate(TAuthPluginType aPluginType, TIdentityId& aIdentity,

			   CAuthExpressionImpl::TType aType, TRequestStatus& aStatus);

	virtual void CancelEvaluate() {} ;

public:

	class TCallEntry

		{

	public:

		inline TCallEntry(TPluginId aPluginId)

		:	iCallType(CAuthExpressionImpl::EPluginId),

			iPluginId(aPluginId)

			{

			// empty.

			}

		inline TCallEntry(TAuthPluginType aPluginType)

		:	iCallType(CAuthExpressionImpl::EPluginType),

			iPluginType(aPluginType)

			{

			// empty.

			}

		bool operator==(const TCallEntry& aRhs) const;

	public:

		/** Type of call - ID or plugin type. */

		CAuthExpressionImpl::TType iCallType;

		union

			{

			TPluginId iPluginId;

			TAuthPluginType iPluginType;

			};

		};

	/**

		The sequence of Evaluate requests which have been received

		by this object.  This is a non-standard case of a T class

		owning resources.  These resources are freed by CLaunchEval

		because it is not worth making this an R-class or C-class

		for test code.

	 */

	RArray<TCallEntry> iCallLog;

	};

class TTestClientInterface : public AuthServer::MEvaluatorClientInterface