/*

* 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 "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 WIMCERTUTIL_H

#define WIMCERTUTIL_H

//INCLUDES

#include "WimClsv.h"

#include "Wimi.h"

#include <ct.h> 

// FORWARD DECLARATIONS

class CWimCertInfo;

class CCTCertInfo;

class CWimUtilityFuncs;

// CONSTANTS

typedef HBufC8* PHBufC8;

typedef TPtr8* PTPtr8;

// CLASS DECLARATION

/**

*  Utility class that handles certificate related operations.

*  @since Series60 3.0

*/

class CWimCertUtil : public CActive

    {

    public:  // Constructors and destructor

        /**

        * Two-phased constructor.

        * @param aToken -Reference to current token

        */

        static CWimCertUtil* NewL( MCTToken& aToken );

        /**

        * Destructor

        */

        virtual ~CWimCertUtil();

    public: // New functions

        /**

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

        */

        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.

        */

        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)

        */

        void RetrieveCertByIndexL( const TInt aIndex,

                                   TDes8& aEncodedCert, 

                                   TRequestStatus& aStatus );

    private:

        /**

        * By default Symbian 2nd phase constructor is private.

        */

        void ConstructL();

        /**

        * C++ default constructor.

        * @param aToken -Reference to current token

        */

        CWimCertUtil( MCTToken& aToken );

        /**

        * Get count of certificates in WIM

        * @param aRef       WIM card reference pointer.

        * @param aCertCount Count of certificates in WIM card pointed by aRef

        * @param aUsage     Certificate usage.

        * @return Status returned by WIMI. See in WimClsv.h.

        */

        WIMI_STAT GetCertificateCountByWIM( WIMI_Ref_t* aRef, 

                                            TUint8& aCertCount, 

                                            TUint8 aUsage ) const;

        /**

        * Get certificate extra data

        * @param aWimRef         WIM card reference pointer.

        * @param aUsage          Certificate usage.

        * @param aKeyHash        Key hash of certificate

        * @param aCertExtrasInfo Returned extra data

        * @return Status returned by WIMI.

        */

        WIMI_STAT GetExtrasFromWimRefL( 

                                    WIMI_Ref_t* aWimRef,

                                    TInt8 aUsage,

                                    TDesC8& aKeyHash,

                                    TCertExtrasInfo& aCertExtrasInfo ) const;

        /**

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

        * @param  aWimCertInfoArr    -Array to be initialized 

        * @param  aCount             -Count of elements in the array         

        */

        void AllocWimCertInfoL( TWimCertInfo* aWimCertInfoArr, TInt aCount );

        /**

        * Deallocates memory from the array.

        */

        void DeallocWimCertInfo();   

        /**

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

        */

        void AllocMemoryForCertDetailsL();

        /**

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

        */

        void CreateNewCertObjectsL();

        /**

        * Creates new wim certificate objects.

        */

        void CreateNewWimCertObjectL();

        /**

        * Gets trusted usages.

        */

        void GetTrustedUsagesL();

        /**

        * Completion of trusted usages.

        */

        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. 

        */

        void SignalOwnStatusAndComplete();

        /**

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

        */

        void CopyRetrievedCertData();

        /**

        * DeAllocates memory from member variables, which are used

        * when communicating with WIM.

        */

        void DeallocCertHBufs();

        /**

        * If user has cancelled initialization process, dealloc references 

        * from loaded certs. 

        */

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

        /**

        * Copy certificate extra data

        * @param aCert           Reference to certificate

        * @param aCertExtrasInfo Returned extra data

        */

        void CopyCertExtrasInfoL( WIMI_Ref_t* aCert,

                                  TCertExtrasInfo& aCertExtrasInfo ) const;

        /**

        * Return count of certificates in WIM

        * @param aType           Certificate type

        * @return Count of certificates

        */

        TUint8 CertCount( TWimEntryType aType );

        /**

        * Get certificate reference list

        * @param aCertAddrLst

        * @param aCertInfoArr

        * @param aCertEntryType

        */

        void CertRefLstL( TCertificateAddressList aCertAddrLst, 

                          TWimCertInfo* aCertInfoArr, 

                          TWimEntryType aCertEntryType );

        /**

        * Get certificate extra data

        * @param aKeyId

        * @param aCertExtrasInfo

        * @param aUsage

        * @param aStatus

        */

        void GetCertExtrasL( const TPtr8* aKeyId, 

                             TCertExtrasInfo& aCertExtrasInfo,

                             TUint aUsage,

                             TRequestStatus& aStatus );

        /**

        * Get certificate details

        * @param aCertAddr

        * @param aWimCertDetails

        */

        void CertDetailsL( const TCertificateAddress aCertAddr, 

                           TWimCertDetails& aWimCertDetails );

        /**

        *

        * @param aTmpWimRef

        * @param aUsage

        * @param aCertNum

        * @param aCertRefLst

        * @param aCertInfoLst

        * @return Error code returned by WIMI

        */

        WIMI_STAT GetCertificateFromWimRefL( WIMI_Ref_t* aTmpWimRef,

                                             TInt8 aUsage,

                                             TUint8& aCertNum,

                                             TUint32* aCertRefLst,

                                             TWimCertInfo* aCertInfoLst );

        /**

        * Copy certificate info

        * @param aCertInfo

        * @param aCert

        */

        void CopyCertificateInfo( TWimCertInfo& aCertInfo,

                                  WIMI_Ref_t* aCert );

    private: //from CActive

        /**

        * Different phases are handled here.

        */

        void RunL();

        /**

        * Cancellation function

        * Deallocates member variables and completes client status with

        * KErrCancel error code.

        */

        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:

        /**

        * Seven different phases, which are used to 

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

        * retrieve certificate

        */

        enum TPhase

            {

            EListCertsFromWim,

            ECreateNewCertObjects,

            EGetTrustedUsages,

            ECertObjectsDone,

            ETrustedUsagesDone,

            ERetrieveCertificate,

            ERetrievingCompleted

            };

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

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

        MCTToken&                       iToken;

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

        //Pointer to utility functions. Owned.

        CWimUtilityFuncs*               iWimUtilFuncs;

    };

#endif  //WIMCERTUTIL_H

// End of File