// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

//INCLUDES

#include "cmmsecuritytsy.h"

#include "cmmphonetsy.h"

#include "cmmtsyreqhandlestore.h"

#include <ctsy/pluginapi/cmmdatapackage.h>

#include "cmmmessagemanagerbase.h"

#include "cmmphoneextinterface.h"

#include "CMmCommonStaticUtility.h"

#include "CMmCustomSecurityTsy.h"

// ======== MEMBER FUNCTIONS ========

CMmSecurityTsy* CMmSecurityTsy::NewL(    

        CMmPhoneTsy* aPhoneTsy ) // Ptr to PhoneTsy   

    {

TFLOGSTRING("TSY: CMmSecurityTsy::NewL");

    CMmSecurityTsy* const mmSecurityTsy = new ( ELeave ) CMmSecurityTsy();

    CleanupStack::PushL( mmSecurityTsy );

    mmSecurityTsy->iMmPhoneTsy = aPhoneTsy;

    mmSecurityTsy->ConstructL();

    CleanupStack::Pop( mmSecurityTsy );

    return mmSecurityTsy;

    }

CMmSecurityTsy::CMmSecurityTsy()

    {

    }

void CMmSecurityTsy::ConstructL()

    {

TFLOGSTRING("TSY: CMmSecurityTsy::ConstructL");

    // Is security codes (PIN and phone password) checked in boot

    iSecurityCheckedForBoot = EFalse;

    // information to know is PIN1 or PIN2 last requested

    iLastPinRequested = EPinUnknown;

    // Is TSY storing ntofication for "Lock if SIM changed" in boot

    iIsSecurityCodeRequestCachedInBoot = EFalse;

    // Is PIN1 disable supported, by default ETrue. Changed when SIM

    // Service Table is read and it does not support PIN1 disable.

    iPin1DisableSupported = ETrue;

    // Set lock setting to unknown 

    iLockSetting = RMobilePhone::ELockSetUnknown;

    //Set iPhonePasswordVerify to EFalse

    iPhonePasswordVerify = EFalse;

    //Set change UPIN state to idle

    iActiveCodeToUpinState = EActiveCodeToUpinIdle;

    }

CMmSecurityTsy::~CMmSecurityTsy()

    {

TFLOGSTRING("TSY: CMmSecurityTsy::~CMmSecurityTsy");

    }  

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

// CMmSecurityTsy::DoExtFunc

// Security-specific functionality of CMmPhoneTsy::DoExtFuncL

// (other items were commented in a header).

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

//

TInt CMmSecurityTsy::DoExtFuncL(

    const TTsyReqHandle aTsyReqHandle, 

    const TInt aIpc, 

    const TDataPackage& aPackage ) 

    {

TFLOGSTRING3("TSY: CMmSecurityTsy::DoExtFuncL.\n  \t\t\t IPC:%d\n  \t\t\t Handle:%d", aIpc, aTsyReqHandle);

    TInt ret ( KErrNone );

    TAny* dataPtr = aPackage.Ptr1();

    switch ( aIpc )

        {

        // Get Security Capabilities

        case EMobilePhoneGetSecurityCaps:

            ret = GetSecurityCaps( aTsyReqHandle, 

                REINTERPRET_CAST( TUint32*, dataPtr ) );

            break;

        // Notify Change of Security Capabilities

        case EMobilePhoneNotifySecurityCapsChange:

            ret = NotifySecurityCapsChange(

                REINTERPRET_CAST( TUint32*, dataPtr ) );

            break;

                case EMobilePhoneGetLockInfo:

            break;

        // Notify Change of Lock Information

        case EMobilePhoneNotifyLockInfoChange:

            ret = NotifyLockInfoChange(  

                REINTERPRET_CAST( RMobilePhone::TMobilePhoneLock*, dataPtr ),

                aPackage.Des2n() );

            break;

        // Set Lock Setting

        case EMobilePhoneSetLockSetting:

            ret = SetLockSettingL( aTsyReqHandle, 

                  aPackage );

            break;

        // Change Security Code

        case EMobilePhoneChangeSecurityCode:

            ret = ChangeSecurityCodeL( aTsyReqHandle, aPackage );

            break;

        // Notify Security Event

        case EMobilePhoneNotifySecurityEvent:

            ret = NotifySecurityEventL(

                REINTERPRET_CAST( RMobilePhone::TMobilePhoneSecurityEvent*, 

                dataPtr ) );

            break;

        // Verify Security Code

        case EMobilePhoneVerifySecurityCode:

            ret = VerifySecurityCodeL( aTsyReqHandle, aPackage );

            break;

        // Abort Security Code

        case EMobilePhoneAbortSecurityCode:

            ret = AbortSecurityCodeL( aTsyReqHandle, aPackage );

            break;

        case EMobilePhoneGetSecurityCodeInfo:

            ret = GetSecurityCodeInfoL( aTsyReqHandle, REINTERPRET_CAST( 

                RMobilePhone::TMobilePhoneSecurityCode*, dataPtr ), 

                aPackage.Des2n() );

            break;

        case EMobilePhoneNotifySecurityCodeInfoChange:

            ret = NotifySecurityCodeInfoChange( REINTERPRET_CAST( 

                RMobilePhone::TMobilePhoneSecurityCode*, dataPtr ), 

                aPackage.Des2n() );

            break;

        default:

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

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

// CMmSecurityTsy::CancelService

// Cancels Security requests

// (other items were commented in a header).

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

//

TInt CMmSecurityTsy::CancelService(

    const TInt aIpc, 

    const TTsyReqHandle aTsyReqHandle ) 

    {

    TInt ret ( KErrNotSupported );

    //When the clients close their sub-sessions (eg. by calling RLine::Close),

    //they may not have cancelled all their outstanding asynchronous requests 

    //before closing.  It is up to the ETel server to clean up in this 

    //situation, so the server will find the list of outstanding requests 

    //related to that sub-session object and pass these outstanding IPC 

    //request numbers, one at a time, to the CancelService method in the TSY.

    switch ( aIpc )

        {

        case EMobilePhoneNotifySecurityCapsChange:

            ret = NotifySecurityCapsChangeCancel( aTsyReqHandle );

            break;

        case EMobilePhoneGetLockInfo:

            ret = GetLockInfoCancel ( aTsyReqHandle );

            break;

        case EMobilePhoneSetLockSetting:

            ret = SetLockSettingCancel( aTsyReqHandle );

            break;

        case EMobilePhoneNotifyLockInfoChange:

            ret = NotifyLockInfoChangeCancel( aTsyReqHandle );

            break;

        case EMobilePhoneNotifySecurityEvent:

            ret = NotifySecurityEventCancel( aTsyReqHandle );

            break;

        case EMobilePhoneGetSecurityCodeInfo:

            ret = GetSecurityCodeInfoCancel( aTsyReqHandle );

            break;

        case EMobilePhoneNotifySecurityCodeInfoChange:

            ret = NotifySecurityCodeInfoChangeCancel( aTsyReqHandle );

            break;

        //Default case

        default:

            ret = KErrNone; 

            break;

        }

    return ret;

    }

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

// CMmSecurityTsy::GetSecurityCaps

// returns a snapshot of the combination of the 

// static and dynamic security capabilities of the phone. 

// (other items were commented in a header).

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

//

TInt CMmSecurityTsy::GetSecurityCaps(

    const TTsyReqHandle aTsyReqHandle, 

    TUint32* aCaps ) 

    {

    TInt ret ( KErrAccessDenied );

    ret = iMmPhoneTsy->iMmPhoneExtInterface->GetSecurityCaps( aCaps ); 

    iMmPhoneTsy->ReqCompleted( aTsyReqHandle, ret );

    return KErrNone;

    }

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

// CMmSecurityTsy::NotifySecurityCapsChange

// This request allows a client to be notified when the phone's 

// security capabilities change

// (other items were commented in a header).

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

//

TInt CMmSecurityTsy::NotifySecurityCapsChange(

    TUint32* aCaps ) 

    {

    iRetNotifySecurityCapsChange = aCaps;

    iMmPhoneTsy->iReqHandleType = 

        CMmPhoneTsy::EMultimodePhoneNotifySecurityCapsChange;

    return KErrNone;    

    }

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

// CMmSecurityTsy::NotifySecurityCapsChangeCancel

// This method cancels an outstanding asynchronous 

// NotifySecurityCapsChange request.

// (other items were commented in a header).

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

//

TInt CMmSecurityTsy::NotifySecurityCapsChangeCancel(

    const TTsyReqHandle aTsyReqHandle ) 

    {

    iRetNotifySecurityCapsChange = NULL;

    iMmPhoneTsy->iTsyReqHandleStore->ResetTsyReqHandle( 

        CMmPhoneTsy::EMultimodePhoneNotifySecurityCapsChange );

    iMmPhoneTsy->ReqCompleted( aTsyReqHandle, KErrCancel );

    return KErrNone;    

    }

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

// CMmSecurityTsy::CompleteNotifySecurityCapsChange

// This method completes an outstanding asynchronous 

// NotifySecurityCapsChange request. 

// (other items were commented in a header).

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

//

TInt CMmSecurityTsy::CompleteNotifySecurityCapsChange(

    TUint32 aCaps ) 

    {

    TTsyReqHandle reqHandle = iMmPhoneTsy->iTsyReqHandleStore->

        ResetTsyReqHandle( 

        CMmPhoneTsy::EMultimodePhoneNotifySecurityCapsChange );

    if ( CMmPhoneTsy::EMultimodePhoneReqHandleUnknown != reqHandle )

        {

        *iRetNotifySecurityCapsChange = aCaps;

        iMmPhoneTsy->ReqCompleted( reqHandle, KErrNone );

        }

    return KErrNone;

    }

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

// CMmSecurityTsy::GetLockInfoL

// This method retrieves the current status and setting of a lock.   

// (other items were commented in a header).

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

//

    {

TFLOGSTRING("LTSY: CMmSecurityTsy::GetLockInfoL - Client call");

    TInt ret ( KErrArgument );

    TDes8* data = reinterpret_cast<TDes8*> ( aPackage.Des2n() );

    if ( sizeof ( RMobilePhone::TMobilePhoneLockInfoV1 ) <= 

        data->MaxLength() )

        {   

        //save pointer to client side for completion

        iRetGetLockInfo = data;

        ret = iMmPhoneTsy->iMmPhoneExtInterface->GetLockInfoL( aPackage );

            {

            }

        }

    return ret;

    }

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

// CMmSecurityTsy::NotifyLockInfoChange

// This method allows a client to be notified when any part of 

// the lock information changes.

// (other items were commented in a header).

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

//

TInt CMmSecurityTsy::NotifyLockInfoChange(

    RMobilePhone::TMobilePhoneLock* aLock, 

    TDes8* aLockInfo ) 

    {

TFLOGSTRING2("LTSY: CMmSecurityTsy::NotifyLockInfoChange - Lock: %d", aLock);

    TInt ret( KErrNone );

    if ( sizeof ( RMobilePhone::TMobilePhoneLockInfoV1 ) <= 

        aLockInfo->MaxLength() )

        {

        iRetNotifyLockInfoChange = aLockInfo;

        iRetNotifyPhoneLockChange = aLock;

        //save tsy req handle type

        iMmPhoneTsy->iReqHandleType = 

            CMmPhoneTsy::EMultimodePhoneNotifyLockInfoChange;

        }

    else

        {

        ret = KErrArgument;

        }

    return ret;

    }

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

// CMmSecurityTsy::NotifyLockInfoChangeCancel

// This method cancels an outstanding asynchronous 

// NotifyLockInfoChange request 

// (other items were commented in a header).

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

//

TInt CMmSecurityTsy::NotifyLockInfoChangeCancel(

    const TTsyReqHandle aTsyReqHandle ) 

    {

TFLOGSTRING("LTSY: CMmSecurityTsy::NotifyLockInfoChangeCancel");

    iRetNotifyLockInfoChange = NULL;

    iRetNotifyPhoneLockChange = NULL;

    iMmPhoneTsy->iTsyReqHandleStore->ResetTsyReqHandle( 

        CMmPhoneTsy::EMultimodePhoneNotifyLockInfoChange );

    iMmPhoneTsy->ReqCompleted( aTsyReqHandle, KErrCancel );

    return KErrNone;

    }

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

// CMmSecurityTsy::CompleteNotifyLockInfoChange

// This method completes an outstanding asynchronous 

// NotifyLockInfoChange request.

// (other items were commented in a header).

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

//

void CMmSecurityTsy::CompleteNotifyLockInfoChange(

    CMmDataPackage* aDataPackage, TInt aErrorCode ) 

    {

    //reset req handle. Returns the deleted req handle

    TTsyReqHandle reqHandle = iMmPhoneTsy->iTsyReqHandleStore->

            ResetTsyReqHandle( CMmPhoneTsy::EMultimodePhoneNotifyLockInfoChange );

    if (KErrNone != aErrorCode)

        {

        iMmPhoneTsy->ReqCompleted( reqHandle, aErrorCode );

        return;

        }

    RMobilePhone::TMobilePhoneLock* lock = NULL;

    RMobilePhone::TMobilePhoneLockInfoV1* lockInfo = NULL;

    aDataPackage->UnPackData( &lockInfo, &lock );

    //update the status of the lock in the extension

    iMmPhoneTsy->iMmPhoneExtInterface->UpdateLockInfo( lockInfo->iStatus,

        lockInfo->iSetting, *lock );

    if ( CMmPhoneTsy::EMultimodePhoneReqHandleUnknown != reqHandle )

        {

        RMobilePhone::TMobilePhoneLockInfoV1Pckg lockInfoPckg( *lockInfo );

        *iRetNotifyLockInfoChange = lockInfoPckg;

        *iRetNotifyPhoneLockChange = *lock;

        iMmPhoneTsy->ReqCompleted( reqHandle, aErrorCode );

        }

    }

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

// CMmSecurityTsy::SetLockSettingL

// This function prevents some other client to set lock setting

// while previous process is still going on because of password query from 

// the client. If process in question is still going function then the request

// complete with error code KErrServerBusy. Some lock settings requires 

// code verification. This method will call CompleteNotifySecurityEvent with 

// required even in each case.(other items were commented in a header).

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

//

TInt CMmSecurityTsy::SetLockSettingL(

    const TTsyReqHandle aTsyReqHandle,    

    const TDataPackage& aPackage ) 

    {

TFLOGSTRING("LTSY: CMmSecurityTsy::SetLockSettingL - Client call" );

    TInt ret( KErrNone );

    // Check if request handle already exists

    TTsyReqHandle reqHandle = iMmPhoneTsy->iTsyReqHandleStore->

        GetTsyReqHandle( CMmPhoneTsy::EMultimodePhoneSetLockSetting );

    if ( CMmPhoneTsy::EMultimodePhoneReqHandleUnknown != reqHandle )

        {

        iMmPhoneTsy->ReqCompleted( aTsyReqHandle, KErrServerBusy );

        }

    else

        {

        ret = LockSettingL( aTsyReqHandle, aPackage );

        // if error is other than KErrAccessDenied or KErrNone, complete now

        // KErrAccessDenied means we need verification first, not that an

        // error has occured and we ought to complete the request. 

        // KErrNone means that EMobilePhoneSetLockSetting request has been 

        // successfully sent to LTSY.

        if ( !( KErrNone == ret || KErrAccessDenied == ret ) )

            {

            iMmPhoneTsy->ReqCompleted( aTsyReqHandle, ret );

            }                     

        }

    return KErrNone;

    }

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

// CMmSecurityTsy::SetLockSettingCancel

// Use this method to cancel a previously placed asynchronous 

// SetLockSetting request 

// (other items were commented in a header).

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

//

TInt CMmSecurityTsy::SetLockSettingCancel(

    TTsyReqHandle aTsyReqHandle ) 

    {

    iActiveCodeToUpinState = EActiveCodeToUpinIdle;

    //reset the req handle

    iMmPhoneTsy->iTsyReqHandleStore->ResetTsyReqHandle( 

            CMmPhoneTsy::EMultimodePhoneSetLockSetting );

    //complete with cancel

    iMmPhoneTsy->ReqCompleted( aTsyReqHandle, KErrCancel );

    return KErrNone;

    }

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

// CMmSecurityTsy::LockSettingL

// This method allows a client to change the current setting of 

// a lock. If password is required, function triggers completion of 

// security event notification and stores required variables for possible 

// retry. Other possible errors are reported to client as well 

// (other items were commented in a header).

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

//

TInt CMmSecurityTsy::LockSettingL(

    const TTsyReqHandle, 

    const TDataPackage& aPackage ) 

    {

    TInt ret ( KErrNotSupported );

    RMobilePhone::TMobilePhoneLock* lock = 

        reinterpret_cast<RMobilePhone::TMobilePhoneLock* > 

                                                        ( aPackage.Ptr1() );

    RMobilePhone::TMobilePhoneLockSetting* setting = 

        reinterpret_cast<RMobilePhone::TMobilePhoneLockSetting* >

        ( aPackage.Ptr2() );

TFLOGSTRING3("LTSY: CMmSecurityTsy::LockSetting - Lock:%d, Setting:%d",

    *lock, *setting );

    // Some SIM cards might not support PIN1 disable. Thus

    // return error if client tries to disable it.

    // complete the request immediately with error.

    if ( ( RMobilePhone::ELockSetDisabled == *setting ) &&

         ( RMobilePhone::ELockICC == *lock ||

           RMobilePhone::ELockUniversalPin == *lock ) &&

           !iPin1DisableSupported )

        {

        // Operation is not allowed as SIM does not support changing

        // SIM from ON to OFF.

        ret = KErrGsm0707OperationNotAllowed;

        }

    else

        {

         //check if the request made is an state change attempt

        if ( RMobilePhone::ELockSetUnknown != *setting )

            {   

            //check if the lock to be set requires previous verification

            RMobilePhone::TMobilePhoneSecurityEvent event (

                RMobilePhone::ENoICCFound );

            //be pesimistic

            ret = KErrAccessDenied;

            //Check the lock to be set