/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Provides api for handling security events.

*

*

*/

#include <aknnotedialog.h>

#include <etelmm.h>

#include <SecUi.rsg>

#include <exterror.h>

#include <textresolver.h>

#ifdef __COVER_DISPLAY

#include <aknmediatorfacade.h>

#include <secondarydisplay/SecondaryDisplayStartupAPI.h>

#endif //__COVER_DISPLAY

#include <centralrepository.h> 

#include <starterclient.h>     //used for RemoveSplashScreen

#include <e32property.h>

#include <PSVariables.h>   // Property values

#include <coreapplicationuisdomainpskeys.h>

#include <startupdomainpskeys.h>

#include <uikon/eiksrvui.h>

#include <settingsinternalcrkeys.h>

#include <securityuisprivatepskeys.h>

#include <AknNotiferAppServerApplication.h>

#include <SCPClient.h>

#include <securitynotification.h>

#include "secui.hrh"

#include "secuisecurityhandler.h"

#include "secuicodequerydialog.h"

#include "secuisecuritysettings.h"

#include "SecUiWait.h"

#include "SecUiLockObserver.h"

#ifdef RD_REMOTELOCK

#include <RemoteLockSettings.h>

#endif // RD_REMOTELOCK

#include <StringLoader.h>

#include <featmgr.h>

//  LOCAL CONSTANTS AND MACROS

const TInt KMaxNumberOfPUKAttempts(10);

const TInt KMaxNumberOfPINAttempts(3);

const TInt KLastRemainingInputAttempt(1);

const TInt KTriesToConnectServer( 2 );

const TInt KTimeBeforeRetryingRequest( 50000 );

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

//

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

// CSecurityHandler::CSecurityHandler()

// C++ constructor

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

//

EXPORT_C CSecurityHandler::CSecurityHandler(RMobilePhone& aPhone):

        iPhone(aPhone), iQueryCanceled(ETrue), iSecurityDlg(NULL), iNoteDlg(NULL) 

    {

        TInt result = iCustomPhone.Open(aPhone);

        TRAP_IGNORE( FeatureManager::InitializeLibL() ); //Shouldn't this panic if FM does not initialise??

    }

//

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

// CSecurityHandler::~CSecurityHandler()

// Destructor

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

//

EXPORT_C CSecurityHandler::~CSecurityHandler()

    {

    #if defined(_DEBUG)

    RDebug::Print(_L("CSecurityHandler::~CSecurityHandler()"));

    #endif

    if ( iDestroyedPtr )

        {

        *iDestroyedPtr = ETrue;

        iDestroyedPtr = NULL;

        }

    CancelSecCodeQuery();

    iCustomPhone.Close();

    FeatureManager::UnInitializeLib();

    }

//

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

// CSecurityHandler::HandleEventL()

// Handles different security events

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

//

EXPORT_C void CSecurityHandler::HandleEventL(

    RMobilePhone::TMobilePhoneSecurityEvent aEvent )

    {

    TInt result = KErrNone;

    HandleEventL( aEvent, result );

    }

//

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

// CSecurityHandler::HandleEventL()

// Handles different security events

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

//

EXPORT_C void CSecurityHandler::HandleEventL(

    RMobilePhone::TMobilePhoneSecurityEvent aEvent,

    TBool aStartup, TInt& aResult )

    {

    iStartup = aStartup;

    HandleEventL( aEvent, aResult );

    }

//

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

// CSecurityHandler::HandleEventL()

// Handles different security events

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

//

EXPORT_C void CSecurityHandler::HandleEventL(

    RMobilePhone::TMobilePhoneSecurityEvent aEvent, TInt& aResult )

    {

    /*****************************************************

    *    Series 60 Customer / ETel

    *    Series 60  ETel API

    *****************************************************/

    #if defined(_DEBUG)

    RDebug::Print(_L("(SECUI)CSecurityHandler::HandleEventL()"));

    RDebug::Print(_L("(SECUI)CSecurityHandler::HandleEventL() EVENT: %d"), aEvent);

    #endif

    TBool wcdmaSupported(FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ));

    TBool upinSupported(FeatureManager::FeatureSupported( KFeatureIdUpin ));

    switch(aEvent)

            {

            case RMobilePhone::EPin1Required:

                #if defined(_DEBUG)

                RDebug::Print(_L("(SECUI)CSecurityHandler::HandleEventL() Pin1Required"));

                #endif

                aResult = Pin1RequiredL();

                break;

            case RMobilePhone::EPuk1Required:

                #if defined(_DEBUG)

                RDebug::Print(_L("(SECUI)CSecurityHandler::HandleEventL() PUK1Required"));

                #endif

                ((CAknNotifierAppServerAppUi*)(CEikonEnv::Static())->EikAppUi())->SuppressAppSwitching(ETrue);

                TRAPD(err,aResult = Puk1RequiredL());

                ((CAknNotifierAppServerAppUi*)(CEikonEnv::Static())->EikAppUi())->SuppressAppSwitching(EFalse);

                User::LeaveIfError(err);

                break;

            case RMobilePhone::EPin2Required:

                Pin2RequiredL();

                break;

            case RMobilePhone::EPuk2Required:

                Puk2RequiredL();        

                break;

            case RMobilePhone::EUniversalPinRequired:

                if(wcdmaSupported || upinSupported)

                   {

                       aResult = UPinRequiredL();

                   }

                else

                    aResult = KErrNotSupported;

                break;

            case RMobilePhone::EUniversalPukRequired:

                if(wcdmaSupported || upinSupported)

                   {

                       aResult = UPukRequiredL();

                   }

                else

                    aResult = KErrNotSupported;

                break;

            case RMobilePhone::EPhonePasswordRequired:

                aResult = PassPhraseRequiredL();

                break;

            case RMobilePhone::EICCTerminated:

                SimLockEventL();

                break;

            default:

                break;

            }

    #if defined(_DEBUG)

    RDebug::Print( _L( "CSecurityHandler::HandleEventL() returning %d." ), aResult );

    #endif

    }

//

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

// CSecurityHandler::AskSecCodeL()

// For asking security code e.g in settings

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

//

EXPORT_C TBool CSecurityHandler::AskSecCodeL()

    {        

    /*****************************************************

    *    Series 60 Customer / ETel

    *    Series 60  ETel API

    *****************************************************/

    #if defined(_DEBUG)

    RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeL()"));

    #endif

    /* if code is still not initialized, then there's no need to ask it. This fixes the error when the RFS requests the code */

    const TUid KCRUidSCPLockCode = {0x2002677B};

    const TUint32 KSCPLockCodeDefaultLockCode = 0x00000001;

    CRepository* repository = CRepository::NewL(KCRUidSCPLockCode);

    TInt currentLockStatus = -1;

    TInt res=-1;

    res = repository->Get(KSCPLockCodeDefaultLockCode , currentLockStatus);

    #if defined(_DEBUG)

    RDebug::Printf( "%s %s (%u) res=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, res );

    RDebug::Printf( "%s %s (%u) currentLockStatus=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, currentLockStatus );

    #endif

    delete repository;

    if(res==0 && currentLockStatus==1)

        {

        // code is the default one; no need to request it.

        return ETrue;

        }

    /* end check for default code */

    iQueryCanceled = EFalse;

    RMobilePhone::TMobilePassword required_fourth;

    TInt ret = KErrNone;

    TInt err = KErrNone;

    TInt status = KErrNone;

            {

            switch(status)

                {        

                case KErrNone:

                    {

                    if(FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw ) &&

    										!(FeatureManager::FeatureSupported(KFeatureIdSapDeviceLockEnhancements)))

    								{

                        RSCPClient scpClient;

                        User::LeaveIfError( scpClient.Connect() );

                        CleanupClosePushL( scpClient );

                        TSCPSecCode newCode;

                        scpClient.StoreCode( newCode );

                  	}

                    return ETrue;

                    }                    

                case KErrGsmSSPasswordAttemptsViolation:

                case KErrLocked:

                    {

                    // security code blocked! 

                    break;

                    }

                case KErrGsm0707IncorrectPassword:

                case KErrAccessDenied:

                    {    

                    // code was entered erroneusly

                    }    

                default:

                    {

                    }

                }     

        } // while

    iQueryCanceled = ETrue;

    return ret;

    }

//

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

// CSecurityHandler::CancelSecCodeQuery()    

// Cancels PIN2 and security code queries

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

//

EXPORT_C void CSecurityHandler::CancelSecCodeQuery()                

    {

    #if defined(_DEBUG)

    RDebug::Print(_L("(SECUI)CSecurityHandler::CancelSecCodeQuery()"));

    #endif

    if (!iQueryCanceled)

        {

        iQueryCanceled = ETrue;

        if (iSecurityDlg != NULL)

            {

            delete iSecurityDlg;

            }

        if (iNoteDlg != NULL)

            {

            delete iNoteDlg;

            }

        iNoteDlg = NULL;

        iSecurityDlg = NULL;

        }

    }

//

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

// CSecurityHandler::AskSecCodeInAutoLock()

// for asking security code in autolock

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

//

EXPORT_C TBool CSecurityHandler::AskSecCodeInAutoLockL()

    {

    /*****************************************************

    *    Series 60 Customer / ETel

    *    Series 60  ETel API

    *****************************************************/

    #ifdef __WINS__

    return ETrue;

    #else

    #if defined(_DEBUG)

    RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL()"));

    #endif

    TInt res;

    CWait* wait;

    RMobilePhone::TMobilePhoneLockSetting lockChange(RMobilePhone::ELockSetDisabled);

    RMobilePhone::TMobilePhoneLock lockType = RMobilePhone::ELockPhoneDevice;

    #if defined(_DEBUG)

    RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() get autolock period"));

    #endif

    // get autolock period from Central Repository.

    CRepository* repository = CRepository::NewL(KCRUidSecuritySettings);

    TInt period = 0;

    res = repository->Get(KSettingsAutoLockTime, period);

    delete repository;

    #if defined(_DEBUG)

    RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() autolock period:%d"), res);

    #endif

    if (res == KErrNone)

        {

        // disable autolock in Domestic OS side too if autolock period is 0.

        if (period == 0 )

            {

            #if defined(_DEBUG)

            RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() Call SetLockSetting"));

            #endif

#ifdef RD_REMOTELOCK

            // If remote lock is enabled, don't disable the domestic OS device lock

            // since that would render the RemoteLock useless.

            // Instead just re-set the DOS lock to enabled which as a side effect

            // requests the security code from the user.

            TBool remoteLockStatus( EFalse );

            CRemoteLockSettings* remoteLockSettings = CRemoteLockSettings::NewL();

            if ( remoteLockSettings->GetEnabled( remoteLockStatus ) )

                {

                if ( remoteLockStatus )

                    {

                    // Remote lock is enabled

                    #ifdef _DEBUG

                    RDebug::Print( _L( "(SecUi)CSecurityHandler::AskSecCodeInAutoLockL() - RemoteLock is enabled: lockChange = RMobilePhone::ELockSetEnabled" ) );

                    #endif // _DEBUG

                    lockChange = RMobilePhone::ELockSetEnabled;

                    }

                else

                    {

                    // Remote lock is disabled

                    #ifdef _DEBUG

                    RDebug::Print( _L( "(SecUi)CSecurityHandler::AskSecCodeInAutoLockL() - RemoteLock is disabled: lockChange = RMobilePhone::ELockSetDisabled" ) );

                    #endif // _DEBUG

                    lockChange = RMobilePhone::ELockSetDisabled;

                    }

                }

            else

                {

                // Failed to get remote lock status

                #ifdef _DEBUG

                RDebug::Print( _L( "(SecUi)CSecurityHandler::AskSecCodeInAutoLockL() - Failed to get RemoteLock status" ) );

                #endif // _DEBUG

                }

            delete remoteLockSettings;

            remoteLockSettings = NULL;

#else // not defined RD_REMOTELOCK

                lockChange = RMobilePhone::ELockSetDisabled;

#endif // RD_REMOTELOCK

                wait = CWait::NewL();

                iPhone.SetLockSetting(wait->iStatus,lockType,lockChange);

                res = wait->WaitForRequestL();

                delete wait;

                #if defined(_DEBUG)

                RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() SetLockSetting RESULT:%d"), res);

                #endif

            }

        else

            {	// ask security code

                #if defined(_DEBUG)

            	RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() Ask sec code via notifier"));

            	#endif

                RNotifier codeQueryNotifier;

                User::LeaveIfError(codeQueryNotifier.Connect());

                CWait* wait = CWait::NewL();

                CleanupStack::PushL(wait);

                TInt queryResponse = 0;

                TPckg<TInt> response(queryResponse);

                TSecurityNotificationPckg params;

                params().iEvent = static_cast<TInt>(RMobilePhone::EPhonePasswordRequired);

                params().iStartup = EFalse;

                #if defined(_DEBUG)

    			RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() Start Notifier"));

    			#endif

                codeQueryNotifier.StartNotifierAndGetResponse(wait->iStatus, KSecurityNotifierUid,params, response);

                res = wait->WaitForRequestL();

                CleanupStack::PopAndDestroy(); // wait

              	#if defined(_DEBUG)

            	RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() results:"));

            	RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() res:%d"), res);

            	RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() queryResponse:%d"), queryResponse);

            	#endif

            	if(res == KErrNone)

                	res = queryResponse;

            }

        }

    else

        {

        #if defined(_DEBUG)

        RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() KERRSOMETHING:Call SetLockSetting"));

        #endif

#ifdef RD_REMOTELOCK

        // If remote lock is enabled, don't disable the domestic OS device lock

        // since that would render the RemoteLock useless.

        // Instead just re-set the DOS lock to enabled which as a side effect

        // requests the security code from the user.

        TBool remoteLockStatus( EFalse );

        CRemoteLockSettings* remoteLockSettings = CRemoteLockSettings::NewL();

        if ( remoteLockSettings->GetEnabled( remoteLockStatus ) )

            {

            if ( remoteLockStatus )

                {

                // Remote lock is enabled

                #ifdef _DEBUG

                RDebug::Print( _L( "(SecUi)CSecurityHandler::AskSecCodeInAutoLockL() - Failed to get AutoLock status and RemoteLock is enabled: lockChange = RMobilePhone::ELockSetEnabled" ) );

                #endif // _DEBUG