/*

* 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>

#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>

#include "SecQueryUi.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 ( 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

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

    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

                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;

            }

    }

//

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

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

    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 status = KErrNone;

		RMobilePhone::TMobilePassword iSecUi_password;

            {

		        RMobilePhone::TMobilePhoneSecurityCode secCodeType;

		        secCodeType = RMobilePhone::ESecurityCodePhonePassword;

						/* request PIN using QT */

						CSecQueryUi *iSecQueryUi;

						iSecQueryUi = CSecQueryUi::NewL();

						RDebug::Print( iSecUi_password );

						delete iSecQueryUi;

						/* end request PIN using QT */

		            {

		            ret = EFalse;

		            return ret;

		            }

            switch(status)

                {        

                case KErrNone:

                    {

                    if(FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw ) &&

    										!(FeatureManager::FeatureSupported(KFeatureIdSapDeviceLockEnhancements)))

    								{

                        RSCPClient scpClient;

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

                        CleanupClosePushL( scpClient );

                        TSCPSecCode newCode;

                        newCode.Copy( iSecUi_password );

                        scpClient.StoreCode( newCode );

                        CleanupStack::PopAndDestroy(); //scpClient

                  	}

                    iQueryCanceled = ETrue;	// TODO

                    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

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

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

                // this will eventually call PassPhraseRequiredL

                res = wait->WaitForRequestL();

                CleanupStack::PopAndDestroy(); // wait

            	if(res == KErrNone)

                	res = queryResponse;

        }

    else

#ifdef RD_REMOTELOCK