/*

* Copyright (c) 2003-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:  Implements WIM TrustSettingsStore for WIM certificates

*

*/

// INCLUDE FILES

#include "WimTrustSettingsStore.h"

#include "WimCertInfo.h"

#include "WimCertUtil.h"

#include <x509cert.h>

#include <x509certext.h>

#include <hash.h>

#include "WimTrace.h"

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

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

// CWimTrustSettingsStore::CWimTrustSettingsStore()

// Default constructor.

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

//

CWimTrustSettingsStore::CWimTrustSettingsStore() 

                      : CActive( EPriorityNormal ),

                        iCompact ( EFalse )

    {

    CActiveScheduler::Add( this );

    }

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

// CWimTrustSettingsStore::ConstructL()

// Second phase constructor.

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

//

void CWimTrustSettingsStore::ConstructL()

    {

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

    // Connect to DB server

    User::LeaveIfError( iDBSession.Connect() );

    // combine trust settings DB path & name

    HBufC* dbPathBuffer = HBufC::NewLC( KWimTrustSettingsStorePath().Length() +

                                        KWimTrustSettingsDBFile().Length() );

    TPtr wimTrustSettingsDB( dbPathBuffer->Des() );

    wimTrustSettingsDB = KWimTrustSettingsStorePath;

    wimTrustSettingsDB.Append( KWimTrustSettingsDBFile );

    // Open database. Note: err used because of create is done if not found

    TInt err = iDatabase.Open( iDBSession, wimTrustSettingsDB );

    if ( err != KErrNone ) //Database could not open, create new

        {

        _WIMTRACE2( _L( "CWimTrustSettingsStore::ConstructL()|DB open error %d" ), err ); 

        CreateDBL(); // Create DB

        User::LeaveIfError( iDatabase.Open( iDBSession, wimTrustSettingsDB ) );

        }

    iPhase = EIdle;

    CleanupStack::PopAndDestroy( dbPathBuffer );

    }

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

// CWimTrustSettingsStore::NewL()

// Two-phased constructor.

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

//

CWimTrustSettingsStore* CWimTrustSettingsStore::NewL()

    {

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

    CWimTrustSettingsStore* self = new( ELeave ) CWimTrustSettingsStore;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWimTrustSettingsStore::~CWimTrustSettingsStore()

// Destructor. If updates has been done, compact databse.

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

CWimTrustSettingsStore::~CWimTrustSettingsStore()

    {

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

    Cancel();

    if ( iCompact ) // Is compact needed

        {

        iDatabase.Compact(); //Compact database

        }

    iDatabase.Close();  // Close database

    iDBSession.Close(); // Close session to DB server

    if ( iWimCertUtil )

        {

        delete iWimCertUtil;

        }

    delete iEncodedCertBuf;

    delete iEncodedCertPtr;

    iCertInfos.ResetAndDestroy();

    }

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

// CWimTrustSettingsStore::CloseD()

// Closes all open resources and deletes this instance of the TrustSettingsStore

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

//

void CWimTrustSettingsStore::CloseD()

    {

    _WIMTRACE ( _L( "CWimTrustSettingsStore::CloseD()" ) );

    delete ( this );

    }

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

// CWimTrustSettingsStore::GetTrustSettings()

// Return trust settings for given certificate.

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

//

void CWimTrustSettingsStore::GetTrustSettings( const CWimCertInfo& aCert,

                                               TBool& aTrusted,

                                               RArray<TUid>& aApplications, 

                                               TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "CWimTrustSettingsStore::GetTrustSettings()" ) );

    TRAPD( err, DoGetTrustSettingsL( aCert, aTrusted, aApplications ) );

    TRequestStatus* status = &aStatus;

    User::RequestComplete( status, err );

    }

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

// CWimTrustSettingsStore::SetApplicability()

// Set applicability for certificate.

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

//

void CWimTrustSettingsStore::SetApplicability( const CWimCertInfo& aCert,

                                              const RArray<TUid>& aApplications,

                                              TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "CWimTrustSettingsStore::SetApplicability()" ) );

    TRAPD( err, DoSetApplicabilityL( aCert, aApplications ) );

    TRequestStatus* status = &aStatus;

    User::RequestComplete( status, err );

    }

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

// CWimTrustSettingsStore::SetTrust()

// Set trust flag for certificate.

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

//

void CWimTrustSettingsStore::SetTrust( const CWimCertInfo& aCert,

                                       TBool aTrusted,

                                       TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "CWimTrustSettingsStore::SetTrust()" ) );

    TRAPD( err, DoSetTrustL( aCert, aTrusted ) );

    TRequestStatus* status = &aStatus;

    User::RequestComplete( status, err );

    }

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

// CWimTrustSettingsStore::SetDefaultTrustSettings()

// Set default trust settings for certificate.

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

//

void CWimTrustSettingsStore::SetDefaultTrustSettings( const CWimCertInfo& aCert,

                                                      TBool aAddApps,

                                                      TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "CWimTrustSettingsStore::SetDefaultTrustSettings()" ) );

    iWimCert = &aCert;

    iAddApps = aAddApps;

    iOriginalRequestStatus = &aStatus;

    iCert = aCert.CctCert();

    //Certificate owner type

    TCertificateOwnerType ownerType;

    ownerType = iCert->CertificateOwnerType();

    //Certificate format

    TCertificateFormat certFormat;

    certFormat = iCert->CertificateFormat();

    // If CA/X509 certificate locates in trusted certs area

    // check if certificate extensions must be fetched

    if ( ownerType == ECACertificate &&

         certFormat == EX509Certificate &&

         iWimCert->CDFRefs() == EWimTrustedCertsCDF )

        {

        // Check if Java Midlet OID is present

        RArray<HBufC*> arr = iWimCert->TrustedUsage();

        TInt oidCount = arr.Count();

        TInt i = 0;

        for ( ; i < oidCount; i++ )

            {

            if ( !arr[i]->Compare( KIpKpJavaMidlet ) )

                {

                i = oidCount + 1;

                }

            }

        // If OID is not present, extensions must be fetched

        if ( i == oidCount )

            {

            // Fetch extensions only for CA X509 certificates         

            iPhase = ERetrieve;

            TRequestStatus* status = &iStatus;

            User::RequestComplete( status, KErrNone );

            SetActive();

            }

        else

            {

            TRAPD( err, DoSetDefaultTrustSettingsL( aCert, aAddApps ) );

            TRequestStatus* status = &aStatus;

            User::RequestComplete( status, err );

            }

        }

    else

        {

        TRAPD( err, DoSetDefaultTrustSettingsL( aCert, aAddApps ) );

        TRequestStatus* status = &aStatus;

        User::RequestComplete( status, err );

        }

    }

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

// CWimTrustSettingsStore::RemoveTrustSettings()

// Remove trust settings of given certificate

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

//

void CWimTrustSettingsStore::RemoveTrustSettings( const CWimCertInfo& aCert,

                                                  TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "CWimTrustSettingsStore::RemoveTrustSettings()" ) );

    TRAPD( err, DoRemoveTrustSettingsL( aCert ) );

    iCompact = ETrue;

    TRequestStatus* status = &aStatus;

    User::RequestComplete( status, err );

    }

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

// CWimTrustSettingsStore::DoGetTrustSettingsL ()

// Get trust settings for given certificate.

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

//

void CWimTrustSettingsStore::DoGetTrustSettingsL( const CWimCertInfo& aCert,

                                                  TBool& aTrusted,

                                                  RArray<TUid>& aApplications )

    {

    _WIMTRACE ( _L( "CWimTrustSettingsStore::DoGetTrustSettingsL()" ) );

    TInt certID;

    GetCertificateIDL( aCert, certID ); // Get certificate ID

    if ( certID == KErrNotFound ) //Not found settings

        {

        User::Leave( KErrNotFound );

        }

    GetTrustedL( certID, aTrusted ); //Get trusted flag

    GetApplicationsL( certID, aApplications ); //Get applications

    }

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

// CWimTrustSettingsStore::DoSetApplicabilityL()

// Set applicability for certificate.

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

//

void CWimTrustSettingsStore::DoSetApplicabilityL( const CWimCertInfo& aCert,

                                            const RArray<TUid>& aApplications )

    {

    _WIMTRACE ( _L( "CWimTrustSettingsStore::DoSetApplicabilityL()" ) );    

    TInt certID;

    GetCertificateIDL( aCert, certID ); // Get certificate ID

    iDatabase.Begin(); // Begin transaction

    TRAPD( err,

    if ( certID == KErrNotFound ) //Certificate not found -> Insert new one

        {

        InsertCertificateL( aCert, EFalse ); //Insert + set flag (EFalse)

        GetCertificateIDL( aCert, certID );    //Now get certificate ID

        }

    else // Certificate found

        {

        RemoveApplicationsL( certID );   //Remove old ones before inserting

        }

    InsertApplicationsL( certID, aApplications ); // Insert new apps

    ); //TRAPD

    if ( err != KErrNone ) //Some error occured

        {

        iDatabase.Rollback(); //Do rollback = restore changes

        User::Leave ( err );

        }

    else // No errors -> commit changes

        {

        iDatabase.Commit(); // Commit changes

        }

    }

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

// CWimTrustSettingsStore::DoSetTrustL()

// Set trust flag for certificate.

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

//

void CWimTrustSettingsStore::DoSetTrustL( const CWimCertInfo& aCert,

                                          TBool aTrusted )

    {

    _WIMTRACE ( _L( "CWimTrustSettingsStore::DoSetTrustL()" ) );    

    TInt certID;

    GetCertificateIDL( aCert, certID ); // Get certificate ID

    if ( certID == KErrNotFound ) // Certificate not found -> Insert new

       {

       InsertCertificateL( aCert, aTrusted ); // Insert + set flag

       }

    else // Certificate found

       {

        SetTrustedL( certID, aTrusted ); // Set trusted flag

       }

    }

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

// CWimTrustSettingsStore::DoSetDefaultTrustSettingsL()

// Set default trust settings for certificate

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

//

void CWimTrustSettingsStore::DoSetDefaultTrustSettingsL( 

                                                    const CWimCertInfo& aCert,

                                                    TBool aAddApps )

    {

    _WIMTRACE ( _L( "CWimTrustSettingsStore::DoSetDefaultTrustSettingsL()" ) );    

    TInt certID;

    GetCertificateIDL( aCert, certID ); // Get certificate ID

    iDatabase.Begin(); // Begin transaction

    TRAPD( err,

        if ( certID == KErrNotFound ) // Certificate not found -> Insert new one

            {

            InsertCertificateL( aCert, KDefaultTrustFlag ); // Set default

            GetCertificateIDL( aCert, certID );

            }

        else // Certificate allready exists, set default trusted flag

            {

            SetTrustedL( certID, KDefaultTrustFlag );

            }

        //

        // Applications

        //

        if ( aAddApps ) // Default applications required

            {

            RArray<TUid> applications;

            CleanupClosePushL( applications );

            DefaultApplicationsL( aCert, applications ); 

            RemoveApplicationsL( certID ); // Remove previous applications

            if ( applications.Count() > 0 ) // There is apps to insert

                {

                InsertApplicationsL( certID, applications );

                }

            CleanupStack::PopAndDestroy( &applications );

            }

    );

    if ( err != KErrNone ) // Some error occured

        {

        iDatabase.Rollback(); // Do rollback = restore changes

        User::Leave( err );

        }

    else // No errors

        {

        iDatabase.Commit(); // Commit changes

        }

    }

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

// CWimTrustSettingsStore::DoRemoveTrustSettingsL()

// Remove trust settings of given certificate

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

//

void CWimTrustSettingsStore::DoRemoveTrustSettingsL( const CWimCertInfo& aCert )

    {

    _WIMTRACE ( _L( "CWimTrustSettingsStore::DoRemoveTrustSettingsL()" ) );    

    TInt certID;

    GetCertificateIDL( aCert, certID ); // Get certificate ID

    if ( certID == KErrNotFound ) // Not found

        {

        User::Leave( KErrNotFound );

        }

    iDatabase.Begin(); // Begin transaction

    TRAPD( err, 

        RemoveApplicationsL( certID );  // Remove applications

        RemoveCertificateL( certID );   // Remove certificate

    );

    if ( err ) // Some error occurred

        {

        iDatabase.Rollback(); // Rollback changes

        User::Leave ( err );

        }

    else

        {

        iDatabase.Commit(); // Commit changes

        }

    }

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

// CWimTrustSettingsStore::GetCertificateIDL()

// Get database ID for given certificate. Return KErrNotFound, if not found

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

//

void CWimTrustSettingsStore::GetCertificateIDL( const CWimCertInfo& aCert,

                                                TInt& aCertificateID )

    {

    _WIMTRACE ( _L( "CWimTrustSettingsStore::GetCertificateIDL()" ) );    

    _LIT( KSQLQuery, "SELECT CertificateID,\

                             CertHash,\

                             TokenSerial,\

                             LabelHash,\

                             IsTrusted\

                      FROM Certificates" );

    TBuf8<KSHA1HashLengthBytes> hash;

    aCert.GetCertHash( hash );

    HBufC8* buf8 = HBufC8::NewLC( aCert.CctCert()->Label().Length() );

    TPtr8* ptr8 = new( ELeave ) TPtr8( buf8->Des() );

    CleanupStack::PushL( ptr8 );

    ptr8->Copy( aCert.CctCert()->Label() );

    HBufC8* labelHash = GetHashL( *ptr8 );

    CleanupStack::PushL( labelHash );

    RDbView view;

    User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( KSQLQuery ) ) );

    CleanupClosePushL( view );

    TInt i = 0;

    while ( i == 0 && view.NextL() ) // Should find only one ID

        {

        view.GetL();

        // Compare given hash, token serial number, cert label hash

        if ( !view.ColDes8( 2 ).Compare( hash ) &&

             !view.ColDes( 3 ).Compare( aCert.CctCert()->

                               Token().Information( MCTToken::ESerialNo ) ) &&

             !view.ColDes8( 4 ).Compare( *labelHash ) )

            {

            aCertificateID = view.ColUint32( 1 );

            i++;

            }

        }

    if ( i == 0 ) // Not found any matching rows

        {

        aCertificateID = KErrNotFound;

        }

    CleanupStack::PopAndDestroy( 4, buf8 ); // view, labelHash, ptr8, buf8

    }

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

// CWimTrustSettingsStore::InsertCertificateL()

// Insert certificate into the Certificates table

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

//

void CWimTrustSettingsStore::InsertCertificateL( const CWimCertInfo& aCert, 

                                                 TBool aTrusted )

    {

    _WIMTRACE ( _L( "CWimTrustSettingsStore::InsertCertificateL()" ) );    

    TBuf8<KSHA1HashLengthBytes> hash;

    aCert.GetCertHash( hash );

    HBufC8* buf8 = HBufC8::NewLC( aCert.CctCert()->Label().Length() );

    TPtr8* ptr8 = new(ELeave) TPtr8( buf8->Des() );

    CleanupStack::PushL( ptr8 );

    ptr8->Copy( aCert.CctCert()->Label() );

    HBufC8* labelHash = GetHashL( *ptr8 );

    CleanupStack::PushL( labelHash );

    RDbView view;

    _LIT( KSQLInsertCert, "SELECT CertHash,\

                                  TokenSerial,\

                                  LabelHash,\

                                  IsTrusted\

                           FROM Certificates" );

    User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( KSQLInsertCert ),

        TDbWindow::EUnlimited, RDbView::EInsertOnly ) );

    CleanupClosePushL( view );

    view.InsertL();

    view.SetColL( 1, hash );

    view.SetColL( 2, aCert.CctCert()->

                           Token().Information( MCTToken::ESerialNo ) );

    view.SetColL( 3, *labelHash );

    view.SetColL( 4, aTrusted );

    view.PutL();