diff -r 000000000000 -r 63b37f68c1ce adaptationlayer/tsy/nokiatsy_dll/src/cmmsecuritymesshandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/adaptationlayer/tsy/nokiatsy_dll/src/cmmsecuritymesshandler.cpp Fri Nov 06 17:28:23 2009 +0000 @@ -0,0 +1,2493 @@ +/* +* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "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: +* +*/ + +// INCLUDE FILES +#include "cmmsecuritymesshandler.h" +#include "cmmphonetsender.h" +#include "cmmstaticutility.h" +#include "cmmmessagerouter.h" +#include "cmmnetmesshandler.h" +#include "cmmcallmesshandler.h" +#include "tsylogger.h" // logging +#include "osttracedefinitions.h" +#ifdef OST_TRACE_COMPILER_IN_USE +#include "cmmsecuritymesshandlertraces.h" +#endif + +#include +#include +#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING +#include +#else /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */ +#include +#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */ +#include +#include +#include +#include + +// EXTERNAL DATA STRUCTURES + //None + +// EXTERNAL FUNCTION PROTOTYPES + //None + +// CONSTANTS +// hard-coded transaction id for ISA messages +const TUint8 KSecurityTransId = 7; + +// Maximum size of UICC_SB_PIN and UICC_SB_PUK +const TUint8 KMaxSizeUiccSbPin = 16; +const TUint8 KMaxSizeUiccSbPuk = 16; + +// Key reference for universal PIN +const TUint8 KUniversalPinKeyReference = 0x11; + +// constants for getting/setting FDN state +const TUint8 KUiccServiceFdn = 0x02; // service in EFust +const TUint8 KIccServiceFdn = 0x03; // service in EFsst +const TUint8 KIccServiceAdn = 0x02; // service in EFsst +const TUint8 KFdnStateMask = 0x01; +const TUint8 KServiceActivated = 0x01; +const TUint8 KServiceNotActivated = 0x00; +const TUint8 KFileStatusIndex = 0x0B; +const TUint8 KInvalidated = 0x00; +const TUint8 KNotInvalidated = 0x01; +const TUint8 KInvalidateFlagMask = 0x01; + +const TUint8 KSw1Position = 0x02; +const TUint8 KSw2Position = 0x01; + +const TUint16 KElemAdnIcc = 0x6F3A; + +// MACROS + //None + +// LOCAL CONSTANTS AND MACROS +const TUint8 KSecPadding = 0x00; // Filler byte for ISI messages + +//TICCType enumerates the SIM card types +enum TICCType + { + EICCTypeSim2GGsm = 0, + EICCTypeSim3G, + EICCTypeSimUnknown + }; + +// MODULE DATA STRUCTURES + //None + +// LOCAL FUNCTION PROTOTYPES + //None + + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::CMmSecurityMessHandler +// C++ default constructor +// ----------------------------------------------------------------------------- +// +CMmSecurityMessHandler::CMmSecurityMessHandler() + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::CMmSecurityMessHandler"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_CMMSECURITYMESSHANDLER, "CMmSecurityMessHandler::CMmSecurityMessHandler" ); + //none + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CMmSecurityMessHandler* CMmSecurityMessHandler::NewL( + CMmPhoNetSender* aPhoNetSender, //pointer to the phonet sender + CMmPhoNetReceiver* aPhoNetReceiver, //pointer to the phonet sender + CMmNetMessHandler* aNetMessHandler, //pointer to the net mess handler + CMmCallMessHandler* aCallMessHandler, //pointer to the call mess handler + CMmMessageRouter* aMessageRouter, + CMmUiccMessHandler* aUiccMessHandler ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::NewL"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_NEWL, "CMmSecurityMessHandler::NewL" ); + CMmSecurityMessHandler* const securityMessHandler = + new ( ELeave ) CMmSecurityMessHandler(); + + CleanupStack::PushL( securityMessHandler ); + securityMessHandler->iPhoNetSender = aPhoNetSender; + securityMessHandler->iNetMessHandler = aNetMessHandler; + securityMessHandler->iCallMessHandler = aCallMessHandler; + securityMessHandler->iMessageRouter = aMessageRouter; + securityMessHandler->iMmUiccMessHandler = aUiccMessHandler; + + securityMessHandler->ConstructL(); + + // UICC + aPhoNetReceiver->RegisterL( securityMessHandler, PN_UICC, UICC_IND ); + aPhoNetReceiver->RegisterL( securityMessHandler, PN_UICC, UICC_RESP ); + aPhoNetReceiver->RegisterL( securityMessHandler, PN_UICC, UICC_CARD_IND ); + aPhoNetReceiver->RegisterL( securityMessHandler, PN_UICC, UICC_PIN_IND ); + aPhoNetReceiver->RegisterL( securityMessHandler, PN_UICC, UICC_PIN_RESP ); + +#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING + //MTC + aPhoNetReceiver->RegisterL( + securityMessHandler, PN_MTC, MTC_STATE_INFO_IND ); + aPhoNetReceiver->RegisterL( + securityMessHandler, PN_MTC, MTC_RF_STATUS_QUERY_RESP ); + aPhoNetReceiver->RegisterL( + securityMessHandler, PN_MTC, MTC_STATE_QUERY_RESP ); +#else /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */ + // MCE + aPhoNetReceiver->RegisterL( + securityMessHandler, PN_MODEM_MCE, MCE_MODEM_STATE_IND ); + aPhoNetReceiver->RegisterL( + securityMessHandler, PN_MODEM_MCE, MCE_MODEM_STATE_QUERY_RESP ); + aPhoNetReceiver->RegisterL( + securityMessHandler, PN_MODEM_MCE, MCE_RF_STATE_QUERY_RESP ); +#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */ + + CleanupStack::Pop( securityMessHandler ); + return securityMessHandler; + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::ConstructL +// Symbian 2nd phase constructor. Initialises internal attributes. +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::ConstructL() + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::ConstructL"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_CONSTRUCTL, "CMmSecurityMessHandler::ConstructL" ); + +#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING + // Initialize the current MTC state to poweroff, and do the first state query + iBootState.iMtcCurrentState = MTC_POWER_OFF; + MtcStateQueryReq( KSecurityTransId ); +#else /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */ + // Initialize the current modem state to poweroff + iBootState.iMceCurrentState = MCE_POWER_OFF; + + // Query modem state and RF state + MceModemStateQueryReq(); + MceRfStateQueryReq(); +#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */ + + iPukCodeRequired = EFalse; + + iApplicationId = 0; + iPinId = 0; + // This flags indicates if PIN attempts left query in case + iPinAttemptsLeftQuery = EFalse; + // This flags indicates if lock state query in case + iLockStateQuery = EFalse; + iCodeType = RMobilePhone::ESecurityCodePin1; + + iFdnSetting = RMobilePhone::EFdnSetOff; + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::~CMmSecurityMessHandler +// Destructor +// ----------------------------------------------------------------------------- +// +CMmSecurityMessHandler::~CMmSecurityMessHandler() + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::~CMmSecurityMessHandler"); +OstTrace0( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_CMMSECURITYMESSHANDLER, "CMmSecurityMessHandler::~CMmSecurityMessHandler" ); + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::ExtFuncL +// Dispatches Etel requests to DOS level handlers +// ----------------------------------------------------------------------------- +// +TInt CMmSecurityMessHandler::ExtFuncL( + TInt aIpc, + const CMmDataPackage* aDataPackage ) + { +TFLOGSTRING2("TSY: CMmSecurityMessHandler::ExtFuncL, aIpc: %d", aIpc); +OstTrace1( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_EXTFUNCL, "CMmSecurityMessHandler::ExtFuncL;aIpc=%d", aIpc ); + + TInt ret( KErrNone ); + + TUint8 transId( KSecurityTransId ); + + switch ( aIpc ) + { + case EMobilePhoneGetLockInfo: + { + // Unpack data + RMobilePhone::TMobilePhoneLock* aLock( NULL ); + RMobilePhone::TMobilePhoneLockInfoV1* aLockInfo( NULL ); + aDataPackage->UnPackData( &aLock, &aLockInfo); + // Set flag to indicate that this is lock state query + iLockStateQuery = ETrue; + switch( *aLock ) + { + case RMobilePhone::ELockPhoneDevice: // Device lock + { + // Not yet supported in modemadaptation + ret = KErrNotSupported; + break; + } + case RMobilePhone::ELockPhoneToICC: // Lock to current (U)SIM + { + // Not yet supported in modemadaptation + ret = KErrNotSupported; + break; + } + case RMobilePhone::ELockICC: // PIN + case RMobilePhone::ELockPin2: // PIN2 + { + UiccPinReqStateQuery( *aLock ); + break; + } + case RMobilePhone::ELockUniversalPin: + { + // UPIN is supported only in 3G + if ( UICC_CARD_TYPE_UICC == + iMmUiccMessHandler->GetCardType() ) + { + UiccPinReqStateQuery( *aLock ); + } + else + { + ret = KErrNotSupported; + } + break; + } + default: + { + ret = KErrNotSupported; + break; + } + } // End of switch( *aLock ) + break; + } + case EMobilePhoneChangeSecurityCode: + { + //unpack data + RMobilePhone::TMobilePhoneSecurityCode* type( NULL ); + RMobilePhone::TMobilePhonePasswordChangeV1* change( NULL ); + aDataPackage->UnPackData( &type, &change ); + ret = SecCodeChangeReq( transId, type, change ); + break; + } + case EMobilePhoneAbortSecurityCode: + { + // Just complete the cancelling to client + // UICC server doesn't support cancelling process. + iMessageRouter->Complete( + EMobilePhoneAbortSecurityCode, + KErrNone ); + break; + } + case EMobilePhoneVerifySecurityCode: + { + //unpack data + RMobilePhone::TMobilePhoneSecurityCode* type( NULL ); + RMobilePhone::TCodeAndUnblockCode* codes( NULL ); + aDataPackage->UnPackData( &type, &codes ); + ret = VerifySecurityCode( type, codes ); + break; + } + case EMobilePhoneGetSecurityCodeInfo: + { + // Set flag to indicate that this is PIN attempts left query + iPinAttemptsLeftQuery = ETrue; + //unpack data + RMobilePhone::TMobilePhoneSecurityCode* type( NULL ); + aDataPackage->UnPackData( &type ); + // Save code type for completing + iCodeType = *type; + TUint8 cardType( iMmUiccMessHandler->GetCardType() ); + + // Initialize lock type to PIN1 + RMobilePhone::TMobilePhoneLock lock( RMobilePhone::ELockICC ); + if ( RMobilePhone::ESecurityCodePin2 == *type ) + { + if ( UICC_CARD_TYPE_UICC != cardType ) + { + ret = KErrNotSupported; + } + lock = RMobilePhone::ELockPin2; + } + else if ( RMobilePhone::ESecurityUniversalPin == *type ) + { + if ( UICC_CARD_TYPE_UICC != cardType ) + { + ret = KErrNotSupported; + } + lock = RMobilePhone::ELockUniversalPin; + } + if ( KErrNone == ret ) + { + ret = UiccPinReqStateQuery( lock ); + } + break; + } + case EMobilePhoneSetLockSetting: + { + //unpack data + TLockAndSetting* lockAndSetting( NULL ); + RMobilePhone::TMobilePassword* password( NULL ); + aDataPackage->UnPackData( &lockAndSetting, &password ); + + RMobilePhone::TMobilePhoneLock lock( *(lockAndSetting->iLock ) ); + RMobilePhone::TMobilePhoneLockSetting setting( + *(lockAndSetting->iSetting ) ); + + // PIN code disabling/enabling is don in UICC server + if ( lock == RMobilePhone::ELockICC || + lock == RMobilePhone::ELockPin2 || + lock == RMobilePhone::ELockUniversalPin ) + { + ret = UiccPinReqChangeState( lock, setting, *password ); + } + else + { + // Not yet supported in modemadaptation + ret = KErrNotSupported; + } + break; + } + case EMmTsySecurityGetSimActivePinStateIPC: + { + GetActivePin(); + break; + } + case EMmTsyBootNotifySimStatusReadyIPC: + { + UiccReq(); + break; + } + case EMmTsySimGetICCType: + { + GetIccType(); +#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING + //NOTE: + // It is possible that the query below is not needed anymore, because always + // in CMmSecurityMessHandler::ConstructL(), the MtcStateQueryReq() is called, which + // eventually in its response calls also MtcRfStatusQueryReq() + ret = MtcRfStatusQueryReq( transId ); +#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */ + break; + } + case EMobilePhoneSetFdnSetting: + { + TUint8 cardType( iMmUiccMessHandler->GetCardType() ); + RMobilePhone::TMobilePhoneFdnSetting* fdnSetting( NULL ); + aDataPackage->UnPackData( &fdnSetting ); + iFdnSetting = *fdnSetting; + + if( UICC_CARD_TYPE_UICC == cardType ) + { + ret = ReadEfEst( ETrIdSetFdnStateReadEst ); + } + else if( UICC_CARD_TYPE_ICC == cardType ) + { + ret = ReadEfAdnFileInfo( ETrIdSetFdnStateReadFileInfo ); + } + else + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::ExtFuncL: unknown card type, FDN state not set"); +OstTrace0( TRACE_NORMAL, DUP3_CMMSECURITYMESSHANDLER_EXTFUNCL, "CMmSecurityMessHandler::ExtFuncL: unknown card type, FDN state not set" ); + ret = KErrGeneral; + } + break; + } + case EMobilePhoneGetFdnStatus: + { + TUint8 cardType( iMmUiccMessHandler->GetCardType() ); + if( UICC_CARD_TYPE_UICC == cardType ) + { + // read EFest + ret = ReadEfEst( ETrIdGetFdnStateReadEst ); + } + else if( UICC_CARD_TYPE_ICC == cardType ) + { + // read file info for EFadn + ret = ReadEfAdnFileInfo( ETrIdGetFdnStateReadFileInfo ); + } + else + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::ExtFuncL: unknown card type, FDN state cannot be solved"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_EXTFUNCL, "CMmSecurityMessHandler::ExtFuncL: unknown card type, FDN state cannot be solved" ); + ret = KErrGeneral; + } + break; + } + case EMobilePhoneGetCurrentActiveUSimApplication: + { + GetActiveUsimApplication(); + break; + } +#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING + case EMmTsyBootGetRFStatusIPC: + { + //This should not be in any use at the moment +TFLOGSTRING("TSY: CMmSecurityMessHandler::ExtFuncL - EMmTsyBootGetRFStatusIPC (NOT IN USE!!!)"); +OstTrace0( TRACE_NORMAL, DUP5_CMMSECURITYMESSHANDLER_EXTFUNCL, "CMmSecurityMessHandler::ExtFuncL, EMmTsyBootGetRFStatusIPC (NOT IN USE!!!)" ); + ret = MtcRfStatusQueryReq( transId ); + break; + } +#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */ + default: + { +TFLOGSTRING2("TSY: CMmSecurityMessHandler::ExtFuncL - Unknown IPC: %d", aIpc); +OstTrace1( TRACE_NORMAL, DUP6_CMMSECURITYMESSHANDLER_EXTFUNCL, "CMmSecurityMessHandler::ExtFuncL;Unknown aIpc=%d", aIpc ); + ret = KErrNotSupported; + break; + } + } + + return ret; + } + + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::ReceiveMessageL +// Called when an ISI message has been received. +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::ReceiveMessageL( + const TIsiReceiveC &aIsiMessage ) // received ISI message + { + TInt resource (aIsiMessage.Get8bit(ISI_HEADER_OFFSET_RESOURCEID)); + TInt messageId(aIsiMessage.Get8bit(ISI_HEADER_OFFSET_MESSAGEID)); + +TFLOGSTRING3("TSY: CMmSecurityMessHandler::ReceiveMessageL - resource: %d, msgId: %d", resource, messageId); +OstTraceExt2( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_RECEIVEMESSAGEL, "CMmSecurityMessHandler::ReceiveMessageL;resource=%d;messageId=%d", resource, messageId ); + + switch ( resource ) + { +#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING + case PN_MTC: + { + switch( messageId ) + { + case MTC_STATE_INFO_IND: + { + MtcStateInfoIndL( aIsiMessage ); + break; + } + case MTC_STATE_QUERY_RESP: + { + MtcStateQueryRespL( aIsiMessage ); + break; + } + case MTC_RF_STATUS_QUERY_RESP: + { + MtcRfStatusQueryResp( aIsiMessage ); + break; + } + default: + { +TFLOGSTRING2("TSY: CMmSecurityMessHandler::ReceiveMessageL - PN_MTC - unknown msgId: %d", messageId); +//OstTrace1( TRACE_NORMAL, DUP3_CMMSECURITYMESSHANDLER_RECEIVEMESSAGEL, "CMmSecurityMessHandler::ReceiveMessageL;PN_MTC - unknown messageId=%d", messageId ); + break; + } + } // end switch ( messageId ) + break; // end case PN_MTC + } +#else /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */ + case PN_MODEM_MCE: + { + switch( messageId ) + { + case MCE_MODEM_STATE_IND: + { + MceModemStateInd( aIsiMessage ); + break; + } + case MCE_MODEM_STATE_QUERY_RESP: + { + MceModemStateQueryResp( aIsiMessage ); + break; + } + case MCE_RF_STATE_QUERY_RESP: + { + MceRfStateQueryResp( aIsiMessage ); + break; + } + default: + { +TFLOGSTRING2("TSY: CMmSecurityMessHandler::ReceiveMessageL - PN_MTC - unknown msgId: %d", messageId); +OstTrace1( TRACE_NORMAL, DUP3_CMMSECURITYMESSHANDLER_RECEIVEMESSAGEL, "CMmSecurityMessHandler::ReceiveMessageL;PN_MTC - unknown messageId=%d", messageId ); + break; + } + } // end switch ( messageId ) + break; // end case PN_MODEM_MCE + } +#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */ + case PN_UICC: + { + switch( messageId ) + { + case UICC_RESP: + { + UiccResp( aIsiMessage ); + break; + } + case UICC_IND: + { + UiccInd( aIsiMessage ); + break; + } + case UICC_CARD_IND: + { + UiccCardInd( aIsiMessage ); + break; + } + case UICC_PIN_IND: + { + UiccPinInd( aIsiMessage ); + break; + } + case UICC_PIN_RESP: + { + UiccPinResp( aIsiMessage ); + break; + } + default: + { + break; + } + } + break; + } + default: + { +TFLOGSTRING2("TSY: CMmSecurityMessHandler::ReceiveMessageL - unknown resource: %d", resource); +OstTrace1( TRACE_NORMAL, DUP5_CMMSECURITYMESSHANDLER_RECEIVEMESSAGEL, "CMmSecurityMessHandler::ReceiveMessageL;resource=%d", resource ); + break; // server not known + } + } // end of switch + } + + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::VerifySecurityCode +// ----------------------------------------------------------------------------- +// +TInt CMmSecurityMessHandler::VerifySecurityCode( + RMobilePhone::TMobilePhoneSecurityCode* aType, + RMobilePhone::TCodeAndUnblockCode* aCodes ) + { + TInt ret( KErrNotReady ); + RMobilePhone::TMobilePassword code( aCodes->iCode ); + RMobilePhone::TMobilePassword unblockCode( aCodes->iUnblockCode ); + +TFLOGSTRING4("TSY: CMmSecurityMessHandler::VerifySecurityCode - code type: %d, code: %S, unblock code: %S",*aType, &code, &unblockCode); +OstTraceExt3( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_SECCODEVERIFYREQ, "CMmSecurityMessHandler::VerifySecurityCode;code=%S;unblockCode=%S;aType=%hhu", code, unblockCode, *aType ); + + switch( *aType ) + { + // PIN codes are verified in UICC server + case RMobilePhone::ESecurityCodePin1: + case RMobilePhone::ESecurityCodePin2: + case RMobilePhone::ESecurityUniversalPin: + { + ret = UiccPinReqVerify( UICC_PIN_VERIFY, code, unblockCode ); + break; + } + // PUK codes are verified in UICC server + case RMobilePhone::ESecurityCodePuk1: + case RMobilePhone::ESecurityCodePuk2: + case RMobilePhone::ESecurityUniversalPuk: + { + if ( *aType == RMobilePhone::ESecurityCodePuk1 ) + { + iPukCodeRequired = EFalse; + } + ret = UiccPinReqVerify( UICC_PIN_UNBLOCK, code, unblockCode ); + break; + } + default: + { + break; + } + } + return ret; + } + + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::SecCodeChangeReq +// +// ----------------------------------------------------------------------------- +// +TInt CMmSecurityMessHandler::SecCodeChangeReq( + TUint8 aTransactionId, + RMobilePhone::TMobilePhoneSecurityCode* aType, + RMobilePhone::TMobilePhonePasswordChangeV1* aChange ) // Old&new password + { +TFLOGSTRING3("TSY: CMmSecurityMessHandler::SecCodeChangeReq - traId: %d, type: %d", aTransactionId, *aType); +OstTraceExt2( TRACE_NORMAL, CMMSECURITYMESSHANDLER_SECCODECHANGEREQ, "CMmSecurityMessHandler::SecCodeChangeReq;aTransactionId=%hhu;aType=%d", aTransactionId, *aType ); +TFLOGSTRING2("TSY: CMmSecurityMessHandler::SecCodeChangeReq - old password: %S", &(aChange->iOldPassword)); +OstTraceExt1( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_SECCODECHANGEREQ, "CMmSecurityMessHandler::SecCodeChangeReq;aChange->iOldPassword=%S", aChange->iOldPassword ); +TFLOGSTRING2("TSY: CMmSecurityMessHandler::SecCodeChangeReq - new password: %S", &(aChange->iNewPassword)); +OstTraceExt1( TRACE_NORMAL, DUP2_CMMSECURITYMESSHANDLER_SECCODECHANGEREQ, "CMmSecurityMessHandler::SecCodeChangeReq;aChange->iNewPassword=%S", aChange->iNewPassword ); + + TInt ret( KErrNone ); + + if ( RMobilePhone::ESecurityCodePin1 == *aType || + RMobilePhone::ESecurityCodePin2 == *aType || + RMobilePhone::ESecurityUniversalPin == *aType ) + { + ret = UiccPinReqChange( + *aType, + aChange->iOldPassword, + aChange->iNewPassword ); + } + else + { + ret = KErrNotSupported; + } + return ret; + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::UiccReq +// Builds UICC_REQ ISI message and sends it via phonet +// ----------------------------------------------------------------------------- +// +TInt CMmSecurityMessHandler::UiccReq() const + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::UiccReq"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_UICCREQ, "CMmSecurityMessHandler::UiccReq" ); + + // Create UICC_REQ message for querying card status + TIsiSend isiMsg( iPhoNetSender->SendBufferDes() ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_UICC ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_TRANSID, KSecurityTransId ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_MESSAGEID, UICC_REQ ); + isiMsg.Set8bit( ISI_HEADER_SIZE + UICC_REQ_OFFSET_SERVICETYPE, + UICC_STATUS_GET ); + + return iPhoNetSender->Send( isiMsg.Complete() ); + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::UiccResp +// Breaks UICC_RESP ISI-message and completes "notify SIM ready" +// to CommonTSY. +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::UiccResp( const TIsiReceiveC& aIsiMessage ) + { + // Get service type + TUint8 serviceType( aIsiMessage.Get8bit( + ISI_HEADER_SIZE + UICC_RESP_OFFSET_SERVICETYPE ) ); + + // Get status + TUint8 status( aIsiMessage.Get8bit( + ISI_HEADER_SIZE + UICC_RESP_OFFSET_STATUS ) ); + +TFLOGSTRING3("TSY: CMmSecurityMessHandler::UiccResp, service type: %d, status: %d", serviceType, status ); +OstTraceExt2( TRACE_NORMAL, CMMSECURITYMESSHANDLER_UICCRESP, "CMmSecurityMessHandler::UiccResp;serviceType=%d;status=%d", serviceType, status ); + + if ( UICC_STATUS_GET == serviceType && UICC_STATUS_OK == status ) + { + if ( !iBootState.iSIMReady ) + { + // Set UICC as ready so that initialization can start + iBootState.iSIMReady = ETrue; + + // let's cache service table and CPHS information table + iMmUiccMessHandler->InitializeSimServiceTableCache(); + iMmUiccMessHandler->InitializeCphsInformationCache(); + } + } + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::UiccInd +// Breaks UICC_IND ISI-message and completes "notify SIM ready" +// to CommonTSY. +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::UiccInd( const TIsiReceiveC& aIsiMessage ) + { + // Get service type + TUint8 serviceType( aIsiMessage.Get8bit( + ISI_HEADER_SIZE + UICC_IND_OFFSET_SERVICETYPE ) ); + +TFLOGSTRING2("TSY: CMmCustomMessHandler::UiccInd, service type: %d", serviceType ); +OstTraceExt1( TRACE_NORMAL, CMMSECURITYMESSHANDLER_UICCIND, "CMmSecurityMessHandler::UiccInd;serviceType=%hhu", serviceType ); + + if ( UICC_START_UP_COMPLETE == serviceType ) + { + // Set UICC state to ready + iBootState.iSIMReady = ETrue; + + // let's cache service table and CPHS information table + iMmUiccMessHandler->InitializeSimServiceTableCache(); + iMmUiccMessHandler->InitializeCphsInformationCache(); + } + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::UiccCardInd +// Breaks UICC_CARD_IND ISI-message +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::UiccCardInd( const TIsiReceiveC& aIsiMessage ) + { + // Get service type + TUint8 serviceType( aIsiMessage.Get8bit( + ISI_HEADER_SIZE + UICC_CARD_IND_OFFSET_SERVICETYPE ) ); + +TFLOGSTRING2("TSY: CMmCustomMessHandler::UiccCardInd, service type: %d", serviceType ); +OstTraceExt1( TRACE_NORMAL, CMMSECURITYMESSHANDLER_UICCCARDIND, "CMmSecurityMessHandler::UiccCardInd;serviceType=%hhu", serviceType ); + + if ( UICC_CARD_REMOVED == serviceType ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::UiccCardInd - SIM Removed!"); +OstTrace0( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_UICCCARDIND, "CMmSecurityMessHandler::UiccCardInd - SIM Removed!" ); + // Change old boot state from TSY to not ready + iBootState.iSecReady = EFalse; + iBootState.iPinRequired = EFalse; + iBootState.iPinVerified = EFalse; + } + } +#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::MtcStateInfoIndL +// Breaks a SIM_IND MTC_STATE_INFO_IND-message ISI-message and completes +// EMmTsyBootNotifyModemStatusReadyIPC to client +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::MtcStateInfoIndL( + const TIsiReceiveC& aIsiMessage ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::MtcStateInfoIndL"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_MTCSTATEINFOINDL, "CMmSecurityMessHandler::MtcStateInfoIndL" ); + + TUint8 state( aIsiMessage.Get8bit( ISI_HEADER_SIZE + MTC_STATE_INFO_IND_OFFSET_STATE ) ); + TUint8 action( aIsiMessage.Get8bit( ISI_HEADER_SIZE + MTC_STATE_INFO_IND_OFFSET_ACTION ) ); + +TFLOGSTRING3("TSY: CMmSecurityMessHandler::MtcStateInfoIndL action: 0x%02x, state: 0x%02x", action, state); +OstTraceExt2( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_MTCSTATEINFOINDL, "CMmSecurityMessHandler::MtcStateInfoIndL;action=%hhx;state=%hhx", action, state ); + + //1. CMT_STATE_READY _AND_ CURRENT_STATE_NEW + if ( ( MTC_NOS_READY == action || MTC_READY == action ) && + iBootState.iMtcCurrentState != state ) + { + iBootState.iMtcCurrentState = state; + +TFLOGSTRING("NTSY: CMmSecurityMessHandler::MtcStateInfoIndL - CMT state transition occurred"); +OstTrace0( TRACE_NORMAL, DUP2_CMMSECURITYMESSHANDLER_MTCSTATEINFOINDL, "CMmSecurityMessHandler::MtcStateInfoIndL, CMT state transition occurred" ); + if ( MTC_NORMAL == state ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::MtcStateInfoIndL - MTC_NORMAL"); +OstTrace0( TRACE_NORMAL, DUP3_CMMSECURITYMESSHANDLER_MTCSTATEINFOINDL, "CMmSecurityMessHandler::MtcStateInfoIndL, MTC_NORMAL" ); + iMessageRouter->Complete( EMmTsyBootNotifyModemStatusReadyIPC, + KErrNone ); + } + //no else + + //to complete EMmTsyBootGetRFStatusIPC + MtcRfStatusQueryReq( KSecurityTransId ); + + if ( MTC_NORMAL == state || MTC_RF_INACTIVE == state ) + { + //Dataport opening must be delayed to here instead of + //CallMessHandler::ConstructL() to make sure CommonTSY is ready. + //Either dataport should not be opened before CSD server + //is started (not started in MTC_ALARM or MTC_CHARGING states). + iCallMessHandler->InitializeDataportL(); + } + //no else + } + //2. CMT_STATE_READY ( _AND_ CURRENT_STATE_OLD ) + else if( ( MTC_NOS_READY == action || MTC_READY == action ) ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::MtcStateInfoIndL - CMT state already active"); +OstTrace0( TRACE_NORMAL, DUP4_CMMSECURITYMESSHANDLER_MTCSTATEINFOINDL, "CMmSecurityMessHandler::MtcStateInfoIndL, CMT state already active" ); + } + //no else //3. CMT_STATE_NOT_READY - no action done in between state transition + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::MtcRfStatusQueryReq +// Creates MTC_RF_STATUS_QUERY_REQ-message ISI-message and sends it via +// phonet +// ----------------------------------------------------------------------------- +// +TInt CMmSecurityMessHandler::MtcRfStatusQueryReq( + TUint8 aTransactionId ) const + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::MtcRfStatusQueryReq"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_MTCRFSTATUSQUERYREQ, "CMmSecurityMessHandler::MtcRfStatusQueryReq" ); + + TBuf8<2> fillerData; + fillerData.AppendFill( KSecPadding, 2 ); // Padding bytes + + TInt ret = iPhoNetSender->Send( PN_MTC, + aTransactionId, + MTC_RF_STATUS_QUERY_REQ, fillerData ); + return ret; + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::MtcRfStatusQueryResp +// Breaks a MTC_RF_STATUS_QUERY_RESP-message ISI-message and completes +// to client +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::MtcRfStatusQueryResp( + const TIsiReceiveC& aIsiMessage ) const + { +TFLOGSTRING("NTSY: CMmSecurityMessHandler::MtcRfStatusQueryResp" ); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_MTCRFSTATUSQUERYRESP, "CMmSecurityMessHandler::MtcRfStatusQueryResp" ); + + TUint8 currentRfState = aIsiMessage.Get8bit( ISI_HEADER_SIZE + + MTC_RF_STATUS_QUERY_RESP_OFFSET_CURRENT ); + + //Defaults to RF ON + TRfStateInfo statusInfo ( ERfsStateInfoNormal ); + + //RF IS OFF ( this state is not updated when MTC_NORMAL ) + if( MTC_RF_OFF == currentRfState ) + { +TFLOGSTRING("NTSY: CMmSecurityMessHandler::MtcRfStatusQueryResp - RF OFF" ); +OstTrace0( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_MTCRFSTATUSQUERYRESP, "CMmSecurityMessHandler::MtcRfStatusQueryResp, RF OFF" ); + statusInfo = ERfsStateInfoInactive; + } +TFLOGSTRING2("TSY: OFFLINE MODE IS: %d", statusInfo ); +OstTrace1( TRACE_NORMAL, DUP4_CMMSECURITYMESSHANDLER_MTCRFSTATUSQUERYRESP, "CMmSecurityMessHandler::MtcRfStatusQueryResp;statusInfo=%d", statusInfo ); + + CMmDataPackage dataPackage; + dataPackage.PackData ( &statusInfo ); + + //inform the upper layer about the new status of the rf + iMessageRouter->Complete( EMmTsyBootGetRFStatusIPC, &dataPackage, KErrNone ); + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::MtcStateQueryReq +// Creates a MTC_STATE_QUERY_REQ-message ISI-message and sends it via +// phonet +// ----------------------------------------------------------------------------- +// +TInt CMmSecurityMessHandler::MtcStateQueryReq( + TUint8 aTransactionId + ) const + { + +TFLOGSTRING("TSY: CMmSecurityMessHandler::MtcStateQueryReq called" ); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_MTCSTATEQUERYREQ, "CMmSecurityMessHandler::MtcStateQueryReq" ); + + TBuf8<2> fillerData; + fillerData.AppendFill( KSecPadding, 2 ); // Padding bytes + + TInt ret = iPhoNetSender->Send( PN_MTC, aTransactionId, MTC_STATE_QUERY_REQ, fillerData ); + return ret; + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::MtcStateQueryRespL +// Breaks a SIM_IND MTC_STATE_QUERY_RESP-message ISI-message and completes +// EMmTsyBootNotifyModemStatusReadyIPC to client. If the CMT is not ready with +// its transition, renews MTC_STATE_QUERY_REQ +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::MtcStateQueryRespL( + const TIsiReceiveC& aIsiMessage ) + { +TFLOGSTRING("NTSY: CMmSecurityMessHandler::MtcStateQueryRespL"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_MTCSTATEQUERYRESPL, "CMmSecurityMessHandler::MtcStateQueryRespL" ); + + TUint8 currentState = aIsiMessage.Get8bit(ISI_HEADER_SIZE + MTC_STATE_QUERY_RESP_OFFSET_CURRENT); + TUint8 nextState = aIsiMessage.Get8bit(ISI_HEADER_SIZE + MTC_STATE_QUERY_RESP_OFFSET_TARGET); + +TFLOGSTRING3("NTSY: CMmSecurityMessHandler::MtcStateQueryRespL - (current: 0x%02x, next: 0x%02x)",currentState, nextState ); +OstTraceExt2( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_MTCSTATEQUERYRESPL, "CMmSecurityMessHandler::MtcStateQueryRespL;currentState=%hhx;nextState=%hhx", currentState, nextState ); + + //CMT side is ready when state transistion is completed (in all normal cases this should be the case) + + //1. CMT_STATE_READY _AND_ CURRENT_STATE_NEW + if( currentState == nextState && iBootState.iMtcCurrentState != currentState ) + { +TFLOGSTRING("NTSY: CMmSecurityMessHandler::MtcStateQueryRespL - CMT ready." ); +OstTrace0( TRACE_NORMAL, DUP2_CMMSECURITYMESSHANDLER_MTCSTATEQUERYRESPL, "CMmSecurityMessHandler::MtcStateQueryRespL, CMT ready" ); + iBootState.iMtcCurrentState = currentState; + + if( MTC_NORMAL == currentState ) + { +TFLOGSTRING("NTSY: CMmSecurityMessHandler::MtcStateQueryRespL - EMmTsyBootNotifyModemStatusReadyIPC"); +OstTrace0( TRACE_NORMAL, DUP3_CMMSECURITYMESSHANDLER_MTCSTATEQUERYRESPL, "CMmSecurityMessHandler::MtcStateQueryRespL, EMmTsyBootNotifyModemStatusReadyIPC" ); + iMessageRouter->Complete( EMmTsyBootNotifyModemStatusReadyIPC, KErrNone ); + } + //to complete EMmTsyBootGetRFStatusIPC + MtcRfStatusQueryReq( KSecurityTransId ); + } + //2. CMT_STATE_NOT_READY - renew state query, if transition is not yet ready + else if ( currentState != nextState ) + { +TFLOGSTRING("NTSY: CMmSecurityMessHandler::MtcStateQueryRespL - CMT state transition not ready."); +OstTrace0( TRACE_NORMAL, DUP4_CMMSECURITYMESSHANDLER_MTCSTATEQUERYRESPL, "CMmSecurityMessHandler::MtcStateQueryRespL, CMT state transition not ready" ); + MtcStateQueryReq( KSecurityTransId ); + } + //no else //3. CMT_STATE_READY _AND_ CURRENT_STATE_OLD - no action needed if state already active + + if ( nextState == currentState && + ( MTC_NORMAL == currentState || MTC_RF_INACTIVE == currentState ) ) + { + //Dataport opening must be delayed to here instead of + //CallMessHandler::ConstructL() to make sure CommonTSY is ready. + //Either dataport should not be opened before CSD server + //is started (not started in MTC_ALARM or MTC_CHARGING states). + iCallMessHandler->InitializeDataportL(); + } + //no else + } +#else /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */ +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::MceModemStateInd +// Breaks a MCE_MODEM_STATE_IND ISI-message and completes +// EMmTsyBootNotifyModemStatusReadyIPC to client +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::MceModemStateInd( const TIsiReceiveC& aIsiMessage ) + { + TUint8 state( aIsiMessage.Get8bit( + ISI_HEADER_SIZE + MCE_MODEM_STATE_IND_OFFSET_STATE ) ); + TUint8 action( aIsiMessage.Get8bit( + ISI_HEADER_SIZE + MCE_MODEM_STATE_IND_OFFSET_ACTION ) ); + +TFLOGSTRING3("TSY: CMmSecurityMessHandler::MceModemStateInd action: 0x%02x, state: 0x%02x", action, state); +OstTraceExt2( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_MCEMODEMSTATEIND, "CMmSecurityMessHandler::MceModemStateInd;state=%hhx;action=%hhx", state, action ); + + // Modem is ready and CMT status has been changed + if ( MCE_READY == action && iBootState.iMceCurrentState != state ) + { + iBootState.iMceCurrentState = state; + +TFLOGSTRING("NTSY: CMmSecurityMessHandler::MceModemStateInd - CMT state transition occurred - MCE_NORMAL"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_MCEMODEMSTATEIND, "CMmSecurityMessHandler::MceModemStateInd - CMT state transition occurred - MCE_NORMAL" ); + + iMessageRouter->Complete( + EMmTsyBootNotifyModemStatusReadyIPC, + KErrNone ); + + // Dataport opening must be delayed to here instead of + // CallMessHandler::ConstructL() to make sure CommonTSY is ready. + iCallMessHandler->InitializeDataportL(); + + // To complete EMmTsyBootGetRFStatusIPC + MceRfStateQueryReq(); + } + // Modem is ready but CMT status has not been changed + else if( MCE_READY == action && iBootState.iMceCurrentState == state ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::MceModemStateInd - CMT state mot changed"); +OstTrace0( TRACE_NORMAL, DUP2_CMMSECURITYMESSHANDLER_MCEMODEMSTATEIND, "CMmSecurityMessHandler::MceModemStateInd - CMT state not changed" ); + } + // No else, modem state not ready - no action needed + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::MceRfStateQueryReq +// Creates MCE_RF_STATE_QUERY_REQ ISI-message and sends it via phonet +// ----------------------------------------------------------------------------- +// +TInt CMmSecurityMessHandler::MceRfStateQueryReq() const + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::MceRfStateQueryReq"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_MCERFSTATEQUERYREQ, "CMmSecurityMessHandler::MceRfStateQueryReq" ); + + // Create MCE_RF_STATE_QUERY_REQ message for querying modem state + TIsiSend isiMsg( iPhoNetSender->SendBufferDes() ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_MODEM_MCE ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_TRANSID, KSecurityTransId ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_MESSAGEID, MCE_RF_STATE_QUERY_REQ ); + isiMsg.Set16bit( + ISI_HEADER_SIZE + MCE_RF_STATE_QUERY_REQ_OFFSET_FILLERBYTE1, + KSecPadding ); + + return iPhoNetSender->Send( isiMsg.Complete() ); + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::MceRfStateQueryResp +// Breaks a MCE_RF_STATE_QUERY_RESP ISI-message and completes to client +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::MceRfStateQueryResp( + const TIsiReceiveC& aIsiMessage ) const + { +TFLOGSTRING("NTSY: CMmSecurityMessHandler::MceRfStateQueryResp" ); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_MCERFSTATEQUERYRESP, "CMmSecurityMessHandler::MceRfStateQueryResp" ); + + TUint8 currentRfState( aIsiMessage.Get8bit( + ISI_HEADER_SIZE + MCE_RF_STATE_QUERY_RESP_OFFSET_CURRENT ) ); + + // Default is RF OFF + TRfStateInfo statusInfo( ERfsStateInfoInactive ); + + if( MCE_RF_ON == currentRfState ) + { + statusInfo = ERfsStateInfoNormal; + } + +TFLOGSTRING2("NTSY: CMmSecurityMessHandler::MceRfStateQueryResp: RF State is: %d", statusInfo ); +OstTrace1( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_MCERFSTATEQUERYRESP, "CMmSecurityMessHandler::MceRfStateQueryResp;statusInfo=%d", statusInfo ); + + CMmDataPackage dataPackage; + dataPackage.PackData ( &statusInfo ); + // Complete RF state + iMessageRouter->Complete( + EMmTsyBootGetRFStatusIPC, + &dataPackage, + KErrNone ); + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::MceModemStateQueryReq +// Creates a MCE_MODEM_STATE_QUERY_REQ ISI-message and sends it via +// phonet +// ----------------------------------------------------------------------------- +// +TInt CMmSecurityMessHandler::MceModemStateQueryReq() const + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::MceModemStateQueryReq" ); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_MCEMODEMSTATEQUERYREQ, "CMmSecurityMessHandler::MceModemStateQueryReq" ); + + // Create MCE_MODEM_STATE_QUERY_REQ message for querying modem state + TIsiSend isiMsg( iPhoNetSender->SendBufferDes() ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_MODEM_MCE ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_TRANSID, KSecurityTransId ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_MESSAGEID, MCE_MODEM_STATE_QUERY_REQ ); + isiMsg.Set16bit( + ISI_HEADER_SIZE + + MCE_MODEM_STATE_QUERY_REQ_OFFSET_FILLERBYTE1, KSecPadding ); + + return iPhoNetSender->Send( isiMsg.Complete() ); + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::MceStateQueryRespL +// Breaks a MCE_MODEM_STATE_QUERY_RESP message ISI-message and completes +// EMmTsyBootNotifyModemStatusReadyIPC to client. If the CMT is not ready with +// its transition, renews MTC_STATE_QUERY_REQ +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::MceModemStateQueryResp( + const TIsiReceiveC& aIsiMessage ) + { +TFLOGSTRING("NTSY: CMmSecurityMessHandler::MceModemStateQueryResp"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_MCEMODEMSTATEQUERYRESP, "CMmSecurityMessHandler::MceModemStateQueryResp" ); + + TUint8 currentState( aIsiMessage.Get8bit( + ISI_HEADER_SIZE + MCE_MODEM_STATE_QUERY_RESP_OFFSET_CURRENT ) ); + TUint8 nextState( aIsiMessage.Get8bit( + ISI_HEADER_SIZE + MCE_MODEM_STATE_QUERY_RESP_OFFSET_TARGET ) ); + +TFLOGSTRING3("NTSY: CMmSecurityMessHandler::MceModemStateQueryResp - (current: 0x%02x, next: 0x%02x)",currentState, nextState ); +OstTraceExt2( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_MCEMODEMSTATEQUERYRESP, "CMmSecurityMessHandler::MceModemStateQueryResp;currentState=%hhx;nextState=%hhx", currentState, nextState ); + + // CMT side is ready when state transistion is completed + // (in all normal cases this should be the case) + + // Modem is ready and CMT status has been changed + if( currentState == nextState && + iBootState.iMceCurrentState != currentState ) + { +TFLOGSTRING("NTSY: CMmSecurityMessHandler::MceModemStateQueryResp - CMT ready." ); +OstTrace0( TRACE_NORMAL, DUP2_CMMSECURITYMESSHANDLER_MCEMODEMSTATEQUERYRESP, "CMmSecurityMessHandler::MceModemStateQueryResp - CMT ready" ); + + iBootState.iMceCurrentState = currentState; + + if( MCE_NORMAL == currentState ) + { +TFLOGSTRING("NTSY: CMmSecurityMessHandler::MceModemStateQueryResp - EMmTsyBootNotifyModemStatusReadyIPC"); +OstTrace0( TRACE_NORMAL, DUP3_CMMSECURITYMESSHANDLER_MCEMODEMSTATEQUERYRESP, "CMmSecurityMessHandler::MceModemStateQueryResp- EMmTsyBootNotifyModemStatusReadyIPC" ); + iMessageRouter->Complete( + EMmTsyBootNotifyModemStatusReadyIPC, + KErrNone ); + + // Dataport opening must be delayed to here instead of + // CallMessHandler::ConstructL() to make sure CommonTSY is ready. + iCallMessHandler->InitializeDataportL(); + } + } + // Renew state query, if transition is not yet ready + else if ( currentState != nextState ) + { +TFLOGSTRING("NTSY: CMmSecurityMessHandler::MceModemStateQueryResp - CMT state transition not ready."); +OstTrace0( TRACE_NORMAL, DUP4_CMMSECURITYMESSHANDLER_MCEMODEMSTATEQUERYRESP, "CMmSecurityMessHandler::MceModemStateQueryResp -- CMT state transition not ready" ); + MceModemStateQueryReq(); + } + } +#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */ + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::UiccPinInd +// Breaks a UICC_PIN_IND ISI-message. +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::UiccPinInd( const TIsiReceiveC& aIsiMessage ) + { +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_UICCPININD, "CMmSecurityMessHandler::UiccPinInd" ); +TFLOGSTRING("TSY: CMmSecurityMessHandler::UiccPinInd"); + + // Event to be completed + RMobilePhone::TMobilePhoneSecurityEvent event( RMobilePhone::ENoICCFound ); + + // Save application ID, needed in UICC_PIN_VERIFY_REQ + iApplicationId = aIsiMessage.Get8bit( + ISI_HEADER_SIZE + UICC_PIN_IND_OFFSET_APPLID ); + + // Get service type + TUint8 serviceType( aIsiMessage.Get8bit( + ISI_HEADER_SIZE + UICC_PIN_IND_OFFSET_SERVICETYPE ) ); + // Get PIN ID + // TS 102.221 Table 9.3: PIN mapping into key references + // PIN1: '01','02','03','04','05','06','07','08' + // PIN2: '81','82','83','84', '85','86','87','88' + // UPIN: '11' + // PIN ID is needed when verifying PIN/PUK code + iPinId = aIsiMessage.Get8bit( + ISI_HEADER_SIZE + UICC_PIN_IND_OFFSET_PINID ); + + if ( UICC_PIN_VERIFY_NEEDED == serviceType ) + { + // PIN1 + if ( 0x01 <= iPinId && 0x08 >= iPinId ) + { + event = RMobilePhone::EPin1Required; + } + // PIN2 + else if ( 0x81 <= iPinId && 0x88 >= iPinId ) + { + event = RMobilePhone::EPin2Required; + } + // UPIN + else if ( 0x11 == iPinId ) + { + event = RMobilePhone::EUniversalPinRequired; + } + // No else + } + else if ( UICC_PIN_UNBLOCK_NEEDED == serviceType ) + { + // PIN1 + if ( 0x01 <= iPinId && 0x08 >= iPinId ) + { + event = RMobilePhone::EPuk1Required; + iPukCodeRequired = ETrue; + } + // PIN2 + else if ( 0x81 <= iPinId && 0x88 >= iPinId ) + { + event = RMobilePhone::EPuk2Required; + } + // UPIN + else if ( 0x11 == iPinId ) + { + event = RMobilePhone::EUniversalPukRequired; + } + // No else + } + // Complete notify security event + CMmDataPackage dataPackage; + dataPackage.PackData( &event ); + iMessageRouter->Complete( + EMobilePhoneNotifySecurityEvent, + &dataPackage, + KErrNone ); + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::UiccPinReqVerify +// Creates and sends UICC_PIN_REQ ISI message. +// ----------------------------------------------------------------------------- +// +TInt CMmSecurityMessHandler::UiccPinReqVerify( + const TUint8 aServiceType, + const RMobilePhone::TMobilePassword& aCode, + const RMobilePhone::TMobilePassword& aUnblockCode ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::UiccPinReqVerify"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_UICCPINREQ, "CMmSecurityMessHandler::UiccPinReqVerify" ); + + TUint8 numOfSubblocks( 1 ); // in case of PIN verify + TUint8 pinQualifier( UICC_PIN_OLD ); // in case of PIN verify + TUint messageOffset( ISI_HEADER_SIZE + SIZE_UICC_PIN_REQ ); + + if ( UICC_PIN_UNBLOCK == aServiceType ) + { + numOfSubblocks = 2; + pinQualifier = UICC_PIN_NEW; + } + + // Create UICC_REQ message for querying card status + TIsiSend isiMsg( iPhoNetSender->SendBufferDes() ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_UICC ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_TRANSID, KSecurityTransId ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_MESSAGEID, UICC_PIN_REQ ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_SERVICETYPE, + aServiceType ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_APPLID, + iApplicationId ); + // 3x filler + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_FILLERBYTE1, + KSecPadding ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_FILLERBYTE1 + 1, + KSecPadding ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_FILLERBYTE1 + 2, + KSecPadding ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_NSB, + numOfSubblocks ); + + // In case unblocking request, create UICC_SB_PUK + if ( UICC_PIN_UNBLOCK == aServiceType ) + { + TBuf8 uiccSbPukBuf( 0 ); + TIsiSubBlock uiccSbPuk( + uiccSbPukBuf, + UICC_SB_PUK, + EIsiSubBlockTypeId16Len16 ); + + uiccSbPukBuf.Append( iPinId ); // PIN ID + uiccSbPukBuf.Append( aUnblockCode.Length() ); // Length of PUK code + uiccSbPukBuf.Append( aUnblockCode ); // PUK code + + // Append subblock to ISI message + isiMsg.CopyData( + messageOffset, + uiccSbPuk.CompleteSubBlock() ); + + messageOffset += uiccSbPukBuf.Length(); + } + + // Create succlock UICC_SB_PIN + TBuf8 uiccSbPinBuf( 0 ); + TIsiSubBlock uiccSbPin( + uiccSbPinBuf, + UICC_SB_PIN, + EIsiSubBlockTypeId16Len16 ); + + // PIN ID + uiccSbPinBuf.Append( iPinId ); + uiccSbPinBuf.Append( pinQualifier ); // PIN qualifier + uiccSbPinBuf.Append( aCode.Length() ); // Length of PIN code + uiccSbPinBuf.Append( aCode ); // PIN code + + // Append subblock to ISI message + isiMsg.CopyData( + messageOffset, + uiccSbPin.CompleteSubBlock() ); + + return iPhoNetSender->Send( isiMsg.Complete() ); + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::UiccPinResp +// Breaks a UICC_PIN_IND ISI-message. +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::UiccPinResp( const TIsiReceiveC& aIsiMessage ) + { +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_UICCPINRESP, "CMmSecurityMessHandler::UiccPinResp" ); +TFLOGSTRING("TSY: CMmSecurityMessHandler::UiccPinResp"); + + // Get service type and status + TUint8 serviceType( aIsiMessage.Get8bit( + ISI_HEADER_SIZE + UICC_PIN_RESP_OFFSET_SERVICETYPE ) ); + TUint8 status( aIsiMessage.Get8bit( + ISI_HEADER_SIZE + UICC_PIN_RESP_OFFSET_STATUS ) ); + + switch( serviceType ) + { + case UICC_PIN_VERIFY: + case UICC_PIN_UNBLOCK: + { + HandleUiccPinVerifyResp( status, aIsiMessage ); + break; + } + case UICC_PIN_INFO: + { + HandleUiccPinInfoResp( status, aIsiMessage ); + break; + } + case UICC_PIN_CHANGE: + { + HandleUiccPinChangeResp( status, aIsiMessage ); + break; + } + case UICC_PIN_ENABLE: + case UICC_PIN_DISABLE: + case UICC_PIN_SUBSTITUTE: + { + HandleUiccPinStateChangeResp( status, aIsiMessage ); + break; + } + default: + { + break; + } + } + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::UiccPinReqStateQuery +// Creates and sends UICC_PIN_REQ ISI message. +// ----------------------------------------------------------------------------- +// +TInt CMmSecurityMessHandler::UiccPinReqStateQuery( + const RMobilePhone::TMobilePhoneLock aLock ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::UiccPinReqStateQuery"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_UICCPINREQSTATEQUERY, "CMmSecurityMessHandler::UiccPinReqStateQuery" ); + + TUint8 pinId( 0 ); + + if ( RMobilePhone::ELockICC == aLock ) + { + pinId = iMmUiccMessHandler->GetPin1KeyReference(); + } + else if ( RMobilePhone::ELockPin2 == aLock ) + { + pinId = iMmUiccMessHandler->GetPin2KeyReference(); + } + else + { + pinId = 0x11; // UPIN + } + // Create UICC_REQ message for querying card status + TIsiSend isiMsg( iPhoNetSender->SendBufferDes() ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_UICC ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_TRANSID, KSecurityTransId ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_MESSAGEID, UICC_PIN_REQ ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_SERVICETYPE, + UICC_PIN_INFO ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_APPLID, + iApplicationId ); + // 3x filler + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_FILLERBYTE1, + KSecPadding ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_FILLERBYTE1 + 1, + KSecPadding ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_FILLERBYTE1 + 2, + KSecPadding ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_NSB, + 1 ); // One subblock, UICC_SB_PIN_REF + + // Create succlock UICC_SB_PIN_REF + TBuf8 uiccSbPinRefBuf( 0 ); + TIsiSubBlock uiccSbPinRef( + uiccSbPinRefBuf, + UICC_SB_PIN_REF, + EIsiSubBlockTypeId16Len16 ); + + // PIN ID + uiccSbPinRefBuf.Append( pinId ); + uiccSbPinRefBuf.Append( KSecPadding ); // PIN qualifier + uiccSbPinRefBuf.Append( KSecPadding ); // Length of PIN code + uiccSbPinRefBuf.Append( KSecPadding ); // PIN code + + // Append subblock to ISI message + isiMsg.CopyData( + ISI_HEADER_SIZE + SIZE_UICC_PIN_REQ, + uiccSbPinRef.CompleteSubBlock() ); + + return iPhoNetSender->Send( isiMsg.Complete() ); + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::UiccPinReqChange +// Creates and sends UICC_PIN_REQ ISI message. +// ----------------------------------------------------------------------------- +// +TInt CMmSecurityMessHandler::UiccPinReqChange( + RMobilePhone::TMobilePhoneSecurityCode& aType, + const RMobilePhone::TMobilePassword& aOldCode, + const RMobilePhone::TMobilePassword& aNewCode ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::UiccPinReqChange"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_UICCPINREQCHANGE, "CMmSecurityMessHandler::UiccPinReqChange" ); + + TUint8 pinId( 0 ); + if ( RMobilePhone::ESecurityCodePin1 == aType ) + { + pinId = iMmUiccMessHandler->GetPin1KeyReference(); + } + else if ( RMobilePhone::ESecurityCodePin2 == aType ) + { + pinId = iMmUiccMessHandler->GetPin2KeyReference(); + } + else + { + pinId = KUniversalPinKeyReference; + } + + // Create UICC_REQ message for changing PIN code + TIsiSend isiMsg( iPhoNetSender->SendBufferDes() ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_UICC ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_TRANSID, KSecurityTransId ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_MESSAGEID, UICC_PIN_REQ ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_SERVICETYPE, + UICC_PIN_CHANGE ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_APPLID, + iApplicationId ); + // 3x filler + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_FILLERBYTE1, + KSecPadding ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_FILLERBYTE1 + 1, + KSecPadding ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_FILLERBYTE1 + 2, + KSecPadding ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_NSB, + 2 ); // Two UICC_SB_PIN subblocks + + // Create succlock UICC_SB_PIN for new PIN code + TBuf8 uiccSbPinBuf( 0 ); + TIsiSubBlock uiccSbPinOld( + uiccSbPinBuf, + UICC_SB_PIN, + EIsiSubBlockTypeId16Len16 ); + + // PIN ID + uiccSbPinBuf.Append( pinId ); + uiccSbPinBuf.Append( UICC_PIN_OLD ); // PIN qualifier + uiccSbPinBuf.Append( aOldCode.Length() ); // Length of PIN code + uiccSbPinBuf.Append( aOldCode ); // PIN code + + // Append subblock to ISI message + isiMsg.CopyData( + ISI_HEADER_SIZE + SIZE_UICC_PIN_REQ, + uiccSbPinOld.CompleteSubBlock() ); + + TUint sbLength( uiccSbPinBuf.Length() ); + + // Create succlock UICC_SB_PIN for old PIN code + uiccSbPinBuf.Zero(); + TIsiSubBlock uiccSbPinNew( + uiccSbPinBuf, + UICC_SB_PIN, + EIsiSubBlockTypeId16Len16 ); + + // PIN ID + uiccSbPinBuf.Append( pinId ); + uiccSbPinBuf.Append( UICC_PIN_NEW ); // PIN qualifier + uiccSbPinBuf.Append( aNewCode.Length() ); // Length of PIN code + uiccSbPinBuf.Append( aNewCode ); // PIN code + + // Append subblock to ISI message + isiMsg.CopyData( + ISI_HEADER_SIZE + SIZE_UICC_PIN_REQ + sbLength, + uiccSbPinNew.CompleteSubBlock() ); + + return iPhoNetSender->Send( isiMsg.Complete() ); + } + + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::UiccPinReqChangeState +// Creates and sends UICC_PIN_REQ ISI message. +// ----------------------------------------------------------------------------- +// +TInt CMmSecurityMessHandler::UiccPinReqChangeState( + const RMobilePhone::TMobilePhoneLock aLock, + const RMobilePhone::TMobilePhoneLockSetting& aSetting, + const RMobilePhone::TMobilePassword& aCode ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::UiccPinReqChangeState"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_UICCPINREQCHANGESTATE, "CMmSecurityMessHandler::UiccPinReqChangeState" ); + + TInt ret( KErrNone ); + TUint8 pinId( KUniversalPinKeyReference ); + TUint8 pinIdToBeSubstituted( KUniversalPinKeyReference ); + TUint8 pinIdSubstitution( KUniversalPinKeyReference ); + TUint8 setting( UICC_PIN_SUBSTITUTE ); + // Set PIN ID + if ( RMobilePhone::ELockICC == aLock ) + { + pinId = iMmUiccMessHandler->GetPin1KeyReference(); + pinIdSubstitution = pinId; // Replace UPIN by PIN + } + else if ( RMobilePhone::ELockPin2 == aLock ) + { + pinId = iMmUiccMessHandler->GetPin2KeyReference(); + } + else + { + pinIdToBeSubstituted = iMmUiccMessHandler->GetPin1KeyReference(); + } + + // Set new state to be changed + if ( RMobilePhone::ELockSetEnabled == aSetting ) + { + setting = UICC_PIN_ENABLE; + } + else if ( RMobilePhone::ELockSetDisabled == aSetting ) + { + setting = UICC_PIN_DISABLE; + } + else if ( RMobilePhone::ELockReplaced == aSetting ) + { + // PIN 1 ID is always used in case of substitute + pinId = iMmUiccMessHandler->GetPin1KeyReference(); + } + else + { + ret = KErrNotSupported; + } + + if ( KErrNone == ret ) + { + // Create UICC_REQ message for changing PIN code state + TIsiSend isiMsg( iPhoNetSender->SendBufferDes() ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_UICC ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_TRANSID, KSecurityTransId ); + isiMsg.Set8bit( ISI_HEADER_OFFSET_MESSAGEID, UICC_PIN_REQ ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_SERVICETYPE, + setting ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_APPLID, + iApplicationId ); + // 3x filler + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_FILLERBYTE1, + KSecPadding ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_FILLERBYTE1 + 1, + KSecPadding ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_FILLERBYTE1 + 2, + KSecPadding ); + isiMsg.Set8bit( + ISI_HEADER_SIZE + UICC_PIN_REQ_OFFSET_NSB, + 1 ); // UICC_SB_PIN + + // Create succlock UICC_SB_PIN for PIN code + TBuf8 uiccSbPinBuf( 0 ); + TIsiSubBlock uiccSbPin( + uiccSbPinBuf, + UICC_SB_PIN, + EIsiSubBlockTypeId16Len16 ); + uiccSbPinBuf.Append( pinId ); // PIN ID + uiccSbPinBuf.Append( UICC_PIN_OLD ); // PIN qualifier + uiccSbPinBuf.Append( aCode.Length() ); // Length of PIN code + uiccSbPinBuf.Append( aCode ); // PIN code + // Append subblock to ISI message + isiMsg.CopyData( + ISI_HEADER_SIZE + SIZE_UICC_PIN_REQ, + uiccSbPin.CompleteSubBlock() ); + + // If request was to replace PIN by UPIN or vice versa + // subblock UICC_SB_PIN_SUBST is also added + if ( UICC_PIN_SUBSTITUTE == setting ) + { + TBuf8 uiccSbPinSubstBuf( 0 ); + TIsiSubBlock uiccSbPinSubst( + uiccSbPinSubstBuf, + UICC_SB_PIN_SUBST, + EIsiSubBlockTypeId16Len16 ); + uiccSbPinSubstBuf.Append( pinIdToBeSubstituted ); + uiccSbPinSubstBuf.Append( pinIdSubstitution ); + uiccSbPinSubstBuf.Append( KSecPadding ); + uiccSbPinSubstBuf.Append( KSecPadding ); + // Append subblock to ISI message + isiMsg.CopyData( + ISI_HEADER_SIZE + SIZE_UICC_PIN_REQ + uiccSbPinBuf.Length(), + uiccSbPinSubst.CompleteSubBlock() ); + } + + ret = iPhoNetSender->Send( isiMsg.Complete() ); + } + return ret; + } + + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::HandleUiccPinVerifyResp +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::HandleUiccPinVerifyResp( + const TUint8 aStatus, + const TIsiReceiveC& aIsiMessage ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::HandleUiccPinVerifyResp"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_HANDLEUICCPINVERIFYRESP, "CMmSecurityMessHandler::HandleUiccPinVerifyResp" ); + + TInt ret( KErrNone ); + + if ( UICC_STATUS_OK != aStatus ) + { + ret = KErrGeneral; + // Subblock UICC_SB_STATUS_WORD contains cause information + TUint uiccSbStatusWordOffset( 0 ); + if ( KErrNone == aIsiMessage.FindSubBlockOffsetById( + ISI_HEADER_SIZE + SIZE_UICC_PIN_RESP, + UICC_SB_STATUS_WORD, + EIsiSubBlockTypeId16Len16, + uiccSbStatusWordOffset ) ) + { + TUint8 sw1( aIsiMessage.Get8bit( + uiccSbStatusWordOffset + + UICC_SB_STATUS_WORD_OFFSET_SW1 ) ); + TUint8 sw2( aIsiMessage.Get8bit( + uiccSbStatusWordOffset + + UICC_SB_STATUS_WORD_OFFSET_SW2 ) ); + + // Get status words and map to symbian error codes + TUint16 statusWord( sw1 << 8 | sw2 ); + + // Map status word to symbian error codes. See status word coding from + // TS 102.221 V7.11.0 Chapter 10.2.1 + + // 0x63CX: PIN was not correct and there are 'X' retries left + if ( 0x63 == sw1 && 0x0C == ( sw2 >> 4 ) ) + { + ret = CMmStaticUtility::EpocErrorCode( + KErrAccessDenied, + KErrGsm0707IncorrectPassword ); + } + else if ( 0x6983 == statusWord ) // Authentication/PIN method blocked + { + ret = CMmStaticUtility::EpocErrorCode( + KErrAccessDenied, + KErrGsmSSPasswordAttemptsViolation ); + } + // No else, KErrGeneral is returned + } + } // End of if ( UICC_STATUS_OK != status ) + + iMessageRouter->Complete( EMobilePhoneVerifySecurityCode, ret ); + } + + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::HandleUiccPinInfoResp +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::HandleUiccPinInfoResp( + const TUint8 aStatus, + const TIsiReceiveC& aIsiMessage ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::HandleUiccPinInfoResp"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_HANDLEUICCPININFORESP, "CMmSecurityMessHandler::HandleUiccPinInfoResp" ); + + TInt ret( KErrNone ); + CMmDataPackage dataPackage; + RMobilePhone::TMobilePhoneLockInfoV1 lockInfo; + lockInfo.iStatus = RMobilePhone::EStatusLockUnknown; + lockInfo.iSetting = RMobilePhone::ELockSetUnknown; + RMobilePhone::TMobilePhoneSecurityCodeInfoV5 securityInfo; + TUint8 pinStatus( UICC_STATUS_UNKNOWN ); + TUint8 pinAttemptsLeft( 0 ); + TUint8 pukAttemptsLeft( 0 ); + + // Subblock UICC_SB_PIN_INFO + TUint uiccSbPinInfoOffset( 0 ); + if ( UICC_STATUS_OK == aStatus && + KErrNone == aIsiMessage.FindSubBlockOffsetById( + ISI_HEADER_SIZE + SIZE_UICC_PIN_RESP, + UICC_SB_PIN_INFO, + EIsiSubBlockTypeId16Len16, + uiccSbPinInfoOffset ) ) + { + pinStatus = aIsiMessage.Get8bit( + uiccSbPinInfoOffset + + UICC_SB_PIN_INFO_OFFSET_PINSTATUS ); + pinAttemptsLeft = aIsiMessage.Get8bit( + uiccSbPinInfoOffset + + UICC_SB_PIN_INFO_OFFSET_PINATT ); + pukAttemptsLeft = aIsiMessage.Get8bit( + uiccSbPinInfoOffset + + UICC_SB_PIN_INFO_OFFSET_PUKATT ); + + // This is PIN attempts left query + if ( iPinAttemptsLeftQuery ) + { + // PIN codes + if ( RMobilePhone::ESecurityCodePin1 == iCodeType || + RMobilePhone::ESecurityCodePin2 == iCodeType || + RMobilePhone::ESecurityUniversalPin == iCodeType ) + { + securityInfo.iRemainingEntryAttempts = pinAttemptsLeft; + } + else // PUK codes + { + securityInfo.iRemainingEntryAttempts = pukAttemptsLeft; + } + } + if ( iLockStateQuery ) // This is lock state query + { + // Set PIN setting + if ( UICC_STATUS_PIN_ENABLED == pinStatus) + { + lockInfo.iSetting = RMobilePhone::ELockSetEnabled; + } + else if ( UICC_STATUS_PIN_DISABLED == pinStatus ) + { + lockInfo.iSetting = RMobilePhone::ELockSetDisabled; + } + // Set PIN status + if ( 0 != pinAttemptsLeft ) + { + lockInfo.iStatus = RMobilePhone::EStatusUnlocked; + } + else + { + lockInfo.iStatus = RMobilePhone::EStatusBlocked; + } + dataPackage.PackData( &lockInfo.iStatus, & lockInfo.iSetting ); + } + } + else // UICC status was not OK or subblock was not found + { + ret = KErrNotFound; + } + + // Complete PIN attempts left query + if ( iPinAttemptsLeftQuery ) + { + iPinAttemptsLeftQuery = EFalse; + dataPackage.PackData( &iCodeType, &securityInfo ); + iMessageRouter->Complete( + EMobilePhoneGetSecurityCodeInfo, + &dataPackage, + ret ); + iPinAttemptsLeftQuery = EFalse; + } + if ( iLockStateQuery ) // Complete PIN state query + { + dataPackage.PackData( &lockInfo.iStatus, & lockInfo.iSetting ); + // Complete PIN info + iMessageRouter->Complete( + EMobilePhoneGetLockInfo, + &dataPackage, + ret ); + iLockStateQuery = EFalse; + } + } + + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::HandleUiccPinChangeResp +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::HandleUiccPinChangeResp( + const TUint8 aStatus, + const TIsiReceiveC& aIsiMessage ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::HandleUiccPinChangeResp"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_HANDLEUICCPINCHANGERESP, "CMmSecurityMessHandler::HandleUiccPinChangeResp" ); + + TInt ret( KErrNone ); + if ( UICC_STATUS_OK != aStatus ) + { + ret = KErrNotSupported; + // Subblock UICC_SB_STATUS_WORD contains cause information + TUint uiccSbStatusWordOffset( 0 ); + if ( KErrNone == aIsiMessage.FindSubBlockOffsetById( + ISI_HEADER_SIZE + SIZE_UICC_PIN_RESP, + UICC_SB_STATUS_WORD, + EIsiSubBlockTypeId16Len16, + uiccSbStatusWordOffset ) ) + { + TUint8 sw1( aIsiMessage.Get8bit( + uiccSbStatusWordOffset + + UICC_SB_STATUS_WORD_OFFSET_SW1 ) ); + TUint8 sw2( aIsiMessage.Get8bit( + uiccSbStatusWordOffset + + UICC_SB_STATUS_WORD_OFFSET_SW2 ) ); + + // Get status words and map to symbian error codes + TUint16 statusWord( sw1 << 8 | sw2 ); + + // Map status word to symbian error codes. See status word coding + // from TS 102.221 V7.11.0 Chapter 10.2.1 + + // 0x63CX: PIN was not correct and there are 'X' retries left + if ( 0x63 == sw1 && 0x0C == ( sw2 >> 4 ) ) + { + ret = CMmStaticUtility::EpocErrorCode( + KErrAccessDenied, + KErrGsm0707IncorrectPassword ); + } + else if ( 0x6983 == statusWord ) // Authent./PIN method blocked + { + ret = CMmStaticUtility::EpocErrorCode( + KErrLocked, + KErrGsmSSPasswordAttemptsViolation ); + } + else if ( 0x6A81 == statusWord ) // Wrong parameters + { + ret = CMmStaticUtility::EpocErrorCode( + KErrArgument, + KErrGsmInvalidParameter ); + } + // No else, KErrNotSupported is returned + } + } + iMessageRouter->Complete ( EMobilePhoneChangeSecurityCode, ret ); + } + + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::HandleUiccPinStateChangeResp +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::HandleUiccPinStateChangeResp( + const TUint8 aStatus, + const TIsiReceiveC& aIsiMessage ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::HandleUiccPinStateChangeResp"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_HANDLEUICCPINSTATECHANGERESP, "CMmSecurityMessHandler::HandleUiccPinStateChangeResp" ); + + TInt ret( KErrNone ); + // Status and setting values are not used in CTSY, set to 'unknown' + RMobilePhone::TMobilePhoneLockStatus status( + RMobilePhone::EStatusLockUnknown ); + RMobilePhone::TMobilePhoneLockSetting setting( + RMobilePhone::ELockSetUnknown ); + + TUint8 serviceType( aIsiMessage.Get8bit( + ISI_HEADER_SIZE + UICC_PIN_RESP_OFFSET_SERVICETYPE ) ); + + if ( UICC_STATUS_OK != aStatus ) + { + ret = KErrNotSupported; + // Subblock UICC_SB_STATUS_WORD contains cause information + TUint uiccSbStatusWordOffset( 0 ); + if ( KErrNone == aIsiMessage.FindSubBlockOffsetById( + ISI_HEADER_SIZE + SIZE_UICC_PIN_RESP, + UICC_SB_STATUS_WORD, + EIsiSubBlockTypeId16Len16, + uiccSbStatusWordOffset ) ) + { + TUint8 sw1( aIsiMessage.Get8bit( + uiccSbStatusWordOffset + + UICC_SB_STATUS_WORD_OFFSET_SW1 ) ); + TUint8 sw2( aIsiMessage.Get8bit( + uiccSbStatusWordOffset + + UICC_SB_STATUS_WORD_OFFSET_SW2 ) ); + + // Get status words and map to symbian error codes + TUint16 statusWord( sw1 << 8 | sw2 ); + + // Map status word to symbian error codes. See status word coding from + // TS 102.221 V7.11.0 Chapter 10.2.1 + + // 0x63CX: PIN was not correct and there are 'X' retries left + if ( 0x63 == sw1 && 0x0C == ( sw2 >> 4 ) ) + { + ret = CMmStaticUtility::EpocErrorCode( + KErrAccessDenied, + KErrGsm0707IncorrectPassword ); + } + else if ( 0x6983 == statusWord ) // Authentication/PIN method blocked + { + ret = CMmStaticUtility::EpocErrorCode( + KErrAccessDenied, + KErrGsmSSPasswordAttemptsViolation ); + } + // No else, KErrNotSupported is returned + } + } + else if ( UICC_PIN_SUBSTITUTE == serviceType ) + { + // If response status is OK PIN/UPIN was substituted. + // Update active pin + iMmUiccMessHandler->ChangeActivePin(); + } + + CMmDataPackage dataPackage; + dataPackage.PackData( &status, &setting ); + iMessageRouter->Complete( + EMobilePhoneSetLockSetting, + &dataPackage, + ret ); + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::GetIccType +// Read ICC type and completes it +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::GetIccType() + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::GetIccType"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_GETICCTYPE, "CMmSecurityMessHandler::GetIccType" ); + + TInt ret( KErrNone ); + TICCType type ( EICCTypeSimUnknown ); + TUint8 applicationType( iMmUiccMessHandler->GetApplicationType() ); + + if ( UICC_APPL_TYPE_UICC_USIM == applicationType ) + { + type = EICCTypeSim3G; + } + else if ( UICC_APPL_TYPE_ICC_SIM == applicationType ) + { + type = EICCTypeSim2GGsm; + } + else + { + ret = KErrGeneral; + } + + // Complete the request + CMmDataPackage dataPackage; + dataPackage.PackData( &type ); + + iMessageRouter->Complete( EMmTsySimGetICCType, &dataPackage, ret ); + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::GetActivePin +// Reads active PIN and completes it +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::GetActivePin() + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::GetActivePin"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_GETACTIVEPIN, "CMmSecurityMessHandler::GetActivePin" ); + RMobilePhone::TMobilePhoneSecurityCode activePin( + iMmUiccMessHandler->GetActivePin()); + CMmDataPackage dataPackage; + dataPackage.PackData( &activePin ); + iMessageRouter->Complete( + EMmTsySecurityGetSimActivePinStateIPC, + &dataPackage, + KErrNone ); + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::GetActiveUsimApplication +// Read AID of active USIM application and complete +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::GetActiveUsimApplication() + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::GetActiveUsimApplication"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_GETACTIVEUSIMAPPLICATION, "CMmSecurityMessHandler::GetActiveUsimApplication" ); + + RMobilePhone::TAID aid( iMmUiccMessHandler->GetAid() ); + CMmDataPackage dataPackage; + dataPackage.PackData( &aid ); + iMessageRouter->Complete( + EMobilePhoneGetCurrentActiveUSimApplication, + &dataPackage, + KErrNone ); + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::GetPukCodeReq +// Returns iPukCodeRequired +// ----------------------------------------------------------------------------- +// +TInt CMmSecurityMessHandler::GetPukCodeReq() + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::GetPukCodeReq"); +OstTrace0( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_GETPUKCODEREQ, "CMmSecurityMessHandler::GetPukCodeReq" ); + return iPukCodeRequired; + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::SetFdnStateUicc +// sets FDN state in case of UICC card +// ----------------------------------------------------------------------------- +// +TInt CMmSecurityMessHandler::ReadEfEst( TUiccTrId aTraId ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::ReadEfEst"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_READEFEST, "CMmSecurityMessHandler::ReadEfEst" ); + + // Set parameters for UICC_APPL_CMD_REQ message + TUiccReadTransparent params; + params.messHandlerPtr = static_cast( this ); + params.trId = aTraId; + params.dataAmount = 0; + params.dataOffset = 0; + params.fileId = KElemEst; + params.fileIdSfi = 0x05; + params.serviceType = UICC_APPL_READ_TRANSPARENT; + + // File id path + params.filePath.Append( KMasterFileId >> 8 ); + params.filePath.Append( KMasterFileId ); + params.filePath.Append( iMmUiccMessHandler->GetApplicationFileId() ); + + return iMmUiccMessHandler->CreateUiccApplCmdReq( params ); + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::ProcessUiccMsg +// Handles data received from UICC server +// ----------------------------------------------------------------------------- +// +TInt CMmSecurityMessHandler::ProcessUiccMsg( + TInt aTraId, + TInt aStatus, + const TDesC8& aFileData ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::ProcessUiccMsg"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_PROCESSUICCMSG, "CMmSecurityMessHandler::ProcessUiccMsg" ); + + TInt ret( KErrNone ); + + switch( aTraId ) + { + case ETrIdSetFdnStateReadEst: + { + FdnSetReadEfEstResp( aStatus, aFileData ); + break; + } + case ETrIdGetFdnStateReadEst: + { + FdnGetReadEfEstResp( aStatus, aFileData ); + break; + } + case ETrIdSetFdnStateWriteEst: + { + WriteEfEstResp( aStatus ); + break; + } + case ETrIdSetFdnIcc: + { + FdnStateCommandResp( aStatus, aFileData ); + break; + } + case ETrIdSetFdnStateReadFileInfo: + { + FdnSetReadEfAdnFileInfoResp( aStatus, aFileData ); + break; + } + case ETrIdGetFdnStateReadFileInfo: + { + FdnGetReadEfAdnFileInfoResp( aStatus, aFileData ); + break; + } + default: + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::ProcessUiccMsg - unknown transaction ID" ); +OstTrace0( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_PROCESSUICCMSG, "CMmSecurityMessHandler::ProcessUiccMsg - unknown transaction ID" ); + break; + } + } + return ret; + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::FdnSetReadEfEstResp +// Handles response for EFest reading in case of setting FDN state +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::FdnSetReadEfEstResp( + TInt aStatus, + const TDesC8& aFileData ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::FdnSetReadEfEstResp"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_FDNSETREADEFESTRESP, "CMmSecurityMessHandler::FdnSetReadEfEstResp" ); + + if( UICC_STATUS_OK == aStatus ) + { + TUint8 fdnState( aFileData[0] & KFdnStateMask ); + TUint8 fdnStateToBeSet( 0 ); + + if( iMmUiccMessHandler->GetServiceStatus( KUiccServiceFdn ) ) + { + if( RMobilePhone::EFdnSetOn == iFdnSetting ) + { + fdnStateToBeSet = KServiceActivated; + } + else + { + fdnStateToBeSet = KServiceNotActivated; + } + + if( fdnState != fdnStateToBeSet ) + { + // update the EFest + TUiccWriteTransparent params; + params.messHandlerPtr = static_cast( this ); + params.trId = ETrIdSetFdnStateWriteEst; + params.dataOffset = 0; + params.dataAmount = 1; // only one byte is update + params.fileId = KElemEst; + params.fileIdSfi = 0x05; + params.serviceType = UICC_APPL_UPDATE_TRANSPARENT; + // File id path + params.filePath.Append( KMasterFileId >> 8 ); + params.filePath.Append( KMasterFileId ); + params.filePath.Append( iMmUiccMessHandler->GetApplicationFileId() ); + + // File data to be updated. + TUint8 data = aFileData[0] & 0xFE; + data += fdnStateToBeSet; + params.fileData.Append( data ); + + iMmUiccMessHandler->CreateUiccApplCmdReq( params ); + } + else + { + // state is already correct, let's just complete the request +TFLOGSTRING("TSY: CMmSecurityMessHandler::FdnSetReadEfEstResp: FDN state already correct, let's complete"); +OstTrace0( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_FDNSETREADEFESTRESP, "CMmSecurityMessHandler::FdnSetReadEfEstResp: FDN state already correct, let's complete" ); + iMessageRouter->Complete( EMobilePhoneSetFdnSetting, KErrNone ); + } + } + else + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::FdnSetReadEfEstResp: FDN state not supported in EFust"); +OstTrace0( TRACE_NORMAL, DUP2_CMMSECURITYMESSHANDLER_FDNSETREADEFESTRESP, "CMmSecurityMessHandler::FdnSetReadEfEstResp: FDN state not supported in EFust" ); + iMessageRouter->Complete( EMobilePhoneSetFdnSetting, KErrNotSupported ); + } + } + else + { + // error in reading EFest, let's complete the request +TFLOGSTRING2("TSY: CMmSecurityMessHandler::FdnSetReadEfEstResp: reading failed, 0x%x", aStatus); +OstTrace1( TRACE_NORMAL, DUP3_CMMSECURITYMESSHANDLER_FDNSETREADEFESTRESP, "CMmSecurityMessHandler::FdnSetReadEfEstResp: reading failed, 0x%x", aStatus ); + + // compete setting of FDN state + iMessageRouter->Complete( EMobilePhoneSetFdnSetting, KErrGeneral ); + } + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::FdnGetReadEfEstResp +// Handles response for EFest reading in case of getting FDN state +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::FdnGetReadEfEstResp( + TInt aStatus, + const TDesC8& aFileData ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::FdnGetReadEfEstResp"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_FDNGETREADEFESTRESP, "CMmSecurityMessHandler::FdnGetReadEfEstResp" ); + + RMobilePhone::TMobilePhoneFdnStatus fdnSetting( RMobilePhone::EFdnNotActive ); + + if( UICC_STATUS_OK == aStatus ) + { + TUint8 fdnState( aFileData[0] & KFdnStateMask ); + + // let's check that FDN is supported in EFust + if( iMmUiccMessHandler->GetServiceStatus( KUiccServiceFdn ) ) + { + if( KServiceActivated == fdnState ) + { + fdnSetting = RMobilePhone::EFdnActive; + } + // no else because of in this case FDN is not active + // and fdnSetting is already set to state not active. + } + else + { + // FDN not supported in EFust + fdnSetting = RMobilePhone::EFdnNotSupported; + } + CMmDataPackage dataPackage; + dataPackage.PackData ( &fdnSetting ); + // Complete the status to the client + iMessageRouter->Complete( EMobilePhoneGetFdnStatus, &dataPackage, KErrNone ); + } + else + { + // error in reading EFest, let's complete the request +TFLOGSTRING2("TSY: CMmSecurityMessHandler::FdnGetReadEfEstResp: reading failed, 0x%x", aStatus); +OstTrace1( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_FDNGETREADEFESTRESP, "CMmSecurityMessHandler::FdnGetReadEfEstResp: reading failed, 0x%x", aStatus ); + + fdnSetting = RMobilePhone::EFdnNotSupported; + CMmDataPackage dataPackage; + dataPackage.PackData ( &fdnSetting ); + iMessageRouter->Complete( EMobilePhoneGetFdnStatus, &dataPackage, KErrGeneral ); + } + } + + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::HandleWriteEfEstResp +// Handles response for EFest update +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::WriteEfEstResp( const TInt aStatus ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::WriteEfEstResp"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_WRITEEFESTRESP, "CMmSecurityMessHandler::WriteEfEstResp" ); + + if( UICC_STATUS_OK == aStatus ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::WriteEfEstResp: FDN state set succesfully"); +OstTrace0( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_WRITEEFESTRESP, "CMmSecurityMessHandler::WriteEfEstResp: FDN state set succesfully" ); + iMessageRouter->Complete( EMobilePhoneSetFdnSetting, KErrNone ); + } + else + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::WriteEfEstResp: FDN state set failed"); +OstTrace0( TRACE_NORMAL, DUP2_CMMSECURITYMESSHANDLER_WRITEEFESTRESP, "CMmSecurityMessHandler::WriteEfEstResp: FDN state set failed" ); + iMessageRouter->Complete( EMobilePhoneSetFdnSetting, KErrGeneral ); + } + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::SendFdnStateCommand +// sends INVALIDATE/REHABILITATE command for setting FDN state +// in case of ICC card +// ----------------------------------------------------------------------------- +// +TInt CMmSecurityMessHandler::SendFdnStateCommand() + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::SendFdnStateCommand"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_SENDFDNSTATECOMMAND, "CMmSecurityMessHandler::SendFdnStateCommand" ); + + TInt ret( 0 ); + TUiccSendApdu params; + params.messHandlerPtr = static_cast( this ); + params.serviceType = UICC_APPL_APDU_SEND; + params.fileId = UICC_EF_ID_NOT_PRESENT; + params.fileIdSfi = UICC_SFI_NOT_PRESENT; + params.filePath.Append( KMasterFileId >> 8 ); + params.filePath.Append( KMasterFileId ); + params.filePath.Append( iMmUiccMessHandler->GetApplicationFileId() ); + params.trId = ETrIdSetFdnIcc; + params.apdu.Append( 0xA0 ); // CLA + + if( RMobilePhone::EFdnSetOn == iFdnSetting ) + { + //INVALIDATE + params.apdu.Append( 0x04 ); // INS + params.apdu.Append( 0 ); // P1 + params.apdu.Append( 0 ); // P2 + params.apdu.Append( 2 ); // Lc + params.apdu.Append( KElemAdnIcc >> 8 ); // File id + params.apdu.Append( KElemAdnIcc ); // File id + ret = iMmUiccMessHandler->CreateUiccApplCmdReq( params ); + } + else if( RMobilePhone::EFdnSetOff == iFdnSetting ) + { + // REHABILITATE + params.apdu.Append( 0x44 ); // INS + params.apdu.Append( 0 ); // P1 + params.apdu.Append( 0 ); // P2 + params.apdu.Append( 2 ); // Lc + params.apdu.Append( KElemAdnIcc >> 8 ); // File id + params.apdu.Append( KElemAdnIcc ); // File id + ret = iMmUiccMessHandler->CreateUiccApplCmdReq( params ); + } + else + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::SendFdnStateCommand: unknown FDN state"); + OstTrace0( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_SENDFDNSTATECOMMAND, "CMmSecurityMessHandler::SendFdnStateCommand: unknown FDN state" ); + ret = KErrArgument; + } + + return ret; + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::FdnStateCommandResp +// handles response to the INVALIDATE/REHABILITATE command in case of ICC card +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::FdnStateCommandResp( + TInt aStatus, + const TDesC8& aFileData ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::SendFdnStateCommand"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_FDNSTATECOMMANDRESP, "CMmSecurityMessHandler::FdnStateCommandResp" ); + + if( UICC_STATUS_OK == aStatus ) + { + // get the status word + TUint8 sw1( aFileData[aFileData.Length() - KSw1Position] ); + TUint8 sw2( aFileData[aFileData.Length() - KSw2Position] ); + +TFLOGSTRING3("TSY: CMmSecurityMessHandler::SendFdnStateCommand: sw1: 0x%x, sw2: 0x%x", sw1, sw2); +OstTraceExt2( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_FDNSTATECOMMANDRESP, "CMmSecurityMessHandler::FdnStateCommandResp: sw1: 0x%x, sw2: 0x%x", sw1, sw2 ); + + TInt ret( KErrGeneral ); + + if( ( 0x90 == sw1 && 0x00 == sw2 ) || + ( 0x91 == sw1 ) ) + { + ret = KErrNone; + } + else if( 0x69 == sw1 ) + { + ret = KErrAccessDenied; + } + iMessageRouter->Complete( EMobilePhoneSetFdnSetting, ret ); + } + else + { +TFLOGSTRING2("TSY: CMmSecurityMessHandler::SendFdnStateCommand, Fdn state set failed: 0x%x", aStatus); +OstTrace1( TRACE_NORMAL, DUP2_CMMSECURITYMESSHANDLER_FDNSTATECOMMANDRESP, "CMmSecurityMessHandler::FdnStateCommandResp, Fdn state set failed: 0x%x", aStatus ); + iMessageRouter->Complete( EMobilePhoneSetFdnSetting, KErrGeneral ); + } + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::ReadEfAdnFileInfo +// Sends file info request for EFadn in case of ICC card +// ----------------------------------------------------------------------------- +// +TInt CMmSecurityMessHandler::ReadEfAdnFileInfo( TUiccTrId aTraId ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::ReadEfAdnFileInfo"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_READEFADNFILEINFO, "CMmSecurityMessHandler::ReadEfAdnFileInfo" ); + + TUiccApplFileInfo params; + params.messHandlerPtr = static_cast( this ); + params.serviceType = UICC_APPL_FILE_INFO; + params.fileId = KElemAdnIcc; + params.fileIdSfi = UICC_SFI_NOT_PRESENT; + params.filePath.Append( KMasterFileId >> 8 ); + params.filePath.Append( KMasterFileId ); + params.filePath.Append( iMmUiccMessHandler->GetApplicationFileId() ); + params.trId = aTraId; + + return iMmUiccMessHandler->CreateUiccApplCmdReq( params ); + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::FdnSetReadEfAdnFileInfoResp +// Handles response for file info reading for EFadn in case of ICC card +// when FDN state is set +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::FdnSetReadEfAdnFileInfoResp( + TInt aStatus, + const TDesC8& aFileData ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::FdnSetReadEfAdnFileInfoResp"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_FDNSETREADEFADNFILEINFORESP, "CMmSecurityMessHandler::FdnSetReadEfAdnFileInfoResp" ); + + if( UICC_STATUS_OK == aStatus ) + { + // let's check is ADN and FDN supported in EFest + if( iMmUiccMessHandler->GetServiceStatus( KIccServiceFdn ) && + iMmUiccMessHandler->GetServiceStatus( KIccServiceAdn ) ) + { + // let's check the current FDN status. + // If EFadn is invalidated, FDN is enabled, otherwise FDN + // is disabled + TUint8 invalidationFlag( aFileData[KFileStatusIndex] & KInvalidateFlagMask ); + + if( ( KInvalidated == invalidationFlag && + RMobilePhone::EFdnSetOn == iFdnSetting ) || + ( KNotInvalidated == invalidationFlag && + RMobilePhone::EFdnSetOff == iFdnSetting ) ) + { + // Current FDN state is already correct, so we can + // complete the request +TFLOGSTRING("TSY: CMmSecurityMessHandler::FdnSetReadEfAdnFileInfoResp: FDN state already correct, let's complete"); +OstTrace0( TRACE_NORMAL, DUP2_CMMSECURITYMESSHANDLER_FDNSETREADEFADNFILEINFORESP, "CMmSecurityMessHandler::FdnSetReadEfAdnFileInfoResp: FDN state already correct, let's complete" ); + iMessageRouter->Complete( EMobilePhoneSetFdnSetting, KErrNone ); + } + else + { + // Current FDN state is not correct, we need to change it + SendFdnStateCommand(); + } + } + else + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::FdnSetReadEfAdnFileInfoResp: FDN or ADN not supported in EFsst"); +OstTrace0( TRACE_NORMAL, DUP3_CMMSECURITYMESSHANDLER_FDNSETREADEFADNFILEINFORESP, "CMmSecurityMessHandler::FdnSetReadEfAdnFileInfoResp: FDN or ADN not supported in EFsst" ); + + iMessageRouter->Complete( EMobilePhoneSetFdnSetting, KErrNotSupported ); + } + } + else + { +TFLOGSTRING2("TSY: CMmSecurityMessHandler::FdnSetReadEfAdnFileInfoResp: reading failed: 0x%x", aStatus); +OstTrace1( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_FDNSETREADEFADNFILEINFORESP, "CMmSecurityMessHandler::FdnSetReadEfAdnFileInfoResp: reading failed: 0x%x", aStatus ); + + iMessageRouter->Complete( EMobilePhoneSetFdnSetting, KErrNotSupported ); + } + } + +// ----------------------------------------------------------------------------- +// CMmSecurityMessHandler::FdnGetReadEfAdnFileInfoResp +// Handles response for file info reading for EFadn in case of ICC card +// when FDN state is get +// ----------------------------------------------------------------------------- +// +void CMmSecurityMessHandler::FdnGetReadEfAdnFileInfoResp( + TInt aStatus, + const TDesC8& aFileData ) + { +TFLOGSTRING("TSY: CMmSecurityMessHandler::FdnGetReadEfAdnFileInfoResp"); +OstTrace0( TRACE_NORMAL, CMMSECURITYMESSHANDLER_FDNGETREADEFADNFILEINFORESP, "CMmSecurityMessHandler::FdnGetReadEfAdnFileInfoResp" ); + + RMobilePhone::TMobilePhoneFdnStatus fdnSetting( RMobilePhone::EFdnNotActive ); + + if( UICC_STATUS_OK == aStatus ) + { + if( iMmUiccMessHandler->GetServiceStatus( KIccServiceFdn ) && + iMmUiccMessHandler->GetServiceStatus( KIccServiceAdn ) ) + { + TUint8 invalidationFlag( aFileData[KFileStatusIndex] & KInvalidateFlagMask ); + + if( KInvalidated == invalidationFlag ) + { + fdnSetting = RMobilePhone::EFdnActive; + } + // no else because of FDN is not active and fdnSetting is + // already set to this value. + } + else + { + fdnSetting = RMobilePhone::EFdnNotSupported; + } + + CMmDataPackage dataPackage; + dataPackage.PackData ( &fdnSetting ); + // Complete the status to the client + iMessageRouter->Complete( EMobilePhoneGetFdnStatus, &dataPackage, KErrNone ); + } + else + { +TFLOGSTRING2("TSY: CMmSecurityMessHandler::FdnGetReadEfAdnFileInfoResp: reading failed: 0x%x", aStatus); +OstTrace1( TRACE_NORMAL, DUP1_CMMSECURITYMESSHANDLER_FDNGETREADEFADNFILEINFORESP, "CMmSecurityMessHandler::FdnGetReadEfAdnFileInfoResp: reading failed: 0x%x", aStatus ); + + fdnSetting = RMobilePhone::EFdnNotSupported; + CMmDataPackage dataPackage; + dataPackage.PackData ( &fdnSetting ); + iMessageRouter->Complete( EMobilePhoneGetFdnStatus, &dataPackage, KErrNotSupported ); + } + } + +// End of File