/*

 * 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 <e32notif.h>

#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 <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 "SecUi.h"

#include "secuisecurityhandler.h"

#include "secuicodequerydialog.h"

#include "secuisecuritysettings.h"

#include "SecUiWait.h"

// #include "SecUiLockObserver.h"

#include <RemoteLockSettings.h>

#include <StringLoader.h>

#include <featmgr.h>

#include <hb/hbcore/hbtextresolversymbian.h>

#include "SecQueryUi.h"

//  LOCAL CONSTANTS AND MACROS

const TInt KMaxNumberOfPUKAttempts(10);

const TInt KMaxNumberOfPINAttempts(3);

// not used

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

    RDEBUG("result", result);

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

    _LIT(KFileName, "secui_");

    _LIT(KPath, "z:/resource/qt/translations/");

    RDEBUG("HbTextResolverSymbian", 0);

    result = HbTextResolverSymbian::Init(KFileName, KPath);

    RDEBUG("result", result);

    }

//

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

// CSecurityHandler::~CSecurityHandler()

// Destructor

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

// qtdone

EXPORT_C CSecurityHandler::~CSecurityHandler()

    {

    RDEBUG("0", 0);

    if (iDestroyedPtr)

        {

        *iDestroyedPtr = ETrue;

        iDestroyedPtr = NULL;

        }

    RDEBUG("calling CancelOpenQuery", 0);

    TInt err = CancelOpenQuery(-1);

    RDEBUG("err", err);

    iCustomPhone.Close();

    FeatureManager::UnInitializeLib();

    RDEBUG("1", 1);

    }

//

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

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

            RDEBUG("RMobilePhone::EPin1Required", 0)

            ;

            aResult = Pin1RequiredL();

            break;

        case RMobilePhone::EPuk1Required:

            RDEBUG("RMobilePhone::EPuk1Required", 0)

            ;

            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:

            RDEBUG("default", aEvent)

            ;

            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

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

    RDEBUG("0", 0);

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

    RMobilePhone::TMobilePassword iSecUi_password;

    res = repository->Get(KSCPLockCodeDefaultLockCode, currentLockStatus);	// 0x3039 = 12345

    RDEBUG("res", res);

    RDEBUG("currentLockStatus", currentLockStatus);

    delete repository;

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

        {

        // code is the default one

        RDEBUG("code is the default one; supply as default", 1);

        iSecUi_password.Copy(_L("12345"));

        // RDEBUG("code is the default one; no need to request it", 1);

        // return ETrue;

        }

    // end check for default code

    RMobilePhone::TMobilePassword required_fourth;

    TInt ret = KErrNone;

    TInt status = KErrNone;

    TInt queryAccepted = KErrCancel;

    while (queryAccepted != KErrNone)

        {

        RMobilePhone::TMobilePhoneSecurityCode secCodeType;

        secCodeType = RMobilePhone::ESecurityCodePhonePassword;

        /* request PIN using QT */

        CSecQueryUi *iSecQueryUi;

        RDEBUG("CSecQueryUi", 0);

        iSecQueryUi = CSecQueryUi::NewL();

        iQueryCanceled = EFalse;

        lAlphaSupported = ESecUiAlphaSupported;

        lCancelSupported = ESecUiCancelSupported;

        TBuf<0x100> title;

        title.Zero();

        title.Append(stringHolder->Des());

        CleanupStack::PopAndDestroy(stringHolder);

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

        title.AppendNum(-1);	// Don't know the number of remaining attempts

        queryAccepted = iSecQueryUi->SecQueryDialog(title, iSecUi_password, SEC_C_SECURITY_CODE_MIN_LENGTH, SEC_C_SECURITY_CODE_MAX_LENGTH, ESecUiSecretSupported | lAlphaSupported

                | lCancelSupported | secCodeType);

        RDEBUG("iSecUi_password", 0);

        RDEBUGSTR(iSecUi_password);

        RDEBUG("delete", 0);

        iQueryCanceled = ETrue;

        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;

                    RDEBUG("iSecUi_password", 1);

                    RDEBUGSTR(iSecUi_password);

                    newCode.Copy(iSecUi_password);

                    RDEBUG(

                            "!!!!!!! ***** deprecated **** !!!!! scpClient.StoreCode",

                            0);

                    scpClient.StoreCode(newCode);

                    RDEBUG("called StoreCode", 1);

                    CleanupStack::PopAndDestroy(); //scpClient

                    queryAccepted = KErrNone;

                    }

                iQueryCanceled = ETrue;

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

                break;

                }

            default:

                {

                CSecuritySettings::ShowResultNoteL(status, CAknNoteDialog::EErrorTone);

                }

            }

        } // while

    iQueryCanceled = ETrue;

    return ret;

    }

//

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

// Cancels all security code queries

// aStatus = -1     from destructor

// aStatus =  1     from API. Will kill all dialogs through signal P&S

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

// qtdone

TInt CSecurityHandler::CancelOpenQuery(TInt aStatus)

    {

    RDEBUG("aStatus", aStatus);

    RDEBUG("iQueryCanceled", iQueryCanceled);

    TInt res = 0;

    if (aStatus == 1) // also signal all other dialogs

        {

        RDEBUG(

                "set KSecurityUIsDismissDialog to ESecurityUIsDismissDialogOn",

                ESecurityUIsDismissDialogOn);

        TInt err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsDismissDialog, ESecurityUIsDismissDialogOn);

        RDEBUG("err", err);

        res += 1;

        }

    if (!iQueryCanceled)

        {

        // notify all dialogs, in particular SecUiNotificationDialog::subscriberKSecurityUIsDismissDialogChanged

        // this will cancel only the dialog which was opened by same client.

        res += 0x10;

        iQueryCanceled = ETrue;

        if (iSecurityDlg != NULL)

            {

            RDEBUG("deleting iSecurityDlg", 0);

            res += 0x100;

            delete iSecurityDlg;

            }

        if (iNoteDlg != NULL)

            {

            RDEBUG("deleting iNoteDlg", 0);

            res += 0x1000;

            delete iNoteDlg;

            }

        iNoteDlg = NULL;

        iSecurityDlg = NULL;

        }

    res += 0x10000;

    RDEBUG("res", res);

    return res;

    }

//

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

// CSecurityHandler::CancelSecCodeQuery()    

// Cancels PIN2 and security code queries

// this is used by rfsHandler

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

// qtdone

EXPORT_C void CSecurityHandler::CancelSecCodeQuery()

    {

    RDEBUG("0", 0);

    TInt err = CancelOpenQuery(1);

    RDEBUG("err", err);

    }

//

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

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

    TInt res;

    CWait* wait;

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

    RMobilePhone::TMobilePhoneLock lockType = RMobilePhone::ELockPhoneDevice;

    // get autolock period from Central Repository.

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

    TInt period = 0;

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

    delete repository;

    RDEBUG("res", res);

    RDEBUG("period", period);

    if (res == KErrNone)

        {

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

        if (period == 0)

            {

            RDEBUG("period", period);

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

                    lockChange = RMobilePhone::ELockSetEnabled;

                    RDEBUG("lockChange", lockChange);

                    }

                else

                    {

                    // Remote lock is disabled

                    lockChange = RMobilePhone::ELockSetDisabled;

                    RDEBUG("lockChange", lockChange);

                    }

                }

            else

                {

                // Failed to get remote lock status

                RDEBUG("Failed", lockChange);

                }

            delete remoteLockSettings;

            remoteLockSettings = NULL;

            RDEBUG("lockChange", lockChange);

            wait = CWait::NewL();

            RDEBUG("0", 0);

            // this also calls PassPhraseRequiredL ???

            RDEBUG("SetLockSetting", 1);

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

            res = KErrNone;