/*

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

#define __KEYTOOL_COMMANDS_H_

#include <e32base.h>

#include <ct/rmpointerarray.h>

#include <mctkeystore.h>

#include <unifiedkeystore.h>

#include <badesca.h>

#ifdef KEYTOOL

#include <authserver/authtypes.h>

#include <authserver/identity.h>

#include <authserver/authclient.h>

#endif // KEYTOOL

class CController;

class CKeyToolController;

#ifdef KEYTOOL

class CKeyInfo;

class CFileKeyData;

class CPermanentFileStore;

class CKeyStoreCenrep;

class CPassphrase;

#endif // KEYTOOL

/** 

 * This class wraps up the command line parameters

 * which affect the keystore command to be executed.

 * E.g. the key label we refer to, the key store to use, etc.

 */

class CKeyToolParameters : public CBase

	{

	public:

		static CKeyToolParameters* NewLC();

		~CKeyToolParameters();

#ifdef KEYTOOL

		enum TErrors

			{

			EMandatoryArgumentMissing=1,

			};

#endif // KEYTOOL

	enum TSetPolicy

		{

		ENone =0,

		ESetUserPolicy,

		ESetManagerPolicy,

		ERemoveUserPolicy,

		ESetAllUsersPolicy,

		};	

	protected:

		void ConstructL();

	private:

		CKeyToolParameters();

	public:

		TBool						iIsDetailed;

		HBufC* 						iPrivate;

		HBufC* 						iLabel;

		HBufC* 						iDefault;

		TInt 						iKeystoreIndex;

		TInt 						iCertstoreIndex;

		TKeyUsagePKCS15	 			iUsage;

		CKeyInfoBase::EKeyAccess	iAccess;

		TTime						iEndDate;

		RArray<TUid>				iUIDs;

		HBufC* 						iOwnerType;

		TBool 						iPageWise;

		TBool						iRemoveKey;

		TSetPolicy					iPolicy;

		HBufC*                      iIsDeletable;

#ifdef KEYTOOL

		HBufC*						iOldKeyFile;

		HBufC*						iNewKeyFile;

		HBufC* 						iAuthExpression;

		TInt						iFreshness;

		HBufC*						iPassphrase;

#endif // KEYTOOL

	};

/**

 * Interface that every keytool command class must implement.

 */

class CKeyToolCommand : public CActive

	{

	public:

		virtual void DoCommandL(CUnifiedKeyStore& aKeyStore, CKeyToolParameters* aParam) = 0;

	protected:

		CKeyToolCommand(CController* aController);

	protected:

		CController* iController;

		CKeyToolParameters* iParams; // we do not own this!		

	};

/**

 * Implements the keytool list action. This is an active object as listing is asynchronous.

 */

class CKeytoolUsage : public CKeyToolCommand

	{

public:

	static CKeytoolUsage* NewLC(CKeyToolController* aController);

	static CKeytoolUsage* NewL(CKeyToolController* aController);

	~CKeytoolUsage();

	void ConstructL();

public: // From CKeyToolCommand

	void DoCommandL(CUnifiedKeyStore& aKeyStore, CKeyToolParameters* aParam);

public: // From CActive

	void RunL();

	void DoCancel();

protected:

	CKeytoolUsage(CKeyToolController* aController);			

	};

/**

 * Implements the keytool list action. This is an active object as listing is asynchronous.

 */

class CKeytoolList : public CKeyToolCommand

	{

public:

	static CKeytoolList* NewLC(CKeyToolController* aController);

	static CKeytoolList* NewL(CKeyToolController* aController);

	~CKeytoolList();

	void ConstructL();

public: // From CKeyToolCommand

	void DoCommandL(CUnifiedKeyStore& aKeyStore, CKeyToolParameters* aParam);

public: // From CActive

	void RunL();

	void DoCancel();

	TInt RunError(TInt aError);	

protected:

	CKeytoolList(CKeyToolController* aController);

protected:

	RMPointerArray<CCTKeyInfo> iKeys;

	CUnifiedKeyStore* iKeyStore;

	TCTKeyAttributeFilter iFilter;

	MKeyStore* iKeyStoreImp;

	enum TState

		{

		EListKeys,

		EFinished,

		EIntermediate

		} iState;			

	};

/**

 * Implements the keytool import action.

 */

class CKeytoolImport : public CKeyToolCommand

	{

public:

	static CKeytoolImport* NewLC(CController* aController);

	static CKeytoolImport* NewL(CController* aController);

	~CKeytoolImport();

	void ConstructL();

public: // From CKeyToolCommand

	void DoCommandL(CUnifiedKeyStore& aKeyStore, CKeyToolParameters* aParam);

public: // From CActive

	void RunL();

	void DoCancel();

	TInt RunError(TInt aError);

protected:	

	/**

	 * Given some (supposed) pkcs8 data, tells you whether we are dealing with 

	 * a PrivateKeyInfo or EncryptedPrivateKeyInfo ASN1 type.

	 */

	TBool IsPkcs8EncryptedL(TDesC8& aBinaryData);

private:

	CKeytoolImport(CController* aController);

	void Pkcs8PreprocessorL();

private:

	HBufC8* iKeyData;

	CCTKeyInfo* iKeyInfo;	

	};

/**

 * Implements the keytool remove action. 

 */

class CKeytoolRemove : public CKeytoolList

	{

public:

	static CKeytoolRemove* NewLC(CKeyToolController* aController);

	static CKeytoolRemove* NewL(CKeyToolController* aController);

	~CKeytoolRemove();

public: // From CActive

	void RunL();

protected:

private:

	CKeytoolRemove(CKeyToolController* aController);

private:

	RArray<CCTKeyInfo*> iKeyList;

	TInt idx;

	};

/**

 */

class CKeyToolListStores : public CKeyToolCommand

	{

public:

	static CKeyToolListStores* NewLC(CKeyToolController* aController);

	static CKeyToolListStores* NewL(CKeyToolController* aController);

	~CKeyToolListStores();

	void ConstructL();

public: // From CCertToolCommand

	void DoCommandL(CUnifiedKeyStore& aKeyStore, CKeyToolParameters* aParam);

public: // From CActive

	void RunL();

	void DoCancel();	

protected:

	CKeyToolListStores(CKeyToolController* aController);			

private:

	RArray<MCTKeyStore> iCertStoreList; 

	};

/**

 * Implements the keytool set policy action. 

 */

class CKeytoolSetPolicy : public CKeytoolList

	{

public:

	static CKeytoolSetPolicy* NewLC(CKeyToolController* aController);

	static CKeytoolSetPolicy* NewL(CKeyToolController* aController);

	~CKeytoolSetPolicy();

public: // From CActive

	void RunL();

	TInt RunError(TInt aError);

protected:

private:

	CKeytoolSetPolicy(CKeyToolController* aController);

private:

	CCTKeyInfo* iKey;

	TInt idx;

	};

#ifdef KEYTOOL

/**

 * Implements the migration of old keystore to the new keystore format 

 * which uses the authentication server. 

 */

class CKeytoolMigrateStore : public CActive

	{

private:

	enum TMigrateStoreState

		{

		EAfterAuthentication,

		};

public:

	static CKeytoolMigrateStore* NewLC(CKeyToolParameters* aParams);

	static CKeytoolMigrateStore* NewL(CKeyToolParameters* aParams);

	~CKeytoolMigrateStore();

	void ConstructL(CKeyToolParameters* aParams);

public: // From CKeyToolCommand

	void DoCommandL();

public: // From CActive

	void RunL();

	void DoCancel();

	TInt RunError(TInt aError);	

private:

	CKeytoolMigrateStore();

	void WriteKeyL(	const CKeyInfo& aKeyInfo, 

					RStoreWriteStream& aWriteInfoStream );

	void WriteAuthDetailsL( RStoreWriteStream& aWriteInfoStream );

	void RevertStore(TAny* aStore);

	void InitializeDefaultParams();

	void WriteKeyInformationL();

	template <class T> inline void EncryptAndStoreL(const T& aKey, RStoreWriteStream& aStream );

	void StoreKeyL(const TDesC8& aKeyData, RStoreWriteStream& aStream);

	template <class T> void RetrieveAndStorePublicKeyL( CFileKeyData* aKeyData, T* aPublicKey );

	template <class T> void RetrieveAndStorePrivateKeyL( CFileKeyData* aKeyData, T* aPrivateKey );

	static void CleanKeyInfo(TAny* aKeyInfo);

private:

	AuthServer::TIdentityId iIdentityId;

	AuthServer::RAuthClient iAuthClient; 

	CPermanentFileStore* iWriteFileStore;

	CPermanentFileStore* iReadFileStore;

	TStreamId iWriteLookupStreamId;

	CKeyToolParameters* iParams;

	RFs iFs;

	CKeyStoreCenrep* iKeyStoreCenrep;

	CPassphrase* iPassphrase;

	AuthServer::CIdentity* iUserIdentity;

	TMigrateStoreState iState;

	RPointerArray<CFileKeyData> iKeyList;

	};

#endif // KEYTOOL

#endif