FCL/sf/incubator/modemadaptation: comparison adaptationlayer/tsy/nokiatsy

equal deleted inserted replaced

-:510c70acdbf6
+:8ccc39f9d787
 * Initial Contributors:
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description:
 *
 */
 // INCLUDE FILES
 #include <tisi.h>
 #include <call_modemisi.h>
 #include <csdisi.h>
 #include <gssisi.h>
-#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING
-// Removed for Bridge camp!
-#include <mtcisi.h>
-#endif
 #include <infoisi.h>
 #include <net_modemisi.h>
 #include <uiccisi.h>
 #include <ss_wmisi.h>
 // #include <permisi.h> To be done in CPS
 #include <ctsy/serviceapi/mmtsy_ipcdefs.h>
 #include <ctsy/serviceapi/gsmerror.h>
 #include <etelmmerr.h>
-#include "osttracedefinitions.h"
+#include "OstTraceDefinitions.h"
 #ifdef OST_TRACE_COMPILER_IN_USE
-#include "cmmcustommesshandlertraces.h"
+#include "cmmcustommesshandlerTraces.h"
 #endif
 // EXTERNAL DATA STRUCTURES
 //None
 aPhoNetReceiver->RegisterL(
 customMessHandler,
 PN_GSS,
 GSS_HSXPA_USER_SETTING_IND );
-#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING
-// MTC
-// Removed for Bridge camp
-aPhoNetReceiver->RegisterL(
-customMessHandler,
-PN_MTC,
-MTC_RAT_QUERY_RESP );
-#endif
 // PMM
 /* To be done in CPS
 aPhoNetReceiver->RegisterL( customMessHandler,
 PN_PERMANENT_DATA,
 PERM_PM_RECORD_READ_RESP );
 iECIDInfo.iCID = 0; // Cell identity
 iECIDInfo.iLAC = 0; // Location area code
 // Initialize Call Life Timer value.
 iCallLifeTimer = KCallLifeTimerNotSet;
 // initialize ISim application activation status
 iIsimApplActivated = EFalse;
 }
 // -----------------------------------------------------------------------------
 }
 }
 break;
 }
 #ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING
-// Removed for Bridge camp
-case PN_MTC:
-{
-switch( messageId )
-{
-case MTC_RAT_QUERY_RESP:
-{
-MtcRatQueryResp( aIsiMessage );
-break;
-}
-default:
-{
-TFLOGSTRING("TSY: CMmCustomMessHandler::ReceiveMessageL - switch resource - case PN_MTC, switch messageId - default");
-OstTrace0( TRACE_NORMAL, DUP5_CMMCUSTOMMESSHANDLER_RECEIVEMESSAGEL, "CMmCustomMessHandler::ReceiveMessageL- switch resource - case PN_MTC, switch messageId - default" );
-break;
-}
-}
-break;
-}
-#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */
-#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING
 case PN_INFO:
 #else /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */
 case PN_MODEM_INFO:
 #endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */
 {
 0 : &telNumber );
 // packed parameter: TBool result
 CMmDataPackage dataPackage;
 dataPackage.PackData( &result );
 TFLOGSTRING2( "TSY: TSY: CMmCustomMessHandler::CallEmergencyNbrCheckResp status: %d", status);
 TFLOGSTRING2( "TSY: TSY: CMmCustomMessHandler::CallEmergencyNbrCheckResp emergency number: %S", &telNumber);
 //we complete with KErrNone as there is always a value to return
 iMessageRouter->Complete( ECustomCheckEmergencyNumberIPC, &dataPackage,
 KErrNone );
 }
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::GssCsServiceResp
 // Breaks a GSS_CS_SERVICE_RESP ISI message.
-// completes ECustomSetSystemNetworkModeIPC, ECustomSetBandSelectionIPC or
+// completes ECustomSetSystemNetworkModeIPC,
+// ECustomGetCurrentSystemNetworkModesIPC, ECustomSetBandSelectionIPC or
 // ECustomGetBandSelectionIPC with KErrNone to SOS layer.
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::GssCsServiceResp (
 const TIsiReceiveC& aIsiMessage ) // Received isi message
 {
 TFLOGSTRING( "TSY: CMmCustomMessHandler::GssCsServiceResp" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_GSSCSSERVICERESP, "CMmCustomMessHandler::GssCsServiceResp" );
 TUint8 transactId ( aIsiMessage.Get8bit(
 ISI_HEADER_SIZE + GSS_CS_SERVICE_RESP_OFFSET_TRANSID ) );
-TUint8 operation ( aIsiMessage.Get8bit(
+if ( KCustomTransId == transactId )
-ISI_HEADER_SIZE + GSS_CS_SERVICE_RESP_OFFSET_OPERATION ) );
+{
+TUint8 operation ( aIsiMessage.Get8bit(
-// GSS_SELECTED_RAT_WRITE (0x0E)
+ISI_HEADER_SIZE + GSS_CS_SERVICE_RESP_OFFSET_OPERATION ) );
-if ( KCustomTransId == transactId && GSS_SELECTED_RAT_WRITE == operation )
-{
+// GSS_SELECTED_RAT_WRITE (0x0E)
-//completion ResetGssServer method (no packed parameters)
+if ( GSS_SELECTED_RAT_WRITE == operation )
-TFLOGSTRING("TSY: CMmCustomMessHandler::GssCsServiceResp - Complete ECustomSetSystemNetworkModeIPC");
+{
+TFLOGSTRING("TSY: CMmCustomMessHandler::GssCsServiceResp - Complete ECustomSetSystemNetworkModeIPC");
 OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_GSSCSSERVICERESP, "CMmCustomMessHandler::GssCsServiceResp - Complete ECustomSetSystemNetworkModeIPC" );
-iMessageRouter->Complete( ECustomSetSystemNetworkModeIPC, KErrNone );
+//completion ResetGssServer method (no packed parameters)
-}
+iMessageRouter->Complete( ECustomSetSystemNetworkModeIPC, KErrNone );
+}
-// not suppoted for S60 ver 3.2
+// GSS_SELECTED_RAT_READ (0x9C)
+else if ( GSS_SELECTED_RAT_READ == operation )
+{
+TFLOGSTRING("TSY: CMmCustomMessHandler::GssCsServiceResp - Complete ECustomGetCurrentSystemNetworkModesIPC");
+OstTrace0( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_GSSCSSERVICERESP, "CMmCustomMessHandler::GssCsServiceResp - Complete ECustomGetCurrentSystemNetworkModesIPC" );
+TInt err( KErrNone );
+TUint32 ratMode ( RMmCustomAPI::KCapsNetworkModeDual );
+TUint subblockOffset( 0 );
+if ( KErrNone == aIsiMessage.FindSubBlockOffsetById(
+ISI_HEADER_SIZE + SIZE_GSS_CS_SERVICE_RESP,
+GSS_RAT_INFO,
+EIsiSubBlockTypeId8Len8,
+subblockOffset ) )
+{
+TUint8 mode = aIsiMessage.Get8bit( subblockOffset +
+GSS_RAT_INFO_OFFSET_FUNCTION );
+switch ( mode )
+{
+case GSS_GSM_RAT:
+{
+ratMode = RMmCustomAPI::KCapsNetworkModeGsm;
+break;
+}
+case GSS_UMTS_RAT:
+{
+ratMode = RMmCustomAPI::KCapsNetworkModeUmts;
+break;
+}
+case GSS_DUAL_RAT:
+{
+ratMode = RMmCustomAPI::KCapsNetworkModeDual;
+break;
+}
+default:
+{
+TFLOGSTRING("TSY: CMmCustomMessHandler::GssCsServiceResp - Unrecognized RAT");
+OstTrace0( TRACE_NORMAL, DUP4_CMMCUSTOMMESSHANDLER_GSSCSSERVICERESP, "CMmCustomMessHandler::GssCsServiceResp - Unrecognized RAT" );
+err = KErrGeneral;
+break;
+}
+}
+}
+else
+{
+err = KErrGeneral;
+}
+CMmDataPackage dataPackage;
+dataPackage.PackData( &ratMode );
+//completion ResetNetServer method (packed parameters)
+iMessageRouter->Complete( ECustomGetCurrentSystemNetworkModesIPC,
+&dataPackage, err );
+}
+// not suppoted for S60 ver 3.2
 #if ( NCP_COMMON_S60_VERSION_SUPPORT != S60_VERSION_32 )
+// GSS_SELECTED_BANDS_WRITE (0x9D)
-// GSS_SELECTED_BANDS_WRITE (0x9D)
+else if ( GSS_SELECTED_BANDS_WRITE == operation )
-else if ( GSS_SELECTED_BANDS_WRITE == operation )
+{
-{
+TFLOGSTRING("TSY: CMmCustomMessHandler::GssCsServiceResp - Complete ECustomSetBandSelectionIPC");
-TFLOGSTRING("TSY: CMmCustomMessHandler::GssCsServiceResp - Complete ECustomSetBandSelectionIPC");
 OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_GSSCSSERVICERESP, "CMmCustomMessHandler::GssCsServiceResp - Complete ECustomSetBandSelectionIPC" );
 iMessageRouter->Complete( ECustomSetBandSelectionIPC, KErrNone );
 }
 // GSS_SELECTED_BANDS_READ (0x9E)
 else if ( GSS_SELECTED_BANDS_READ == operation )
 {
 CompleteGetBandSelection( aIsiMessage );
 }
 #endif // NCP_COMMON_S60_VERSION_SUPPORT
+}
 }
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::GssCsServiceFailResp
 // Breaks a GSS_CS_SERVICE_FAIL_RESP ISI message.
 return iPhoNetSender->Send( PN_GSS, aTransId, GSS_CS_SERVICE_REQ, messageData );
 }
 // -----------------------------------------------------------------------------
+// CMmCustomMessHandler::GssCsServiceReq
+// Constructs GSS_CS_SERVICE_REQ ISI message from input parameters and
+// sends it through phonet.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CMmCustomMessHandler::GssCsServiceReq
+(
+TUint8 aTransId   //transaction Id
+)
+{
+TFLOGSTRING( "TSY: CMmCustomMessHandler::GssCsServiceReq" );
+OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_GSSCSSERVICEREQ, "CMmCustomMessHandler::GssCsServiceReq" );
+TBuf8<KTwo> messageData;
+messageData.Append( GSS_SELECTED_RAT_READ );
+messageData.Append( 0 ); // number of subblocks
+// Sending message to phonet
+return iPhoNetSender->Send( PN_GSS, aTransId, GSS_CS_SERVICE_REQ, messageData );
+}
+// -----------------------------------------------------------------------------
 // CMmCustomMessHandler::ExtFuncL
 // Forwards requests coming from the Symbian OS layer to the
 // specific method.
 // -----------------------------------------------------------------------------
 //
 RMmCustomAPI::TNetworkModeCaps networkModeCaps;
 aDataPackage->UnPackData( networkModeCaps );
 ret = GssCsServiceReq( transId, networkModeCaps  );
 break;
 }
-#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING
 // Current network modes
-// Removed for Bridge camp!
 case ECustomGetCurrentSystemNetworkModesIPC:
 {
-ret = MtcRatQueryReq( transId );
+ret = GssCsServiceReq( transId );
 break;
 }
-#endif /*  INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */
 // Get GSM/WCDMA cell info
 case ECustomGetCellInfoIPC:
 {
 iECIDInfoRequested = ETrue;
 ret = NetNeighbourCellsReq( transId );
 // -----------------------------------------------------------------------------
 //
 TInt CMmCustomMessHandler::ProcessUiccMsg(
 TInt aTraId,
 TInt aStatus,
+TUint8 /*aDetails*/,
 const TDesC8& aFileData )
 {
 TFLOGSTRING3("TSY: CMmCustomMessHandler::ProcessUiccMsg, transaction ID: %d, status: %d", aTraId, aStatus );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_PROCESSUICCMSG, "CMmCustomMessHandler::ProcessUiccMsg" );
 break;
 }
 }
 return ret;
 }
-// -----------------------------------------------------------------------------
-// CMmCustomMessHandler::MtcRatQueryReq
-// Constructs MTC_RAT_QUERY_REQ ISI message from input parameters and
-// sends it through phonet.
-// (other items were commented in a header).
-// -----------------------------------------------------------------------------
-//
-#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING
-// Removed for Bridge camp
-TInt CMmCustomMessHandler::MtcRatQueryReq
-(
-TUint8 aTransId   //transaction Id
-)
-{
-TFLOGSTRING("TSY: CMmCustomMessHandler::MtcRatQueryReq.\n" );
-OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_MTCRATQUERYREQ, "CMmCustomMessHandler::MtcRatQueryReq" );
-TBuf8<KTwo> messageData;
-//append padding bytes
-messageData.Append( 0 );
-messageData.Append( 0 );
-// Sending message to phonet
-return iPhoNetSender->Send( PN_MTC, aTransId, MTC_RAT_QUERY_REQ, messageData );
-}
-// -----------------------------------------------------------------------------
-// CMmCustomMessHandler::MtcRatQueryResp
-// Breaks a MTC_RAT_QUERY_RESP ISI message.
-// This method get the ratMode and complete the request with error value
-// to SOS layer.
-// (other items were commented in a header).
-// -----------------------------------------------------------------------------
-//
-// Removed for Bridge camp
-void CMmCustomMessHandler::MtcRatQueryResp
-(
-const TIsiReceiveC& aIsiMessage // Received isi message
-)
-{
-TInt ret ( KErrNone );
-TUint32 ratMode ( RMmCustomAPI::KCapsNetworkModeDual );
-TUint8 mode = aIsiMessage.Get8bit( ISI_HEADER_SIZE + MTC_RAT_QUERY_RESP_OFFSET_RAT );
-TFLOGSTRING3("TSY: CMmCustomMessHandler::MtcRatQueryResp. RatMode:%d, mode:%d", ratMode, mode);
-OstTraceExt2( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_MTCRATQUERYRESP, "CMmCustomMessHandler::MtcRatQueryResp;mode=%hhu;ratMode=%u", mode, ratMode );
-switch ( mode )
-{
-case MTC_GSM_RAT:
-{
-ratMode = RMmCustomAPI::KCapsNetworkModeGsm;
-break;
-}
-case MTC_UMTS_RAT:
-{
-ratMode = RMmCustomAPI::KCapsNetworkModeUmts;
-break;
-}
-case MTC_NO_RAT_SELECTION: //this means dual mode
-{
-//value already initalized to dual
-break;
-}
-default: // MTC_UNKNOWN_RAT
-{
-TFLOGSTRING("TSY: CMmCustomMessHandler::MtcRatQueryResp, switch mode - default.\n" );
-OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_MTCRATQUERYRESP, "CMmCustomMessHandler::MtcRatQueryResp, switch mode - default" );
-ret = KErrGeneral;
-break;
-}
-}
-CMmDataPackage dataPackage;
-dataPackage.PackData( &ratMode );
-//completion ResetNetServer method (packed parameters)
-iMessageRouter->Complete( ECustomGetCurrentSystemNetworkModesIPC,
-&dataPackage, ret );
-}
-#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::UiccReadViagHomeZoneParametersReq
 // Read home zone parameters from UICC
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::UiccSendAuthenticateApdu
 // Constructs and sends AUTHENTICATE APDU to the UICC server
 // -----------------------------------------------------------------------------
 //
 TInt CMmCustomMessHandler::UiccSendAuthenticateApdu(
 const CMmDataPackage& aDataPackage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccSendAuthenticateApdu.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU, "CMmCustomMessHandler::UiccSendAuthenticateApdu" );
 apduSendNeeded = ETrue;
 }
 else if( UICC_CARD_TYPE_UICC == cardType )
 {
 // In 3G we need to send command AUTHENTICATE to the UICC
 UiccCreate3GSecurityContextApdu(
 params,
 eapAka.iRandomParameters,
 eapAka.iAUTN,
 ETrIdEEapAkaAuthenticate );
 apduSendNeeded = ETrue;
 }
 break;
 }
 case RMmCustomAPI::TSimAuthenticationBase::EGbaBootstrap:
 {
 serviceStatus = iMmUiccMessHandler->GetServiceStatus( KServiceGBA );
 if( UICC_CARD_TYPE_UICC == cardType &&
 EFalse != serviceStatus )
 {
 UiccCreateGBABootstrappingApdu( params, aDataPackage );
 apduSendNeeded = ETrue;
 }
 }
 case RMmCustomAPI::TSimAuthenticationBase::EGbaBootstrapUpdate:
 {
 serviceStatus = iMmUiccMessHandler->GetServiceStatus( KServiceGBA );
 if( UICC_CARD_TYPE_UICC == cardType &&
 EFalse != serviceStatus )
 {
 UiccGBABootstrapUpdate( aDataPackage );
 }
 else
 }
 case RMmCustomAPI::TSimAuthenticationBase::EGbaBootstrapNafDerivation:
 {
 serviceStatus = iMmUiccMessHandler->GetServiceStatus( KServiceGBA );
 if( UICC_CARD_TYPE_UICC == cardType &&
 EFalse != serviceStatus )
 {
 UiccCreateGBABootstrapNafDerivationApdu( params, aDataPackage );
 apduSendNeeded = ETrue;
 }
 }
 case RMmCustomAPI::TSimAuthenticationBase::EMgvMskUpdate:
 {
 serviceStatus = iMmUiccMessHandler->GetServiceStatus( KServiceMBMSsecurity );
 if( UICC_CARD_TYPE_UICC == cardType &&
 EFalse != serviceStatus )
 {
 UiccCreateMbmsMskUpdateApdu( params, aDataPackage );
 apduSendNeeded = ETrue;
 }
 }
 case RMmCustomAPI::TSimAuthenticationBase::EMgvMtkGeneration:
 {
 serviceStatus = iMmUiccMessHandler->GetServiceStatus( KServiceMBMSsecurity );
 if( UICC_CARD_TYPE_UICC == cardType &&
 EFalse != serviceStatus )
 {
 UiccCreateMbmsMtkGenerationApdu( params, aDataPackage );
 apduSendNeeded = ETrue;
 }
 }
 case RMmCustomAPI::TSimAuthenticationBase::EMgvMskDeletion:
 {
 serviceStatus = iMmUiccMessHandler->GetServiceStatus( KServiceMBMSsecurity );
 if( UICC_CARD_TYPE_UICC == cardType &&
 EFalse != serviceStatus )
 {
 UiccCreateMbmsMskDeletionApdu( params, aDataPackage );
 apduSendNeeded = ETrue;
 }
 }
 if( EFalse != apduSendNeeded )
 {
 // send the apdu to the UICC server
 ret = iMmUiccMessHandler->CreateUiccApplCmdReq( params );
 }
 else
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccSendAuthenticateApdu: APDU not sent\n" );
 OstTrace0( TRACE_NORMAL, DUP8_CMMCUSTOMMESSHANDLER_UICCSENDAUTHENTICATEAPDU, "CMmCustomMessHandler::UiccSendAuthenticateApduu: APDU not sent" );
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::UiccCreateRunGsmAlgorithmApdu
 // Constructs GSM context AUTHENTICATE APDU
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccCreateRunGsmAlgorithmApdu(
 TUiccSendApdu& aParams,
 const TDesC8& aRand,
 TUiccTrId aTraId )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCreateRunGsmAlgorithmApdu.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCREATERUNGSMALGORITHMAPDU, "CMmCustomMessHandler::UiccCreateRunGsmAlgorithmApdu" );
 }
 else if( KCmdNotAllowedSecurityStatusNotSatisfied == result )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccRunGsmAlgorithmApduResp: Security conditions not satisfied\n" );
 OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_UICCRUNGSMALGORITHMAPDURESP, "CMmCustomMessHandler::UiccRunGsmAlgorithmApduResp: Security conditions not satisfied" );
 ret = CMmStaticUtility::EpocErrorCode(
 KErrAccessDenied,
 KErrGsm0707SimPin1Required );
 }
 else
 {
 TFLOGSTRING2("TSY: CMmCustomMessHandler::UiccRunGsmAlgorithmApduResp. unknown result: 0x%X\n", result );
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::UiccCreateGsmSecurityContextApdu
 // Constructs GSM context AUTHENTICATE APDU
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccCreateGsmSecurityContextApdu(
 TUiccSendApdu& params,
 const CMmDataPackage& aDataPackage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCreateGsmSecurityContextApdu.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCREATEGSMSECURITYCONTEXTAPDU, "CMmCustomMessHandler::UiccCreateGsmSecurityContextApdu" );
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::UiccCreate3GSecurityContextApdu
 // Constructs 3G security context AUTHENTICATE APDU
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccCreate3GSecurityContextApdu(
 TUiccSendApdu& aParams,
 const TDesC8& aRand,
 const TDesC8& aAuth,
 TUiccTrId aTraId )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCreate3GSecurityContextApdu.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCREATE3GSECURITYCONTEXTAPDU, "CMmCustomMessHandler::UiccCreate3GSecurityContextApdu" );
 // len of data is sizeof RAND + sizeof AUTN + two length fields
 // (one for RAND len and one for AUTN len)
 TUint8 lc( aRand.Size() + aAuth.Size() + 2 );
 aParams.trId = aTraId;
 aParams.apdu.Append( KClaNoSm );             // CLA
 aParams.apdu.Append( KEvenInstructionCode ); // INS
 aParams.apdu.Append( 0 ); // P1 is set to 0 in case of even instruction
 aParams.apdu.Append( K3GAuthenticationContext ); // P2
 aParams.apdu.Append( lc );                       // Lc
 aParams.apdu.Append( aRand.Size() ); // len of RAND
 aParams.apdu.Append( aRand );        // RAND
 aParams.apdu.Append( aAuth.Size() );             // len of AUTN
 aParams.apdu.Append( aAuth );                    // AUTN
 aParams.apdu.Append( KMaximumLenOfDataExpected );       // Le
 // get the IK
 len = aFileData[index++];
 eapAka.iIK.Copy( aFileData.Mid( index, len ) );
 index += len;
 // Kc is not supported at the moment because of
 // RMmCustomAPI::TSimAuthenticationEapAka doesn't
 // have parameter for that
 }
 else
 {
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Uicc3GSecurityContextApduResp: APDU validation failed\n" );
 OstTrace0( TRACE_NORMAL, DUP1_CMMCUSTOMMESSHANDLER_UICC3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Uicc3GSecurityContextApduResp: APDU validation failed" );
 ret = KErrMMEtelAuthenticateFailed;
 }
 }
 else if( KAppAuthErrorIncorrectMac == result )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Uicc3GSecurityContextApduResp: incorrect MAC\n" );
 OstTrace0( TRACE_NORMAL, DUP2_CMMCUSTOMMESSHANDLER_UICC3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Uicc3GSecurityContextApduResp: incorrect MAC" );
 // no parameters in this case
 }
 else if( KCmdNotAllowedSecurityStatusNotSatisfied == result )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Uicc3GSecurityContextApduResp: Security conditions not satisfied\n" );
 OstTrace0( TRACE_NORMAL, DUP3_CMMCUSTOMMESSHANDLER_UICC3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Uicc3GSecurityContextApduResp: Security conditions not satisfied" );
 ret = CMmStaticUtility::EpocErrorCode(
 KErrAccessDenied,
 KErrGsm0707SimPin1Required );
 }
 else
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::Uicc3GSecurityContextApduResp: unknown result\n" );
 TFLOGSTRING2("TSY: CMmCustomMessHandler::Uicc3GSecurityContextApduResp: UICC status not ok: 0x%x\n", aStatus );
 OstTrace1( TRACE_NORMAL, DUP5_CMMCUSTOMMESSHANDLER_UICC3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Uicc3GSecurityContextApduResp: UICC status not ok: 0x%x", aStatus );
 ret = ETrIdEEapAkaAuthenticateIms == aTraId ? KErrGeneral : KErrMMEtelAuthenticateFailed;
 }
 if( KErrNone == ret ||
 KErrMMEtelSqnVerificationFailed == ret ||
 KErrMMEtelMacVerificationFailed == ret )
 {
 CMmDataPackage dataPackage;
 if( ETrIdEEapAkaAuthenticate == aTraId )
 }
 iMessageRouter->Complete(
 ipc,
 &dataPackage,
 ret );
 }
 else
 {
 iMessageRouter->Complete(
 ipc,
 // CMmCustomMessHandler::UiccCreateGBABootstrappingApdu
 // Constructs GBA security context AUTHENTICATE APDU (bootstrapping mode)
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccCreateGBABootstrappingApdu(
 TUiccSendApdu& aParams,
 const CMmDataPackage& aDataPackage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCreateGBABootstrappingApdu.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCREATEGBABOOTSTRAPPINGAPDU, "CMmCustomMessHandler::UiccCreateGBABootstrappingApdu" );
 RMmCustomAPI::TSimAuthenticationGbaBootstrap gbaBootstrap;
 aDataPackage.UnPackData( gbaBootstrap );
 // len of data is GBA bootstrapping mode tag (1 byte) + sizeof RAND
 // + sizeof AUTN + two length fields (one for RAND len and one for AUTN len)
 TUint8 lc( 1 + gbaBootstrap.iRandomParameters.Size() + gbaBootstrap.iAUTN.Size() + 2 );
 aParams.trId = ETrIdEGbaBootstrap;
 aParams.apdu.Append( KClaNoSm );             // CLA
 aParams.apdu.Append( KEvenInstructionCode ); // INS
 aParams.apdu.Append( 0 ); // P1 is set to 0 in case of even instruction
 aParams.apdu.Append( KGBAAuthenticationContext ); // P2
 aParams.apdu.Append( lc );                        // Lc
 aParams.apdu.Append( KGBABootstappingModeTag );   // GBA bootstrapping mode tag
 aParams.apdu.Append( gbaBootstrap.iRandomParameters.Size() ); // len of RAND
 aParams.apdu.Append( gbaBootstrap.iRandomParameters );        // RAND
 aParams.apdu.Append( gbaBootstrap.iAUTN.Size() );             // len of AUTN
 aParams.apdu.Append( gbaBootstrap.iAUTN );                    // AUTN
 aParams.apdu.Append( KMaximumLenOfDataExpected );             // Le
 }
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::UiccGBABootstrappingApduResp
 // Handles response APDU for GBA security context AUTHENTICATE APDU
 // (bootstrapping mode)
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccGBABootstrappingApduResp(
 TInt aTraId,
 TFLOGSTRING2("TSY: CMmCustomMessHandler::UiccGBABootstrappingApduResp: UICC status not ok: 0x%x\n", aStatus );
 OstTrace1( TRACE_NORMAL, DUP4_CMMCUSTOMMESSHANDLER_UICCGBABOOTSTRAPPINGAPDURESP, "CMmCustomMessHandler::UiccGBABootstrappingApduResp: UICC status not ok: 0x%x", aStatus );
 ret = KErrMMEtelAuthenticateFailed;
 }
 if( KErrNone == ret ||
 KErrMMEtelSqnVerificationFailed == ret ||
 KErrMMEtelMacVerificationFailed == ret )
 {
 CMmDataPackage dataPackage;
 dataPackage.PackData( &gbaBootstrap );
 iMessageRouter->Complete(
 ECustomGetSimAuthenticationDataIPC,
 &dataPackage,
 ret );
 }
 else
 {
 iMessageRouter->Complete(
 ECustomGetSimAuthenticationDataIPC,
 // File id path
 params.filePath.Append( KMasterFileId >> 8 );
 params.filePath.Append( KMasterFileId );
 params.filePath.Append( iMmUiccMessHandler->GetApplicationFileId() );
 iMmUiccMessHandler->CreateUiccApplCmdReq( params );
 }
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::UiccGBABootstrapReadResp
 // Handles response to elementary file EFgba read operation
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccGBABootstrapReadResp(
 TInt aStatus,
 const TDesC8& aFileData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccGBABootstrapReadResp.\n" );
 {
 // Get the rand len
 TUint32 index( 0 );
 TUint8 randLen( aFileData[index++] );
 if( aFileData.Length() >= randLen +
 iBTidBuf.Length() +
 iKeyLifetimeBuf.Length() +
 3 )
 {
 // store rand temporarily so that we can complete it
 // when B-Tid and keylifetime is updated to the EFgba.
 iRandBuf.Copy( aFileData.Mid( index, randLen ) );
 // CMmCustomMessHandler::UiccCreateGBABootstrapNafDerivationApdu
 // Constructs GBA security context AUTHENTICATE APDU (NAF derivation mode)
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccCreateGBABootstrapNafDerivationApdu(
 TUiccSendApdu& aParams,
 const CMmDataPackage& aDataPackage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCreateGBABootstrapNafDerivationApdu.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCREATEGBABOOTSTRAPNAFDERIVATIONAPDU, "CMmCustomMessHandler::UiccCreateGBABootstrapNafDerivationApdu" );
 RMmCustomAPI::TSimAuthenticationGbaNafDerivation gbaBootstrapNafDerivation;
 aDataPackage.UnPackData( gbaBootstrapNafDerivation );
 // len of data is GBA NAF derivation mode tag (1 byte) + sizeof NAFId
 // + sizeof IMPI + two length fields (one for NAFId len and one for IMPI len)
 TUint8 lc( 1 +
 gbaBootstrapNafDerivation.iNafId.Size() +
 gbaBootstrapNafDerivation.iImpi.Size() +
 2 );
 aParams.trId = ETrIdEGbaNafDerivation;
 aParams.apdu.Append( KClaNoSm );             // CLA
 aParams.apdu.Append( KEvenInstructionCode ); // INS
 aParams.apdu.Append( 0 ); // P1 is set to 0 in case of even instruction
 aParams.apdu.Append( KGBAAuthenticationContext ); // P2
 aParams.apdu.Append( lc );                        // Lc
 aParams.apdu.Append( KGBANAFDerivationModeTag );   // GBA bootstrapping mode tag
 aParams.apdu.Append( gbaBootstrapNafDerivation.iNafId.Size() ); // len of NAFId
 aParams.apdu.Append( gbaBootstrapNafDerivation.iNafId );        // NAFId
 aParams.apdu.Append( gbaBootstrapNafDerivation.iImpi.Size() );  // len of IMPI
 aParams.apdu.Append( gbaBootstrapNafDerivation.iImpi );         // IMPI
 }
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::UiccGBABootstrapNafDerivationApduResp
 // Handles response APDU for GBA security context AUTHENTICATE APDU
 // (NAF derivation mode)
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccGBANafDerivationApduResp(
 TInt aTraId,
 if( KNormalCommandEnding == result )
 {
 if( KApduOk == ValidateReceivedAuthenticateApdu( aTraId, aFileData ) )
 {
 // Let's skip "Successful GBA operation" tag
 // and start with Length of Length of Ks ext NAF
 TUint32 index( 1 );
 // get the Ks ext NAF
 TUint8 len( aFileData[index++] );
 gbaNafDerivation.iKsExtNaf.Copy( aFileData.Mid( index, len ) );
 dataPackage.PackData( &gbaNafDerivation );
 iMessageRouter->Complete(
 ECustomGetSimAuthenticationDataIPC,
 &dataPackage,
 ret );
 }
 else
 {
 iMessageRouter->Complete(
 ECustomGetSimAuthenticationDataIPC,
 // CMmCustomMessHandler::UiccCreateMbmsMskUpdateApdu
 // Constructs MBMS security context AUTHENTICATE APDU (MSK Update Mode)
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccCreateMbmsMskUpdateApdu(
 TUiccSendApdu& params,
 const CMmDataPackage& aDataPackage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCreateMbmsMskUpdateApdu.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCREATEMBMSMSKUPDATEAPDU, "CMmCustomMessHandler::UiccCreateMbmsMskUpdateApdu" );
 // Note. MBMS functionality is not tested in real hardware and in real environmen
 //  because of there is no users for this authentication type. So this is implemented
 // with the best knowledge at the moment and it can contain some bugs which
 // can be found when this is tested in real environment.
 RMmCustomAPI::TSimAuthenticationMgvMskUpdate mskUpdate;
 aDataPackage.UnPackData( mskUpdate );
 params.trId = ETrIdEMbmsMskUpdate;
 params.apdu.Append( KClaNoSm );             // CLA
 params.apdu.Append( KOddInstructionCode );  // INS
 params.apdu.Append( KFirstBlockOfAuthenticationData ); // P1
 params.apdu.Append( KMBMSAuthenticationContext ); // P2
 params.apdu.Append( lc );                         // Lc
 params.apdu.Append( KMBMSDataObjectTag );          // MBMS Data object tag
 params.apdu.Append( mskUpdate.iMikey.Size() + 1 ); // MBMS data obj len
 params.apdu.Append( KMskUpdateMode );              // MBMS Security Context Mode
 params.apdu.Append( mskUpdate.iMikey );            // Mikey
 }
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::UiccMbmsMskUpdateApduResp
 // Handles response APDU for MBMS security context AUTHENTICATE APDU
 // (MSK Update Mode)
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccMbmsMskUpdateApduResp(
 TInt aStatus,
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccMbmsMskUpdateApduResp.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCMBMSMSKUPDATEAPDURESP, "CMmCustomMessHandler::UiccMbmsMskUpdateApduResp" );
 // Note. MBMS functionality is not tested in real hardware and in real environment
 // because of at the moment there is no users for this authentication type.
 // So this is implemented with the best knowledge at the moment and it can contain
 // some bugs which can be found when this is tested in real environment.
 TInt ret( KErrGeneral );
 RMmCustomAPI::TSimAuthenticationMgvMskUpdate mskUpdate;
 TBool completeNeeded( ETrue );
 dataPackage.PackData( &mskUpdate );
 iMessageRouter->Complete(
 ECustomGetSimAuthenticationDataIPC,
 &dataPackage,
 ret );
 }
 else
 {
 iMessageRouter->Complete(
 ECustomGetSimAuthenticationDataIPC,
 TUint8 index( 0 );
 TUint32 objLen( aMbmsData.Length() );
 if( KSuccessfullMbmsOperationTag == aMbmsData[index] &&
 1 <= objLen &&
 ( KMaxMbmsMikeyLen + 1 ) >= objLen  ) // + 1 for 0xDB TLV tag
 {
 index++;
 // len of MIKEY is obj len - 1 because of
 // obj data contains 1 byte for
 // Successfull Mbms Operation Tag
 TUint8 mikeyLen = objLen - 1;
 if( 0 < mikeyLen )
 {
 aMskUpdate.iMikey.Copy( aMbmsData.Mid( index, mikeyLen ) );
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::UiccMskUpdateHandleMbmsOperationData
 // Handles OMA BCAST operation data from authenticate APDU
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccMskUpdateHandleOMABcastOperationData(
 RMmCustomAPI::TSimAuthenticationMgvMskUpdate& aMskUpdate,
 TDesC8& aMbmsData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccMskUpdateHandleOMABcastOperationData.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCMSKUPDATEHANDLEOMABCASTOPERATIONDATA, "CMmCustomMessHandler::UiccMskUpdateHandleOMABcastOperationData" );
 // CMmCustomMessHandler::UiccCreateMbmsMtkGenerationApdu
 // Constructs MBMS security context AUTHENTICATE APDU (MTK Generation Mode)
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccCreateMbmsMtkGenerationApdu(
 TUiccSendApdu& params,
 const CMmDataPackage& aDataPackage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCreateMbmsMtkGenerationApdu.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCREATEMBMSMTKGENERATIONAPDU, "CMmCustomMessHandler::UiccCreateMbmsMtkGenerationApdu" );
 // Note. MBMS functionality is not tested in real hardware and in real environment
 // because of at the moment there is no users for this authentication type.
 // So this is implemented with the best knowledge at the moment and it can contain
 // some bugs which can be found when this is tested in real environment.
 RMmCustomAPI::TSimAuthenticationMgvMtkGeneration mtkGen;
 aDataPackage.UnPackData( mtkGen );
 params.trId = ETrIdEMbmsMtkGeneration;
 params.apdu.Append( KClaNoSm );             // CLA
 params.apdu.Append( KOddInstructionCode );  // INS
 params.apdu.Append( KFirstBlockOfAuthenticationData ); // P1
 params.apdu.Append( KMBMSAuthenticationContext ); // P2
 params.apdu.Append( lc );                         // Lc
 params.apdu.Append( KMBMSDataObjectTag );          // MBMS Data object tag
 params.apdu.Append( mtkGen.iMikey.Size() + 1 ); // MBMS data obj len
 params.apdu.Append( KMtkGenerationMode );          // MBMS Security Context Mode
 params.apdu.Append( mtkGen.iMikey );            // Mikey
 }
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::UiccMbmsMtkGenerationApduResp
 // Handles response APDU for MBMS security context AUTHENTICATE APDU
 // (MTK Generation Mode)
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccMbmsMtkGenerationApduResp(
 TInt aStatus,
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccMbmsMtkGenerationApduResp.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCMBMSMTKGENERATIONAPDURESP, "CMmCustomMessHandler::UiccMbmsMtkGenerationApduResp" );
 // Note. MBMS functionality is not tested in real hardware and in real environment
 // because of at the moment there is no users for this authentication type.
 // So this is implemented with the best knowledge at the moment and it can contain
 // some bugs which can be found when this is tested in real environment.
 TInt ret( KErrGeneral );
 RMmCustomAPI::TSimAuthenticationMgvMtkGeneration mtkGen;
 TBool completeNeeded( ETrue );
 case KNormalCommandEnding:
 case KWarningMoreDataAvailable:
 {
 TBuf8<KMaxApduSize> mbmsOperationData;
 if( FindTlvObject( KMbmsOperationResponseTag53, aFileData.Mid( 0, aFileData.Length() - 2 ), mbmsOperationData ) ||
 FindTlvObject( KMbmsOperationResponseTag73, aFileData.Mid( 0, aFileData.Length() - 2 ), mbmsOperationData ) )
 {
 ret = KErrNone;
 if( KSuccessfullMbmsOperationTag == mbmsOperationData[0] )
 {
 dataPackage.PackData( &mtkGen );
 iMessageRouter->Complete(
 ECustomGetSimAuthenticationDataIPC,
 &dataPackage,
 ret );
 }
 else
 {
 iMessageRouter->Complete(
 ECustomGetSimAuthenticationDataIPC,
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::UiccMtkGenHandleMbmsOperationData
 // Handles MBMS operation data from MTK Generation authenticate APDU
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccMtkGenHandleMbmsOperationData(
 RMmCustomAPI::TSimAuthenticationMgvMtkGeneration& aMtkGen,
 TDesC8& aMbmsData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccMtkGenHandleMbmsOperationData.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCMTKGENHANDLEMBMSOPERATIONDATA, "CMmCustomMessHandler::UiccMtkGenHandleMbmsOperationData" );
 TUint8 index( 0 );
 TUint32 objLen( aMbmsData.Length() );
 if( KSuccessfullMbmsOperationTag == aMbmsData[index] &&
 1 <= objLen &&
 ( KMaxMbmsSaltLen + 1 ) >= objLen  ) // + 1 for 0xDB TLV tag
 {
 index++;
 // len of SALT is obj len - 1 because of
 // obj data contains 1 byte for
 // Successfull Mbms Operation Tag
 TUint8 saltLen( objLen - 1 );
 if( 0 < saltLen )
 {
 aMtkGen.iMtkSalt.Copy( aMbmsData.Mid( index, saltLen ) );
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::UiccMtkGenHandleOMABcastOperationData
 // Handles OMA BCAST operation data from authenticate APDU
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccMtkGenHandleOMABcastOperationData(
 RMmCustomAPI::TSimAuthenticationMgvMtkGeneration& aMtkGen,
 TDesC8& aMbmsData )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccMtkGenHandleOMABcastOperationData.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCMTKGENHANDLEOMABCASTOPERATIONDATA, "CMmCustomMessHandler::UiccMtkGenHandleOMABcastOperationData" );
 {
 aMtkGen.iTrafficEncryptionKey.Copy( tekData );
 }
 if( FindTlvObject( KParentalControlTag, omaBcastData, parentalControlData ) )
 {
 // first parameter of parental control data is "key reference for second
 // application PIN defined for parental contol" but it's not supported
 // at the moment
 aMtkGen.iParentalControl.Append( parentalControlData[1] ); // rating type
 aMtkGen.iParentalControl.Append( parentalControlData[2] ); // rating value
 aMtkGen.iParentalControl.Append( parentalControlData[3] ); // level granted value
 }
 // CMmCustomMessHandler::UiccCreateMbmsMskDeletionApdu
 // Constructs MBMS security context AUTHENTICATE APDU (MSK Deletion Mode)
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccCreateMbmsMskDeletionApdu(
 TUiccSendApdu& params,
 const CMmDataPackage& aDataPackage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccCreateMbmsMskDeletionApdu.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCCREATEMBMSMSKDELETIONAPDU, "CMmCustomMessHandler::UiccCreateMbmsMskDeletionApdu" );
 // Note. MBMS functionality is not tested in real hardware and in real environment
 // because of at the moment there is no users for this authentication type.
 // So this is implemented with the best knowledge at the moment and it can contain
 // some bugs which can be found when this is tested in real environment.
 RMmCustomAPI::TSimAuthenticationMgvMskDeletion mskDel;
 aDataPackage.UnPackData( mskDel );
 // len of data is MBMS Data Object tag (1 byte) +
 // MBMS Data Object length (1 byte) +
 // MBMS Security Context Mode (1 byte) +
 // size of Key Domain Id + size of Key Group Id Part
 TUint8 lc( 1 +
 1 +
 1 +
 mskDel.iKeyDomainId.Size() +
 mskDel.iKeyGroupIdPart.Size() );
 // data size in MBMS Data Object Tag is:
 // MBMS Security Context Mode (1 byte) +
 // size of Key Domain Id + size of Key Group Id Part
 TUint8 dataSize( 1 +
 mskDel.iKeyDomainId.Size() +
 mskDel.iKeyGroupIdPart.Size() );
 params.trId = ETrIdEMbmsMskDeletion;
 params.apdu.Append( KClaNoSm );             // CLA
 params.apdu.Append( KOddInstructionCode );  // INS
 params.apdu.Append( KFirstBlockOfAuthenticationData ); // P1
 params.apdu.Append( KMBMSAuthenticationContext ); // P2
 params.apdu.Append( lc );                         // Lc
 params.apdu.Append( KMBMSDataObjectTag );       // MBMS Data object tag
 params.apdu.Append( dataSize );                 // MBMS data obj len
 params.apdu.Append( KMskDeletionMode );         // MBMS Security Context Mode
 params.apdu.Append( mskDel.iKeyDomainId );      // Key Domain Id
 params.apdu.Append( mskDel.iKeyGroupIdPart );   // Key Group Id
 }
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::UiccMbmsMskDeletionApduResp
 // Handles response APDU for MBMS security context AUTHENTICATE APDU
 // (MSK Deletion Mode)
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::UiccMbmsMskDeletionApduResp(
 TInt aStatus,
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccMbmsMskDeletionApduResp.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCMBMSMSKDELETIONAPDURESP, "CMmCustomMessHandler::UiccMbmsMskDeletionApduResp" );
 // Note. MBMS functionality is not tested in real hardware and in real environment
 // because of at the moment there is no users for this authentication type.
 // So this is implemented with the best knowledge at the moment and it can contain
 // some bugs which can be found when this is tested in real environment.
 TInt ret( KErrGeneral );
 RMmCustomAPI::TSimAuthenticationMgvMskDeletion mskDel;
 TBool completeNeeded( ETrue );
 dataPackage.PackData( &mskDel );
 iMessageRouter->Complete(
 ECustomGetSimAuthenticationDataIPC,
 &dataPackage,
 ret );
 }
 else
 {
 iMessageRouter->Complete(
 ECustomGetSimAuthenticationDataIPC,
 params.trId = aTrId;
 params.apdu.Append( KClaNoSm );             // CLA
 params.apdu.Append( KOddInstructionCode );  // INS
 params.apdu.Append( KFirstBlockOfAuthenticationResponseData ); // P1
 params.apdu.Append( 0x00 ); // P2
 params.apdu.Append( 0x00 ); // Le
 iMmUiccMessHandler->CreateUiccApplCmdReq( params );
 }
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::MapSw1Sw2ToAuthenticateResult
 // Maps sw1 and sw2 from response authenticate apdu to result
 // -----------------------------------------------------------------------------
 //
 TUint8 CMmCustomMessHandler::MapSw1Sw2ToAuthenticateResult( TUint8 sw1, TUint8 sw2 )
 {
 TFLOGSTRING3("TSY: CMmCustomMessHandler::MapSw1Sw2ToAuthenticateResult. sw1: 0x%x sw2: 0x%x\n", sw1, sw2 );
 {
 if( 0x00 == sw2 )
 {
 ret = KNormalCommandEnding;
 }
 else if( 0xF1 == sw2 ||
 0xF2 == sw2 )
 {
 ret = KWarningMoreDataAvailable;
 }
 else if( 0xF3 == sw2 )
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::ValidateReceivedAuthenticateApdu
 // Validates received apdu
 // -----------------------------------------------------------------------------
 //
 TUint8 CMmCustomMessHandler::ValidateReceivedAuthenticateApdu(
 TInt aTraId,
 const TDesC8& aApdu )
 {
 TUint8 ret( KApduOk );
 switch( aTraId )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::ValidateGsmSecurityContextApduResp.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_VALIDATEGSMSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::ValidateGsmSecurityContextApduResp" );
 TUint8 ret( KApduNok );
 // apdu len is len of aApdu - 2 (because of
 // aApdu contains sw1 and sw2)
 TUint apduLen( aApdu.Length() - 2 );
 TUint32 index( 0 );
 index += aApdu[index] + 1;
 TFLOGSTRING("TSY: CMmCustomMessHandler::Validate3GSecurityContextApduResp.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_VALIDATE3GSECURITYCONTEXTAPDURESP, "CMmCustomMessHandler::Validate3GSecurityContextApduResp" );
 TUint8 ret( KApduOk );
 // Let's calculate total APDU data len in aApdu. Length is
 // decremented by 2 because of aApdu contains also sw1 and sw2
 // and these are total 2 bytes long.
 TUint8 apduLen( aApdu.Length() - 2 );
 TUint32 index( 0 );
 TUint8 tag( aApdu[index++] );
 TFLOGSTRING("TSY: CMmCustomMessHandler::ValidateGBABootstrappingApduResp.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_VALIDATEGBABOOTSTRAPPINGAPDURESP, "CMmCustomMessHandler::ValidateGBABootstrappingApduResp" );
 TUint8 ret( KApduNok );
 // Let's calculate total APDU data len in aApdu. Length is
 // decremented by 2 because of aApdu contains also sw1 and sw2
 // and these are total 2 bytes long.
 TUint8 apduLen( aApdu.Length() - 2 );
 TUint32 index( 0 );
 TUint8 tag( aApdu[index++] );
 TFLOGSTRING("TSY: CMmCustomMessHandler::ValidateGBANafDerivationApduResp.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_VALIDATEGBANAFDERIVATIONAPDURESP, "CMmCustomMessHandler::ValidateGBANafDerivationApduResp" );
 TUint8 ret = KApduNok;
 // Let's calculate total APDU data len in aApdu. Length is
 // decremented by 2 because of aApdu contains also sw1 and sw2
 // and these are total 2 bytes long.
 TUint8 apduLen( aApdu.Length() - 2 );
 TUint32 index( 0 );
 TUint8 tag( aApdu[index++] );
 if( apduLen > 1 )
 {
 if( KSuccessfull3GAuthTag == tag )
 {
 // response apdu contains only parameter Ks Ext NAF
 // so, let's check that apdu len contains parameter
 // correctly. So apduLen should be len of Ks Ext NAF
 // + 2 ("Successful GBA operation" field +
 // Length of Ks_ext_NAF field)
 if( apduLen == aApdu[index] + 2 )
 {
 ret = KApduOk;
 }
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::FindTlvObject
 // Finds TLV object
 // -----------------------------------------------------------------------------
 //
 TBool CMmCustomMessHandler::FindTlvObject(
 TUint8 aTlvTag,
 const TDesC8& aBerTlv,
 TDes8& aTlvObject )
 {
 {
 tag = aBerTlv[index++];
 tlvLength = aBerTlv[index++];
 // let's check if len of tlv object is coded
 // with one or two bytes
 if( 0x81 == tlvLength ||
 0x82 == tlvLength )
 {
 TUint8 byteCount( tlvLength & 0x7F );
 TUint8 ind( 0 );
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::DeriveCkFromKc
 // derives Ck from Kc
 // -----------------------------------------------------------------------------
 //
 void CMmCustomMessHandler::DeriveCkFromKc(
 TDes8& aCk,
 const TDesC8& aKc )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::DeriveCkFromKc.\n" );
 // -----------------------------------------------------------------------------
 // CMmCustomMessHandler::DeriveIkFromKc
 // derives Ck from Kc
 // -----------------------------------------------------------------------------
 //
 TInt CMmCustomMessHandler::UiccHandleImsAuthentication(
 const CMmDataPackage& aDataPackage )
 {
 TFLOGSTRING("TSY: CMmCustomMessHandler::UiccHandleImsAuthentication.\n" );
 OstTrace0( TRACE_NORMAL, CMMCUSTOMMESSHANDLER_UICCHANDLEIMSAUTHENTICATION, "CMmCustomMessHandler::UiccHandleImsAuthentication" );
 TInt ret( KErrNone );
 TUint8 cardType( iMmUiccMessHandler->GetCardType() );
 if( UICC_CARD_TYPE_ICC == cardType )
 {
 // no need to activate ISIM application,
 // let's just send the authentication APDU
 UiccCreateRunGsmAlgorithmApdu(
 params,
 authenticationData.iRAND,
 ETrIdRunGsmAlgorithmIms );
 if( iMmUiccMessHandler->IsIsimApplicationFound() )
 {
 // let's check is ISIM application already tried to activate
 if( iIsimApplActivated )
 {
 UiccCreate3GSecurityContextApdu(
 params,
 authenticationData.iRAND,
 authenticationData.iAUTN,
 ETrIdEEapAkaAuthenticateIms );
 ret = iMmUiccMessHandler->CreateUiccApplCmdReq( params, UICC_APPL_TYPE_UICC_ISIM );
 }
 params.fileIdSfi = UICC_SFI_NOT_PRESENT;
 params.filePath.Append( KMasterFileId >> 8 );
 params.filePath.Append( KMasterFileId );
 params.filePath.Append( iMmUiccMessHandler->GetApplicationFileId() );
 UiccCreate3GSecurityContextApdu(
 params,
 iRandBuf,
 iAutnBuf,
 ETrIdEEapAkaAuthenticateIms );
 if( UICC_STATUS_OK == aStatus )
 {
 // to the ISim application
 iMmUiccMessHandler->CreateUiccApplCmdReq( params, UICC_APPL_TYPE_UICC_ISIM );
 }
 else
 {
 // ISim application activation fails, le'ts send authentication apdu
 // to the USim application
 iMmUiccMessHandler->CreateUiccApplCmdReq( params );
 }
 }

changeset 5	8ccc39f9d787
parent 0	63b37f68c1ce
child 7	fa67e03b87df