/*
* 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;
  private:
  	CCertStoreChangeNotifier(TInt& aNotificationFlag);
  	void ConstructL();
  	void DoCancel();
  	void RunL();
  private:	
  	RProperty iCertStoreChangeProperty;	
  	};

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