/*

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

#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

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

// qtdone

EXPORT_C CSecurityHandler::CSecurityHandler(RMobilePhone& aPhone) :

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

    {

    RDEBUG("0", 0);

    TInt result = iCustomPhone.Open(aPhone);

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

    }

//

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

// CSecurityHandler::~CSecurityHandler()

// Destructor

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

// qtdone

EXPORT_C CSecurityHandler::~CSecurityHandler()

    {

    RDEBUG("0", 0);

    if (iDestroyedPtr)

        {

        *iDestroyedPtr = ETrue;

        iDestroyedPtr = NULL;

        }

    CancelSecCodeQuery();

    iCustomPhone.Close();

    FeatureManager::UnInitializeLib();

    }

//

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

// CSecurityHandler::HandleEventL()

// Handles different security events

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

// qtdone

EXPORT_C void CSecurityHandler::HandleEventL(

        RMobilePhone::TMobilePhoneSecurityEvent aEvent)

    {

    RDEBUG("0", 0);

    TInt result = KErrNone;

    HandleEventL(aEvent, result);

    }

//

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

// CSecurityHandler::HandleEventL()

// Handles different security events

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

// qtdone

EXPORT_C void CSecurityHandler::HandleEventL(

        RMobilePhone::TMobilePhoneSecurityEvent aEvent, TBool aStartup,

        TInt& aResult)

    {

    RDEBUG("0", 0);

    iStartup = aStartup;

    HandleEventL(aEvent, aResult);

    }

//

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

// CSecurityHandler::HandleEventL()

// Handles different security events

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

// qtdone

EXPORT_C void CSecurityHandler::HandleEventL(

        RMobilePhone::TMobilePhoneSecurityEvent aEvent, TInt& aResult)

    {

    RDEBUG("0", 0);

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

     *    Series 60 Customer / ETel

     *    Series 60  ETel API

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

    TBool wcdmaSupported(

            FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma));

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

    RDEBUG("aEvent", aEvent);

    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

            Puk1RequiredL();

            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;

        }

    RDEBUG("aResult", aResult);

    }

//

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

// CSecurityHandler::AskSecCodeL()

// For asking security code e.g in settings

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

// qtdone

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;

    TInt lAlphaSupported = 0;

    TInt lCancelSupported = 0;

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

    RDEBUG("res", res);

    RDEBUG("currentLockStatus", 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;

    TInt queryAccepted = KErrCancel;

    while (queryAccepted != KErrNone)

        {

        RMobilePhone::TMobilePhoneSecurityCode secCodeType;

        secCodeType = RMobilePhone::ESecurityCodePhonePassword;

        /* request PIN using QT */

        CSecQueryUi *iSecQueryUi;

        RDEBUG("CSecQueryUi", 0);

        iSecQueryUi = CSecQueryUi::NewL();

        lAlphaSupported = ESecUiAlphaSupported;

        lCancelSupported = ESecUiCancelSupported;

        TBuf<0x100> title;

        title.Zero();

        title.Append(_L("AskSecCodeL"));

        title.Append(_L("#"));

        title.AppendNum(-1);

        queryAccepted

                = iSecQueryUi->SecQueryDialog(title, iSecUi_password,

                        SEC_C_SECURITY_CODE_MIN_LENGTH,

                        SEC_C_SECURITY_CODE_MAX_LENGTH, ESecUiSecretSupported

                                | lAlphaSupported | lCancelSupported

                                | secCodeType /*aMode*/);

        RDEBUG("iSecUi_password", 0);

        RDebug::Print(iSecUi_password);

        RDEBUG("delete", 0);

        delete iSecQueryUi;

        RDEBUG("queryAccepted", queryAccepted);

        /* end request PIN using QT */

        if (queryAccepted != KErrNone)

            {

            ret = EFalse;

            return ret;

            }

        CWait* wait = CWait::NewL();

        RDEBUG("VerifySecurityCode", 0);

        iPhone.VerifySecurityCode(wait->iStatus, secCodeType,

                iSecUi_password, required_fourth);

        RDEBUG("WaitForRequestL", 0);

        status = wait->WaitForRequestL();

        RDEBUG("status", status);

        delete wait;

#ifdef __WINS__

        if(status==KErrNotSupported || status == KErrTimedOut)

            {

            RDEBUG( "status", status );

            status=KErrNone;

            }

#endif

        ret = ETrue;

        queryAccepted = KErrCancel; // because it's not yet validated

        switch (status)

            {

            case KErrNone:

                {

                if (FeatureManager::FeatureSupported(

                        KFeatureIdSapTerminalControlFw)

                        && !(FeatureManager::FeatureSupported(

                                KFeatureIdSapDeviceLockEnhancements)))

                    {

                    RDEBUG("calling RSCPClient", 0);

                    RSCPClient scpClient;

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

                    CleanupClosePushL(scpClient);

                    TSCPSecCode newCode;

                    newCode.Copy(iSecUi_password);

                    scpClient.StoreCode(newCode);

                    RDEBUG("called StoreCode", 1);

                    CleanupStack::PopAndDestroy(); //scpClient

                    queryAccepted = KErrNone;

                    }

                iQueryCanceled = ETrue; // TODO

                return ETrue;

                }

            case KErrGsmSSPasswordAttemptsViolation:

            case KErrLocked:

                {

                // security code blocked! 

                CSecuritySettings::ShowResultNoteL(R_SEC_BLOCKED,

                        CAknNoteDialog::EErrorTone);

                break;

                }

            case KErrGsm0707IncorrectPassword:

            case KErrAccessDenied:

                {

                // code was entered erroneusly

                CSecuritySettings::ShowResultNoteL(R_CODE_ERROR,

                        CAknNoteDialog::EErrorTone);

                }

            default:

                {

                CSecuritySettings::ShowResultNoteL(status,

                        CAknNoteDialog::EErrorTone);

                }

            }

        } // while

    iQueryCanceled = ETrue;

    return ret;

    }

//

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

// CSecurityHandler::CancelSecCodeQuery()    

// Cancels PIN2 and security code queries

// TODO is this used?

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

// qtdone

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

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

// qtdone

EXPORT_C TBool CSecurityHandler::AskSecCodeInAutoLockL()

    {

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

     *    Series 60 Customer / ETel

     *    Series 60  ETel API

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

    RDEBUG("0", 0);

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

    RDEBUG("res", res);

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

        RDEBUG("period", period);

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

                {

                RDEBUG( "0", 0 );

                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

            RDEBUG("lockChange", lockChange);

            wait = CWait::NewL();

            RDEBUG("0", 0);

            // this also calls PassPhraseRequiredL ???

            RDEBUG("SetLockSetting", 1);

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

            res = KErrNone;

            RDEBUG("WaitForRequestL", 0);

            res = wait->WaitForRequestL();

            RDEBUG("res", res);

            delete wait;

#if defined(_DEBUG)

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

#endif

            } // from   period == 0

        else

            { // ask security code

#if defined(_DEBUG)

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

#endif

            RDEBUG("0", 0);

            RNotifier codeQueryNotifier;

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

            CWait* wait = CWait::NewL();

            CleanupStack::PushL(wait);

            TInt queryResponse = 0;

            TPckg<TInt> response(queryResponse);

            RDEBUG("0", 0);

            TSecurityNotificationPckg params;