/*

* 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:  A token represents one instance of a particular kind of 

*               cryptographic module

*

*/

// INCLUDE FILES

#include "WimToken.h"

#include "WimCertStore.h"

#include "WimAuthenticationObjectList.h"

#include "WimAuthenticationObject.h"

#include "WimKeyStore.h"

#include "WimSecModuleMgr.h"

#include "WimImplementationUID.hrh"

#include "WimTokenListener.h"

#include "WimTrace.h"

#include <mctkeystoreuids.h>            // KInterfaceKeyStore

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

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

// CWimToken::CWimToken()

// Default constructor.

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

//

CWimToken::CWimToken( CWimSecModule* aWimSecModule, MCTTokenType& aTokenType )

          :iWimSecModule( aWimSecModule ),

           iTokenType( aTokenType )

    {

    }

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

// CWimToken::ConstructL()

// Second phase constructor

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

//

void CWimToken::ConstructL()

    {

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

    iLabel = WimSecModule()->Label().AllocL();

    iWimTokenListener = CWimTokenListener::NewL( iWimSecModule );

    iWimTokenListener->StartListening(); //Start listening

    iCount = 0;

    }

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

// CWimToken::NewL()

// Two-phased constructor.

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

//

CWimToken* CWimToken::NewL( CWimSecModule* aWimSecModule, 

                            MCTTokenType& aTokenType )

    {

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

    // First parameter should not be NULL

    __ASSERT_ALWAYS( aWimSecModule, User::Leave( KErrCorrupt ) );

    CWimToken* self = new( ELeave ) CWimToken( aWimSecModule, aTokenType );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWimToken::~CWimToken()

// Destructor

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

//

CWimToken::~CWimToken()

    {

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

    delete iLabel;

    iWimSecModule = NULL;

    delete iWimTokenListener;

    }

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

// CWimToken::Label()

// Get the label from current token

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

//

const TDesC& CWimToken::Label()

    {

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

    return reinterpret_cast<TDesC&>( *iLabel );

    }

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

// CWimToken::Information()

// Returns the specified information string about the token

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

//

const TDesC& CWimToken::Information( TTokenInformation aRequiredInformation )

    {

    _WIMTRACE ( _L( "CWimToken::Information()" ) );

    if ( TokenRemoved() )

        {

        return KNullDesC;

        }

    if ( iWimSecModule )

        {

        switch( aRequiredInformation ) 

           {

            case EVersion: // Returns the version from current token

                {   

                return WimSecModule()->Version();

                }

            case ESerialNo: // Returns the Serialnumber from current token

                {

                return WimSecModule()->SerialNumber();

                }

            case EManufacturer: // Returns the Manufacturer from current token

                {

                return WimSecModule()->Manufacturer();

                }

            default:    // Returns empty string 

                break;

             }

        }

    return KNullDesC;

    }

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

// MCTTokenType& CWimToken::TokenType()

// Returns the associated token type.

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

//

MCTTokenType& CWimToken::TokenType()

    {

    _WIMTRACE ( _L( "CWimToken::TokenType()" ) );

    return iTokenType;

    }

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

// TCTTokenHandle CWimToken::Handle()

// Returns the token's handle. TCTTokenHandle defines a handle to a subclass 

// of the MCTToken class

// WimSecModule()->TokenNumber retrieves the token actually exists. 

// Values 0..7 are for hardware tokens. Value 255 is for SoftId-token.

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

//

TCTTokenHandle CWimToken::Handle()

    {

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

    const TInt tokenNumber = WimSecModule()->TokenNumber();

    return TCTTokenHandle( TokenType().Type(), tokenNumber );

    }

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

// CWimToken::DoGetInterface()

// Returns a valid interface and KErrNone, or interface = NULL and 

// KErrNotSupported if it isn't supported by this token

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

// 

void CWimToken::DoGetInterface( TUid aRequiredInterface,

                                MCTTokenInterface*& aReturnedInterface,

                                TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "CWimToken::DoGetInterface()" ) );

    if ( TokenRemoved() )

        {

        Release();

        TRequestStatus* status = &aStatus;

        User::RequestComplete( status, KErrHardwareNotAvailable );             

        return;

        }

	    TInt error = KErrNone;

	    if ( TokenType().Type().iUid == WIM_IMPLEMENTATION_UID )

	        {

	        TRAP( error, MakeInterfaceL( aRequiredInterface, aReturnedInterface ) );

	        }

	    else

	        {

	        error = KErrArgument;

	        }

	    TRequestStatus* status = &aStatus;

	    User::RequestComplete( status, error );

	    // If something went wrong, this interface must be released, 

	    // because framework has just before incremented references

	    if ( error != KErrNone )

	        {

	        Release();

	        }	

    }

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

// CWimToken::MakeInterfaceL()

// At first checks if interface is supported. Note: support is depending on

// Uids that are indicated in resource file.

// Calls actual interface maker. All leavable functions are gathered into this.

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

//

void CWimToken::MakeInterfaceL( TUid aRequiredInterface,

                                MCTTokenInterface*& aReturnedInterface )

    {

    _WIMTRACE ( _L( "CWimToken::MakeInterfaceL()" ) );

    RCPointerArray <CCTTokenTypeInfo> tokenTypes;

    TCurrentTokenType filter;

    CCTTokenTypeInfo::ListL( tokenTypes, filter );

    if ( tokenTypes.Count() != 1 ) // There shoud be only one Wim implementation

        {

        tokenTypes.Close();

        User::Leave( KErrCorrupt );

        }

    // Check that given interface uid is found from resource file

    TInt count = tokenTypes[0]->Interfaces().Count();

    TInt i = 0;

    for ( ; i < count; i++ )

        {

        if ( tokenTypes[0]->Interfaces()[i].iUid == aRequiredInterface.iUid )

            {

            i = count + 1;

            }

        }

    tokenTypes.Close();

    if ( i == count )

        {

        User::Leave( KErrNotSupported );

        }

    switch ( aRequiredInterface.iUid )

        {

        case KInterfaceCertStore:   // Read Only Cert Store Interface.

            {

            iCertStoreIf = CWimCertStore::NewL( *this );

            aReturnedInterface = iCertStoreIf;

            break;

            }

        case KInterfaceWritableCertStore:

            {                       // Writable Cert Store Interface

            iCertStoreWritableIf = CWimCertStore::NewL( *this );

            aReturnedInterface = iCertStoreWritableIf;

            break;

            }

        case KInterfaceKeyStore:    // KeyStore Interface

            {

            iKeyStoreIf = CWimKeyStore::NewL( *this );

            aReturnedInterface = iKeyStoreIf;

            break;

            }

        case KCTInterfaceAuthenticationObject:

            {                       // Authentication Object Interface

            iAuthObjectListIf = CWimAuthenticationObjectList::NewL( *this );

            aReturnedInterface = iAuthObjectListIf;

            break;

            }

        default: // Should be checked in the caller function

            { 

            User::Leave( KErrCorrupt );             

            break;

            }

        }

    }

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

// CWimToken::DoCancelGetInterface()

// Nothing to do

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

//

TBool CWimToken::DoCancelGetInterface()

    {

    _WIMTRACE ( _L( "CWimToken::DoCancelGetInterface()" ) );

    return EFalse;

    }

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

// CWimToken::ReferenceCount()

// Returns a reference to reference counter.

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

//

TInt& CWimToken::ReferenceCount()

    {

    return iCount;

    }

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

// CWimToken::NotifyOnRemoval( TRequestStatus& aStatus )

// Notifies the client when the token has been removed.

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

//

void CWimToken::NotifyOnRemoval( TRequestStatus& aStatus )

    {

    _WIMTRACE ( _L( "CWimToken::NotifyOnRemoval()" ) );

    iWimTokenListener->SetClientStatus( aStatus );

    }

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

// CWimToken::CancelNotify()

// Cancels the NotifyOnRemoval request.

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

//

void CWimToken::CancelNotify()

    {

    _WIMTRACE ( _L( "CWimToken::CancelNotify()" ) );

    if ( TokenRemoved() )

        {

        return;

        }

    iWimTokenListener->ClearClientStatus();

    }

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

// CWimToken::WimSecModule()

// Returns a pointer to current security module

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

//

CWimSecModule* CWimToken::WimSecModule()

    {

    return iWimSecModule;

    }

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

// CWimToken::TokenListener()

// Returns a pointer to token listener

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

//

CWimTokenListener* CWimToken::TokenListener()

    {

    return iWimTokenListener;

    }

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

// CWimToken::TokenRemoved()

//

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

//

TBool CWimToken::TokenRemoved()

    {

    if ( TokenListener()->TokenStatus() == KRequestPending )

        {

        return EFalse;

        }

    else

        {

        return ETrue;

        }

    }

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

// TCurrentTokenType::Accept( const CCTTokenTypeInfo& ) const

// Returns true if current token type is same as given token type

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

//

TBool TCurrentTokenType::Accept( const CCTTokenTypeInfo& aInfo ) const

    {

    if ( aInfo.Type().iUid == WIM_IMPLEMENTATION_UID )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }   

    }