/*

* 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:  Utility functions for certificate related functionality

*

*/

#include    "WimCertUtil.h"

#include    "WimTrace.h"

#include    "WimCertInfo.h"

#include    "WimUtilityFuncs.h"

#include    "WimCleanup.h"

#include    <cctcertinfo.h>

#include    <asn1dec.h>         // ASN.1 decoding

// -----------------------------------------------------------------------------

// CWimCertUtil::CWimCertUtil()

// Default constructor

// -----------------------------------------------------------------------------

CWimCertUtil::CWimCertUtil( MCTToken& aToken )

    : CActive( EPriorityStandard ),

      iToken( aToken )

    {

    }

// -----------------------------------------------------------------------------

// CWimCertUtil::NewL()

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

CWimCertUtil* CWimCertUtil::NewL( MCTToken& aToken )

    {

    _WIMTRACE( _L( "WimServer|CWimCertUtil::NewL" ) );

    CWimCertUtil* self = new( ELeave ) CWimCertUtil( aToken );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self ); //self

    return self;

    }

// -----------------------------------------------------------------------------

// CWimCertUtil::ConstructL()

// Second phase

// -----------------------------------------------------------------------------

void CWimCertUtil::ConstructL()

    {

    _WIMTRACE( _L( "WimServer|CWimCertUtil::ConstructL" ) );

    CActiveScheduler::Add( this );

    iWimUtilFuncs = CWimUtilityFuncs::NewL();

    _WIMTRACE ( _L( "CWimCertUtil::ConstructL() completed" ) );

    }

// -----------------------------------------------------------------------------

// CWimCertUtil::Restore()

// Returns CCTCertInfo objects in array

// -----------------------------------------------------------------------------

void CWimCertUtil::Restore( RPointerArray<CWimCertInfo>& aArray, 

                            TRequestStatus& aStatus )

    {

    _WIMTRACE( _L( "WimServer|CWimCertUtil::Restore" ) );

    iClientStatus = &aStatus;

    aStatus = KRequestPending;

    iArray = &aArray;

    iPhase = EListCertsFromWim;

    SignalOwnStatusAndComplete();

    }

// -----------------------------------------------------------------------------

// CWimCertUtil::CancelRestore()

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

// After necessary cleanup, caller is signalled with KErrCancel 

// -error code.

// -----------------------------------------------------------------------------

void CWimCertUtil::CancelRestore()

    {

    _WIMTRACE ( _L( "CWimCertUtil::CancelRestore" ) );

    Cancel(); 

    }

// -----------------------------------------------------------------------------

// CWimCertUtil::RetrieveCertByIndexL()

// Retrieves the actual certificate.

// -----------------------------------------------------------------------------

void CWimCertUtil::RetrieveCertByIndexL( const TInt aIndex,

                                         TDes8& aEncodedCert, 

                                         TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "WimServer|CWimCertUtil::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();

    }

// -----------------------------------------------------------------------------

// CWimCertUtil::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. 

// -----------------------------------------------------------------------------

void CWimCertUtil::SignalOwnStatusAndComplete()

    {

    _WIMTRACE( _L( "WimServer|CWimCertUtil::SignalOwnStatusAndComplete()" ) );

    iStatus = KRequestPending;

    SetActive();

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    }

// -----------------------------------------------------------------------------

// CWimCertUtil::~CWimCertUtil()

// Allocated memory is released.

// -----------------------------------------------------------------------------

CWimCertUtil::~CWimCertUtil()

    {

    _WIMTRACE( _L( "WimServer|CWimCertUtil::~CWimCertUtil()" ) );

    Cancel();

    DeallocWimCertInfo();

    DeallocCertHBufs();

    DeallocReferences();

    delete iTrustedUsages;

    delete iTrustedUsagesPtr;

    delete iKeyIdBuf;

    delete iKeyIdPointer;

    delete iWimUtilFuncs;

    }

// -----------------------------------------------------------------------------

// CWimCertUtil::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 CWimCertUtil::RunL()

    {

    _WIMTRACE3(_L("WimServer|CWimCertUtil::RunL(), iStatus=%d, iPhase=%d"), iStatus.Int(), iPhase);

    //Check for error

    if ( iStatus.Int() != KErrNone )

        {

        //failed to retrieve certificate

        if ( iPhase == ERetrievingCompleted )

            {

             DeallocCertHBufs();

             _WIMTRACE2 ( _L( "CWimCertUtil::RunL() failed to retrieve \

                 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 = CertCount( EWimEntryTypeAll ); 

                _WIMTRACE2 ( _L( "CWimCertUtil::RunL() \

                    certCount =%d" ),iCertCount );

                if ( !iCertCount )  

                    {

                    User::RequestComplete( iClientStatus, KErrNotFound );

                    }

                else

                    {

                    __ASSERT_DEBUG( iCertRefLst == NULL, User::Invariant() );

                    iCertRefLst = new( ELeave ) TCertificateAddress[iCertCount];

                    //Creates new array according to certificate count

                    __ASSERT_DEBUG( iCertInfoArr == NULL, User::Invariant() );

                    iCertInfoArr  = new( ELeave ) TWimCertInfo[iCertCount];

                    AllocWimCertInfoL( iCertInfoArr, iCertCount );

                    iStatus = KRequestPending;

                    CertRefLstL( iCertRefLst, 

                                 iCertInfoArr, 

                                 EWimEntryTypeAll );

                    iPhase = ECreateNewCertObjects;

                    iIndex = 0;

                    SetActive();

                    TRequestStatus* status = &iStatus;

                    User::RequestComplete( status, KErrNone );

                    _WIMTRACE( _L( "CWimCertUtil::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( "CWimCertUtil::RunL() \

                    ECertObjectsDone" ) );

                break;

                }

            case ERetrieveCertificate: //Get Cert details from WIM

                {

                AllocMemoryForCertDetailsL();

                CertDetailsL( iCertRefLst[iCertRetrieveIndex], 

                              iWimCertDetails );

                iPhase = ERetrievingCompleted;

                SetActive();

                TRequestStatus* status = &iStatus;

                    User::RequestComplete( status, KErrNone );

                _WIMTRACE ( _L( "CWimCertUtil::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();

                DeallocCertHBufs();

                User::RequestComplete( iClientStatus, KErrNone );

                _WIMTRACE ( _L( "CWimCertUtil::RunL() \

                    ERetrievingCompleted" ) );

                break;

                }

            default:

                {

                User::RequestComplete( iClientStatus, KErrNotSupported );

                break;

                }          

            }

        }

    }

// -----------------------------------------------------------------------------

// CWimCertUtil::CreateNewCertObjectsL()

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

// -----------------------------------------------------------------------------

void CWimCertUtil::CreateNewCertObjectsL()

    {

    _WIMTRACE( _L( "WimServer|CWimCertUtil::CreateNewCertObjectsL() | Begin" ) );

    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 )

            {

            iCert = CCTCertInfo::NewL( label16->Des(), 

                                      format, 

                                      certificateType,

                                      iCertInfoArr[iIndex].iCertlen, 

                                      &subjectKeyId, 

                                      &issuerKeyId, 

                                      iToken, 

                                      iIndex,

                                      iCertInfoArr[iIndex].iModifiable,

                                      hash8 );

            }

        else

            {

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

    }

// -----------------------------------------------------------------------------

// CWimCertUtil::CreateNewWimCertObjectL()

// 

// -----------------------------------------------------------------------------

void CWimCertUtil::CreateNewWimCertObjectL()

    {

    _WIMTRACE( _L( "WimServer|CWimCertUtil::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++;

    }

// -----------------------------------------------------------------------------

// CWimCertUtil::GetTrustedUsagesL

// Get trusted usages (OIDs) of a current certificate, which is pointed out 

// by a index

// -----------------------------------------------------------------------------

void CWimCertUtil::GetTrustedUsagesL()

    {

    _WIMTRACE( _L( "WimServer|CWimCertUtil::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() );

    GetCertExtrasL( iKeyIdPointer,

                    iCertExtrasInfo,

                    iCertInfoArr[iIndex].iUsage,

                    iStatus );

    SetActive();

    _WIMTRACE ( _L( "CWimCertUtil::GetTrustedUsagesL() | End" ) );

    }

// -----------------------------------------------------------------------------

// CWimCertUtil::TrustedUsagesDoneL()

// -----------------------------------------------------------------------------

void CWimCertUtil::TrustedUsagesDoneL()

    {

    _WIMTRACE( _L( "WimServer|CWimCertUtil::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() );

        }

    }

// -----------------------------------------------------------------------------

// CWimCertUtil::GetCertFormatByIndex()

// Returns certificate format according to received index

// -----------------------------------------------------------------------------

TCertificateFormat CWimCertUtil::GetCertFormatByIndex( TInt aIndex )

    {

    _WIMTRACE ( _L( "WimServer|CWimCertUtil::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;

    }

// -----------------------------------------------------------------------------

// CWimCertUtil::DoCancel()

// Deallocates member variables and completes client status with

// KErrCancel error code.

// -----------------------------------------------------------------------------

void CWimCertUtil::DoCancel()

    {

    _WIMTRACE( _L( "WimServer|CWimCertUtil::DoCancel()" ) );

    if ( iPhase == EGetTrustedUsages || iPhase == ETrustedUsagesDone )

        {

        iCert->Release();

        }