/*

* 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:  Interface which handles certificate related operations

*

*/

#ifndef WIMCERTCONVERTER_H

#define WIMCERTCONVERTER_H

//INCLUDES

#include "WimClsv.h"        

#include <e32base.h>

#include <ct.h> 

// FORWARD DECLARATIONS

class RWimCertMgmt;

class CWimCertInfo;

class CCTCertInfo;

// CONSTANTS

typedef HBufC8* PHBufC8;

typedef TPtr8* PTPtr8;

//CLASS DECLARATION

/**

*  Interface which handles certificate related operations 

*  with WimServer.

*  Caller can add a certificate, remove a certificate,

*  list a certificate and get certificate details.

*

*  @lib WimClient

*  @since Series60 2.1

*/

class CWimCertConverter: public CActive

    {

    public:

        /**

        * Two-phased constructor.

        * @param aToken -Reference to current token

        */

        IMPORT_C static CWimCertConverter* NewL( MCTToken& aToken );

        /**

        * Restores certificates from WIM cache. If Restore cannot find

        * any certificate, it will return KErrNotFound to caller.

        * @param  aArray    -Array where new certificates are 

        *                   inserted. Caller is responsible 

        *                   to deallocate CWimCertInfo -objects

        *                   by calling ResetAndDestroy.(IN/OUT)

        * @param  aStatus   -Status from caller.         

        * @return void

        */

        IMPORT_C void Restore( RPointerArray<CWimCertInfo>& aArray, 

                               TRequestStatus& aStatus );

        /** 

        * Cancels outgoing Restore operation. Sets an internal flag to true. 

        * After necessary cleanup, caller is signalled with KErrCancel 

        * -error code.

        * @return void

        */

        IMPORT_C void CancelRestore();

        /**

        * Retrieves the actual certificate. In case of other cert than

        * Url cert the binary encoded certificate is written into the 

        * aEncodedCert parameter. In case of Url cert the data is 

        * the actual url.

        * @param  aIndex. Used to point iCertRefLst and iCertInfoArr 

        *         -arrays for correct certificate.

        * @param  aEncodedCert. A buffer to put the certificate in. 

        * @param  aStatus. A request status that is completed when the 

        *         operation has finished.(IN/OUT)

        * @return void

        */

        IMPORT_C void RetrieveCertByIndexL( const TInt aIndex,

                                           TDes8& aEncodedCert, 

                                           TRequestStatus& aStatus );

        /**

        * Cancels an ongoing Retrieve operation.

        * If retrieve is cancelled, then operation is completed with 

        * KErrCancel -error code.

        * @return void

        */

        IMPORT_C void CancelRetrieve();

        /** 

        * Adds a certificate to the cert store.

        * The caller of this function owns all its parameters.

        * @since Series 60 2.6

        * @param  aLabel  -The label of the certificate to add 

        * @param  aFormat  -The format of the certificate. Supported formats are

                           EX509Certificate, EWTLSCertificate,

                           EX509CertificateUrl and EWTLSCertificateUrl 

        * @param  aCertificateOwnerType  -The owner type. Supported types are

                                        ECACertificate and EUserCertificate.

        * @param  aSubjectKeyId  -The Subject key ID

        * @param  aIssuerKeyId  -The issuer key ID

        * @param  aCert  -The certificate to add

        * @param  aStatus  This is completed with the return result 

        *         when the add has completed (IN/OUT)

        * @return  void

        */

        IMPORT_C void AddCertificate( const TDesC& aLabel, 

                              const TCertificateFormat aFormat,

                              const TCertificateOwnerType aCertificateOwnerType, 

                              const TKeyIdentifier& aSubjectKeyId,

                              const TKeyIdentifier& aIssuerKeyId,

                              const TDesC8& aCert, 

                              TRequestStatus& aStatus );

        /**

        * Cancels an ongoing add operation.

        * @since Series 60 2.6

        * @return void

        */

        IMPORT_C void CancelAddCertificate();

        /** 

        * Removes a certificate from WIM.

        * @since Series 60 2.6

        * @param aIndex     -Used to point iCertInfoArr 

        *                   for the certificate to be removed.

        * @param aStatus    -Status from caller 

        * @return void      

        */

        IMPORT_C void RemoveL( const TInt aIndex, TRequestStatus& aStatus );

        /** 

        * Cancels ongoing remove operation.

        * @since Series 60 2.6

        * @return void

        */

        IMPORT_C void CancelRemove();

        /**

        * Destructor

        */

        IMPORT_C virtual ~CWimCertConverter();

    private:

        /**

        * By default Symbian 2nd phase constructor is private.

        */

        void ConstructL();

        /**

        * C++ default constructor.

        * @param aToken -Reference to current token

        */

        CWimCertConverter( MCTToken& aToken );

    private: //from CActive

        /**

        * Different phases are handled here.

        * @return void

        */

        void RunL();

        /**

        * Cancellation function

        * Deallocates member variables and completes client status with

        * KErrCancel error code.

        * @return void

        */

        void DoCancel();

        /**

        * The active scheduler calls this function if this active 

        * object's RunL() function leaves. 

        * Handles necessary cleanup and completes request with

        * received error code.

        * @param aError -The error code which caused this function call.

        * @return TInt  -Error code to activescheduler, is always KErrNone.

        */ 

        TInt RunError( TInt aError );

    private:

        /**

        * Allocates memory for the array which is filled by server.

        * @param  aWimCertInfoArr    -Array to be initialized 

        * @param  aCount             -Count of elements in the array         

        * @return void

        */

        void AllocWimCertInfoL( TWimCertInfo* aWimCertInfoArr, TInt aCount );  

        /**

        * Deallocates memory from the array.

        * @return void

        */

        void DeallocWimCertInfo();   

        /**

        * Allocates memory for a struct which is filled by server.

        * @return void

        */

        void AllocMemoryForCertDetailsL();

        /**

        * Creates new certificate objects which can be returned to the caller.

        * @return void

        */

        void CreateNewCertObjectsL();

        /**

        * Creates new wim certificate objects.

        * @return void

        */

        void CreateNewWimCertObjectL();

        /**

        * Gets trusted usages.

        * @return void

        */

        void GetTrustedUsagesL();

        /**

        * Completion of trusted usages.

        * @return void

        */

        void TrustedUsagesDoneL();

        /**

        * Sets own iStatus to KRequestPending, and signals it 

        * with User::RequestComplete() -request. This gives chance 

        * to activescheduler to run other active objects. After a quick

        * visit in activescheduler, signal returns to RunL() and starts next

        * phase of operation. 

        * @return void

        */

        void SignalOwnStatusAndComplete();

        /**

        * Allocates memory for member variables, which are needed when adding

        * a certificate asynchronously to WIM.

        * @param aLabel -certificate label (IN)

        * @param aIssuerKeyId -Issuer KeyId of a certificate 

        * @param aSubjectKeyId -Subject KeyId of a certificate

        * @param aCert -certificate data

        * @return void

        */

        void AllocMemoryForAddCertL( const TDesC& aLabel, 

                            const TKeyIdentifier& aIssuerKeyId, 

                            const TKeyIdentifier& aSubjectKeyId,

                            const TDesC8& aCert );

        /**

        * Copies data to caller's buffer by using pointer.

        * @return void

        */

        void CopyRetrievedCertData();

        /**

        * DeAllocates memory from member variables, which are used

        * when communicating with WIM.

        * @return void

        */

        void DeallocCertHBufs();

        /**

        * If user has cancelled initialization process, dealloc references 

        * from loaded certs. 

        * @return void

        */

        void DeallocReferences();

        /**

        * Returns certificate format according to received index.

        * @param aIndex -index of the certificate to be returned.

        * @return TCertificateFormat -format of the certificate

        */

        TCertificateFormat GetCertFormatByIndex( TInt aIndex );

    private:

        /**

        * Ten different phases, which are used to 

        * Read certificates from WIM cache, create new certificate objects,

        * retrieve certificate, add certificate and remove certificate.

        */

        enum TPhase

            {

            EListCertsFromWim,

            ECreateNewCertObjects,

            EGetTrustedUsages,

            ECertObjectsDone,

            ETrustedUsagesDone,

            ERetrieveCertificate,

            ERetrievingCompleted,

            EAddCertificate,

            EAddCertificateCompleted,

            ERemove,

            ERemoveCompleted

            };

    private:

        //Client status is stored here while operation

        //on the server side is done.

        TRequestStatus*                 iClientStatus;

        //Array which is used to contain new certificate objects.

        //Not owned. Caller is responsible to destroy array.

        RPointerArray<CWimCertInfo>*    iArray;

        //Details of the certificate. Owned.

        TWimCertDetails                 iWimCertDetails;

        //Struct which is used when adding a certificate

        //to WIM.

        TWimCertAddParameters           iParam;

        //Struct which is used when removing a certificate for WIM.

        TWimCertRemoveAddr              iWimCertRemoveAddr;    

        //Reference to current token. Needed in CCTCertInfo creation.

        MCTToken&                       iToken;

        //Handle to connection with server. Owned.

        RWimCertMgmt*                   iConnectionHandle;

        //Typedefs for the reference to certificate. Owned.

        TCertificateAddressList         iCertRefLst; 

        // Certificate information structure. Owned.

        TWimCertInfo*                    iCertInfoArr;

        //Used to handle different phases.

        TPhase                          iPhase;

        //Index to point which certificate we want to be retrieved

        TInt                            iCertRetrieveIndex;

        //Used to inform the size of the array, needed in array construction/

        //destruction.

        TInt                            iArraySize;

        //The count of certificates

        TUint8                          iCertCount;

        //Pointer to HBufC8*. This is used as an array when listing every 

        //certificate from WIM to an array during startup. Owned.

        PHBufC8*                        iLabel;

        //Pointer to HBufC8*. This is used as an array when listing every 

        //certificate from WIM to an array during startup. Owned.

        PHBufC8*                        iKeyId;

        //Pointer to HBufC8*. This is used as an array when listing every 

        //certificate from WIM to an array during startup. Owned.

        PHBufC8*                        iCAId;

        //Pointer to HBufC8*. This is used as an array when listing every 

        //certificate from WIM to an array during startup. Owned.

        PHBufC8*                        iIssuerHash;

        //Pointer to iLabel. Also used as an array. Owned.        

        PTPtr8*                         iLabelPtr;

        //Pointer to iKeyId. Also used as an array. Owned.        

        PTPtr8*                         iKeyIdPtr;

        //Pointer to iCAId. Also used as an array. Owned.        

        PTPtr8*                         iCAIdPtr;

        //Pointer to iIssuerHash. Also used as an array. Owned.

        PTPtr8*                         iIssuerHashPtr;

        //Modifiable 8-bit descriptor which points

        //to caller's descriptor. We copy retrieved certificate

        //data to this descriptor. Owned.

        TDes8*                          iEncodedCert;

        //Buffer which is used to contain certificate data. Owned.

        HBufC8*                         iCertHBufOne;

        //Pointer to iCertHBufOne. Owned.

        TPtr8*                          iCertHBufOnePtr;

        //Buffer which is used to contain certificate data. Owned.        

        HBufC8*                         iCertHBufTwo;

        //Pointer to iCertHBufTwo. Owned.

        TPtr8*                          iCertHBufTwoPtr;

        //Buffer which is used to contain certificate data. Owned.        

        HBufC8*                         iCertHBufThree;

        //Pointer to iCertHBufThree. Owned.

        TPtr8*                          iCertHBufThreePtr;

        //Buffer which is used to contain certificate data. Owned.        

        HBufC8*                         iCertHBufFour;

        //Pointer to iCertHBufFour. Owned.

        TPtr8*                          iCertHBufFourPtr;

        //ActiveSchedulerWaiter for certificate extra information

        //fetching.

        CActiveSchedulerWait            iActiveSchedulerWait;

        //Pointer for trusted usage buffer

        HBufC*                          iTrustedUsages;

        //Pointer to trusted usage buffer pointer

        TPtr*                           iTrustedUsagesPtr;

        //Index pointing to certificate elements

        TUint8                          iIndex;

        //Pointer to one certificate info, owned

        CCTCertInfo*                    iCert;

        //Pointer to one WIM specific certificate info, owned

        CWimCertInfo*                   iCertInfo;

        //An array of trusted usage oids

        RArray<HBufC*>*                 iOids;

        //Package structure for certificate extra info

        TCertExtrasInfo                 iCertExtrasInfo;

        //Pointer for key identifier buffer

        HBufC8*                         iKeyIdBuf;

        //Used to point right keyId when retrieving extra data

        TPtr8*                          iKeyIdPointer;

    };

#endif  //WIMCERTCONVERTER_H