diff -r 000000000000 -r 164170e6151a wim/WimClient/src/WimCertConverter.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/wim/WimClient/src/WimCertConverter.cpp	Tue Jan 26 15:20:08 2010 +0200
@@ -0,0 +1,1047 @@
+/*
+* Copyright (c) 2002-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:  API which handles certificate related operatons
+*
+*/
+
+
+
+#include "WimCertMgmt.h"
+#include "WimCertConverter.h"
+#include "WimTrace.h"
+#include "WimCertInfo.h"
+#include "Wimi.h"   
+#include <cctcertinfo.h>
+
+
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::CWimCertConverter()
+// Default constructor
+// -----------------------------------------------------------------------------
+CWimCertConverter::CWimCertConverter( MCTToken& aToken ): 
+CActive( EPriorityStandard ), iToken( aToken )
+    {
+    }
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::NewL()
+// Symbian 2nd phase constructor can leave.
+// -----------------------------------------------------------------------------
+EXPORT_C CWimCertConverter* CWimCertConverter::NewL( MCTToken& aToken )
+    {
+    CWimCertConverter* self = new( ELeave ) CWimCertConverter( aToken );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self ); //self
+    return self;
+    }
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::ConstructL()
+// Second phase
+// -----------------------------------------------------------------------------
+void CWimCertConverter::ConstructL()
+    {
+    CActiveScheduler::Add( this );
+    iConnectionHandle = RWimCertMgmt::ClientSessionL();           
+    _WIMTRACE ( _L( "CWimCertConverter::ConstructL() completed" ) );
+    }
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::Restore()
+// Returns CCTCertInfo objects in array
+// -----------------------------------------------------------------------------
+EXPORT_C void CWimCertConverter::Restore( RPointerArray<CWimCertInfo>& aArray, 
+                                          TRequestStatus& aStatus )
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::Restore" ) );
+    iClientStatus = &aStatus;
+    aStatus = KRequestPending;
+    iArray = &aArray;
+    iPhase = EListCertsFromWim;
+    SignalOwnStatusAndComplete();
+    }
+
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::CancelRestore()
+// Cancels outgoing Restore operation. Sets an internal flag to true. 
+// After necessary cleanup, caller is signalled with KErrCancel 
+// -error code.
+// -----------------------------------------------------------------------------
+EXPORT_C void CWimCertConverter::CancelRestore()
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::CancelRestore" ) );
+    Cancel(); 
+    }
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::RetrieveCertByIndexL()
+// Retrieves the actual certificate.
+// -----------------------------------------------------------------------------
+
+EXPORT_C void CWimCertConverter::RetrieveCertByIndexL( const TInt aIndex,
+                                                    TDes8& aEncodedCert, 
+                                                    TRequestStatus& aStatus )
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::RetrieveCertByIndexL" ) );
+    //Check that index is valid
+    __ASSERT_ALWAYS( aIndex <= iArraySize && iCertRefLst,
+        User::Leave( KErrArgument )  );
+    iClientStatus = &aStatus;
+    iCertRetrieveIndex = aIndex;
+    iEncodedCert = &aEncodedCert;
+    aStatus = KRequestPending;
+    iPhase = ERetrieveCertificate;
+    SignalOwnStatusAndComplete();
+    }
+
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::CancelRetrieve()
+// Cancels an ongoing Retrieve operation.
+// If retrieve is cancelled, then operation is completed with 
+// KErrCancel -error code.
+// -----------------------------------------------------------------------------
+EXPORT_C void CWimCertConverter::CancelRetrieve()
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::CancelRetrieve" ) );
+    Cancel();
+    }
+
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::AddCertificate()
+// Adds a certificate to the store.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CWimCertConverter::AddCertificate( const TDesC& aLabel, 
+                              const TCertificateFormat aFormat, 
+                              const TCertificateOwnerType aCertificateOwnerType,
+                              const TKeyIdentifier& aSubjectKeyId,
+                              const TKeyIdentifier& aIssuerKeyId,
+                              const TDesC8& aCert,
+                              TRequestStatus& aStatus )
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::AddCertificate()" ) );        
+    iClientStatus = &aStatus;
+    aStatus = KRequestPending;
+    TBool paramErr = EFalse;
+    //First convert format 
+    switch ( aFormat )
+        {
+        case EX509Certificate:
+            {
+            iParam.iFormat = EWimX509Certificate; 
+            break;
+            }
+        case EWTLSCertificate:
+            {
+            iParam.iFormat = EWimWTLSCertificate;
+            break;
+            }
+        case EX968Certificate:
+            {
+            paramErr = ETrue; 
+            break;
+            }
+        case EUnknownCertificate:
+            {
+            paramErr = ETrue;
+            break;
+            }
+        case EX509CertificateUrl:
+            {
+            iParam.iFormat = EWimCertificateURL;
+            break;
+            }
+        case EWTLSCertificateUrl:
+            {
+            iParam.iFormat = EWimCertificateURL; 
+            break;
+            }
+        case EX968CertificateUrl:
+            {
+            paramErr = ETrue; 
+            break;
+            }
+        default:
+            {
+            paramErr = ETrue;
+            break;
+            }
+            
+        }
+    
+    //Then convert owner type    
+    switch ( aCertificateOwnerType )
+        {
+        case ECACertificate:
+            {
+            iParam.iUsage = EWimCertTypeCA;
+            break;
+            }
+        case EUserCertificate:
+            {
+            iParam.iUsage = EWimCertTypePersonal; 
+            break;
+            }
+        case EPeerCertificate:
+            {
+            paramErr = ETrue;
+            break;
+            }   
+        default:
+            {
+            paramErr = ETrue;
+            break;
+            }
+            
+        }
+    if ( paramErr )
+        {
+        User::RequestComplete( iClientStatus, KErrNotSupported );
+        return;
+        }
+
+    TRAPD( err, AllocMemoryForAddCertL( aLabel, 
+                                        aIssuerKeyId, 
+                                        aSubjectKeyId, 
+                                        aCert ) );
+    
+    if ( err != KErrNone ) // is everything ok?
+        {
+        DeallocCertHBufs();         //No.
+        _WIMTRACE ( _L( "CWimCertConverter::AddCertificate error = %d" ) );
+        User::RequestComplete( iClientStatus, err );    
+        }
+    else
+        {
+        iPhase = EAddCertificate;
+        SignalOwnStatusAndComplete(); //Yes.
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::CancelAddCertificate()
+// Cancels an ongoing certificate add operation.
+// If add operation is cancelled, then operation is completed with 
+// KErrCancel -error code.
+// -----------------------------------------------------------------------------
+EXPORT_C void CWimCertConverter::CancelAddCertificate()
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::CancelAddCertificate()" ) );
+    Cancel();
+    }
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::RemoveL()
+// Removes a certificate from WIM
+// -----------------------------------------------------------------------------
+EXPORT_C void CWimCertConverter::RemoveL( const TInt aIndex, 
+                                         TRequestStatus& aStatus )
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::RemoveL()" ) );
+    //Check that index is valid
+    __ASSERT_ALWAYS( aIndex <= iArraySize && iCertRefLst, 
+        User::Leave( KErrArgument )  );    
+    iClientStatus = &aStatus;
+    iCertRetrieveIndex = aIndex;
+    aStatus = KRequestPending;
+    iPhase = ERemove;
+    SignalOwnStatusAndComplete();
+    }
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::CancelRemove()
+// Cancels outgoing certificate remove operation. 
+// -----------------------------------------------------------------------------
+EXPORT_C void CWimCertConverter::CancelRemove()
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::CancelRemove()" ) );
+    Cancel();
+    }
+
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::AllocMemoryForAddCertL()
+// Allocates memory for member variables, which are needed when adding
+// a certificate asynchronously to WIM.
+// -----------------------------------------------------------------------------
+void CWimCertConverter::AllocMemoryForAddCertL( const TDesC& aLabel, 
+                                      const TKeyIdentifier& aIssuerKeyId, 
+                                      const TKeyIdentifier& aSubjectKeyId, 
+                                      const TDesC8& aCert )
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::AllocMemoryForAddCertL()" ) );
+    iCertHBufOne = aCert.AllocL(); //certificate
+    iCertHBufOnePtr = new( ELeave ) TPtr8( iCertHBufOne->Des() );
+
+    iCertHBufTwo = aIssuerKeyId.AllocL(); //IssuerKeyId
+    iCertHBufTwoPtr = new( ELeave ) TPtr8( iCertHBufTwo->Des() );
+    iParam.iCaId.Copy( iCertHBufTwoPtr->Ptr(), iCertHBufTwoPtr->Length() );
+
+    iCertHBufThree = aSubjectKeyId.AllocL(); //SubjectKeyId
+    iCertHBufThreePtr = new( ELeave ) TPtr8( iCertHBufThree->Des() );
+    iParam.iKeyId.Copy( iCertHBufThreePtr->Ptr(), iCertHBufThreePtr->Length() );
+
+    TBuf8<KLabelLen>buf;
+    buf.Copy( aLabel );
+    buf.ZeroTerminate();
+    iCertHBufFour = buf.AllocL();           //label
+    iCertHBufFourPtr = new( ELeave ) TPtr8( iCertHBufFour->Des() );
+    iParam.iLabel.Copy( iCertHBufFourPtr->Ptr(), iCertHBufFourPtr->Length() );
+    }
+
+
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::SignalOwnStatusAndComplete()       
+// Sets own iStatus to KRequestPending, and signals it 
+// with User::RequestComplete() -request. This gives chance 
+// active scheduler to run other active objects. After a quick
+// visit in active scheduler, signal returns to RunL() and starts next
+// phase of operation. 
+// @return void
+// -----------------------------------------------------------------------------
+void CWimCertConverter::SignalOwnStatusAndComplete()
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::SignalOwnStatusAndComplete()" ) );
+    iStatus = KRequestPending;
+    SetActive();
+    TRequestStatus* status = &iStatus;
+    User::RequestComplete( status, KErrNone );
+    }
+    
+// -----------------------------------------------------------------------------
+// CWimCertConverter::~CWimCertConverter()
+// Allocated memory is released.
+// -----------------------------------------------------------------------------
+EXPORT_C CWimCertConverter::~CWimCertConverter()
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::~CWimCertConverter()" ) );
+    Cancel();
+    if( iConnectionHandle )
+        {
+        iConnectionHandle->DeallocWimCertPckgBuf();
+        iConnectionHandle->DeallocCertAddParametersPckgBuf();
+        iConnectionHandle->DeallocRemoveCertPckgBuf();
+        iConnectionHandle->DeallocGetExtrasPckgBuf();
+        iConnectionHandle->Close();
+        delete iConnectionHandle;
+        }
+    
+    DeallocWimCertInfo();
+    DeallocCertHBufs();
+    DeallocReferences();
+    delete iTrustedUsages;
+    delete iTrustedUsagesPtr;
+    delete iKeyIdBuf;
+    delete iKeyIdPointer;
+
+    }
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::RunL()
+// This has eight different phases which are explained here:
+// 1. EListCertsFromWim:Allocate member variables for arrays usage. 
+//    Array is passed as an argument to server and it is filled with 
+//    certificate information found from WIM.
+// 2. ECreateNewCertObjects: New certificate objects are created based on 
+//    received information on step one. A little bit of conversion is 
+//    required. Objects are inserted to an array.
+// 3. ERetrieveCertificate:Allocate member variables for struct, 
+//    which is used to fetch certificate details
+// 4. ERetrievingCompleted: Check cancellation. If not cancelled,
+//    copy information to caller's buffer. 
+// 5. EAddCertificate: Adds certificate to WIM.
+// 6. EAddCertificateCompleted: Certificate is added successfully. Deallocate
+//                              variables and complete request.
+// 7. ERemove: Before removing, we will check for cancellation. After that
+//    cancellation is too late.
+// 8. ERemoveCompleted: Removal operation completed ok. Deallocte variables and
+//    complete request
+// 9. EGetCertExtras: Extra data is fetched and async. waiter needs to be 
+//    stopped
+// -----------------------------------------------------------------------------
+void CWimCertConverter::RunL()
+    {
+    _WIMTRACE3( _L( "CWimCertConverter::RunL()|iPhase=%d, iStatus = %d" ), iPhase, iStatus.Int() );
+    //Check for error
+    if( iStatus.Int() != KErrNone )
+        {
+        //failed to retrieve certificate
+        if ( iPhase == ERetrievingCompleted )
+            {
+             iConnectionHandle->DeallocWimCertPckgBuf();
+             DeallocCertHBufs();
+             _WIMTRACE2 ( _L( "CWimCertConverter::RunL() failed to retrieve \
+                 certificate, ERROR = %d" ),iStatus.Int() );
+            }
+        //failed to add certificate
+        else if ( iPhase == EAddCertificateCompleted )
+            {
+            //If user has tried to cancel at this stage, ignore flag.
+            iConnectionHandle->DeallocCertAddParametersPckgBuf();
+            DeallocCertHBufs();
+             _WIMTRACE2 ( _L( "CWimCertConverter::RunL() failed to add \
+                 certificate, ERROR = %d" ),iStatus.Int() );
+            }
+        //failed to remove certificate
+        else if ( iPhase == ERemoveCompleted )
+            {
+            //If user has tried to cancel at this stage, ignore flag.
+            iConnectionHandle->DeallocRemoveCertPckgBuf();
+             _WIMTRACE2 ( _L( "CWimCertConverter::RunL() failed to remove \
+                 certificate, ERROR = %d" ), iStatus.Int() );
+            }
+        User::RequestComplete( iClientStatus, iStatus.Int() );
+        }
+    else
+        {
+        switch( iPhase )
+            {
+            case EListCertsFromWim: //get certificates from WIM.
+                {                  
+                if ( iArraySize ) //Delete previous preferences. 
+                    {           //User might added or removed a certificate. 
+                    DeallocWimCertInfo();
+                    DeallocReferences();
+                    }
+            
+                //Ok ready to begin. First get Cert count
+                iCertCount = iConnectionHandle->CertCount( EWimEntryTypeAll ); 
+                _WIMTRACE2 ( _L( "CWimCertConverter::RunL() \
+                    certCount =%d" ),iCertCount );
+                if ( !iCertCount )  
+                    {
+                    User::RequestComplete( iClientStatus, KErrNotFound );
+                    }
+                else
+                    {
+                    iCertRefLst = new( ELeave ) TCertificateAddress[iCertCount];
+
+                    //Creates new array according to certificate count
+                    iCertInfoArr  = new( ELeave ) TWimCertInfo[iCertCount];
+            
+                    AllocWimCertInfoL( iCertInfoArr, iCertCount );
+                    iStatus = KRequestPending;
+                    iConnectionHandle->CertRefLst( iCertRefLst, 
+                                          iCertInfoArr, 
+                                          iCertCount, 
+                                          EWimEntryTypeAll, 
+                                          iStatus );
+                    iPhase = ECreateNewCertObjects;
+                    iIndex = 0;
+                    SetActive();    
+                    _WIMTRACE ( _L( "CWimCertConverter::RunL() \
+                        GetCertRefLst" ) );
+                    }
+                break;
+                }
+            case ECreateNewCertObjects: //Certificates fetched, 
+                { 
+                CreateNewCertObjectsL();//create new cert-objects
+                break;
+                }
+            case EGetTrustedUsages:
+                {
+                GetTrustedUsagesL();
+                break;
+                }
+            case ETrustedUsagesDone:
+                {
+                TrustedUsagesDoneL();
+                break;
+                }
+            case ECertObjectsDone: 
+                {
+                User::RequestComplete( iClientStatus, KErrNone );    
+                _WIMTRACE ( _L( "CWimCertConverter::RunL() \
+                    ECertObjectsDone" ) );
+                break;
+                }
+            case ERetrieveCertificate: //Get Cert details from WIM
+                {
+                AllocMemoryForCertDetailsL();
+                iConnectionHandle->CertDetailsL( 
+                            iCertRefLst[iCertRetrieveIndex], 
+                            iWimCertDetails, 
+                            iStatus );
+                iPhase = ERetrievingCompleted;
+                SetActive();
+                _WIMTRACE ( _L( "CWimCertConverter::RunL() \
+                    ERetrieveCertificate" ) );
+                break;
+                }
+            case ERetrievingCompleted: //Cert details fetched, check errors &                         
+                {                      //cancellations & complete request                   
+                //copy cert details to iEncodedCert -buffer,
+                //which points to received aEncoded -cert buffer.
+                CopyRetrievedCertData();
+                iConnectionHandle->DeallocWimCertPckgBuf();                
+                DeallocCertHBufs();
+                User::RequestComplete( iClientStatus, KErrNone );
+                _WIMTRACE ( _L( "CWimCertConverter::RunL() \
+                    ERetrievingCompleted" ) );
+                break;
+                }
+            case EAddCertificate: //Add a certificate
+                {
+                iConnectionHandle->StoreCertificateL( *iCertHBufOnePtr, 
+                                                iParam, 
+                                                EWimCertLocationWIMCard, 
+                                                iStatus );  
+                iPhase = EAddCertificateCompleted;
+                SetActive();   
+                _WIMTRACE ( _L( "CWimCertConverter::RunL() \
+                    EAddCertificate" ) );                    
+                break;
+                }
+            case EAddCertificateCompleted: //certificate added 
+                {
+                iConnectionHandle->DeallocCertAddParametersPckgBuf();
+                DeallocCertHBufs();
+                User::RequestComplete( iClientStatus, KErrNone );
+                _WIMTRACE ( _L( "CWimCertConverter::RunL() \
+                        EAddCertificateCompleted" ) );                    
+                break;
+                }
+            case ERemove:                //remove certificate
+                {
+                iWimCertRemoveAddr.iCertAddr = 
+                                iCertRefLst[iCertRetrieveIndex];
+                iWimCertRemoveAddr.iLocation = EWimCertLocationWIMCard;
+                iConnectionHandle->RemoveL( iWimCertRemoveAddr, iStatus );
+                iPhase = ERemoveCompleted;
+                SetActive();
+                _WIMTRACE ( _L( "CWimCertConverter::RunL() \
+                    ERemove" ) );                    
+
+                break;
+                }  
+            case ERemoveCompleted:      //certificate removed. 
+                {
+                iConnectionHandle->DeallocRemoveCertPckgBuf();
+                User::RequestComplete( iClientStatus, KErrNone );
+                _WIMTRACE ( _L( "CWimCertConverter::RunL() \
+                        ERemoveCompleted" ) ); 
+                break;
+                }
+            default:
+                {
+                User::RequestComplete( iClientStatus, KErrNotSupported );
+                break;
+                }
+                
+            }
+        }
+    }
+
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::CreateNewCertObjectsL()
+// Creates new certificate objects which can be returned to the caller.
+// -----------------------------------------------------------------------------
+void CWimCertConverter::CreateNewCertObjectsL()
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::CreateNewCertObjectsL()" ) );
+
+    HBufC16* label16 = NULL;
+    HBufC8* hash8 = NULL;
+
+    if ( iIndex < iCertCount )
+        {
+        TCertificateOwnerType certificateType;
+        if ( iCertInfoArr[iIndex].iUsage == 0 )
+            {
+            certificateType = EUserCertificate; // 0 == User
+            }
+        else
+            {
+            certificateType = ECACertificate;   // 1 == CA
+            }
+                        
+        label16 = HBufC16::NewLC( iCertInfoArr[iIndex].iLabel.Length() );
+        label16->Des().Copy( iCertInfoArr[iIndex].iLabel );
+            
+        hash8 = HBufC8::NewLC( iCertInfoArr[iIndex].iIssuerHash.Length() );
+        hash8->Des().Copy( iCertInfoArr[iIndex].iIssuerHash );
+        // Convert type 
+        TCertificateFormat format;
+        format = GetCertFormatByIndex( iIndex );
+        //Create key indentifiers
+        TKeyIdentifier subjectKeyId;
+        TKeyIdentifier issuerKeyId;
+        //needs these for CCTCertInfo object -creation
+        subjectKeyId = iCertInfoArr[iIndex].iKeyId;
+        issuerKeyId  = iCertInfoArr[iIndex].iCAId;
+        //Create CCTCertInfo object. 
+        if ( iCertInfoArr[iIndex].iIssuerHash.Length() > 0 )
+            {
+            /**
+            * Certificate modification is not supported in 3.0, 
+            * the iCertInfoArr[iIndex].iModifiable will be replaced 
+            * by EFalse. 
+            * In the future, when modification is supported, it will be 
+            * change back.
+            */
+            iCertInfoArr[iIndex].iModifiable = EFalse;
+            iCert = CCTCertInfo::NewL( label16->Des(), 
+                                      format, 
+                                      certificateType,
+                                      iCertInfoArr[iIndex].iCertlen, 
+                                      &subjectKeyId, 
+                                      &issuerKeyId, 
+                                      iToken, 
+                                      iIndex,
+                                      iCertInfoArr[iIndex].iModifiable,
+                                      hash8 );
+            }
+        else
+            {
+            /**
+            * Same reason as mentioned above
+            */
+            iCertInfoArr[iIndex].iModifiable = EFalse;
+            iCert = CCTCertInfo::NewL( label16->Des(), 
+                                      format, 
+                                      certificateType,
+                                      iCertInfoArr[iIndex].iCertlen, 
+                                      &subjectKeyId, 
+                                      &issuerKeyId, 
+                                      iToken, 
+                                      iIndex,
+                                      iCertInfoArr[iIndex].iModifiable );
+            }
+
+        CleanupStack::PopAndDestroy( hash8 ); 
+        CleanupStack::PopAndDestroy( label16 );
+
+        iOids = new( ELeave ) RArray<HBufC*>();
+        //Check whether certificate has extra data. Certificate type must be
+        // X509
+        if ( iCertInfoArr[iIndex].iCDFRefs &&
+             iCertInfoArr[iIndex].iType == WIMI_CT_X509 )
+            {  
+            iPhase = EGetTrustedUsages;
+            }
+        else
+            {
+            CreateNewWimCertObjectL();
+            }
+        }
+    else
+        {
+        DeallocWimCertInfo(); 
+        iPhase = ECertObjectsDone;
+        }
+    SignalOwnStatusAndComplete();
+    }
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::CreateNewWimCertObjectL()
+// 
+// -----------------------------------------------------------------------------
+void CWimCertConverter::CreateNewWimCertObjectL()
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::CreateNewWimCertObjectL()" ) );
+
+    iCertInfo = CWimCertInfo::NewL( iCert, //CCTCertInfo object
+                                    iCert->SubjectKeyId(), //key hash
+                                    *iOids, 
+                                    iCertInfoArr[iIndex].iCDFRefs );
+    
+    delete iOids;
+    iOids = NULL;
+
+    //Append WimCertInfo -object to array. Ownership to iArray here.
+    User::LeaveIfError( iArray->Append( iCertInfo ) );
+
+    iPhase = ECreateNewCertObjects;
+    iIndex++;
+    }
+        
+// -----------------------------------------------------------------------------
+// CWimCertConverter::GetTrustedUsagesL
+// Get trusted usages (OIDs) of a current certificate, which is pointed out 
+// by a index
+// -----------------------------------------------------------------------------
+void CWimCertConverter::GetTrustedUsagesL()
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::GetTrustedUsagesL() | Begin" ) );
+
+    delete iTrustedUsages;
+    iTrustedUsages = NULL;
+    delete iTrustedUsagesPtr;
+    iTrustedUsagesPtr = NULL;
+    //Allocate variables for trusted usage fetching
+    iTrustedUsages = HBufC::NewL( iCertInfoArr[iIndex].iTrustedUsageLength );
+    iTrustedUsagesPtr = new( ELeave ) TPtr( iTrustedUsages->Des() );
+
+    iCertExtrasInfo.iTrustedUsage = iTrustedUsagesPtr;
+    iPhase = ETrustedUsagesDone;
+
+    delete iKeyIdBuf;
+    iKeyIdBuf = NULL;
+    delete iKeyIdPointer;
+    iKeyIdPointer = NULL;
+    // Take a copy of key identifier
+    iKeyIdBuf = iCertInfoArr[iIndex].iKeyId.AllocL();
+    iKeyIdPointer = new( ELeave ) TPtr8( iKeyIdBuf->Des() );
+
+    iConnectionHandle->GetCertExtrasL( iKeyIdPointer,
+                                       iCertExtrasInfo,
+                                       iCertInfoArr[iIndex].iUsage,
+                                       iStatus );
+    SetActive();
+    _WIMTRACE ( _L( "CWimCertConverter::GetTrustedUsagesL() | End" ) );
+    }
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::TrustedUsagesDoneL()
+// -----------------------------------------------------------------------------
+void CWimCertConverter::TrustedUsagesDoneL()
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::TrustedUsagesDoneL()" ) );
+    if ( iStatus.Int() == KErrNone )
+        {
+        //Parse oids and put them to an array
+        TLex16 lex( *iTrustedUsages );
+        TPtrC16 lexToken;
+        for ( TBool extrasDone = EFalse; extrasDone == EFalse; )
+            {
+            lexToken.Set( lex.NextToken() );
+            if ( lexToken.Length() )
+                {
+                HBufC* oid = lexToken.AllocLC();
+                User::LeaveIfError( iOids->Append( oid ) );
+                CleanupStack::Pop( oid ); //oid
+                }
+            else
+                {
+                extrasDone = ETrue;
+                }
+            }
+        CreateNewWimCertObjectL();
+        SignalOwnStatusAndComplete();
+        }
+    else
+        {
+        User::RequestComplete( iClientStatus, iStatus.Int() );
+        }
+
+    iConnectionHandle->DeallocGetExtrasPckgBuf();
+    }
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::GetCertFormatByIndex()
+// Returns certificate format according to received index
+// -----------------------------------------------------------------------------
+TCertificateFormat CWimCertConverter::GetCertFormatByIndex( TInt aIndex )
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::GetCertFormatByIndex()" ) );
+
+    // Convert type 
+    TCertificateFormat format;
+    switch ( iCertInfoArr[aIndex].iType )
+        {
+        case WIMI_CT_WTLS: 
+            {
+            format = EWTLSCertificate;
+            break;
+            }
+        case WIMI_CT_X509: 
+            {
+            format = EX509Certificate;
+            break;
+            }
+        case WIMI_CT_X968: 
+            {
+            format = EX968Certificate;
+            break;
+            }
+        case WIMI_CT_URL: 
+            {
+            format = EX509CertificateUrl;
+            break;
+            }
+        default:
+            {
+            format = EUnknownCertificate;
+            break;
+            }         
+        }
+    return format;
+    }
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::DoCancel()
+// Deallocates member variables and completes client status with
+// KErrCancel error code.
+// -----------------------------------------------------------------------------
+void CWimCertConverter::DoCancel()
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::DoCancel()" ) );
+    if ( iConnectionHandle && iPhase == ERetrievingCompleted )
+        {
+        iConnectionHandle->DeallocWimCertPckgBuf();
+        }
+    else if ( iConnectionHandle && iPhase == EAddCertificateCompleted ) 
+        {
+        iConnectionHandle->DeallocCertAddParametersPckgBuf();
+        }
+    else if ( iConnectionHandle && iPhase == ERemoveCompleted ) 
+        {
+        iConnectionHandle->DeallocRemoveCertPckgBuf();
+        }
+    else if ( iConnectionHandle && iPhase == ETrustedUsagesDone ) 
+        {
+        iConnectionHandle->DeallocGetExtrasPckgBuf();
+        }
+
+    if ( iPhase == EGetTrustedUsages || iPhase == ETrustedUsagesDone )
+        {
+        iCert->Release();
+        }
+
+    DeallocWimCertInfo();
+    DeallocCertHBufs();
+    DeallocReferences();
+    User::RequestComplete( iClientStatus, KErrCancel );
+    }
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::RunError() 
+//                                       
+// The active scheduler calls this function if this active object's RunL() 
+// function leaves. This gives this active object the opportunity to perform 
+// any necessary cleanup.
+// After array's cleanup, complete request with received error code.
+// -----------------------------------------------------------------------------
+TInt CWimCertConverter::RunError( TInt aError )
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::RunError \
+            Error = %d" ) );
+    DeallocWimCertInfo();
+    DeallocCertHBufs();
+    delete iTrustedUsages;
+    iTrustedUsages = NULL;
+    delete iTrustedUsagesPtr;
+    iTrustedUsagesPtr = NULL;
+    delete iKeyIdBuf;
+    iKeyIdBuf = NULL;
+    delete iKeyIdPointer;
+    iKeyIdPointer = NULL;
+
+    User::RequestComplete( iClientStatus, aError );
+    return KErrNone;
+    }
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::AllocWimCertInfoL()
+// Allocates memory for the array which is filled by server.
+// -----------------------------------------------------------------------------
+void CWimCertConverter::AllocWimCertInfoL( TWimCertInfo* aWimCertInfoArr, 
+                                           TInt aCount )
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::AllocWimCertInfoL()" ) );
+
+    TUint8 index;    
+    //These are arrays
+    iLabel = new( ELeave ) PHBufC8[aCount];
+    iKeyId = new( ELeave ) PHBufC8[aCount];
+    iCAId  = new( ELeave ) PHBufC8[aCount];
+    iIssuerHash = new( ELeave ) PHBufC8[aCount];
+
+    iLabelPtr = new( ELeave ) PTPtr8[aCount];
+    iKeyIdPtr = new( ELeave ) PTPtr8[aCount];
+    iCAIdPtr  = new( ELeave ) PTPtr8[aCount];
+    iIssuerHashPtr = new( ELeave ) PTPtr8[aCount];
+
+    for ( index = 0; index < aCount ; index++ )
+        {
+        iLabel[index] = HBufC8::NewL( KLabelLen );
+        iKeyId[index] = HBufC8::NewL( KKeyIdLen );
+        iCAId[index]  = HBufC8::NewL( KPkcs15IdLen );
+        iIssuerHash[index] = HBufC8::NewL( KIssuerHash );
+        
+        iLabelPtr[index]  = new( ELeave ) TPtr8( iLabel[index]->Des() );
+        iKeyIdPtr[index]  = new( ELeave ) TPtr8( iKeyId[index]->Des() );
+        iCAIdPtr[index]   = new( ELeave ) TPtr8( iCAId[index]->Des() );
+        iIssuerHashPtr[index] = new( ELeave ) 
+                                TPtr8( iIssuerHash[index]->Des() );
+
+        aWimCertInfoArr[index].iLabel.Copy( iLabelPtr[index]->Ptr(),
+                                            iLabelPtr[index]->Length() );
+        aWimCertInfoArr[index].iKeyId.Copy( iKeyIdPtr[index]->Ptr(),
+                                            iKeyIdPtr[index]->Length() );
+        aWimCertInfoArr[index].iCAId.Copy( iCAIdPtr[index]->Ptr(),
+                                           iCAIdPtr[index]->Length() );
+        aWimCertInfoArr[index].iIssuerHash.Copy(
+            iIssuerHashPtr[index]->Ptr(), iIssuerHashPtr[index]->Length() );
+        }
+    iArraySize = aCount;   
+    }
+
+ 
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::AllocMemoryForCertDetailsL()
+// Allocates memory for a struct which is filled by server.
+// -----------------------------------------------------------------------------     
+void CWimCertConverter::AllocMemoryForCertDetailsL()
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::AllocMemoryForCertDetailsL()" ) );
+    iCertHBufOne = HBufC8::NewL( iEncodedCert->MaxLength() ); //whole cert
+    iCertHBufOnePtr = new( ELeave ) TPtr8( iCertHBufOne->Des() ); 
+    iWimCertDetails.iCert = iCertHBufOnePtr;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::CopyRetrievedCertData()
+// Writes data to caller's buffer by using pointer.
+// -----------------------------------------------------------------------------
+void CWimCertConverter::CopyRetrievedCertData()
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::CopyRetrievedCertData()" ) );
+    TPtr8 ptr = iCertHBufOne->Des();
+    iEncodedCert->Copy( ptr );
+    }
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::DeallocCertHBufs()
+// DeAllocates memory from member variables, which are used
+// when communicating with WIM.
+// -----------------------------------------------------------------------------
+void CWimCertConverter::DeallocCertHBufs()
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::DeallocCertHBufs()" ) ); 
+    if ( iCertHBufOne )
+        {
+        delete iCertHBufOne;
+        delete iCertHBufOnePtr;
+        iCertHBufOne = NULL;
+        iCertHBufOnePtr = NULL;
+        }
+    if ( iCertHBufTwo )
+        {
+        delete iCertHBufTwo;
+        delete iCertHBufTwoPtr;
+        iCertHBufTwo = NULL;
+        iCertHBufTwoPtr = NULL;
+        }
+    if ( iCertHBufThree )
+        {
+        delete iCertHBufThree;
+        delete iCertHBufThreePtr;
+        iCertHBufThree = NULL;
+        iCertHBufThreePtr = NULL;
+        }
+    if ( iCertHBufFour )
+        {
+        delete iCertHBufFour;
+        delete iCertHBufFourPtr;
+        iCertHBufFour = NULL;
+        iCertHBufFourPtr = NULL;
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::DeallocReferences()
+// Deallocates memory. If user has cancelled initialization process, we need
+// to dealloc our references to loaded certs. 
+// -----------------------------------------------------------------------------
+void CWimCertConverter::DeallocReferences()
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::DeallocReferences()" ) ); 
+    if ( iCertRefLst )
+        {
+        delete[] iCertRefLst;  
+        iCertRefLst = NULL;
+        }
+    if ( iCertInfoArr )
+        {
+        delete[] iCertInfoArr;
+        iCertInfoArr = NULL;
+        }  
+    iArraySize = 0;
+    iArray = NULL;
+    iCertCount = 0;
+    }
+
+// -----------------------------------------------------------------------------
+// CWimCertConverter::DeallocWimCertInfo()
+// Deallocates memory. If something has leaved during asynchronous request, we 
+// will deallocate all member data. 
+// -----------------------------------------------------------------------------
+void CWimCertConverter::DeallocWimCertInfo()
+    {
+    _WIMTRACE ( _L( "CWimCertConverter::DeallocWimCertInfo()" ) ); 
+    TUint8 index;
+    for ( index = 0; index < iArraySize; index ++ )
+        {
+        if ( iLabel )
+            {
+            delete iLabel[index];
+            }
+        if ( iKeyId )
+            {
+            delete iKeyId[index];
+            }
+        if ( iCAId )
+            {
+            delete iCAId[index];
+            }
+        if ( iIssuerHash )
+            {
+            delete iIssuerHash[index];
+            }
+        if ( iLabelPtr )
+            {
+            delete iLabelPtr[index];
+            }
+        if ( iKeyIdPtr )
+            {
+            delete iKeyIdPtr[index];
+            }
+        if ( iCAIdPtr )
+            {
+            delete iCAIdPtr[index];
+            }
+        if ( iIssuerHashPtr )
+            {
+            delete iIssuerHashPtr[index];
+            }
+        }
+
+    delete[] iLabel;
+    delete[] iKeyId;
+    delete[] iCAId;
+    delete[] iIssuerHash;
+    delete[] iLabelPtr;
+    delete[] iKeyIdPtr;
+    delete[] iCAIdPtr;
+    delete[] iIssuerHashPtr;
+    iLabel = NULL;
+    iKeyId  = NULL;
+    iCAId = NULL;
+    iIssuerHash = NULL;
+    iLabelPtr = NULL;
+    iKeyIdPtr = NULL;
+    iCAIdPtr = NULL;
+    iIssuerHashPtr = NULL;
+    }