/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:  An implementation of single key store interface

*

*/

#ifndef CWIMKEYSTORE_H

#define CWIMKEYSTORE_H

//  INCLUDES

#include <mctkeystore.h>

#include <e32base.h>

// FORWARD DECLARATION

class CWimKeyDetails;

class MCTAuthenticationObjectList;

class CWimToken;

class CWimPin;

class CWimRSASigner;

// CLASS DECLARATION

/**

*  Represents read only key store.

*

*  @lib   WimPlugin

*  @since Series60 2.1

*/

class CWimKeyStore : public CActive, public MCTKeyStore 

    {

    public: // Constructor and destructor

        /**

        * Constructor

        * @param  aToken   (IN) A reference to current token

        * @return An instance of this class

        */

        static CWimKeyStore* NewL( CWimToken& aToken );

    public: // Function from base class MCTTokenInterface

        /**

        * Returns a reference to current token

        * @return A Reference to current token

        */

        MCTToken& Token();

    public: // Functions from base class MKeyStore

        /**

        * Lists all the keys in the store that match the filter

        * The caller of this function owns all given parameters

        * @param  aKeys    (OUT) An array to which the returned keys 

        *         are appended.

        * @param  aFilter  (IN) A filter controlling which keys are returned

        * @param  aStatus  (IN/OUT) This will be completed with the final 

        *         status code. Caller should set it to value TRequestPending

        *         KErrNone, if no errors detected. Note: if no keys are found,

        *         it is also KErrNone

        *         KErrArgument, if aKeys array is NULL

        *         KErrHardwareNotAvailable, if Wim card suddenly removed

        *         Any other system wide error code (e.g. KErrNoMemory)

        * @return void

        */

        void List( RMPointerArray<CCTKeyInfo>& aKeys, 

                   const TCTKeyAttributeFilter& aFilter, 

                   TRequestStatus& aStatus );

        /**

        * Cancels an ongoing List operation

        * @return void

        */

        void CancelList();

        /**

        * Retrieves a reference to pointer of key depending on given 

        * handle (aHandle). The caller of this function owns all given 

        * parameters.

        * @param  aHandle   The handle of the required key.

        * @param  aInfo     The returned key info.

        * @param  aStatus   Async request notification.

        *         KErrNone, if no errors detected

        *         KErrArgument, if aHandle is not current token's handle

        *         KErrNotFound, if aInfo not found

        *         KErrHardwareNotAvailable, if Wim card suddenly removed

        *         Any other system wide error code (e.g. KErrNoMemory)

        * @return void

        */

        void GetKeyInfo( TCTTokenObjectHandle aHandle, 

                         CCTKeyInfo*& aInfo,

                         TRequestStatus& aStatus );

        /**

        * Cancels an ongoing GetKeyInfo operation

        * @return void

        */

        void CancelGetKeyInfo();

        /** 

        * Open an RSA key for signing

        * @param aHandle The handle of the key to be opened

        * This must be the handle of a RSA key on this store that is

        * usable for signing by this process or the operation will fail.

        * @param aSigner The returned signer object

        * @param aStatus Asynchronous request notification.

        * @return void

        */

        void Open( const TCTTokenObjectHandle& aHandle, 

                   MRSASigner*& aSigner,

                   TRequestStatus& aStatus );

        /** 

        * Open a DSA key for signing

        * @param aHandle -The handle of the key to be opened

        * This must be the handle of a DSA key on this store that is

        * usable by this process for signing or the operation will fail.

        * @param aSigner -The returned signer object

        * @param aStatus -Asynchronous request notification.

        * @return void

        */

        void Open( const TCTTokenObjectHandle& aHandle, 

                   MDSASigner*& aSigner, 

                   TRequestStatus& aStatus );

        /** 

        * Open a RSA key for private decryption

        * @param aHandle -The handle of the key to be opened

        * This must be the handle of a RSA key on this store that is

        * usable by this process for decryption or the operation will fail.

        * @param aDecryptor -The returned decryptor object

        * @param aStatus -Asynchronous request notification.

        * @return void

        */

        void Open( const TCTTokenObjectHandle& aHandle, 

                   MCTDecryptor*& aDecryptor,

                   TRequestStatus& aStatus );

        /** 

        * Open a DH key for key agreement

        * @param aHandle -The handle of the key to be opened

        * This must be the handle of a DH key on this store that is

        * usable by this process for decryption or the operation will fail.

        * @param aDH    -The returned agreement object

        * @param aStatus -Asynchronous request notification.

        * @return void

        */

        void Open( const TCTTokenObjectHandle& aHandle, 

                   MCTDH*& aDH, 

                   TRequestStatus& aStatus );

        /** 

        * Cancels an ongoing Open operation

        * @return void

        */

        void CancelOpen();

        /** 

        * Returns the public key in DER-encoded ASN-1

        * @param aHandle    -The handle of the key to be opened

        * @param aPublicKey -returned key

        * @param aStatus    -Asynchronous request notification.

        * @return void

        */

        void ExportPublic( const TCTTokenObjectHandle& aHandle,

                           HBufC8*& aPublicKey,

                           TRequestStatus& aStatus );

        /**  

        * Cancels an ongoing Export operation

        * @return void

        */

        void CancelExportPublic();

        /** 

        * Perform signing operation.

        * @param  aObject -The handle of signer object. 

        * @param  aDigest -The data to be signed.   

        * @param  aSignature -The returned signature. This remains owned

        *         by the signer, and is valid until the signer is released or

        *         until the next Sign.

        * @param aStatus -Async status notification

        * @return void

        */ 

        void NonRepudiableRSASign( const TCTTokenObjectHandle& aObject, 

                                   const TDesC8& aDigest, 

                                   CRSASignature*& aSignature, 

                                   TRequestStatus& aStatus );

    protected:  // From base class MCTTokenInterface

        virtual void DoRelease();

    private: // Constructors

        /**

        * Default constructor

        * @param  aToken   (IN) A reference to current token

        */

        CWimKeyStore( CWimToken& aToken );

        // Second phase constructor

        void ConstructL();

        // Destructor

        virtual ~CWimKeyStore();

    private:

        /**

        * Starts initialization on this class.

        * @return void

        */

        void Initialize();

        /**

        * Creates one key info for list or get key info operation

        * @param   aIndex (IN) An index value of current key info in

        *          the internal array

        * @return  A pointer to created key info

        */

        CCTKeyInfo* CreateKeyInfoL( TInt aIndex );

        /**

        * Leavable function to filter keys in list operation.

        * @return void

        */

        void DoFilterKeysL();

        /**

        * Leavable function for key creation.

        * @param   aHandle (IN) Handle of desired authentication object.

        * @return  A pointer to created authentication object

        */

        MCTAuthenticationObject* MakeAuthObjectL( TInt aHandle );

        /**

        * Returns boolean value true or false indicating if token is removed

        * @return  Boolean value: true, if token removed, false if not

        */

        TBool TokenRemoved();

        /**

        * Checks if token is removed or is this object active

        * @return  Boolean value: true if allowed, false if not

        */

        TBool EnteringAllowed( TRequestStatus& aStatus );

    private: // From base class CActive

        void RunL();

        /** 

        * Leaves in RunL are handled here.

        * @param  aError  Leaving code

        * @return An integer that should be KErrNone if leave was handled.

        */

        TInt RunError( TInt aError );

        void DoCancel();

    private: // Data

        // A reference to current token of this interface

        CWimToken& iToken;

        // State flag for RunL

        enum TPhase

            {

            EIdle,

            EOpenAuthObjectsInterface,

            EListAuthObjects,

            EGetKeyList,

            ECheckGetKeyList,

            EFilterKeys,

            EGetKey,

            ECreateRSASignerObject,

            EStartNonRepudiableRSASign,

            ESignCompleted,

            EStartExportPublicKey,

            EExportPublicKeyDone

            };

        // Flag for internal state machine

        TPhase iPhase;

        // Flag for internal state machine

        TPhase iPhaseOriginal;

        // The pointed object acts as a converter between

        // CWimCertStore/CWimKeyStore interface and WimClient

        // This class owns the pointed object

        CWimKeyDetails* iCWimKeyDetails;

        // Used for saving caller status in asynchronous call

        // This class don't own the pointed object

        TRequestStatus* iOriginalRequestStatus;

        // Temporal array for key info pointers

        // This array is used to append key infos in List operation

        // This class don't own the pointed objects

        RPointerArray<CCTKeyInfo>* iKeyList;

        // Temporal array for key infos. 

        // This array is used to fetch key infos from WimClient.

        RPointerArray<CCTKeyInfo> iKeyInfos;

        // Used with list operation to filter keys

        TCTKeyAttributeFilter iKeyFilter;   

        // Index for going through all keys asynchronously 

        // in list operation.

        TInt iKeyIndex;

        // Used to fetch one key info from wimclient

        // This class don't own the pointed object.

        CCTKeyInfo** iInfo;

        // Key value for key object. Used in asynchronous call of

        // getting one key info.

        TInt iHandle;

        // Array for key info keys fetched from wimclient

        CArrayFixFlat<TUint8>* iKeyNumbers;

        // Array of pointers to PIN-NRs.This class don't own the pointed

        // objects

        const CArrayPtrFlat<CWimPin>* iPinNRs; 

        // Is key list done or not already. Set to true value in the first

        // key list.

        TBool iListDone;

        //Signer object, which is returned to caller. Not Owned.

        CWimRSASigner*              iSigner;

        //Handle stored during opening new RSA signer object.

        TCTTokenObjectHandle        iOpenSigninKeyHandle;

        //Buffer, which holds received signature from server. Owned.

        HBufC8*                     iSignature;

        //Signature object which is filled with data received from server.

        //Not owned.

        CRSASignature**              iRSASignature; 

        //Buffer used to contain KeyId in Sign and public key export

        //operations. Owned.

        HBufC8*                     iKeyId;

        //Buffer to hold public key data during public key export. Not Owned.

        HBufC8*                     iPublicKey;

        // The index of exported key

        TInt                        iExportKeyIdIndex;

        TInt                        iRSAKeyIdIndex;

        const TDesC8*               iDigest;

    };

#endif      // CWIMKEYSTORE_H   

// End of File