diff -r 000000000000 -r 164170e6151a wim/WimServer/src/WimAuthObjHandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wim/WimServer/src/WimAuthObjHandler.cpp Tue Jan 26 15:20:08 2010 +0200 @@ -0,0 +1,1417 @@ +/* +* Copyright (c) 2002-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: Services for authentication object management +* +*/ + + + +// INCLUDE FILES +#include "WimServer.h" +#include "Wimi.h" //WIMI definitions +#include "WimClsv.h" +#include "WimAuthObjHandler.h" +#include "WimMemMgmt.h" +#include "WimResponse.h" +#include "WimUtilityFuncs.h" +#include "WimSecurityDlgHandler.h" +#include "WimTrace.h" +#include "WimCallbackImpl.h" +#include "WimCleanup.h" +#include "JavaUtils.h" +#include + +#ifdef _DEBUG +_LIT( KWimAuthObjPanic, "WimAuthObj" ); +#endif + + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::CWimAuthObjHandler +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CWimAuthObjHandler::CWimAuthObjHandler() : CActive( EPriorityStandard ) + { + _WIMTRACE(_L("WIM | WIMServer | CWimAuthObjHandler::CWimAuthObjHandler | Begin")); + iDisablePINBlocked = EFalse; + iUnblockPING = EFalse; + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::ConstructL() + { + _WIMTRACE(_L("WIM | WIMServer | CWimAuthObjHandler::ConstructL | Begin")); + CActiveScheduler::Add( this ); + iWimUtilFuncs = CWimUtilityFuncs::NewL(); + iWimSecDlg = CWimSecurityDlgHandler::NewL(); + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CWimAuthObjHandler* CWimAuthObjHandler::NewL() + { + _WIMTRACE(_L("WIM | WIMServer | CWimAuthObjHandler::NewL | Begin")); + CWimAuthObjHandler* self = new( ELeave ) CWimAuthObjHandler; + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +// Destructor +CWimAuthObjHandler::~CWimAuthObjHandler() + { + _WIMTRACE(_L("WIM | WIMServer | CWimAuthObjHandler::~CWimAuthObjHandler | Begin")); + Cancel(); + delete iWimUtilFuncs; + delete iWimSecDlg; + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::GetPINCountL +// Fetches the count of PINs in WIM. +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::GetPINCountL( const RMessage2& aMessage ) const + { + _WIMTRACE(_L("WIM | WIMServer | CWimAuthObjHandler::GetPINCountL | Begin")); + WIMI_Ref_pt pWimStruct = const_cast( aMessage.Ptr0() ); + TUint16 pinNum; + WIMI_RefList_t refList; + WIMI_STAT status = WIMI_Ok; + + status = WIMI_GetPINList( pWimStruct, &pinNum, &refList ); + + if ( status == WIMI_Ok ) + { + free_WIMI_RefList_t( refList ); + TPckgBuf pckg( pinNum ); + aMessage.WriteL( 1, pckg ); + } + aMessage.Complete( CWimUtilityFuncs::MapWIMError( status ) ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::GetPINRefListL +// Get reference list for PINs. +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::GetPINRefListL( + const RMessage2& aMessage, + CWimMemMgmt* aWimMgmt ) + { + _WIMTRACE(_L("WIM | WIMServer | CWimAuthObjHandler::GetPINRefListL | Begin")); + WIMI_Ref_pt pWimStruct = const_cast( aMessage.Ptr0() ); + __ASSERT_ALWAYS( pWimStruct, User::Leave( KErrArgument ) ); + HBufC8* buf = iWimUtilFuncs->DesLC( 2, aMessage ); + TUint32* pinArr = ( TUint32* )( buf->Des().Ptr() ); + TUint16 pinNum; + WIMI_RefList_t pinRefLst; + WIMI_STAT status = WIMI_Ok; + + status = WIMI_GetPINList( pWimStruct, &pinNum, &pinRefLst ); + + if ( status == WIMI_Ok ) + { + aWimMgmt->AppendWIMRefLstL( pinRefLst ); // takes ownership + TPckgBuf lstAddr( ( TUint32 ) pinRefLst ); + for ( TUint8 index = 0; index < pinNum; index++ ) + { + pinArr[index] = ( TUint32 ) pinRefLst[index]; + } + + iPinGRef = const_cast< WIMI_Ref_pt >( pinRefLst[0] ); + + aMessage.WriteL( 1, lstAddr ); + aMessage.WriteL( 2, buf->Des() ); + } + CleanupStack::PopAndDestroy( buf ); + aMessage.Complete( CWimUtilityFuncs::MapWIMError( status ) ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::GetPINInfoL +// Get detailed information about the PIN. +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::GetPINInfoL( const RMessage2& aMessage ) + { + _WIMTRACE(_L("WIM | WIMServer | CWimAuthObjHandler::GetPINInfoL | Begin")); + WIMI_Ref_pt pPinStruct = const_cast( aMessage.Ptr0() ); + __ASSERT_ALWAYS( pPinStruct, User::Leave( KErrArgument ) ); + TUint8 flags; + TUint8 minLength; + TUint8 pinNumber = 0; + WIMI_BinData_t ptLabel; + WIMI_STAT status = WIMI_Ok; + + if ( pPinStruct ) + { + iPinValue.Zero(); + TRequestStatus status1; + CWimCallBack::SetSignTextRequestStatus( &status1 ); + status = WIMI_VerifyPINReq( NULL,pPinStruct, + ( TUint8 )iPinValue.Length(), + ( TUint8* )iPinValue.Ptr() ); + + if ( status != WIMI_Ok ) + { + aMessage.Complete( CWimUtilityFuncs::MapWIMError( status ) ); + return; + } + + User::WaitForRequest( status1 ); + CWimCallBack::SetSignTextRequestStatus( NULL ); + WIMI_Ref_t* cmeWimRef = NULL; + + status = WIMI_GetPINStatus( pPinStruct, + &cmeWimRef, + &flags, + &minLength, + &pinNumber, + &ptLabel ); + + if ( status == WIMI_Ok ) + { + // Code MAY NOT leave before cmeWimRef and ptLabel.pb_buf are deallocated. + + TPckgBuf infoPckg; + TInt readErr = aMessage.Read( 1, infoPckg ); + if( readErr ) + { + free_WIMI_Ref_t( cmeWimRef ); + WSL_OS_Free( ptLabel.pb_buf ); + // Code can leave after this point. + User::Leave( readErr ); + } + + TBuf label; + label.Copy( TPtr8( ptLabel.pb_buf, + ptLabel.ui_buf_length, + ptLabel.ui_buf_length ) ); + + // Possible values of iStatus are: + // EEnabled = 0x80, + // EChangeDisabled = 0x40, + // EUnblockDisabled = 0x20, + // EDisableAllowed = 0x10, + + if( status1.Int() == KErrLocked ) + { + infoPckg().iStatus = flags & KPINStatusMask; + infoPckg().iStatus = infoPckg().iStatus | KWimAuthObjectBlocked; + } + else if( iDisablePINBlocked ) + { + infoPckg().iStatus = flags & KPINStatusMask; + infoPckg().iStatus = infoPckg().iStatus | KWimAuthObjectBlocked; + } + else + { + infoPckg().iStatus = flags & KPINStatusMask; + } + + infoPckg().iPinNumber = pinNumber; + infoPckg().iLabel = label; + + TInt writeErr = aMessage.Write( 1, infoPckg ); + + free_WIMI_Ref_t( cmeWimRef ); + WSL_OS_Free( ptLabel.pb_buf ); + // Code can leave after this point. + User::LeaveIfError( writeErr ); + } + } + else + { + status = WIMI_ERR_BadParameters; + } + aMessage.Complete( CWimUtilityFuncs::MapWIMError( status ) ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::GetPINsInfoL +// Get detailed information about the all of the PINs on a certain SecMod. +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::GetPINsInfoL( const RMessage2& aMessage ) + { + //Get pin number and reflist + _WIMTRACE(_L("WIM | WIMServer | CWimAuthObjHandler::GetPINsInfoL | Begin")); + WIMI_Ref_pt pWimStruct = const_cast( aMessage.Ptr0() ); + + TUint16 pinNum; + WIMI_RefList_t refList; + WIMI_STAT status = WIMI_Ok; + + status = WIMI_GetPINList( pWimStruct, &pinNum, &refList ); + CleanupPushWimRefListL( refList ); + + CArrayFixFlat* pinsInfo = new( ELeave ) CArrayFixFlat( pinNum ); + CleanupStack::PushL( pinsInfo ); + + RArray pinRefsArray; + CleanupClosePushL( pinRefsArray ); + + if( status == WIMI_Ok ) + { + if( pinNum != aMessage.Int2() ) + { + status = WIMI_ERR_Internal; + CleanupStack::PopAndDestroy( 3, refList ); // pinRefsArray, pinsInfo, refList + aMessage.Complete( CWimUtilityFuncs::MapWIMError( status ) ); + return; + } + for ( TUint8 index = 0; index < pinNum; index++ ) + { + pinRefsArray.Append( refList[index] ); + } + } + else + { + CleanupStack::PopAndDestroy( 3, refList ); // pinRefsArray, pinsInfo, refList + aMessage.Complete( CWimUtilityFuncs::MapWIMError( status ) ); + return; + } + + //Get pin details bt pin reference + for ( TUint8 index = 0; index < pinNum; index++ ) + { + WIMI_Ref_pt pPinStruct = pinRefsArray[ index ]; + + __ASSERT_ALWAYS( pPinStruct, User::Leave( KErrArgument ) ); + + TUint8 flags; + TUint8 minLength; + TUint8 pinNumber = 0; + WIMI_BinData_t ptLabel; + WIMI_STAT status = WIMI_Ok; + + TRequestStatus status1; + + iPinValue.Zero(); + + CWimCallBack::SetSignTextRequestStatus( &status1 ); + + status = WIMI_VerifyPINReq( NULL,pPinStruct, + ( TUint8 )iPinValue.Length(), + ( TUint8* )iPinValue.Ptr() ); + + _WIMTRACE2(_L("WIM | WIMServer | CWimAuthObjHandler::GetPINsInfoL status %d "), status ); + + if ( status != WIMI_Ok ) + { + CleanupStack::PopAndDestroy( 3, refList ); // pinRefsArray, pinsInfo, refList + aMessage.Complete( CWimUtilityFuncs::MapWIMError( status ) ); + return; + } + + User::WaitForRequest( status1 ); + + CWimCallBack::SetSignTextRequestStatus( NULL ); + + WIMI_Ref_t* cmeWimRef = NULL; + + status = WIMI_GetPINStatus( pPinStruct, + &cmeWimRef, + &flags, + &minLength, + &pinNumber, + &ptLabel ); + + if ( status == WIMI_Ok ) + { + free_WIMI_Ref_t( cmeWimRef ); + CleanupPushWimBufL( ptLabel ); + + TWimPinStruct pinStruct; + pinStruct.iLabel.Copy( TPtr8( ptLabel.pb_buf, + ptLabel.ui_buf_length, + ptLabel.ui_buf_length ) ); + CleanupStack::PopAndDestroy( ptLabel.pb_buf ); + + // Possible values of iStatus are: + // EEnabled = 0x80, + // EChangeDisabled = 0x40, + // EUnblockDisabled = 0x20, + // EDisableAllowed = 0x10, + + if( status1.Int() == KErrLocked ) + { + pinStruct.iStatus = flags & KPINStatusMask; + pinStruct.iStatus = pinStruct.iStatus | KWimAuthObjectBlocked; + } + else if( iDisablePINBlocked ) + { + pinStruct.iStatus = flags & KPINStatusMask; + pinStruct.iStatus = pinStruct.iStatus | KWimAuthObjectBlocked; + } + else + { + pinStruct.iStatus = flags & KPINStatusMask; + } + pinStruct.iPinNumber = pinNumber; + + pinsInfo->AppendL( pinStruct ); + } + else + { + status = WIMI_ERR_BadParameters; + break; + } + } + + TInt16 length = ( TInt16 )pinsInfo->Count()*( sizeof( TWimPinStruct ) ); + + TPtrC8 pinInfoPtr; + + pinInfoPtr.Set( (TText8*)&(*pinsInfo)[0], length ); + + if( status == WIMI_Ok ) + { + aMessage.WriteL( 1, pinInfoPtr ); + } + + CleanupStack::PopAndDestroy( 3, refList ); // pinRefsArray, pinsInfo, refList + + aMessage.Complete( CWimUtilityFuncs::MapWIMError( status ) ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::VerifyDisabledPINRequestL +// Verifies Disabled PIN number. +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::VerifyDisabledPINRequestL( + const RMessage2& aMessage ) + { + __ASSERT_DEBUG( iResponseID == NULL, User::Panic( KWimAuthObjPanic, KErrGeneral ) ); + iResponseID = new ( ELeave )CWimResponse( aMessage ); + iResponseID->iOpcode = EVerifyDisabledPinReq; + + if( iDisablePINBlocked ) + { + iResponseID->iStatus = WIMI_ERR_PINBlocked; + iResponseID->CompleteMsgAndDelete(); + iResponseID = NULL; + } + else + { + iResponseID->iStatus = WIMI_Ok; + iResponseID->CompleteMsgAndDelete(); + iResponseID = NULL; + } + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::VerifyPINRequestL +// Verifies PIN number. +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::VerifyPINRequestL( + const RMessage2& aMessage, + TBool aShowDialog ) + { + _WIMTRACE(_L("WIM|WIMServer|CWimAuthObjHandler::VerifyPINRequestL|Begin")); + + __ASSERT_DEBUG( iResponseID == NULL, User::Panic( KWimAuthObjPanic, KErrGeneral ) ); + iResponseID = new ( ELeave )CWimResponse( aMessage ); + iResponseID->iOpcode = EVerifyPinReq; + + __ASSERT_DEBUG( iTrId == NULL, User::Panic( KWimAuthObjPanic, KErrGeneral ) ); + iTrId = iWimUtilFuncs->TrIdLC( iResponseID, EWimMgmtReq ); + CleanupStack::Pop( iTrId ); + + iShowDialog = aShowDialog; + + if ( aShowDialog ) // Ask PIN from user + { + _WIMTRACE(_L("WIM|WIMServer|CWimAuthObjHandler::Verify|Show dialog")); + TPckgBuf infoPckg; + aMessage.ReadL( 1, infoPckg ); + _WIMTRACE(_L("WIM|WIMServer|CWimAuthObjHandler::Verify|PINParamas read")); + + iPinParams.iPINLabel = infoPckg().iPINLabel; + iPinParams.iTokenLabel = infoPckg().iTokenLabel; + iPinParams.iMinLength = infoPckg().iMinLength; + iPinParams.iMaxLength = infoPckg().iMaxLength; + + _WIMTRACE(_L("WIM|WIMServer|CWimAuthObjHandler::Verify|Call dialog")); + + iRetry = EFalse; + + VerifyPINAskPIN(); + + } + else // Do not ask PIN from user, just try if PIN is blocked with empty PIN + { + iRequest = EVerifyPINAskPIN; + iStatus = KRequestPending; + SetActive(); + iPinValue.Zero(); + TRequestStatus* status = &iStatus; + User::RequestComplete( status, KErrNone ); + } + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::VerifyPINAskPIN +// +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::VerifyPINAskPIN() + { + iRequest = EVerifyPINAskPIN; + iStatus = KRequestPending; + SetActive(); + iWimSecDlg->EnterPIN( iRetry, + iPinParams, + iPinValue, + iStatus ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::ContinueVerifyPINReqL +// Continue verify PIN request. Calls WIMI. +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::ContinueVerifyPINReqL( ) + { + __ASSERT_DEBUG( iResponseID, User::Panic( KWimAuthObjPanic, KErrGeneral ) ); + WIMI_Ref_pt pPINref = const_cast( (iResponseID->iMessage).Ptr0() ); + + HBufC8* pinBuf = HBufC8::NewLC( iPinValue.Length() ); + TPtr8 pinPtr = pinBuf->Des(); + pinPtr.Copy( iPinValue ); + + if ( iShowDialog ) + { + iStatus = KRequestPending; + TRequestStatus* status = &iStatus; + + iRequest = EVerifyPINCallBackResponse; + SetActive(); + + iResponseID->iStatus = WIMI_VerifyPINReq( iTrId, + pPINref, + ( TUint8 )pinPtr.Length(), + ( TUint8* )pinPtr.Ptr() ); + + if ( iResponseID->iStatus != WIMI_Ok ) + { + iRequest = EWIMIError; + User::RequestComplete( status, iResponseID->iStatus ); + } + } + else + { + iResponseID->iStatus = WIMI_VerifyPINReq( iTrId, + pPINref, + ( TUint8 )pinPtr.Length(), + ( TUint8* )pinPtr.Ptr() ); + + if ( iResponseID->iStatus != WIMI_Ok ) + { + iResponseID->CompleteMsgAndDelete(); + iResponseID = NULL; + delete iTrId; + iTrId = NULL; + } + } + + CleanupStack::PopAndDestroy( pinBuf ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::CancelVerifyPin +// Cancel verify Pin operation +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::CancelVerifyPin( const RMessage2& aMessage ) + { + if( IsActive() ) + { + Cancel(); + } + + aMessage.Complete( KErrNone ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::EnablePINReqL +// Enables/disables PIN query. +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::EnablePINReqL( const RMessage2& aMessage ) + { + _WIMTRACE(_L("WIM|WIMServer|CWimAuthObjHandler::EnablePINReqL|Begin")); + + __ASSERT_DEBUG( iResponseID == NULL, User::Panic( KWimAuthObjPanic, KErrGeneral ) ); + iResponseID = new( ELeave )CWimResponse( aMessage ); + iResponseID->iOpcode =EEnablePINReq; + + __ASSERT_DEBUG( iTrId == NULL, User::Panic( KWimAuthObjPanic, KErrGeneral ) ); + iTrId = iWimUtilFuncs->TrIdLC( iResponseID, EWimMgmtReq ); + CleanupStack::Pop( iTrId ); + + TPckgBuf statePckg; + aMessage.ReadL( 1, statePckg ); + + TPckgBuf infoPckg; + aMessage.ReadL( 2, infoPckg ); + + iPinParams.iPINLabel = infoPckg().iPINLabel; + iPinParams.iTokenLabel = infoPckg().iTokenLabel; + iPinParams.iMinLength = infoPckg().iMinLength; + iPinParams.iMaxLength = infoPckg().iMaxLength; + + iEnablePinQuery = statePckg().iEnable; + + iRetry = EFalse; + + EnablePINAskPIN(); + + } + +void CWimAuthObjHandler::EnablePINAskPIN() + { + if ( iEnablePinQuery ) + { + iRequest = EEnablePINAskPIN; + } + else + { + iRequest = EDisablePINAskPIN; + } + + iStatus = KRequestPending; + SetActive(); + // Query PIN code from the user by using security dialog + iWimSecDlg->EnablePIN( iEnablePinQuery, + iRetry, + iPinParams, + iPinValue, + iStatus ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::ContinueEnablePINReqL +// Continue enable/disable PIN query request. Calls WIMI. +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::ContinueEnablePINReqL() + { + __ASSERT_DEBUG( iResponseID, User::Panic( KWimAuthObjPanic, KErrGeneral ) ); + WIMI_Ref_pt pPINref = const_cast( (iResponseID->iMessage).Ptr0() ); + + HBufC8* pinBuf = HBufC8::NewLC( iPinValue.Length() ); + TPtr8 pinPtr = pinBuf->Des(); + pinPtr.Copy( iPinValue ); + + iStatus = KRequestPending; + TRequestStatus* status = &iStatus; + + if ( iEnablePinQuery ) + { + iRequest = EEnablePINCallBackResponse; + } + else + { + iRequest = EDisablePINCallBackResponse; + } + SetActive(); + + iResponseID->iStatus = WIMI_EnablePINReq( iTrId, + pPINref, + ( TUint8 )pinPtr.Length(), + ( TUint8* )pinPtr.Ptr(), + iEnablePinQuery ); + + if ( iResponseID->iStatus != WIMI_Ok ) + { + iRequest = EWIMIError; + User::RequestComplete( status, iResponseID->iStatus ); + } + CleanupStack::PopAndDestroy( pinBuf ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::CancelEnablePinL +// Cancel enable Pin operation +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::CancelEnablePin( const RMessage2& aMessage ) + { + if( IsActive() ) + { + Cancel(); + } + + aMessage.Complete( KErrNone ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::ChangePINRequestL +// Changes a PIN number. +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::ChangePINRequestL( const RMessage2& aMessage ) + { + _WIMTRACE(_L("WIM | WIMServer | CWimAuthObjHandler::ChangePINRequestL | Begin")); + + __ASSERT_DEBUG( iResponseID == NULL, User::Panic( KWimAuthObjPanic, KErrGeneral ) ); + iResponseID = new ( ELeave ) CWimResponse( aMessage ); + iResponseID->iOpcode = EChangePINReq; + + __ASSERT_DEBUG( iTrId == NULL, User::Panic( KWimAuthObjPanic, KErrGeneral ) ); + iTrId = iWimUtilFuncs->TrIdLC( iResponseID, EWimMgmtReq ); + CleanupStack::Pop( iTrId ); + + TPckgBuf infoPckg; + aMessage.ReadL( 1, infoPckg ); + + iPinParams.iPINLabel = infoPckg().iPINLabel; + iPinParams.iTokenLabel = infoPckg().iTokenLabel; + iPinParams.iMinLength = infoPckg().iMinLength; + iPinParams.iMaxLength = infoPckg().iMaxLength; + + iRetry = EFalse; + + ChangePINAskPIN(); + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::ChangePINAskPIN +// +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::ChangePINAskPIN() + { + iRequest = EChangePINAskPIN; + iStatus = KRequestPending; + SetActive(); + // Query PIN code from the user by using security dialog + iWimSecDlg->ChangePINValue( iRetry, + iPinParams, + iOldPinValue, + iNewPinValue, + iStatus ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::ContinueChangePINReqL +// Continue change PIN request. Calls WIMI. +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::ContinueChangePINReqL() + { + __ASSERT_DEBUG( iResponseID, User::Panic( KWimAuthObjPanic, KErrGeneral ) ); + WIMI_Ref_pt pPINref = const_cast( (iResponseID->iMessage).Ptr0() ); + + HBufC8* pinOldBuf = HBufC8::NewLC( iOldPinValue.Length() ); + HBufC8* pinNewBuf = HBufC8::NewLC( iNewPinValue.Length() ); + + TPtr8 oldPin = pinOldBuf->Des(); + oldPin.Copy( iOldPinValue ); + TPtr8 newPin = pinNewBuf->Des(); + newPin.Copy( iNewPinValue ); + + iStatus = KRequestPending; + TRequestStatus* status = &iStatus; + iRequest = EChangePINCallBackResponse; + SetActive(); + + iResponseID->iStatus = WIMI_ChangePINReq( iTrId, + pPINref, + ( TUint8 )oldPin.Length(), + ( TUint8* )oldPin.Ptr() , + ( TUint8 )newPin.Length(), + ( TUint8* )newPin.Ptr() ); + if ( iResponseID->iStatus != WIMI_Ok ) + { + iRequest = EWIMIError; + User::RequestComplete( status, iResponseID->iStatus ); + } + CleanupStack::PopAndDestroy( 2, pinOldBuf ); // pinNewBuf, pinOldBuf + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::CancelChangePin +// Cancel change Pin operation +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::CancelChangePin( const RMessage2& aMessage ) + { + if( IsActive() ) + { + Cancel(); + } + + aMessage.Complete( KErrNone ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::UnblockPinReqL +// Unblocks blocked PIN. +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::UnblockPinReqL( const RMessage2& aMessage ) + { + _WIMTRACE(_L("WIM | WIMServer | CWimAuthObjHandler::UnblockPinReqL | Begin")); + + __ASSERT_DEBUG( iResponseID == NULL, User::Panic( KWimAuthObjPanic, KErrGeneral ) ); + iResponseID = new ( ELeave ) CWimResponse( aMessage ); + iResponseID->iOpcode = EUnblockPinReq; + + __ASSERT_DEBUG( iTrId == NULL, User::Panic( KWimAuthObjPanic, KErrGeneral ) ); + iTrId = iWimUtilFuncs->TrIdLC( iResponseID, EWimMgmtReq ); + CleanupStack::Pop( iTrId ); + + TPckgBuf blockedPINPckg; + aMessage.ReadL( 1, blockedPINPckg ); + + iPinParams.iPINLabel = blockedPINPckg().iPINLabel; + iPinParams.iTokenLabel = blockedPINPckg().iTokenLabel; + iPinParams.iMinLength = blockedPINPckg().iMinLength; + iPinParams.iMaxLength = blockedPINPckg().iMaxLength; + + iUnblockingPinParams.iPINLabel = KUnblockingPinLabel; + iUnblockingPinParams.iTokenLabel = blockedPINPckg().iTokenLabel; + iUnblockingPinParams.iMinLength = blockedPINPckg().iMinLength; + iUnblockingPinParams.iMaxLength = KMaxPINLength; + + iRetry = EFalse; + + UnblockPINAskPIN(); + } + +void CWimAuthObjHandler::UnblockPINAskPIN() + { + iRequest = EUnblockPINAskPIN; + iStatus = KRequestPending; + SetActive(); + // Query PIN code from the user by using security dialog + iWimSecDlg->UnblockPIN( iRetry, + iPinParams, + iUnblockingPinParams, + iUnblockingPinValue, + iNewPinValue, + iStatus ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::ContinueUnblockPinReqL +// Continue Unblock PIN request. Calls WIMI. +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::ContinueUnblockPinReqL() + { + __ASSERT_DEBUG( iResponseID, User::Panic( KWimAuthObjPanic, KErrGeneral ) ); + WIMI_Ref_pt pPINref = const_cast< WIMI_Ref_pt>( (iResponseID->iMessage).Ptr0() ); + + if( iPinGRef == pPINref ) + { + iUnblockPING = ETrue; + } + else + { + iUnblockPING = EFalse; + } + + HBufC8* unblockPinBuf = HBufC8::NewLC( iUnblockingPinValue.Length() ); + HBufC8* newPinBuf = HBufC8::NewLC( iNewPinValue.Length() ); + + TPtr8 unblockingPin = unblockPinBuf->Des(); + unblockingPin.Copy( iUnblockingPinValue ); + + TPtr8 newPin = newPinBuf->Des(); + newPin.Copy( iNewPinValue ); + + iStatus = KRequestPending; + TRequestStatus* status =&iStatus; + iRequest = EUnblockPINCallBackResponse; + SetActive(); + + iResponseID->iStatus = WIMI_UnblockPINReq( iTrId, + pPINref, + ( TUint8 )unblockingPin.Length(), + ( TUint8* )unblockingPin.Ptr(), + ( TUint8 )newPin.Length(), + ( TUint8* )newPin.Ptr() ); + + if ( iResponseID->iStatus != WIMI_Ok ) + { + iRequest = EWIMIError; + User::RequestComplete( status, iResponseID->iStatus ); + } + CleanupStack::PopAndDestroy( 2, unblockPinBuf ); // newPinBuf, unblockPinBuf + + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::CancelUnblockPinL +// Cancel Unblock Pin operation +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::CancelUnblockPin( const RMessage2& aMessage ) + { + if( IsActive() ) + { + Cancel(); + } + + aMessage.Complete( KErrNone ); + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::RunL +// Continue authentication request after PIN is asked +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::RunL() + { + _WIMTRACE3(_L("WIM|WIMServer|CWimAuthObjHandler::RunL|iRequest=%d, status=%d"), iRequest, iStatus.Int()); + + switch ( iRequest ) + { + // Verify PIN request + case EVerifyPINAskPIN: + { + iRetry = ETrue; + + if( iStatus.Int() == KErrCancel ) + { + _WIMTRACE2(_L("WIM|WIMServer|CWimAuthObjHandler::RunL|User cancel %d "), iStatus.Int()); + if( iResponseID ) + { + iResponseID->iStatus = WIMI_ERR_UserCancelled; + iResponseID->CompleteMsgAndDelete(); + iResponseID = NULL; + } + if( iTrId ) + { + delete iTrId; + iTrId = NULL; + } + + } + else + { + if( iShowDialog ) + { + CWimCallBack::SetSignTextRequestStatus( &iStatus ); + } + ContinueVerifyPINReqL(); + } + break; + } + + case EVerifyPINCallBackResponse: + { + CWimCallBack::SetSignTextRequestStatus( NULL ); + if( iStatus.Int() == WIMI_ERR_BadPIN ) + { + VerifyPINAskPIN(); + } + else if ( iStatus.Int() == WIMI_ERR_PINBlocked ) + { + iRequest = EShowPINBlocked; + iWimSecDlg->ShowPINBlocked( iPinParams, iStatus ); + SetActive(); + } + else if ( iStatus.Int() == WIMI_ERR_CardIOError ) + { + iRequest = EShowCardIsRemoved; + iStatus = KRequestPending; + TRequestStatus* status = &iStatus; + SetActive(); + User::RequestComplete( status, KErrNone ); + } + else if ( iStatus.Int() == WIMI_ERR_UserCancelled ) + { + iStatus = KRequestPending; + iRequest = EIdle; + TRequestStatus* status = &iStatus; + SetActive(); + User::RequestComplete( status, KErrNone ); + } + else + { + iStatus = KRequestPending; + iRequest = EIdle; + TRequestStatus* status = &iStatus; + SetActive(); + User::RequestComplete( status, KErrNone ); + } + break; + } + + // Change PIN request + case EChangePINAskPIN: + { + iRetry = ETrue; + if( iStatus.Int() == KErrCancel ) + { + if( iResponseID ) + { + iResponseID->iStatus = WIMI_ERR_UserCancelled; + iResponseID->CompleteMsgAndDelete(); + iResponseID = NULL; + } + if( iTrId ) + { + delete iTrId; + iTrId = NULL; + } + } + else + { + CWimCallBack::SetSignTextRequestStatus( &iStatus ); + ContinueChangePINReqL(); + } + break; + } + + case EChangePINCallBackResponse: + { + CWimCallBack::SetSignTextRequestStatus( NULL ); + if( iStatus.Int() == WIMI_ERR_BadPIN ) + { + ChangePINAskPIN(); + } + else if ( iStatus.Int() == WIMI_ERR_PINBlocked ) + { + iRequest = EShowPINBlocked; + iWimSecDlg->ShowPINBlocked( iPinParams, iStatus ); + SetActive(); + } + else if ( iStatus.Int() == WIMI_ERR_CardIOError ) + { + iRequest = EShowCardIsRemoved; + iStatus = KRequestPending; + TRequestStatus* status = &iStatus; + SetActive(); + User::RequestComplete( status, KErrNone ); + } + else if ( iStatus.Int() == WIMI_ERR_UserCancelled ) + { + iStatus = KRequestPending; + iRequest = EIdle; + TRequestStatus* status = &iStatus; + SetActive(); + User::RequestComplete( status, KErrNone ); + } + else + { + iStatus = KRequestPending; + iRequest = EIdle; + TRequestStatus* status = &iStatus; + SetActive(); + User::RequestComplete( status, KErrNone ); + } + break; + } + + // Enable/Disable PIN query request + case EEnablePINAskPIN: // Flow trough + case EDisablePINAskPIN: + { + iRetry = ETrue; + if( iStatus.Int() == KErrCancel ) + { + if( iResponseID ) + { + iResponseID->iStatus = WIMI_ERR_UserCancelled; + iResponseID->CompleteMsgAndDelete(); + iResponseID = NULL; + } + if( iTrId ) + { + delete iTrId; + iTrId = NULL; + } + } + else + { + CWimCallBack::SetSignTextRequestStatus( &iStatus ); + ContinueEnablePINReqL(); + } + break; + } + + case EEnablePINCallBackResponse: + case EDisablePINCallBackResponse: + { + CWimCallBack::SetSignTextRequestStatus( NULL ); + if( iStatus.Int() == WIMI_ERR_BadPIN ) + { + EnablePINAskPIN(); + } + else if ( iStatus.Int() == WIMI_ERR_PINBlocked ) + { + iRequest = EShowPINBlocked; + iWimSecDlg->ShowPINBlocked( iPinParams, iStatus ); + SetActive(); + if( iEnablePinQuery ) + { + iDisablePINBlocked = ETrue; + } + } + else if ( iStatus.Int() == WIMI_ERR_CardIOError ) + { + iRequest = EShowCardIsRemoved; + iStatus = KRequestPending; + TRequestStatus* status = &iStatus; + SetActive(); + User::RequestComplete( status, KErrNone ); + } + else if ( iStatus.Int() == WIMI_ERR_UserCancelled ) + { + iStatus = KRequestPending; + iRequest = EIdle; + TRequestStatus* status = &iStatus; + SetActive(); + User::RequestComplete( status, KErrNone ); + } + else + { + iStatus = KRequestPending; + iRequest = EIdle; + TRequestStatus* status = &iStatus; + SetActive(); + User::RequestComplete( status, KErrNone ); + } + break; + } + + // Unblock PIN request + case EUnblockPINAskPIN: + { + iRetry = ETrue; + if( iStatus.Int() == KErrCancel ) + { + if( iResponseID ) + { + iResponseID->iStatus = WIMI_ERR_UserCancelled; + iResponseID->CompleteMsgAndDelete(); + iResponseID = NULL; + } + if( iTrId ) + { + delete iTrId; + iTrId = NULL; + } + } + else + { + CWimCallBack::SetSignTextRequestStatus( &iStatus ); + ContinueUnblockPinReqL(); + } + break; + } + case EUnblockPINCallBackResponse: + { + CWimCallBack::SetSignTextRequestStatus( NULL ); + if( iStatus.Int() == WIMI_ERR_BadPIN ) + { + UnblockPINAskPIN(); + } + else if ( iStatus.Int() == WIMI_ERR_PINBlocked ) + { + iRequest = EShowPINBlocked; + iWimSecDlg->ShowPINTotalBlocked( iPinParams, iStatus ); + SetActive(); + } + else if ( iStatus.Int() == WIMI_ERR_CardIOError ) + { + iRequest = EShowCardIsRemoved; + iStatus = KRequestPending; + TRequestStatus* status = &iStatus; + SetActive(); + User::RequestComplete( status, KErrNone ); + } + else if ( iStatus.Int() == WIMI_ERR_UserCancelled ) + { + iStatus = KRequestPending; + iRequest = EIdle; + TRequestStatus* status = &iStatus; + SetActive(); + User::RequestComplete( status, KErrNone ); + } + else + { + iStatus = KRequestPending; + iRequest = EIdle; + TRequestStatus* status = &iStatus; + SetActive(); + User::RequestComplete( status, KErrNone ); + + if( iDisablePINBlocked && iUnblockPING ) + { + iDisablePINBlocked = EFalse; + } + } + break; + } + + case EShowPINBlocked: + { + if( iResponseID ) + { + iResponseID->iStatus = WIMI_ERR_PINBlocked; + iResponseID->CompleteMsgAndDelete(); + iResponseID = NULL; + } + if( iTrId ) + { + delete iTrId; + iTrId = NULL; + } + + iStatus = KRequestPending; + iRequest = EIdle; + TRequestStatus* status = &iStatus; + SetActive(); + User::RequestComplete( status, KErrNone ); + break; + } + + case EShowCardIsRemoved: + { + if( iResponseID ) + { + iResponseID->iStatus = WIMI_ERR_CardIOError; + iResponseID->CompleteMsgAndDelete(); + iResponseID = NULL; + } + if( iTrId ) + { + delete iTrId; + iTrId = NULL; + } + + iStatus = KRequestPending; + iRequest = EIdle; + TRequestStatus* status = &iStatus; + SetActive(); + User::RequestComplete( status, KErrNone ); + break; + } + + case EWIMIError: + { + CWimCallBack::SetSignTextRequestStatus( NULL ); + if( iResponseID ) + { + iResponseID->iStatus = ( TUint )iStatus.Int(); + iResponseID->CompleteMsgAndDelete(); + iResponseID = NULL; + } + if( iTrId ) + { + delete iTrId; + iTrId = NULL; + } + break; + } + + // Idle request, do nothing + case EIdle: + _WIMTRACE(_L("WIM|WIMServer|CWimAuthObjHandler::RunL|Idle")); + break; + + // Illegal request + default: + _WIMTRACE(_L("WIM|WIMServer|CWimAuthObjHandler::RunL|Unknown request")); + __ASSERT_DEBUG( EFalse, User::Panic( KWimAuthObjPanic, KErrNotSupported ) ); + break; + } + + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::DoCancel +// Asynchronous request cancelled +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::DoCancel() + { + _WIMTRACE(_L("WIM|WIMServer|CWimAuthObjHandler::DoCancel")); + if( iRequest == EEnablePINCallBackResponse || + iRequest == EUnblockPINCallBackResponse || + iRequest == EDisablePINCallBackResponse || + iRequest == EChangePINCallBackResponse || + iRequest == EVerifyPINCallBackResponse ) + { + CWimCallBack::CancelPinOperation(); + } + if( iRequest == EEnablePINAskPIN || + iRequest == EUnblockPINAskPIN || + iRequest == EDisablePINAskPIN || + iRequest == EChangePINAskPIN || + iRequest == EVerifyPINAskPIN ) + { + iWimSecDlg->Cancel(); + } + } + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::RunError +// RunL leaved, handle error here. Note that message is completed by +// CWimResponse that is deleted by CleanupStack when some function leaves. +// ----------------------------------------------------------------------------- +// +TInt CWimAuthObjHandler::RunError( TInt aError ) + { + _WIMTRACE(_L("WIM|WIMServer|CWimAuthObjHandler::RunError")); + CWimCallBack::SetSignTextRequestStatus( NULL ); + if( iResponseID ) + { + iResponseID->iStatus = ( TUint16 ) aError; + iResponseID->CompleteMsgAndDelete(); + iResponseID = NULL; + } + + if( iTrId ) + { + delete iTrId; + iTrId = NULL; + } + + return KErrNone; + } + + +// ----------------------------------------------------------------------------- +// CWimAuthObjHandler::RetrieveAuthObjectsInfo +// ----------------------------------------------------------------------------- +// +void CWimAuthObjHandler::RetrieveAuthObjectsInfo( const RMessage2& aMessage ) + { + //Get pin number and reflist + _WIMTRACE(_L("WIM | WIMServer | RetrieveAuthObjectsInfo() | start ")); + WIMI_Ref_t* wimRef = WIMI_GetWIMRef( 0 ); + + TInt count = aMessage.Int2(); + + TInt authIdLength = count * sizeof( TInt ); + TInt authobjLength = count* sizeof( TJavaPINParams ); + + RArray authIdList( count ); + + TInt temp = 0; + for( TInt i = 0; i < count ; i++ ) + { + authIdList.Append(temp); + } + + RArray authobjsList( count ); + + TPtr8 authIdLstPtr( (TText8*)&authIdList[0], authIdLength, authIdLength ); + + TInt err = aMessage.Read(0, authIdLstPtr ); + if ( err!= KErrNone ) + { + aMessage.Complete( err ); + return; + } + + for ( TInt i = 0 ; i < authIdList.Count() ; i++ ) + { + TJavaPINParams authobject; + WIMI_STAT status = WIMI_Ok; + + TUint32 authId = authIdList[i]; + + WIMI_BinData_t ptLabel; + TUint16 flags; + TUint8 pinNumber = 0; + TUint8 minLength; + TUint8 maxLength; + TUint8 pinType; + TUint8 storedLength; + TUint8 PinReference; + TUint8 padChar; + + status = WIMI_GetAuthObjInfo( wimRef, + &authId, + &ptLabel, + &flags, + &pinNumber, + &minLength, + &maxLength, + &pinType, + &storedLength, + &PinReference, + &padChar ); + + if( status == WIMI_Ok ) + { + TBuf label; + label.Copy( TPtr8( ptLabel.pb_buf, + ptLabel.ui_buf_length, + ptLabel.ui_buf_length ) ); + + authobject.iPINLabel = label; + authobject.iFlags = flags; + authobject.iAuthId = authId; + authobject.iPinNumber =pinNumber; + authobject.iMinLength = minLength; + authobject.iMaxLength = maxLength; + authobject.iPinType = pinType; + authobject.iStoredLength = storedLength; + authobject.iPinReference = PinReference; + authobject.iPadChar = padChar; + + authobjsList.Append( authobject ); + } + else + { + _WIMTRACE2(_L("WIM | WIMServer | RetrieveAuthObjectsInfo() | WIMI_GetAuthObjInfo returns error %d"), status); + //information did not found or error occured so return empty authOjbect + TBuf label; + authobject.iPINLabel = label; + authobject.iFlags = KErrNotFound; + authobject.iPinNumber =KErrNotFound; + authobject.iMinLength = KErrNotFound; + authobject.iMaxLength = KErrNotFound; + authobject.iPinType = KErrNotFound; + authobject.iStoredLength = KErrNotFound; + authobject.iPinReference = KErrNotFound; + authobject.iPadChar = KErrNotFound; + authobjsList.Append( authobject ); + } + } + + TPtrC8 authObjsInfoLstPtr; + authObjsInfoLstPtr.Set( (TText8*)&authobjsList[0], authobjLength ); + + err = aMessage.Write( 1, authObjsInfoLstPtr ); + free_WIMI_Ref_t( wimRef ); + + aMessage.Complete( err ); + } + +// End of File