/*

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

*

*/

// INCLUDE FILES

#include "WimAuthenticationObjectList.h"

#include "WimAuthenticationObject.h"

#include "WimPin.h"

#include "WimClsv.h"

#include "WimTrace.h"

#include "WimTokenListener.h"

#include "WimImplementationUID.hrh"

#include <mctauthobject.h>

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

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

// CWimAuthenticationObjectList::CWimAuthenticationObjectList()

// Default constructor

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

//

CWimAuthenticationObjectList::CWimAuthenticationObjectList( CWimToken& aToken ) : 

                                                            CActive( EPriorityHigh ),

                                                            iToken( aToken ) 

    {

    }

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

// CWimAuthenticationObjectList::NewL()

// Two phased constructor

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

//

CWimAuthenticationObjectList* 

                      CWimAuthenticationObjectList::NewL( CWimToken& aToken ) 

    {

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

    CWimAuthenticationObjectList* that = 

                        new( ELeave ) CWimAuthenticationObjectList( aToken );

    CleanupStack::PushL( that );

    that->ConstructL();

    CleanupStack::Pop( that );

    return that;

    }

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

// CWimAuthenticationObjectList::ConstructL()

// Second phase constructor.

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

//

void CWimAuthenticationObjectList::ConstructL()

    {

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

    CActiveScheduler::Add( this ); 

    }

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

// CWimKeyStore::DoRelease()

// Deletes this interface on demand.

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

//

void CWimAuthenticationObjectList::DoRelease()

    {

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

    delete this;

    }

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

// CWimAuthenticationObjectList::~CWimAuthenticationObjectList()

// Destructor

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

//

CWimAuthenticationObjectList::~CWimAuthenticationObjectList()

    {

    _WIMTRACE ( 

        _L( "CWimAuthenticationObjectList::~CWimAuthenticationObjectList()" ) );

    Cancel();

    TInt count = iAuthObjects.Count();

    while ( count )

        {

        CWimAuthenticationObject* entry = iAuthObjects[count - 1];

        entry->Release();

        iAuthObjects.Remove( count - 1 );

        count--;

        }

    iAuthObjects.Close();

    }

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

// CWimAuthenticationObjectList::Token()

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

// object list interface.

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

//

MCTToken& CWimAuthenticationObjectList::Token()

    {

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

    return iToken;

    }

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

// CWimAuthenticationObjectList::List()

// Lists all authentication objects.

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

//

void CWimAuthenticationObjectList::List( 

                        RMPointerArray<MCTAuthenticationObject>& aAuthObjects, 

                        TRequestStatus& aStatus )

    {

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

    if ( TokenRemoved() )

        {

        return;

        }

    _WIMTRACE ( _L( "CWimAuthenticationObjectList::List() after TokenRemoved checking" ) );

    aStatus = KRequestPending;

    iPhase = ECreateList;

    iClientStatus = &aStatus;

    iClientAuthObjects = &aAuthObjects;

    iStatus = KRequestPending;

    SetActive();

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    _WIMTRACE ( _L( "CWimAuthenticationObjectList::List() End" ) );

    }

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

// CWimAuthenticationObjectList::DoListL()

// Fetches first all authentication objects from Wim. After that makes a copy

// each of them for the client.

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

//

void CWimAuthenticationObjectList::DoListL( 

                        RMPointerArray<MCTAuthenticationObject>& aAuthObjects )

    {

    _WIMTRACE ( _L( "CWimAuthenticationObjectList::DoListL()" ) );

    TInt count = iAuthObjects.Count();

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

        {

        //SecModUI will call Status() to get the PIN status later.

        //We donot need to send PIN status in the phase

        TUint32 status = 0;

        CWimAuthenticationObject* me = 

                          MakeAuthObjectL( iAuthObjects[i]->TokenWider(),

                                           iAuthObjects[i]->PinModule(),

                                           iAuthObjects[i]->Label(),

                                           iAuthObjects[i]->Type(),

                                           iAuthObjects[i]->Handle().iObjectId,

                                           status );

        CleanupStack::PushL( me );

        User::LeaveIfError( aAuthObjects.Append( me ) );

        CleanupStack::Pop( me );

        }

    }

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

// CWimAuthenticationObjectList::CreateListL()

// This function creates an internal array for authentication objects.

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

//

void CWimAuthenticationObjectList::CreateListL( TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "CWimAuthenticationObjectList::CreateListL()" ) );

    // Delete previous ones

    TInt count = iAuthObjects.Count();

    while ( count )

        {

        CWimAuthenticationObject* entry = iAuthObjects[count - 1];

        entry->Release();

        iAuthObjects.Remove( count - 1 );

        count--;

        }

   TInt ret = iToken.WimSecModule()->PinNrEntriesL( iPinNRs, aStatus );

    if ( ret != KErrNone )

        {

        User::Leave( ret );

        }

    }

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

// CWimAuthenticationObjectList::MakeAuthObjectL()

// This function is called from two different places

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

//

CWimAuthenticationObject* 

     CWimAuthenticationObjectList::MakeAuthObjectL( CWimToken& aToken,

                                                    CWimPin& aPinModule,

                                                    const TDesC& aLabel,

                                                    TUid aType,

                                                    TUint32 aHandle,

                                                    TUint32 aStatus )

    {

    _WIMTRACE ( _L( "CWimAuthenticationObjectList::MakeAuthObjectL()" ) );

    CWimAuthenticationObject* me = 

                   CWimAuthenticationObject::NewLC( aToken,

                                                    aPinModule,

                                                    aLabel,

                                                    aType,

                                                    aHandle,

                                                    aStatus );

    CleanupStack::Pop( me );

    return me;

    }

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

// CWimAuthenticationObjectList::CancelList()

// Because List is synchronous, there is nothing to do here.

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

//

void CWimAuthenticationObjectList::CancelList()

    {

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

    Cancel();

    }

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

// CWimAuthenticationObjectList::TokenRemoved()

// Returns true or false indicating if token is removed

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

//

TBool CWimAuthenticationObjectList::TokenRemoved()

    {

    _WIMTRACE ( _L( "CWimAuthenticationObjectList::TokenRemoved()" ) );

    // If token listener is not alive, then token is removed

    if ( iToken.TokenListener()->TokenStatus() != KRequestPending )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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

// CWimAuthenticationObjectList::RunL()

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

//

void CWimAuthenticationObjectList::RunL()

    {

    _WIMTRACE ( _L( "CWimAuthenticationObjectList::RunL()" ) );

    switch ( iPhase )

        {

        case ECreateList:

            {

            iPhase = ECreateListDone;

            iStatus = KRequestPending;

            SetActive();

            //iPinNRs is initialized here

            CreateListL( iStatus ); 

            break;	

            }

        case ECreateListDone:

            {

            //Pin type is set here

            if ( iPinNRs ) // If PINs were found

	           {

	           TUid pintype = {WIM_PIN_G_UID}; // The first one is always PIN-G

	           TInt count = iPinNRs->Count();

	           TUint32 status = 0;

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

		           {

		           CWimAuthenticationObject* me = 

		                                MakeAuthObjectL( iToken, 

		                                             *( *iPinNRs )[i],

		                                              ( *iPinNRs )[i]->Label(),

		                                                 pintype,

		                                              ( *iPinNRs )[i]->PinNumber(),

		                                                 status );

		           CleanupStack::PushL( me );

		           User::LeaveIfError ( iAuthObjects.Append( me ) );

		           CleanupStack::Pop( me );

		           pintype.iUid = WIM_PIN_NR_UID; // The others are always PIN-NR

		           }

	           }    

            iPhase  = EDoList;  

            iStatus = KRequestPending;

            SetActive();

            TRequestStatus* status = &iStatus;

            User::RequestComplete( status, KErrNone );

            break;         	

            } 

    	case EDoList:

    	    {

    	    _WIMTRACE ( _L( "CWimAuthenticationObjectList::RunL(): EDoList" ) );

    	    DoListL( *iClientAuthObjects );

			    User::RequestComplete( iClientStatus, KErrNone );  	

			    break;

    	    }

       default:

            break;	

         }

    }

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

// CWimAuthenticationObjectList::DoCancel()

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

//       

void CWimAuthenticationObjectList::DoCancel()

   {

   _WIMTRACE ( _L( "CWimAuthenticationObjectList::DoCancel()" ) );	

   User::RequestComplete( iClientStatus, KErrCancel );

   }

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

// CWimAuthenticationObjectList::RunError()

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

//  

TInt CWimAuthenticationObjectList::RunError( TInt aError )    

   {

   _WIMTRACE ( _L( "CWimAuthenticationObjectList::RunError()" ) );	

   User::RequestComplete( iClientStatus, aError );

   return KErrNone;

   }

//  End of File