/*

* 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: 

*

*/

/**

 @file

*/

#ifndef __T_KEYSTORE_ACTIONS_H__

#define __T_KEYSTORE_ACTIONS_H__

#include "t_testhandler.h"

#include <e32cons.h>

#include <badesca.h>

#include "t_testaction.h"

#include "t_output.h"

#include "clientsession.h"

#include <hash.h>

#include <mctkeystore.h>

#include <unifiedkeystore.h>

#include <secdlgimpldefs.h>

#include <bigint.h>

typedef RPointerArray<CUnifiedKeyStore> RUnifiedKeyStoreArray;

class CPBEncryptParms;

enum TKSPanicCode

{

	EKSTestNotInitialised,

	EKSTestUnexpected,

	EKSTestResetPanic

};

class CSharedKeyStores : public CBase

{

public:

	static void InitialiseKeyStoresL();

	static void DestroyKeyStores();

	static RUnifiedKeyStoreArray& TheUnifiedKeyStores();

private:

	CSharedKeyStores(){};

	~CSharedKeyStores();

private:

	static CSharedKeyStores* iTheKeyStores;

private:

	RUnifiedKeyStoreArray iUnifiedKeyStores;

};

class CKeyStoreTestAction : public CTestAction

{

public:

	virtual ~CKeyStoreTestAction();

protected:

	void ConstructL(const TTestActionSpec& aTestActionSpec);

	CKeyStoreTestAction(RFs& aFs, CConsoleBase& aConsole, Output& aOut);

	TInt SetExpectedResultL(const TDesC8& aResult);

	TBool SetKeyUsageL(const TDesC8& aKeyUsage);

	void SetKeyLabel(const TDesC8& aKeyLabel);

	void SetKeyAlgorithm(const TDesC8& aKeyAlgorithm);

	TBool SetKeyAccessType(const TDesC8& aKeyAccessType);

	void DoPerformPrerequisite(TRequestStatus& aStatus);

	void DoPerformPostrequisite(TRequestStatus& aStatus);

	void AfterOOMFailure();

	TBool AddExpectedDialogL(const TDesC8& aData);

	void WriteExpectedDialogDataL();

	void WriteDialogRecordL(RFileWriteStream& aStream, TSecurityDialogOperation aOp, const TDesC& aLabelSpec,

							const TDesC& aResponse1, const TDesC& aResponse2);

	TInt ReadDialogCountL();

	void PrintKeyInfoL(const CCTKeyInfo& aKey);

	void SetKeyType(const TDesC8& aKeyType);

	void SetKeyStoreIndex(CUnifiedKeyStore* aUnifiedKeyStore);

public:

	enum TKeyTypes

		{

		ERSASign,

		EDSASign,

		EDH,

		EDecrypt,

#if (defined(SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT) && defined(SYMBIAN_ENABLE_SDP_ECC))

		EECC,

#endif // SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT && SYMBIAN_ENABLE_SDP_ECC

		};

protected:

	TUint iServerAlloc;

	RFs& iFs;

	TKeyUsagePKCS15 iUsage;

	HBufC* iLabel;

	CCTKeyInfo::EKeyAlgorithm iAlgorithm;

	TInt iAccessType;

	RPointerArray<HBufC> iExpectedDialogs;

	TInt iKeystore;

	// The following are here because they are used by most derived test actions

	TCTKeyAttributeFilter iFilter;

	RMPointerArray<CCTKeyInfo> iKeys;

	TInt iDisableCheckDialog;

	TKeyTypes iType;

	TInt iKeyStoreImplIndex;

#ifdef SYMBIAN_AUTH_SERVER

	// this variable would be used to retrieve the rom build variant 

	// for key store.

	TBool iUseNewApi;

	HBufC* iAuthExpression;

	TInt iFreshness;

	TInt iDeauthenticate;

#endif // SYMBIAN_AUTH_SERVER

#if (defined(SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT) && defined(SYMBIAN_ENABLE_SDP_ECC))

	TInt iHardwareType;

#endif // SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT && SYMBIAN_ENABLE_SDP_ECC

};

class CInitialiseKeyStore : public CKeyStoreTestAction

{

public:

	static CTestAction* NewL(RFs& aFs, CConsoleBase& aConsole,	Output& aOut, const TTestActionSpec& aTestActionSpec);

	static CTestAction* NewLC(RFs& aFs, CConsoleBase& aConsole,	Output& aOut, const TTestActionSpec& aTestActionSpec);

	~CInitialiseKeyStore();

public:

	virtual void PerformAction(TRequestStatus& aStatus);

	virtual void PerformCancel();

	virtual void Reset();

private:

	CInitialiseKeyStore(RFs& aFs, CConsoleBase& aConsole, Output& aOut);

	void ConstructL(const TTestActionSpec& aTestActionSpec);

private:

	void DoReportAction();

	void DoCheckResult(TInt aError);

private:

	enum TState

		{

		ENew,

		EInit,

		EAppend,

		EFinished,

		EAnalyseResults

		};

private:

	TState iState;

	TBool iKeyManager;

	TBool iEnableStoreCountCheck;

	TInt iKeyStoreManagerCount;

	TInt iKeyStoreCount;

	TBool iEnableKeyStoreLabelCheck;

	TInt iKeyStoreIndex;

	HBufC8* iKeyStoreLabel;

private:

	CUnifiedKeyStore* iNewUnifiedKeyStore;

};

class COnlyCreateKeyStore : public CKeyStoreTestAction

	{

public:

	static CTestAction* NewL(RFs& aFs, CConsoleBase& aConsole,	Output& aOut, const TTestActionSpec& aTestActionSpec);

	static CTestAction* NewLC(RFs& aFs, CConsoleBase& aConsole,	Output& aOut, const TTestActionSpec& aTestActionSpec);

	~COnlyCreateKeyStore();

public:

	virtual void PerformAction(TRequestStatus& aStatus);

	virtual void PerformCancel();

	virtual void Reset();

private:

	enum TState

		{

		EInit,

		EFinished,

		EErrNoMemory

		};

private:

	COnlyCreateKeyStore(RFs& aFs, CConsoleBase& aConsole, Output& aOut);

	void ConstructL(const TTestActionSpec& aTestActionSpec);

private:

	void DoReportAction();

	void DoCheckResult(TInt aError);

private:

	TState iState;

	TBool iKeyManager;

private:

	CUnifiedKeyStore* iNewUnifiedKeyStore;

};

class CDeleteKeyStore : public CKeyStoreTestAction

{

public:

	static CTestAction* NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec);

	static CTestAction* NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec);

	~CDeleteKeyStore();

	virtual void PerformAction(TRequestStatus& aStatus);

	virtual void PerformCancel();

	virtual void Reset();

private:

	CDeleteKeyStore(RFs& aFs, CConsoleBase& aConsole, Output& aOut);

	void ConstructL(const TTestActionSpec& aTestActionSpec);

private:

	void DoReportAction();

	void DoCheckResult(TInt aError);

private:

	enum TState

		{

		EDelete,

		EFinished

		};

private:

	TState iState;

};

class CAddKey : public CKeyStoreTestAction

{

public:

	static CTestAction* NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec);

	static CTestAction* NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec);

	~CAddKey();

	virtual void PerformAction(TRequestStatus& aStatus);

	virtual void PerformCancel();

	virtual void Reset();

private:

	void SetKeySize(const TDesC8& aKeySize);

	void SetStartDateL(const TDesC8& aData);

	void SetEndDateL(const TDesC8& aData);

private:

	CAddKey(RFs& aFs, CConsoleBase& aConsole, Output& aOut);

	void ConstructL(const TTestActionSpec& aTestActionSpec);

private:

	void DoReportAction();

	void DoCheckResult(TInt aError);

private:

	enum TState

		{

		EAddKey,

		EFinished

		};

private:

	TState iState;

private:

	TUint iSize;

	TTime iStartDate, iEndDate;

	CCTKeyInfo* iKeyInfo;

};

class CListKeys : public CKeyStoreTestAction

{

public:

	static CTestAction* NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec);

	static CTestAction* NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec);

	~CListKeys();

	virtual void PerformAction(TRequestStatus& aStatus);

	virtual void PerformCancel();

	virtual void Reset();

private:

	void DoReportAction();

	void DoCheckResult(TInt aError);

	CListKeys(RFs& aFs, CConsoleBase& aConsole, Output& aOut);

	void ConstructL(const TTestActionSpec& aTestActionSpec);

	void SetKeySize(const TDesC8& aKeySize);

	void SetListCount(const TDesC8& aListCount);

	void SetListStatus(const TDesC8& aListStatus);

	void AddFoundKeyL(const TDesC8& aFoundKey);

private:	

	enum TState

		{

		EListKeys,

		EFinished

		};

private:

	TState iState;

	TInt iResultCount; // The expected result count (or -1 for don't care)

	RCPointerArray<HBufC> iKeysToFind; // Labels of expected keys

	// Filter componenets

	TUint iSize;

	CCTKeyInfo::EKeyAccess iAccessType;

	TDesC8* iListStatus;

};

/**

 The same as ListKeys except that it checks all stores

 */

class CListAllKeys : public CKeyStoreTestAction

{

public:

	static CTestAction* NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec);

	static CTestAction* NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec);

	~CListAllKeys();

	virtual void PerformAction(TRequestStatus& aStatus);

	virtual void PerformCancel();

	virtual void Reset();

private:

	void DoReportAction();

	void DoCheckResult(TInt aError);

	CListAllKeys(RFs& aFs, CConsoleBase& aConsole, Output& aOut);

	void ConstructL(const TTestActionSpec& aTestActionSpec);

	void SetKeySize(const TDesC8& aKeySize);

	void SetListCount(const TDesC8& aListCount);

	void AddFoundKeyL(const TDesC8& aFoundKey);

private:	

	enum TState

		{

		EListKeys,

		EFinished

		};

private:

	TState iState;

	TInt iStore;

	TInt iResultCount; // The expected result count (or -1 for don't care)

	RCPointerArray<HBufC> iKeysToFind; // Labels of expected keys

	// Filter componenets

	TUint iSize;

	CCTKeyInfo::EKeyAccess iAccessType;

};

//	Allows script to filter on keys algorithm (or all) and deletes listed keys

//	and calls list again to ensure they've gone

class CDeleteKeys : public CKeyStoreTestAction

{

public:

	static CTestAction* NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec);

	static CTestAction* NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec);

	~CDeleteKeys();

	virtual void PerformAction(TRequestStatus& aStatus);

	virtual void PerformCancel();

	virtual void Reset();

private:

	void DoReportAction();

	void DoCheckResult(TInt aError);

	CDeleteKeys(RFs& aFs, CConsoleBase& aConsole, Output& aOut);

	void ConstructL(const TTestActionSpec& aTestActionSpec);

private:

	void SetNonExistent(const TDesC8&);

	void SetDeleteCount(const TDesC8&);

private:	

	enum TState

		{

		EListKeys,

		EDeleteAllKeys,

		EDeleteNonExistentKey,

		EDeleteKeyByLabel,

		EFinished

		};

private:

	TState iState;

	TCTTokenObjectHandle iDeleteHandle;

	TInt iInitialKeyCount;

	TInt iFinalKeyCount;

	TInt iDeletedCount;

	TInt iDeleteIndex;

	TInt iNonExistentKey;		//	Set!=0 if trying to delete something non existent

	TInt iExpectedDeleteCount;	//	Number of keys expected to be deleted (-1 for don't care)

};

class CImportKey : public CKeyStoreTestAction

{

public:

	static CTestAction* NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec);

	static CTestAction* NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec);

	virtual ~CImportKey();

	virtual void PerformAction(TRequestStatus& aStatus);

	virtual void PerformCancel();

	virtual void Reset();

protected:

	CImportKey(RFs& aFs, CConsoleBase& aConsole, Output& aOut);

	void SetKeyDataFileL(const TDesC8& aDes);

protected:

	void DoReportAction();

	void DoCheckResult(TInt aError);

private:

	TBool SetKeyUsage(const TDesC8& aKeyUsage);

private:

	void ConstructL(const TTestActionSpec& aTestActionSpec);

protected:

	HBufC8*  iImportFileName;

	HBufC8* iKeyData;

	CCTKeyInfo* iKeyInfo;

#if (defined(SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT) && defined(SYMBIAN_ENABLE_SDP_ECC))

	TUint iImportHardwareType;

	HBufC8* iPublicKey;

	HBufC8* iPrivateKey;

#endif // SYMBIAN_ENABLE_SDP_WMDRM_SUPPORT && SYMBIAN_ENABLE_SDP_ECC

private:

	enum TState

		{

		EImportKey,

		EFinished

		};

	TState iState;

};

class CExportKey : public CImportKey

{

public:

	static CTestAction* NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec);

	static CTestAction* NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec);

	virtual ~CExportKey();

	virtual void PerformAction(TRequestStatus& aStatus);	

	virtual void PerformCancel();

	virtual void Reset();

protected:

	void WriteToFileL();

	void DoReportAction();

	void DoCheckResult(TInt aError);

	//void DoPerformPrerequisite(TRequestStatus& aStatus);

protected:

	void SetKeyDataFile(const TDesC8& aDes);

	void SetPBEParametersL(const TDesC8& aCipher, const TDesC8& aSalt, const TDesC8& aIV, const TInt aIteration);

	void ConstructL(const TTestActionSpec& aTestActionSpec);

	void SetKeyEncrypted(const TDesC8& aDes);

protected:

	CExportKey(RFs& aFs, CConsoleBase& aConsole, Output& aOut);

protected:

	TBool iEncrypted;

	TFileName iKeyDataFile;

	CPBEncryptParms* iPbeParams;

	enum TState

		{

		EExportKey,

		EListing,

		EIntermediate,

		EFinished

		};

	TState iState;	

};

class CExportPublicKey : CExportKey

	{

public:

	static CTestAction* NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec);

	static CTestAction* NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec);

	 ~CExportPublicKey();

	virtual void PerformAction(TRequestStatus& aStatus);	

	virtual void PerformCancel();

protected:

	void ConstructL(const TTestActionSpec& aTestActionSpec);

private:

	CExportPublicKey(RFs& aFs, CConsoleBase& aConsole, Output& aOut);

	};

/**

* Compare two files bit-wise. This is used as a sanity check

* for key import/export.

*/

class CCompare : public CKeyStoreTestAction

	{

public:

	static CTestAction* NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec);

	static CTestAction* NewLC(RFs& aFs, CConsoleBase& aConsole, Output& aOut, const TTestActionSpec& aTestActionSpec);

	~CCompare();

	virtual void PerformAction(TRequestStatus& aStatus);	

	virtual void PerformCancel();

	virtual void Reset();	

protected:

	void DoReportAction();

	void DoCheckResult(TInt aError);

	TInt CompareFilesL();

private:

	CCompare(RFs& aFs, CConsoleBase& aConsole, Output& aOut);

	void ConstructL(const TTestActionSpec& aTestActionSpec);	

private:

	TFileName iOriginalFile;

	TFileName iNewFile;

	TInt pos;

	enum TState

		{

		EComparing,

		EFinished

		};