/*

* 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 <etelmm.h>

#include <tisi.h>

#ifdef INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING

#include <mtcisi.h>

#else /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

#include <mceisi.h>

#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

#include <ctsy/pluginapi/cmmdatapackage.h>

#include <ctsy/serviceapi/gsmerror.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include <uiccisi.h>

// 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 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");

    //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");

    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");

#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");

    }

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

// CMmSecurityMessHandler::ExtFuncL

// Dispatches Etel requests to DOS level handlers

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

//

TInt CMmSecurityMessHandler::ExtFuncL(

    TInt aIpc,

    const CMmDataPackage* aDataPackage )

    {

TFLOGSTRING2("TSY: 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:

            {

            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");

                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");

                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!!!)");

            ret = MtcRfStatusQueryReq( transId );

            break;

            }

#endif /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

        default:

            {

TFLOGSTRING2("TSY: CMmSecurityMessHandler::ExtFuncL - Unknown IPC: %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);

    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);

                    break;

                    }

                } // end switch ( messageId )

            break; // end case PN_MTC

            }

#else /* INTERNAL_TESTING_OLD_IMPLEMENTATION_FOR_UICC_TESTING */

        case PN_MODEM_MCE:

            {

            switch( messageId )

                {