/*

* 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 authentication object

*

*/

// INCLUDE FILES

#include "WimSecModuleMgr.h"

#include "WimAuthenticationObject.h"

#include "WimPin.h"

#include "WimTrace.h"

//#include "WimDebug.h"

#include "WimTokenListener.h"

#include "WimImplementationUID.hrh"

#include <unifiedkeystore.h>

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

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

// CWimAuthenticationObject::CWimAuthenticationObject()

// Defalt constructor

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

//

CWimAuthenticationObject::CWimAuthenticationObject(

                                               CWimToken& aToken,

                                               CWimPin& aWimPin,

                                               const TUid aType,

                                               const TInt aHandle,

                                               TUint32 aObjectStatus ) :

                                               CActive( EPriorityNormal ),

                                               MCTAuthenticationObject( aToken ),

                                               iToken( aToken ),

                                               iWimPin ( aWimPin ),

                                               iType ( aType ),

                                               iObjectId ( aHandle ),

                                               iObjectStatus( aObjectStatus ),

                                               iTokenWider( aToken )

    {

    CActiveScheduler::Add( this );

    iPhase = EIdle;

    }

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

// CWimAuthenticationObject::NewLC()

// Two-phased constructor. One object stays in cleanup stack.

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

//

CWimAuthenticationObject* CWimAuthenticationObject::NewLC(

                                                         CWimToken& aToken,

                                                         CWimPin& aWimPin,

                                                         const TDesC& aLabel,

                                                         const TUid aType,

                                                         const TInt aHandle,

                                                         TUint32 aObjectStatus )

    {

    _WIMTRACE ( _L( "CWimAuthenticationObject::NewLC()" ) );

    __ASSERT_ALWAYS( aLabel.Length() > 0, User::Leave( KErrArgument ) );

    if ( aType.iUid != WIM_PIN_G_UID && aType.iUid != WIM_PIN_NR_UID )

        {

        User::Leave( KErrArgument );

        }

    CWimAuthenticationObject* that =

        new( ELeave ) CWimAuthenticationObject( aToken,

                                                 aWimPin,

                                                 aType,

                                                 aHandle,

                                                 aObjectStatus );

    CleanupStack::PushL( that );

    that->ConstructL( aLabel );

    return that;

    }

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

// CWimAuthenticationObject::ConstructL()

// Second phase constructor.

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

//

void CWimAuthenticationObject::ConstructL( const TDesC& aLabel )

    {

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

    iLabel = aLabel.AllocL();

    iPhase = EIdle;

    }

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

// CWimAuthenticationObject::~CWimAuthenticationObject()

// Destructor

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

//

CWimAuthenticationObject::~CWimAuthenticationObject()

    {

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

    Cancel();

    FreeUnifiedKeyStore();

    FreeUnifiedCertStore();

    delete iCertFilter;

    delete iLabel;

    }

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

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

// CWimAuthenticationObject::Label()

// Returns a reference to this authentication object's label.

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

//

const TDesC& CWimAuthenticationObject::Label() const

    {

    _WIMTRACE ( _L( "CWimAuthenticationObject::Label()" ) );

    return *iLabel;

    }

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

// CWimAuthenticationObject::Token()

// Returns a reference to token (MCTToken) of this authentication object

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

//

MCTToken& CWimAuthenticationObject::Token() const

    {

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

    return iToken;

    }

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

// CWimAuthenticationObject::TokenWider()

// Returns a reference to token (CWimToken) of this authentication object

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

//

CWimToken& CWimAuthenticationObject::TokenWider() const

    {

    _WIMTRACE ( _L( "CWimAuthenticationObject::TokenWider()" ) );

    return iTokenWider;

    }

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

// CWimAuthenticationObject::Type()

// Returns type (TUid) of current authentication object.

// WIM_PIN_G_UID or WIM_PIN_NR_UID

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

//

TUid CWimAuthenticationObject::Type() const

    {

    _WIMTRACE ( _L( "CWimAuthenticationObject::Type()" ) );

    return iType;

    }

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

// CWimAuthenticationObject::Release()

// Deletes this instance

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

//

void CWimAuthenticationObject::DoRelease()

    {

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

    delete this;

    }

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

// CWimAuthenticationObject::Handle()

// Returns a handle (TCTTokenObjectHandle) of this authentication object.

// iObjectId runs from 0 to N where N is (count of authentication objects) - 1

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

//

TCTTokenObjectHandle CWimAuthenticationObject::Handle() const

    {

    _WIMTRACE ( _L( "CWimAuthenticationObject::Handle()" ) );

    return TCTTokenObjectHandle( Token().Handle(), iObjectId );

    }

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

// CWimAuthenticationObject::PinModule()

// Returns a reference to pin module manager (CWimPin)

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

//

CWimPin& CWimAuthenticationObject::PinModule() const

    {

    _WIMTRACE ( _L( "CWimAuthenticationObject::PinModule()" ) );

    return iWimPin;

    }

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

// CWimAuthenticationObject::ListProtectedObjects()

// Returns a list of all the objects which this authentication object protects.

// Procedure: 1. Fetch all keys this authentication object protects

//            2. Fetch certificates those keys are used for and

//            3. Make objects from those protected keys and certificates

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

//

void CWimAuthenticationObject::

     ListProtectedObjects( RMPointerArray<MCTTokenObject>& aObjects,

                           TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "CWimAuthenticationObject::ListProtectedObjects()" ) );

    if ( !EnteringAllowed( aStatus ) )

        {

        return;

        }

    iObjects = &aObjects;

    iKeyInfos.Close();

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

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

    if ( err != KErrNone )

        {

        User::RequestComplete( iOriginalRequestStatus, err );

        }

    else

        {

        iStatus = KRequestPending;

        iUnifiedKeyStore->Initialize( iStatus );

        iPhase = EGetKeyInfos;

        SetActive();

        }

    }

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

// void CWimAuthenticationObject::RunL()

// Core operations are done here.

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

//

void CWimAuthenticationObject::RunL()

    {

    switch ( iPhase )

        {

        case EGetKeyInfos:

            {

            if ( iStatus.Int() == KErrNone )

                {

                iKeyFilter.iKeyId = KNullDesC8;

                iKeyFilter.iUsage = EPKCS15UsageAll;

                iStatus = KRequestPending;

                iPhase = EFilterKeys;

                iStatus = KRequestPending;

                iUnifiedKeyStore->List( iKeyInfos, iKeyFilter, iStatus );

                SetActive();

                }

            else // Something went wrong (or call was cancelled) with

                 // iUnifiedKeyStore->Initialize( iStatus )

                {

                FreeUnifiedKeyStore();

                iPhase = EIdle;

                User::RequestComplete( iOriginalRequestStatus, iStatus.Int() );

                }

            break;

            }

        case EFilterKeys:

            {

            DoFilterKeys();

            break;

            }

        case EGetCerts:

            {

            // In this phase cert store must allways be NULL

            if ( !iUnifiedCertStore )

                {

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

                iUnifiedCertStore = CUnifiedCertStore::NewL( iFs, EFalse );

                iStatus = KRequestPending;

                iPhase = EInitCertStore;

                iUnifiedCertStore->Initialize( iStatus );

                SetActive();

                }

            else

                {

                FreeUnifiedKeyStore();

                iPhase = EIdle;

                User::RequestComplete( iOriginalRequestStatus, KErrCorrupt );

                }

            break;

            }

        case EInitCertStore:

            {

            // Called when cert store init completes

            if ( iStatus.Int() == KErrNone )

                {

                if ( iCertFilter )

                    {

                    delete iCertFilter;

                    iCertFilter = NULL;

                    }

                iCertFilter = CCertAttributeFilter::NewL();

                iStatus = KRequestPending;

                iPhase = EListCertEntries;

                iUnifiedCertStore->List( iCertStoreEntries,

                                        *iCertFilter,

                                         iStatus );

                SetActive();

                }

            else // Something went wrong (or call was cancelled) with

                 // iUnifiedCertStore->Initialize( iStatus )

                {

                FreeUnifiedKeyStore();

                FreeUnifiedCertStore();

                iPhase = EIdle;

                User::RequestComplete( iOriginalRequestStatus, iStatus.Int() );

                }

            break;

            }

        case EListCertEntries:

            {

            DoListCertEntries();

            break;

            }

        case EMakeObjects:

            {

            DoMakeObjectsL();

            break;

            }

        case EEnablePinQuery:

            {

            User::RequestComplete( iOriginalRequestStatus, iStatus.Int() );

            break;

            }

        case EDisablePinQuery:

            {

            User::RequestComplete( iOriginalRequestStatus, iStatus.Int() );

            break;

            }

        case EChangePin:

            {

            User::RequestComplete( iOriginalRequestStatus, iStatus.Int() );

            break;

            }

        case EUnblockPin:

            {

            User::RequestComplete( iOriginalRequestStatus, iStatus.Int() );

            break;

            }

        case EVerifyPin:

            {

            User::RequestComplete( iOriginalRequestStatus, iStatus.Int() );

            break;

            }

        default:

            {

            User::RequestComplete( iOriginalRequestStatus, KErrCorrupt );

            break;

            }

        }

    }

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

// void CWimAuthenticationObject::DoFilterKeys()

// Select keys according to given filter

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

//

void CWimAuthenticationObject::DoFilterKeys()

    {

    _WIMTRACE ( _L( "CWimAuthenticationObject::DoFilterKeys()" ) );

    if ( iStatus.Int() == KErrNone )

        {

        // From all keys get only those that match with

        // this protector

        TInt count = iKeyInfos.Count();

        TInt i = 0;

        for ( i = 0; i < count ; i++ )

            {

            // If protector is not set or protector is not this, delete item

            if ( !iKeyInfos[i]->Protector() ||

                ( iKeyInfos[i]->Protector()->Handle().iObjectId !=

                                       this->Handle().iObjectId ) )

                {

                    // If match is not found, delete object

                    CCTKeyInfo* keyinfo = ( iKeyInfos ) [i];

                    keyinfo->Release();

                    ( iKeyInfos ) [i] = NULL;

                }

            }

        i = 0;

        while ( count )

            {

            if ( !iKeyInfos[i] )

                {

                // Remove element placeholder from CWimCertStore array

                iKeyInfos.Remove( i );

                }

            else

                {

                i++;

                }

            count--;

            }

        iKeyInfos.Compress();

        count = iKeyInfos.Count();

        if ( count ) // Continue handling

            {

            iPhase = EGetCerts;

            TRequestStatus* status = &iStatus;

            User::RequestComplete( status, KErrNone );

            SetActive();

            }

        else // No keys, no continue

            {

            FreeUnifiedKeyStore();

            iPhase = EIdle;

            User::RequestComplete( iOriginalRequestStatus, iStatus.Int() );

            }

        }

    else // Something went wrong (or call was cancelled) with

         // iUnifiedKeyStore->List(...)

        {

        FreeUnifiedKeyStore();

        iPhase = EIdle;

        User::RequestComplete( iOriginalRequestStatus, iStatus.Int() );

        }

    }

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

// void CWimAuthenticationObject::DoListCertEntries()

// Select certificates according to keys

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

//

void CWimAuthenticationObject::DoListCertEntries()

    {

    _WIMTRACE ( _L( "CWimAuthenticationObject::DoListCertEntries()" ) );

    if ( iStatus.Int() == KErrNone )

        {

         // All certs are listed

         // Match every cert to keys. If match not found, delete cert

         TInt certcount = iCertStoreEntries.Count();

         TInt i = 0;

         for ( i = 0; i < certcount; i++ )

             {

             TInt keycount = iKeyInfos.Count();

             TInt j = 0;

             for ( j = 0; j < keycount; j++ )

                 {

                 if ( iKeyInfos[j]->ID() ==

                                iCertStoreEntries[i]->SubjectKeyId() )

                    {

                    j = keycount + 1;

                    }

                 }

             if ( j == keycount )

                {

                // If match is not found, delete object and remove item

                CCTCertInfo* certinfo = ( iCertStoreEntries ) [i];

                // Delete object self

                certinfo->Release();

                ( iCertStoreEntries ) [i] = NULL;

                }

            }

        i = 0;

        while ( certcount )

            {

            if ( !iCertStoreEntries[i] )

                {

                // Remove element placeholder from array

                iCertStoreEntries.Remove( i );

                }

            else

                {

                i++;

                }

            certcount--;

            }

        iCertStoreEntries.Compress();

        iPhase = EMakeObjects;

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

        SetActive();

        }

    else // Something went wrong (or call was cancelled) with

         // iUnifiedCertStore->List(...)

        {

        FreeUnifiedKeyStore();

        FreeUnifiedCertStore();

        iPhase = EIdle;

        User::RequestComplete( iOriginalRequestStatus, iStatus.Int() );

        }

    }

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

// void CWimAuthenticationObject::DoMakeObjectsL()

// Protected objects are validated here

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

//

void CWimAuthenticationObject::DoMakeObjectsL()

    {

    _WIMTRACE ( _L( "CWimAuthenticationObject::DoMakeObjectsL()" ) );

    if ( iStatus.Int() == KErrNone ) // Not cancelled

        {

        TInt count = iKeyInfos.Count();

        TInt i = 0;

        for ( ; i < count; i++ )

            {

            // Make a copy of key info

            HBufC* wlabel = HBufC::NewLC( ( iKeyInfos )[i]->Label().Length() );

            wlabel->Des().Copy( ( iKeyInfos )[i]->Label() );

            // Make a copy of protector if there is

            MCTAuthenticationObject* protector = NULL;

            if ( iKeyInfos[i]->Protector() )

                {

                TUint thishandle = iKeyInfos[i]->Protector()->

                                                    Handle().iObjectId;

                //All the key list here is protected by this Authobj

                if( this->Handle().iObjectId == thishandle )

	                {

	                protector = MakeAuthObjectL();

	                }

                else

                    {

                	return;

                    }