diff -r 000000000000 -r 164170e6151a wim/WimPlugin/src/WimAuthenticationObject.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wim/WimPlugin/src/WimAuthenticationObject.cpp Tue Jan 26 15:20:08 2010 +0200 @@ -0,0 +1,1189 @@ +/* +* 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 + +// ============================ 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& aObjects, + TRequestStatus& aStatus ) + { + _WIMTRACE ( _L( "CWimAuthenticationObject::ListProtectedObjects()" ) ); + + if ( !EnteringAllowed( aStatus ) ) + { + return; + } + + iObjects = &aObjects; + + iKeyInfos.Close(); + + iFs = static_cast( 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( 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; + } + + + if ( protector ) + { + CleanupStack::PushL( protector ); + } + } +#ifdef __SECURITY_PLATSEC_ARCH__ + CCTKeyInfo* copy = + CCTKeyInfo::NewL( ( iKeyInfos ) [i]->ID(), + ( iKeyInfos ) [i]->Usage(), + ( iKeyInfos ) [i]->Size(), + protector, + wlabel, + ( iKeyInfos ) [i]->Token(), + ( iKeyInfos ) [i]->Handle().iObjectId, + ( iKeyInfos ) [i]->UsePolicy(), + ( iKeyInfos ) [i]->ManagementPolicy(), + ( iKeyInfos ) [i]->Algorithm(), + ( iKeyInfos ) [i]->AccessType(), + ( iKeyInfos ) [i]->Native(), + ( iKeyInfos ) [i]->StartDate(), + ( iKeyInfos ) [i]->EndDate() ); +#else + CCTKeyInfo* copy = + CCTKeyInfo::NewL( ( iKeyInfos ) [i]->ID(), + ( iKeyInfos ) [i]->Usage(), + ( iKeyInfos ) [i]->Size(), + protector, + wlabel, + ( iKeyInfos ) [i]->Token(), + ( iKeyInfos ) [i]->Handle().iObjectId, + ( iKeyInfos ) [i]->Owner(), + ( iKeyInfos ) [i]->Users(), + ( iKeyInfos ) [i]->Algorithm(), + ( iKeyInfos ) [i]->AccessType(), + ( iKeyInfos ) [i]->Native(), + ( iKeyInfos ) [i]->StartDate(), + ( iKeyInfos ) [i]->EndDate() ); +#endif + // Call Release() for copy, if leave occurs + CleanupReleasePushL( *copy ); + // Take MCTokenObject part of it and append it to client + MCTTokenObject* obj = copy; + User::LeaveIfError( iObjects->Append ( obj ) ); + CleanupStack::Pop( copy ); + if ( protector ) + { + CleanupStack::Pop( protector ); + } + CleanupStack::Pop( wlabel ); + } + count = iCertStoreEntries.Count(); + for ( i = 0; i < count; i++ ) + { + // Make a copy of certificate info + + CCTCertInfo* copy = CCTCertInfo::NewLC( *iCertStoreEntries [i] ); + MCTTokenObject* obj = copy; + User::LeaveIfError( iObjects->Append ( obj ) ); + CleanupStack::Pop( copy ); + } + } + FreeUnifiedKeyStore(); + FreeUnifiedCertStore(); + iPhase = EIdle; + User::RequestComplete( iOriginalRequestStatus, iStatus.Int() ); + } + +// ----------------------------------------------------------------------------- +// void CWimAuthenticationObject::MakeAuthObjectL() +// Leavable function for making authenticaton objects +// ----------------------------------------------------------------------------- +// +MCTAuthenticationObject* + CWimAuthenticationObject::MakeAuthObjectL() + { + _WIMTRACE ( _L( "CWimAuthenticationObject::MakeAuthObjectL()" ) ); + + CWimAuthenticationObject* me = + CWimAuthenticationObject::NewLC( this->TokenWider(), + this->PinModule(), + this->Label(), + this->Type(), + this->Handle().iObjectId, + this->Status() ); + CleanupStack::Pop( me ); + return me; + } + +// ----------------------------------------------------------------------------- +// void CWimAuthenticationObject::FreeUnifiedKeyStore() +// Frees key storage resources. +// ----------------------------------------------------------------------------- +// +void CWimAuthenticationObject::FreeUnifiedKeyStore() + { + _WIMTRACE ( _L( "CWimAuthenticationObject::FreeUnifiedKeyStore()" ) ); + if ( iUnifiedKeyStore ) + { + iKeyInfos.Close(); + delete iUnifiedKeyStore; + iUnifiedKeyStore = 0; + } + iPhase = EIdle; + } + +// ----------------------------------------------------------------------------- +// void CWimAuthenticationObject::FreeUnifiedCertStore() +// Frees certificate storage resources. +// ----------------------------------------------------------------------------- +// +void CWimAuthenticationObject::FreeUnifiedCertStore() + { + if ( iUnifiedCertStore ) + { + iCertStoreEntries.Close(); + delete iUnifiedCertStore; + iUnifiedCertStore = NULL; + } + } +// ----------------------------------------------------------------------------- +// void CWimAuthenticationObject::RunError() +// Unexpected error in RunL (e.g. Leave) leads us here. +// ----------------------------------------------------------------------------- +// +TInt CWimAuthenticationObject::RunError( TInt aError ) + { + _WIMTRACE ( _L( "CWimAuthenticationObject::RunError()" ) ); + FreeUnifiedKeyStore(); + FreeUnifiedCertStore(); + iPhase = EIdle; + User::RequestComplete( iOriginalRequestStatus, aError ); + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// void CWimAuthenticationObject::DoCancel() +// +// ----------------------------------------------------------------------------- +// +void CWimAuthenticationObject::DoCancel() + { + _WIMTRACE ( _L( "CWimAuthenticationObject::DoCancel()" ) ); + + if ( iUnifiedKeyStore ) + { + switch ( iPhase ) + { + case EGetKeyInfos: + { + if ( iUnifiedKeyStore->IsActive() ) + { + iUnifiedKeyStore->CancelInitialize(); + } + break; + } + case EFilterKeys: + { + if ( iUnifiedKeyStore->IsActive() ) + { + iUnifiedKeyStore->CancelList(); + } + break; + } + default: + { + break; + } + } + } + + if ( iUnifiedCertStore ) + { + switch ( iPhase ) + { + case EInitCertStore: + { + if ( iUnifiedCertStore->IsActive() ) + { + iUnifiedCertStore->CancelInitialize(); + } + break; + } + case EListCertEntries: + { + if ( iUnifiedCertStore->IsActive() ) + { + iUnifiedCertStore->CancelList(); + } + break; + } + default: + { + // Other phases won't cause any action + break; + } + } + } + + switch ( iPhase ) + { + case EEnablePinQuery: + { + PinModule().CancelEnablePinQuery(); + break; + } + case EDisablePinQuery: + { + PinModule().CancelDisablePinQuery(); + break; + } + case EChangePin: + { + PinModule().CancelChangePin(); + break; + } + case EUnblockPin: + { + PinModule().CancelUnblockPin(); + break; + } + case EVerifyPin: + { + PinModule().CancelVerifyPin(); + break; + } + default: break; + } + + + FreeUnifiedKeyStore(); + FreeUnifiedCertStore(); + iPhase = EIdle; + User::RequestComplete( iOriginalRequestStatus, KErrCancel ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthenticationObject::CancelListProtectedObjects() +// Cancels an ongoing ListProtectedObjects operation. +// ----------------------------------------------------------------------------- +// +void CWimAuthenticationObject::CancelListProtectedObjects() + { + _WIMTRACE ( _L( "CWimAuthenticationObject::CancelListProtectedObjects()" ) ); + + if ( TokenRemoved() ) + { + return; + } + + Cancel(); + } + +// ----------------------------------------------------------------------------- +// CWimAuthenticationObject::ChangeReferenceData() +// Change the reference data (e.g. PIN value). +// ----------------------------------------------------------------------------- +// +void CWimAuthenticationObject::ChangeReferenceData( TRequestStatus& aStatus ) + { + _WIMTRACE ( _L( "CWimAuthenticationObject::ChangeReferenceData()" ) ); + + if ( !EnteringAllowed( aStatus ) ) + { + return; + } + + PinModule().ChangePin( iStatus ); + iPhase = EChangePin; + SetActive(); + } + +// ----------------------------------------------------------------------------- +// CWimAuthenticationObject::CancelListProtectedObjects() +// Cancel an ongoing ChangeReferenceData operation. +// ----------------------------------------------------------------------------- +// +void CWimAuthenticationObject::CancelChangeReferenceData() + { + _WIMTRACE ( _L( "CWimAuthenticationObject::CancelChangeReferenceData()" ) ); + + if ( TokenRemoved() ) + { + return; + } + + Cancel(); + } + +// ----------------------------------------------------------------------------- +// CWimAuthenticationObject::Unblock() +// Unblock the authentication object. +// ----------------------------------------------------------------------------- +// +void CWimAuthenticationObject::Unblock( TRequestStatus& aStatus ) + { + _WIMTRACE ( _L( "CWimAuthenticationObject::Unblock()" ) ); + + if ( !EnteringAllowed( aStatus ) ) + { + return; + } + + PinModule().UnblockPin( iStatus ); + iPhase = EUnblockPin; + SetActive(); + } + +// ----------------------------------------------------------------------------- +// CWimAuthenticationObject::CancelUnblock() +// Cancel an ongoing Unblock operation. +// ----------------------------------------------------------------------------- +// +void CWimAuthenticationObject::CancelUnblock() + { + _WIMTRACE ( _L( "CWimAuthenticationObject::CancelUnblock()" ) ); + + if ( TokenRemoved() ) + { + return; + } + + Cancel(); + } + +// ----------------------------------------------------------------------------- +// CWimAuthenticationObject::Status() +// Get the status of the authentication object. +// Values are as in enum TCTAuthenticationStatus. Note: Blocked information +// is not available before authentication object is verified. +// ----------------------------------------------------------------------------- +// +TUint32 CWimAuthenticationObject::Status() const + { + _WIMTRACE ( _L( "CWimAuthenticationObject::Status()" ) ); + + if ( iToken.TokenListener()->TokenStatus() != KRequestPending ) + { + return 0; + } + + return PinModule().PinStatus(); + } + +// ----------------------------------------------------------------------------- +// CWimAuthenticationObject::Disable() +// Disables the authentication object. This means that authentication data is +// is not asked for any operations. Note: Disabling requires authentication data +// to be entered. +// ----------------------------------------------------------------------------- +// +void CWimAuthenticationObject::Disable( TRequestStatus& aStatus ) + { + _WIMTRACE ( _L( "CWimAuthenticationObject::Disable()" ) ); + + + if ( !EnteringAllowed( aStatus ) ) + { + return; + } + + PinModule().DisablePinQuery( iStatus ); + iPhase = EDisablePinQuery; + SetActive(); + } + +// ----------------------------------------------------------------------------- +// CWimAuthenticationObject::CancelDisable() +// Cancel an ongoing Disable operation. +// ----------------------------------------------------------------------------- +// +void CWimAuthenticationObject::CancelDisable() + { + _WIMTRACE ( _L( "CWimAuthenticationObject::CancelDisable()" ) ); + + if ( TokenRemoved() ) + { + return; + } + + Cancel(); + } + +// ----------------------------------------------------------------------------- +// CWimAuthenticationObject::Enable() +// Enables the authentication object. This means that authentication data is +// is asked for certain operations. Note: Enabling requires authentication data +// to be entered. +// ----------------------------------------------------------------------------- +// +void CWimAuthenticationObject::Enable( TRequestStatus& aStatus ) + { + _WIMTRACE ( _L( "CWimAuthenticationObject::Enable()" ) ); + + if ( !EnteringAllowed( aStatus ) ) + { + return; + } + + PinModule().EnablePinQuery( iStatus ); + iPhase = EEnablePinQuery; + SetActive(); + } + +// ----------------------------------------------------------------------------- +// CWimAuthenticationObject::CancelEnable() +// Cancel an ongoing Enable operation. +// ----------------------------------------------------------------------------- +// +void CWimAuthenticationObject::CancelEnable() + { + _WIMTRACE ( _L( "CWimAuthenticationObject::CancelEnable()" ) ); + + if ( TokenRemoved() ) + { + return; + } + + Cancel(); + } + +// ----------------------------------------------------------------------------- +// CWimAuthenticationObject::Open() +// Opens the authentication object, meaning that the protected objects can be +// accessed without provoking the authentication mechanism for the duration of +// the timeout period. Note. It is not strictly necessary to call this function, +// as the authentication object will be opened when any operation that needs it +// to be opened is called, but it is sometimes useful to control the timing of +// authentication dialogs. Note also that this function will do nothing if the +// authentication object is open, or if it authentication object requires +// the authentication +// ----------------------------------------------------------------------------- +// +void CWimAuthenticationObject::Open( TRequestStatus& aStatus ) + { + _WIMTRACE ( _L( "CWimAuthenticationObject::Open()" ) ); + + if ( !EnteringAllowed( aStatus ) ) + { + return; + } + + if ( this->Type().iUid == WIM_PIN_G_UID ) // If this is a Pin-G + { + TBool wimopen = iToken.WimSecModule()->IsOpen(); + if ( !wimopen ) + { + if( iToken.WimSecModule()->CloseAfter() != 0 ) + { + PinModule().VerifyPin( iStatus ); + iPhase = EVerifyPin; + SetActive(); + } + else + { + User::RequestComplete( iOriginalRequestStatus, KErrNone ); + } + + } + else + { + User::RequestComplete( iOriginalRequestStatus, KErrNone ); + } + } + else + { + User::RequestComplete( iOriginalRequestStatus, KErrNotSupported ); + } + } + +// ----------------------------------------------------------------------------- +// CWimAuthenticationObject::Close() +// Closes an authentication object. After this call authentication data is +// needed again for certain operations. +// ----------------------------------------------------------------------------- +// +void CWimAuthenticationObject::Close( TRequestStatus& aStatus ) + { + _WIMTRACE ( _L( "CWimAuthenticationObject::Close()" ) ); + TInt err = KErrNone; + + if ( !EnteringAllowed( aStatus ) ) + { + return; + } + + if ( this->Type().iUid == WIM_PIN_G_UID ) // If this is a Pin-G + { + TBool wimopen = iToken.WimSecModule()->IsOpen(); + if ( wimopen ) + { + err = iToken.WimSecModule()->Close(); + } + } + else + { + err = KErrNotSupported; + } + User::RequestComplete( iOriginalRequestStatus, err ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthenticationObject::TimeRemaining() +// Returns the amount of time in seconds that the authentication object +// will remain open for, or 0 if it is closed. +// ----------------------------------------------------------------------------- +void CWimAuthenticationObject::TimeRemaining( TInt& aStime, + TRequestStatus& aStatus ) + { + _WIMTRACE ( _L( "CWimAuthenticationObject::TimeRemaining()" ) ); + TInt ret = KErrNone; + aStime = 0; + + if ( !EnteringAllowed( aStatus ) ) + { + return; + } + + if ( this->Type().iUid == WIM_PIN_G_UID ) // If this is a Pin-G + { + TBool wimopen = iToken.WimSecModule()->IsOpen(); + if ( wimopen ) + { + aStime = iToken.WimSecModule()->CloseAfter(); + } + } + else + { + ret = KErrNotSupported; + } + User::RequestComplete( iOriginalRequestStatus, ret ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthenticationObject::SetTimeout() +// Sets the time in seconds for this authentication object. Non-positive +// special values is 0, meaning always ask, and -1, meaning until it's +// explicitly closed. +// ----------------------------------------------------------------------------- +// +void CWimAuthenticationObject::SetTimeout( TInt aTimeout, + TRequestStatus& aStatus ) + { + _WIMTRACE ( _L( "CWimAuthenticationObject::SetTimeout()" ) ); + TInt ret = KErrNone; + + if ( !EnteringAllowed( aStatus ) ) + { + return; + } + + if ( this->Type().iUid == WIM_PIN_G_UID ) // If this is a Pin-G + { + if ( aTimeout >= -1 && aTimeout <= 2146 ) + { + iToken.WimSecModule()->SetCloseAfter( aTimeout ); + } + else + { + ret = KErrArgument; + } + } + else + { + ret = KErrNotSupported; + } + User::RequestComplete( iOriginalRequestStatus, ret ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthenticationObject::Timeout() +// Gets the current timeout value, in seconds. See SetTimeout for an explanation +// of the values. +// ----------------------------------------------------------------------------- +// +void CWimAuthenticationObject::Timeout( TInt& aTime, + TRequestStatus& aStatus ) + { + _WIMTRACE ( _L( "CWimAuthenticationObject::Timeout()" ) ); + TInt ret = KErrNone; + + if ( !EnteringAllowed( aStatus ) ) + { + return; + } + + aTime = 0; + + if ( this->Type().iUid == WIM_PIN_G_UID ) // If this is a Pin-G + { + aTime = iToken.WimSecModule()->CloseAfter(); + } + else + { + ret = KErrNotSupported; + } + User::RequestComplete( iOriginalRequestStatus, ret ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthenticationObject::EnteringAllowed() +// +// ----------------------------------------------------------------------------- +// +TBool CWimAuthenticationObject::EnteringAllowed( TRequestStatus& aStatus ) + { + _WIMTRACE ( _L( "CWimAuthenticationObject::EnteringAllowed()" ) ); + if ( TokenRemoved() ) + { + TRequestStatus* status = &aStatus; + User::RequestComplete( status, KErrHardwareNotAvailable ); + return EFalse; + } + + // If this active object is in running, don't accept entering + if ( IsActive() ) + { + // If the caller status is the same as the status, that activated + // this object, just return + if ( &aStatus == iOriginalRequestStatus ) + { + return EFalse; + } + else + { + // Otherwise complete it with error + TRequestStatus* status = &aStatus; + User::RequestComplete( status, KErrInUse ); + return EFalse; + } + } + else + { + iOriginalRequestStatus = &aStatus; + aStatus = KRequestPending; + return ETrue; + } + } + +// ----------------------------------------------------------------------------- +// CWimAuthenticationObject::TokenRemoved() +// Returns true or false indicating if token is removed +// ----------------------------------------------------------------------------- +// +TBool CWimAuthenticationObject::TokenRemoved() + { + _WIMTRACE ( _L( "CWimAuthenticationObject::TokenRemoved()" ) ); + + // If token listener is not alive, then token is removed + if ( iToken.TokenListener()->TokenStatus() != KRequestPending ) + { + return ETrue; + } + else + { + return EFalse; + } + } + +// End of File