/*

* 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:  Implementation of single certificate store interface

*

*/

// INCLUDE FILES

#include "WimCertStore.h"

#include "WimCertConverter.h"

#include "WimCertInfo.h"

#include "WimTrustSettingsAPI.h"

#include "WimTrace.h"

#include "WimToken.h"

#include "WimTokenListener.h"

#include <unifiedkeystore.h>

#include <ct.h>

#include <x509cert.h>

#include <x509certext.h>

#include <wtlscert.h>

#include <certificateapps.h>

// ============================ MEMBER FUNCTIONS ===============================

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

// CWimCertStore::CWimCertStore()

// Default constructor

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

//

CWimCertStore::CWimCertStore( CWimToken& aToken )

                            : CActive( EPriorityNormal ),

                              iToken( aToken )

    {

    CActiveScheduler::Add( this );

    }

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

// CWimCertStore::NewL()

// Two-phased constructor

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

//

CWimCertStore* CWimCertStore::NewL( CWimToken& aToken )

    {

    _WIMTRACE ( _L( "CWimCertStore::NewL()" ) );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWimCertStore::ConstructL()

// Instantiates converter, completes message

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

//

void CWimCertStore::ConstructL()

    {

    _WIMTRACE ( _L( "CWimCertStore::ConstructL()" ) );

    iCWimCertConverter = CWimCertConverter::NewL( Token() );

    // Open trust settings database

    iCWimTrustSettingsStore = CWimTrustSettingsAPI::NewL();

    iPhase = EIdle;

    iPhaseOriginal = EIdle;

    }

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

// CWimCertStore::~CWimCertStore()

// Destructor

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

//

CWimCertStore::~CWimCertStore()

    {

    _WIMTRACE ( _L( "CWimCertStore::~CWimCertStore()" ) );

    Cancel();

    iKeyInfos.Close();

    if ( iCerts )

        {

        delete iCerts;

        }

    iCertInfos.ResetAndDestroy();

    iCertsList = NULL;

    delete iUnifiedKeyStore;

    if ( iCWimTrustSettingsStore )

        {

        iCWimTrustSettingsStore->Close();

        }

    iOriginalRequestStatus = NULL;

    iFilter = NULL;

    iEncodedCert = NULL;

    if ( iCWimCertConverter )

        {

        delete iCWimCertConverter;

        }

    if ( iOldTrusters )

        {

        iOldTrusters->Close();

        delete iOldTrusters;

        }

    }

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

// CWimCertStore::Token()

// Returns a reference to current token (MCTToken) of this certificate store

// interface. Reference is created during construction.

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

//

MCTToken& CWimCertStore::Token()

    {

    _WIMTRACE ( _L( "CWimCertStore::Token()" ) );

    return iToken;

    }

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

// CWimCertStore::DoRelease()

// Deletes this interface on demand.

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

//

void CWimCertStore::DoRelease()

    {

    _WIMTRACE ( _L( "CWimCertStore::DoRelease()" ) );

    delete this;

    }

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

// CWimCertStore::List()

// Lists certificates according to filter parameter.

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

//

void CWimCertStore::List( RMPointerArray<CCTCertInfo>& aCertInfos,

                          const CCertAttributeFilter& aFilter,

                          TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "CWimCertStore::List()" ) );

    if ( !EnteringAllowed( aStatus ) )

        {

        return;

        }

    iCertsList = &aCertInfos;

    iFilter = &aFilter;

    if ( iFilter->iKeyUsage != EX509UsageAll )

        {

        // We must ensure that in this case only user certs are allowed

        if ( iFilter->iOwnerTypeIsSet &&

             iFilter->iOwnerType == EUserCertificate )

            {

            // We have to initialize the unified key store because

            // in this phase we don't know if user certificates are found or not.

            // User certificate private key must be checked for usage reason

            if ( iUnifiedKeyStore )

                {

                User::RequestComplete( iOriginalRequestStatus, KErrCorrupt );

                }

            else

                {

                iFs = static_cast<CCTTokenType&>( Token().TokenType() ).Fs();

                TRAPD( err, iUnifiedKeyStore = CUnifiedKeyStore::NewL( iFs ) );

                if ( err != KErrNone )

                    {

                    User::RequestComplete( iOriginalRequestStatus, err );

                    }

                else

                    {

                    iPhase = EGetKeyInfos;

                    iUnifiedKeyStore->Initialize( iStatus );

                    SetActive();

                    }

                }

            }

        else

            {

            User::RequestComplete( iOriginalRequestStatus, KErrArgument );

            }

        }

    else

        {

        iPhase = EList;

        iPhaseOriginal = EList;

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

        SetActive();

        }

    }

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

// CWimCertStore::CancelList()

// Cancels issued List operation. Main functionality in DoCancel().

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

//

void CWimCertStore::CancelList()

    {

    _WIMTRACE ( _L( "CWimCertStore::CancelList()" ) );

    if ( TokenRemoved() )

        {

        return;

        }

    Cancel();

    }

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

// CWimCertStore::GetCert()

// Fetches one certificate info according to given handle.

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

//

void CWimCertStore::GetCert( CCTCertInfo*& aCertInfo,

                             const TCTTokenObjectHandle& aHandle,

                             TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "CWimCertStore::GetCert()" ) );

    if ( !EnteringAllowed( aStatus ) )

        {

        return;

        }

    if ( aHandle.iTokenHandle != Token().Handle() )

        {

        User::RequestComplete( iOriginalRequestStatus, KErrBadHandle );

        }

    else

        {

        iCertInfo = &aCertInfo;

        iHandle = &aHandle;

        iPhase = EGetCert;

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

        SetActive();

        }

    }

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

// CWimCertStore::DoGetCert()

// Fetches one certificate

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

//

void CWimCertStore::DoGetCert()

    {

    _WIMTRACE ( _L( "CWimCertStore::DoGetCert()" ) );

    TInt err = KErrNotFound;

    TRAP( err, *iCertInfo =

            CCTCertInfo::NewL( iCerts->EntryByHandleL ( iHandle->iObjectId ) ) );

    User::RequestComplete( iOriginalRequestStatus, err );

    }

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

// CWimCertStore::CancelGetCert()

// Cancels issued GetCert operation. Main functionality in DoCancel().

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

//

void CWimCertStore::CancelGetCert()

    {

    _WIMTRACE ( _L( "CWimCertStore::CancelGetCert()" ) );

    Cancel();

    }

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

// CWimCertStore::Applications()

// Lists the applications of a certificate. Applications are represented by UIDs

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

//

void CWimCertStore::Applications( const CCTCertInfo& aCertInfo,

                                  RArray<TUid>& aApplications,

                                  TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "CWimCertStore::Applications()" ) );

    if ( !EnteringAllowed( aStatus ) )

        {

        return;

        }

    iCertInfoReadOnly = &aCertInfo;

    iApplications = &aApplications;

    iPhase = EApplications;

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    SetActive();

    }

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

// CWimCertStore::DoApplications()

// Fetch all certificate's applications

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

//

void CWimCertStore::DoApplications()

    {

    _WIMTRACE ( _L( "CWimCertStore::DoApplications()" ) );

    TInt err = KErrNone;

    TInt index = iCerts->Index( *iCertInfoReadOnly );

    if ( index != KErrNotFound )

        {

        const RArray<TUid>& apps = iCerts->Mapping( index )->CertificateApps();

        TInt end = apps.Count();

        for ( TInt i = 0; ( i < end ) && ( err == KErrNone ); i++ )

            {

            err = iApplications->Append( apps[i] );

            }

        }

    else

        {

        err = index;

        }

    if ( err != KErrNone )

        {

        iApplications->Reset();

        }

    User::RequestComplete( iOriginalRequestStatus, err );

    }

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

// CWimCertStore::CancelApplications()

// Cancels issued Applications operation. Main functionality in DoCancel().

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

//

void CWimCertStore::CancelApplications()

    {

    _WIMTRACE ( _L( "CWimCertStore::CancelApplications()" ) );

    Cancel();

    }

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

// CWimCertStore::IsApplicable()

// Checks if a particular certificate is applicable to a particular application.

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

//

void CWimCertStore::IsApplicable( const CCTCertInfo& aCertInfo,

                                  TUid aApplication,

                                  TBool& aIsApplicable,

                                  TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "CWimCertStore::IsApplicable()" ) );

    if ( !EnteringAllowed( aStatus ) )

        {

        return;

        }

    iCertInfoReadOnly = &aCertInfo;

    iApplication = aApplication;

    iIsApplicable = &aIsApplicable;

    iPhase = EIsApplicable;

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    SetActive();

    }

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

// CWimCertStore::DoIsApplicable()

// Match given application to certificate's application

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

//

void CWimCertStore::DoIsApplicable()

    {

    _WIMTRACE ( _L( "CWimCertStore::DoIsApplicable()" ) );

    TInt index = iCerts->Index( *iCertInfoReadOnly );

    if ( index != KErrNotFound )

        {

        const RArray<TUid>& apps = iCerts->Mapping( index )->CertificateApps();

        TInt end = apps.Count();

        TInt i = 0;

        for ( ; i < end; i++ )

            {

            if ( apps[i] == iApplication )

                {

                i = end + 1; // This completes loop but differentiates from

                             // normal end condition

                }

            }

        if ( i == end )

            {

            *iIsApplicable = EFalse;

            }

        else

            {

            *iIsApplicable = ETrue;

            }

        index = KErrNone;

        }

    User::RequestComplete( iOriginalRequestStatus, index );

    }

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

// CWimCertStore::CancelIsApplicable()

// Cancels issued IsApplicable operation. Main functionality in DoCancel().

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

//

void CWimCertStore::CancelIsApplicable()

    {

    _WIMTRACE ( _L( "CWimCertStore::CancelIsApplicable()" ) );

    Cancel();

    }

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

// CWimCertStore::Trusted()

// Returns a parameter with true or false, if a certificate is trusted.

// Trust is only meaningful for CA certificates where it means that the

// certificate can be used as a trust root for the purposes

// of certificate validation.

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

//

void CWimCertStore::Trusted( const CCTCertInfo& aCertInfo,

                             TBool& aTrusted,

                             TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "CWimCertStore::Trusted()" ) );

    if ( !EnteringAllowed( aStatus ) )

        {

        return;

        }

    iCertInfoReadOnly = &aCertInfo;

    iTrustedCert = &aTrusted;

    iPhase = ETrusted;

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    SetActive();

    }

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

// CWimCertStore::DoTrusted()

// 

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

//

void CWimCertStore::DoTrusted()

    {

    _WIMTRACE ( _L( "CWimCertStore::DoTrusted()" ) );

    TInt index = iCerts->Index( *iCertInfoReadOnly );

    if ( index != KErrNotFound )

        {

        *iTrustedCert = iCerts->Mapping( index )->Trusted();

        index = KErrNone;

        }

    User::RequestComplete( iOriginalRequestStatus, index );

    }

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

// CWimCertStore::CancelTrusted()

// Cancels issued Trusted operation. Main functionality in DoCancel().

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

//

void CWimCertStore::CancelTrusted()

    {

    _WIMTRACE ( _L( "CWimCertStore::CancelTrusted()" ) );

    Cancel();

    }

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

// CWimCertStore::Retrieve()

// Retrieves all the data of the certificate.

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

//

void CWimCertStore::Retrieve( const CCTCertInfo& aCertInfo,

                              TDes8& aEncodedCert,

                              TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "CWimCertStore::Retrieve()" ) );

    if ( !EnteringAllowed( aStatus ) )

        {

        return;

        }

    iCertInfoReadOnly = &aCertInfo;

    iEncodedCert = &aEncodedCert;

    iPhase = ERetrieve;

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    SetActive();

    }

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

// CWimCertStore::DoRetrieve()

// Retrieves all the data of the certificate.

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

//

void CWimCertStore::DoRetrieve()

    {

    _WIMTRACE ( _L( "CWimCertStore::DoRetrieve()" ) );

    // Let's get the index of certificate info

    // Index used as handle in WimClient in order to locate this certificate

    iCertIndex = iCerts->Index( *iCertInfoReadOnly );

    if ( iCertIndex == KErrNotFound )

        {

        User::RequestComplete( iOriginalRequestStatus, KErrNotFound );

        }

    else

        {

        iPhase = ERetrieveFromWim;

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

        SetActive();

        }

    }

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

// CWimCertStore::CancelRetrieve()

// Cancels issued Retrieve operation and informs converter to stop.

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

//

void CWimCertStore::CancelRetrieve()

    {

    _WIMTRACE ( _L( "CWimCertStore::CancelRetrieve()" ) );