/*

 * Copyright (c) 1998-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 

  @internalTechnology

 */

 #ifndef __T_CERTSTOREACTIONS_H__

 #define __T_CERTSTOREACTIONS_H__

 #include "t_testhandler.h"

 #include <unifiedcertstore.h>

 #include <unifiedkeystore.h>

 #include <certificateapps.h>

 #include <e32cons.h>

 #include <badesca.h>

 #include "t_testaction.h"

 #include <cctcertinfo.h>

 class Output;

 class CSWICertStore;

 enum TCertStoreType

 	{

 	EUnifiedCertStore,

 	ESWICertStore

 	};

 class CCertStoreChangeNotifier : public CActive

   	{

   public:

   	static CCertStoreChangeNotifier* NewL(TInt& aNotificationFlag);

   	virtual ~CCertStoreChangeNotifier();

   	void StartNotification();

   	TInt& iNotifiedCounter;

   	void SetCompleteStatus(TRequestStatus* aStatus);

   private:

   	CCertStoreChangeNotifier(TInt& aNotificationFlag);

   	void ConstructL();

   	void DoCancel();

   	void RunL();

   private:	

   	RProperty iCertStoreChangeProperty;	

   	TRequestStatus* iCompleteStatus;

   	};

 /**

  * Contains either a unified cert store instance or a SWI cert store instance.

  * 

  * Either can be accessed through the CertStore() method, but

  * AsUnifiedCertStore() and AsSWICertStore() will panic if the store is the

  * wrong type.

  *

  * This class owns the cert store pointer.

  */

 class COpenCertStore : public CBase

 	{

  public:

 	virtual ~COpenCertStore();

 	TCertStoreType Type();

 	MCertStore& CertStore();

 	void SetCertStore(CUnifiedCertStore* aCertStore);

 	CUnifiedCertStore& AsUnifiedCertStore();

 	void SetCertStore(CSWICertStore* aCertStore);

 	CSWICertStore& AsSWICertStore();

  private:

  private:

 	TBool iSet;

 	TCertStoreType iType;

 	union

 		{

 		TAny* iAny;

 		CUnifiedCertStore* iUnifiedCertStore;

 		CSWICertStore* iSwiCertStore;

 		};

 	};

 /**

  * Per-thread shared data.

  *

  * This contains stuff that is shared by more than one test action, eg the cert

  * stores we are testing.

  */

 class CSharedData : public CBase

 	{

 public:

 	~CSharedData();

 	void InitCertificateAppInfoManagerL();

 	void DeleteCertificateAppInfoManager();

 	RPointerArray<COpenCertStore>& CertStores();

 public:

 	RFs iFs;

 	RPointerArray<COpenCertStore> iCertStores;	

 	CCertificateAppInfoManager* iCertificateAppInfoManager;

 	};

 class CCertStoreTestAction : public CTestAction

 	{

 public:

 	virtual ~CCertStoreTestAction();

 protected:

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

 	// Methods for accessing the shared app info manager

 	void InitTheCertificateAppInfoManagerL();

 	void DeleteTheCertificateAppInfoManager();

   	CCertificateAppInfoManager* TheCertificateAppInfoManager();

 	// Methods for accessing the shared cert stores

 	TInt CertStoreCount();

 	TCertStoreType CertStoreType(TInt aIndex = 0);

 	MCertStore& CertStore(TInt aIndex = 0);

 	void AddCertStoreL(CUnifiedCertStore* aCertStore);

 	CUnifiedCertStore& UnifiedCertStore(TInt aIndex = 0);

 	void AddCertStoreL(CSWICertStore* aCertStore);

 	CSWICertStore& SWICertStore(TInt aIndex = 0);

 	void RemoveCertStore(TInt aIndex);

 protected:

 	RFs& iFs;

  private:

 	CSharedData& CertStoreSharedData();

 	RPointerArray<COpenCertStore>& CertStores();	

 	void DoPerformPrerequisite(TRequestStatus& aStatus);

 	void DoPerformPostrequisite(TRequestStatus& aStatus);

 	};

 class CSubscriberAction: public CCertStoreTestAction

 	{

 public:

  	virtual ~CSubscriberAction();

 protected:

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

  	void ConstructL(const TTestActionSpec& aTestActionSpec);

  	TInt iNotifierFlag;

  	TInt iNotificationSubscribed;		

  	CCertStoreChangeNotifier* iNotifier;		

  	};

 /**

  * This action creates and initializes a certificate store manager.

  * It should be used before any action requiring a certificate store manager.

  * All the actions are likely to require one.

  */

 class CInitialiseCertStore : public CCertStoreTestAction

 	{

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

 	~CInitialiseCertStore();

 public:

 	virtual void PerformAction(TRequestStatus& aStatus);

 	virtual void PerformCancel();

 	virtual void Reset();

 private:

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

 	void ConstructL(const TTestActionSpec& aTestActionSpec);

 	void DoReportAction();

 	void DoCheckResult(TInt aError);

 private:

 	enum TState

 		{

 		ENew,

 		EAppend,

 		ECheckOrder,

 		EFinished

 		};

 private:

 	TState iState;

 	TBool iOpenedForWrite;

  	RArray<TInt> iFilterOrdering;

  	RArray<TInt32> iExpectedOrderingResult;

 	CUnifiedCertStore* iNewUnifiedCertStore;

 	};

 class COnlyCreateCertStore : public CCertStoreTestAction

 	{

 public:

 	static CTestAction* NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 

 		const TTestActionSpec& aTestActionSpec);

 	~COnlyCreateCertStore() {};

 public:

 	virtual void PerformAction(TRequestStatus& aStatus);

 	virtual void PerformCancel();

 	virtual void Reset();

 private:

 	enum TState

 		{

 		EInit,

 		EFinished

 		};

 private:

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

 	void ConstructL(const TTestActionSpec& aTestActionSpec);

 	void DoReportAction();

 	void DoCheckResult(TInt aError);

 private:

 	TState iState;

 	TBool iOpenedForWrite;

 	CUnifiedCertStore* iNewUnifiedCertStore;

 	};

 class CDeleteCertStore : public CCertStoreTestAction

 	{

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

 		~CDeleteCertStore();

 		virtual void PerformAction(TRequestStatus& aStatus);

 		virtual void PerformCancel();

 		virtual void Reset();

 	private:

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

 		void ConstructL(const TTestActionSpec& aTestActionSpec);

 		void DoReportAction();

 		void DoCheckResult(TInt aError);

 	private:

 		enum TState

 			{

 			EDelete,

 			EFinished

 			};

 	private:

 		TState iState;

 	};

 class CX509Certificate;

 class CWTLSCertificate;

 // This is the base class used by both CSetApplications and CSetTrusters. This

 // is required because of the merging of the SetApplicability and SetTrust API

 // calls on the certstore

 class CSetAppsAndTrust : public CSubscriberAction

 	{

 public:

 	~CSetAppsAndTrust();

 	virtual void PerformAction(TRequestStatus& aStatus);

 	virtual void Reset();

 	virtual void PerformCancel();

 protected:

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

 	void ConstructL(const TTestActionSpec& aTestActionSpec);

 	void GetCerts(TRequestStatus& aStatus);

 	void SetCertLabel(const TDesC8& aLabel);

 	/** Implemented by derived classes, called from PerformAction. */

 	virtual void DoSetAppTrust(const CCTCertInfo& aCertInfo, TRequestStatus& aStatus) = 0;

 	/** Implemented by derived classes, called from PerformCancel. */

 	virtual void DoPerformCancel() = 0;

 protected:

 	enum TState

 		{

 		EGetCAEntries,

 		ESetAppTrust,

 		ECheckNotification,

 		EFinished

 		};

 protected:

 	/**

 	 * The label of the certificate we want to set the trust settings for

 	 */ 

 	TCertLabel iLabel;

 	// Index into the certinfo list which points to the certificate we

 	// are interested in

 	TInt iIndex;

 	TState iState;

 	CCertAttributeFilter *iFilter;

 	RMPointerArray<CCTCertInfo> iCertInfos;

 	};

 /**

  * This class is used to test the trust settings of a certificate.

  */

 class CSetApplications : public CSetAppsAndTrust

 	{

 public:

 	/**

 	 * @param aInfo This is what is enclosed in the <actionbody> and </actionbody> tags 

 	 * of the test script.

 	 */

 	static CTestAction* NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 

 		const TTestActionSpec& aTestActionSpec);

 	~CSetApplications();

 private:

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

 	void ConstructL(const TTestActionSpec& aTestActionSpec);

 	void DoReportAction();

 	void DoCheckResult(TInt aError);

 	void AppendUid(const TDesC8& aUid);

 	void DoSetAppTrust(const CCTCertInfo& aCertInfo, TRequestStatus& aStatus);

 	void DoPerformCancel();

 private:

 	/**

 	 * The array of applications that trust this certificate.

 	 */

 	RArray<TUid> iApplications;

 	};

 /**

  * This class is used to test the trust settings of a certificate.

  */

 class CSetTrusters : public CSetAppsAndTrust

 	{

 public:

 	/**

 	 * @param aInfo This is what is enclosed in the <actionbody> and </actionbody> tags 

 	 * of the test script.

 	 */

 	static CTestAction* NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 

 		const TTestActionSpec& aTestActionSpec);

 	~CSetTrusters();

 private:

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

 	void ConstructL(const TTestActionSpec& aTestActionSpec);

 	void DoReportAction();

 	void DoCheckResult(TInt aError);

 	void SetTrusted(const TDesC8& aTrusted);

 	void DoSetAppTrust(const CCTCertInfo& aCertInfo, TRequestStatus& aStatus);

 	void DoPerformCancel();

 private:

 	// The trusted setting to set

 	TBool iTrusted;

 	};

 /**

  * This class is used to test the trust settings of a certificate.

  */

 class CGetTrusters : public CCertStoreTestAction

 	{

 public:

 	/**

 	 * @param aInfo This is what is enclosed in the <actionbody> and </actionbody> tags 

 	 * of the test script.

 	 */

 	static CTestAction* NewL(RFs& aFs, CConsoleBase& aConsole, Output& aOut, 

 		const TTestActionSpec& aTestActionSpec);

 	~CGetTrusters();

 	virtual void PerformAction(TRequestStatus& aStatus);

 	virtual void PerformCancel();

 	virtual void Reset();

 private:

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

 	void ConstructL(const TTestActionSpec& aTestActionSpec);

 	void GetCerts(TRequestStatus& aStatus);

 	void SetCertLabel(const TDesC8& aLabel);

 	void SetExpectedTrusters(const TDesC8& aExpectedTrusters);

 	void DoReportAction();

 	void DoCheckResult(TInt aError);

 private:

 	enum TState

 		{

 		EGetCAEntries,

 		EGetTrusters,

 		EFinished

 		};

 private:

 	/**

 	 * The label of the certificate we want to get the trust settings of

 	 */ 

 	TCertLabel iLabel;

 	TState iState;

 	TBool iTrust;

 	TBool iExpectedTrust;

 	CCertAttributeFilter *iFilter;

 	RMPointerArray<CCTCertInfo> iCertInfos;

 	RArray<TUid> iTrusters;

 	RArray<TUid> iExpectedTrusters;

 	};

 #endif