/*

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

    // Destructor sets thisDestroyed to ETrue

    TBool thisDestroyed( EFalse );

    iDestroyedPtr = &thisDestroyed;

    iQueryCanceled = EFalse;

    RMobilePhone::TMobilePassword password;

    RMobilePhone::TMobilePassword required_fourth;

    TInt ret = KErrNone;

    TInt err = KErrNone;

    TInt status = KErrNone;

    if(FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw ) &&

    		FeatureManager::FeatureSupported(KFeatureIdSapDeviceLockEnhancements))

    {

        // Connect to the SCP server, and request the code query

        RSCPClient scpClient;

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

        CleanupClosePushL( scpClient );      

        status = scpClient.SecCodeQuery( password, 

                                      RSCPClient::SCP_OK_CANCEL,

                                      EFalse,

                                      0 );         

        if ( status != KErrCancel )

            {

            // Set this "true" to indicate that the input wasn't cancelled

            ret = ETrue;

            }

        else

            {

            ret = EFalse;

            }

        CleanupStack::PopAndDestroy(); //scpClient                       

  }

  else

  {

    iSecurityDlg = new (ELeave) CCodeQueryDialog (password,SEC_C_SECURITY_CODE_MIN_LENGTH,SEC_C_SECURITY_CODE_MAX_LENGTH,ESecUiNone);

    #ifdef __COVER_DISPLAY

    iSecurityDlg->PublishDialogL(SecondaryDisplay::ECmdShowSecurityQuery, SecondaryDisplay::KCatStartup);

    CAknMediatorFacade* covercl = AknMediatorFacade(iSecurityDlg); // uses MOP, so control provided

	if (covercl) // returns null if __COVER_DISPLAY is not defined

    	{

    	// … -  add data that cover ui is interested in

    	covercl->BufStream().WriteInt32L(SecondaryDisplay::EShowSecCode);// adds int to additional data to be posted to cover ui

    	covercl->BufStream().CommitL(); // no more data to send so commit buf

     	}  

    #endif //__COVER_DISPLAY

	    CSecUiLockObserver* deviceLockStatusObserver = CSecUiLockObserver::NewL(iSecurityDlg);

		CleanupStack::PushL(deviceLockStatusObserver);

		err =KErrNone;

	    TRAP(err,ret = iSecurityDlg->ExecuteLD(R_SECURITY_QUERY));

		CleanupStack::PopAndDestroy(deviceLockStatusObserver);

  }

    // check if CSecurityHandler has been "killed"

    if ( thisDestroyed )

        {

        return EFalse;

        }

    iDestroyedPtr = NULL;

    iSecurityDlg = NULL;

    if (err != KErrNone)

        {

        User::Leave(err);

        }

    if (ret)

        {

        while (!iQueryCanceled)

            {

	           if (!FeatureManager::FeatureSupported(KFeatureIdSapDeviceLockEnhancements))

		           {           

		                RMobilePhone::TMobilePhoneSecurityCode secCodeType;

		                secCodeType = RMobilePhone::ESecurityCodePhonePassword;

		                CWait* wait = CWait::NewL();

		                iPhone.VerifySecurityCode(wait->iStatus,secCodeType, password, required_fourth);

		                status = wait->WaitForRequestL();

		                delete wait;

		           }

            switch(status)

                {        

                case KErrNone:

                    {

                    if(FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw ) &&

    										!(FeatureManager::FeatureSupported(KFeatureIdSapDeviceLockEnhancements)))

    								{

                        RSCPClient scpClient;

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

                        CleanupClosePushL( scpClient );

                        TSCPSecCode newCode;

                        newCode.Copy( password );

                        scpClient.StoreCode( newCode );

                        CleanupStack::PopAndDestroy(); //scpClient  

                  	}

                    iQueryCanceled = ETrue;

                    return ETrue;

                    }                    

                case KErrGsmSSPasswordAttemptsViolation:

                case KErrLocked:

                    {

                    iDestroyedPtr = &thisDestroyed;

                    // security code blocked! 

                    iNoteDlg = new (ELeave) CAknNoteDialog(REINTERPRET_CAST(CEikDialog**,&iNoteDlg));

                    iNoteDlg->SetTimeout(CAknNoteDialog::ELongTimeout);

                    iNoteDlg->SetTone(CAknNoteDialog::EErrorTone);

                    err =KErrNone;

                    TRAP(err,iNoteDlg->ExecuteLD(R_SEC_BLOCKED));

                    // check if CSecurityHandler has been "killed"

                    if ( thisDestroyed )

                        {

                        return EFalse;

                        }

                    iDestroyedPtr = NULL;

                    iNoteDlg = NULL;

                    if (err != KErrNone)

                        {

                        User::Leave(err);

                        }

                    break;

                    }

                case KErrGsm0707IncorrectPassword:

                case KErrAccessDenied:

                    {    

                    iDestroyedPtr = &thisDestroyed;

                    // code was entered erroneusly

                    iNoteDlg = new (ELeave) CAknNoteDialog(REINTERPRET_CAST(CEikDialog**,&iNoteDlg));

                    iNoteDlg->SetTimeout(CAknNoteDialog::ELongTimeout);

                    iNoteDlg->SetTone(CAknNoteDialog::EErrorTone);

                    err =KErrNone;

                    TRAP(err,iNoteDlg->ExecuteLD(R_CODE_ERROR));    

                    // check if CSecurityHandler has been "killed"

                    if ( thisDestroyed )

                        {

                        return EFalse;

                        }

                    iDestroyedPtr = NULL;

                    iNoteDlg = NULL;

                    if (err != KErrNone)

                        {

                        User::Leave(err);

                        }

                    break;

                    }    

                default:

                    {

                    iDestroyedPtr = &thisDestroyed;

                    err =KErrNone;

                    TRAP(err,ShowGenericErrorNoteL(status));

                    // check if CSecurityHandler has been "killed"

                    if ( thisDestroyed )

                        {

                        return EFalse;

                        }

                    iDestroyedPtr = NULL;

                    iNoteDlg = NULL;

                    if (err != KErrNone)

                        {

                        User::Leave(err);

                        }    

                    break;

                    }

                }     

            if (iQueryCanceled)

                {

                ret = EFalse;

                break;

                }    

            password = _L("");

            iDestroyedPtr = &thisDestroyed;

             if(FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw ) &&

    						FeatureManager::FeatureSupported(KFeatureIdSapDeviceLockEnhancements))  

    				{       

                // Connect to the SCP server, and request the code query

                RSCPClient scpClient;

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

                CleanupClosePushL( scpClient );

                status = scpClient.SecCodeQuery( password, 

                                      RSCPClient::SCP_OK_CANCEL,

                                      EFalse,

                                      0 ); 

                if ( status != KErrCancel )

                    {

                    // Set this "true" to indicate that the input wasn't cancelled

                    ret = ETrue;

                    }

                else

                    {

                    ret = EFalse;

                    }                                

                CleanupStack::PopAndDestroy(); //scpClient                              

          }

          else

          {

            iSecurityDlg = new (ELeave) CCodeQueryDialog (password,SEC_C_SECURITY_CODE_MIN_LENGTH,SEC_C_SECURITY_CODE_MAX_LENGTH,ESecUiNone);

            CSecUiLockObserver* deviceLockStatusObserver = CSecUiLockObserver::NewL(iSecurityDlg);

						CleanupStack::PushL(deviceLockStatusObserver);

						err =KErrNone;

            TRAP(err,ret = iSecurityDlg->ExecuteLD(R_SECURITY_QUERY));         

						CleanupStack::PopAndDestroy(deviceLockStatusObserver);

          }

            // check if CSecurityHandler has been "killed"

            if ( thisDestroyed )

                {

                return EFalse;

                }

            iDestroyedPtr = NULL;

            iSecurityDlg = NULL;

            if (err != KErrNone)

                {

                User::Leave(err);

                }

            if (!ret)

                break;

        } // while

    }    // if

    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;