* 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 changing security settings.

 *

 *

 */

#include "SecUi.h"

#include <hb/hbcore/hbtextresolversymbian.h>

#include "SecQueryUi.h"

#include <hb/hbwidgets/hbdevicemessageboxsymbian.h>

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

 *    Series 60 Customer / TSY

 *    Needs customer TSY implementation

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

const TInt KTriesToConnectServer(2);

const TInt KTimeBeforeRetryingServerConnection(50000);

const TInt PhoneIndex(0);

const TInt KMaxNumberOfPINAttempts(3); // is this valid also for PIN2 ?

#define ESecUiTypeLock                  0x00100000

#define KErrTDevicelockPolicies					0x10207837

// qtdone

// qtdone

// qtdone

     *    Series 60 Customer / ETel

     *    Series 60  ETel API

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

     *    Series 60 Customer / TSY

     *    Needs customer TSY implementation

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

    RDEBUG("0", 0);

    TInt err(KErrGeneral);

    TInt thisTry(0);

     fails on connections are possible, at least on some servers */

    while ((err = iServer.Connect()) != KErrNone && (thisTry++) <= KTriesToConnectServer)

        User::After( KTimeBeforeRetryingServerConnection);

    User::LeaveIfError(err);

    err = iServer.LoadPhoneModule(KMmTsyModuleName);

    if (err != KErrAlreadyExists)

        User::LeaveIfError(err);

    User::LeaveIfError(iPhone.Open(iServer, PhoneInfo.iName));

    iSecurityHandler = new (ELeave) CSecurityHandler(iPhone);

    _LIT(KFileName, "secui_");

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

    RDEBUG("HbTextResolverSymbian", 0);

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

    RDEBUG("result", result);

// qtdone

     *    Series 60 Customer / ETel

     *    Series 60  ETel API

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

     *    Series 60 Customer / TSY

     *    Needs customer TSY implementation

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

    if (iWait->IsActive())

        {

        RDEBUG("CancelAsyncRequest", 0);

        switch (iWait->GetRequestType())

            { //inform query that it has beeen canceled

            case EMobilePhoneSetLockSetting:

            case EMobilePhoneSetFdnSetting:

                RProperty::Set(KPSUidSecurityUIs, KSecurityUIsQueryRequestCancel, ESecurityUIsQueryRequestCanceled);

                break;

            default:

                break;

            }

        }

// qtdone

    RDEBUG("0", 0);

    RMobilePhone::TMobilePassword iOldPassword;

    RMobilePhone::TMobilePassword iNewPassword;

    TInt iFlags = ESecUiTypeLock;

    iOldPassword.Copy(_L(""));

    iNewPassword.Copy(_L(""));

    TBuf<0x80> iCaption;

    iCaption.Copy(_L("ChangePinL")); // no need to translate. Not used

    TInt iShowError = 1;

    TInt err = ChangePinParamsL(iOldPassword, iNewPassword, iFlags, iCaption, iShowError);

    RDEBUG("err", err);

// qtdone

    RDEBUG("0", 0);

    RMobilePhone::TMobilePassword iOldPassword;

    RMobilePhone::TMobilePassword iNewPassword;

    TInt iFlags = ESecUiTypeLock;

    iOldPassword.Copy(_L(""));

    iNewPassword.Copy(_L(""));

    TBuf<0x80> iCaption;

    iCaption.Copy(_L("ChangeUPinL")); // no need to translate. Not used

    TInt iShowError = 1;

    TInt err = ChangeUPinParamsL(iOldPassword, iNewPassword, iFlags, iCaption, iShowError);

    RDEBUG("err", err);

// qtdone

EXPORT_C void CSecuritySettings::ChangePin2L()

    {

    RDEBUG("0", 0);

    RMobilePhone::TMobilePassword iOldPassword;

    RMobilePhone::TMobilePassword iNewPassword;

    TInt iFlags = ESecUiTypeLock;

    iOldPassword.Copy(_L(""));

    iNewPassword.Copy(_L(""));

    TBuf<0x80> iCaption;

    iCaption.Copy(_L("ChangePin2L")); // no need to translate. Not used

    TInt iShowError = 1;

    TInt err = ChangePin2ParamsL(iOldPassword, iNewPassword, iFlags, iCaption, iShowError);

    RDEBUG("err", err);

    }

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

// CSecuritySettings::ChangeSecCodeL()

// Changes security code 

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

// qtdone

EXPORT_C void CSecuritySettings::ChangeSecCodeL()

    {

    RDEBUG("0", 0);

    RMobilePhone::TMobilePassword iOldPassword;

    RMobilePhone::TMobilePassword iNewPassword;

    TInt iFlags = 0;

    iOldPassword.Copy(_L(""));

    iNewPassword.Copy(_L(""));

    TBuf<0x80> iCaption;

    iCaption.Copy(_L("ChangeSecCodeL")); // no need to translate. Not used

    TInt iShowError = 1;

    TInt err = ChangeSecCodeParamsL(iOldPassword, iNewPassword, iFlags, iCaption, iShowError);

    RDEBUG("err", err);

    }

//

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

// CSecuritySettings::ChangeAutoLockPeriodL()

// Changes autolock period

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

// qtdone

EXPORT_C TInt CSecuritySettings::ChangeAutoLockPeriodL(TInt aPeriod)

    {

    TInt ret = 0;

    RDEBUG("aPeriod", aPeriod);

    RMobilePhone::TMobilePassword iOldPassword;

    TInt iFlags = 0;

    TInt iShowError = 1;

    TBuf<0x80> iCaption;

    iCaption.Copy(_L("ChangeAutoLockPeriodL")); // no need to translate. Not used

    iOldPassword.Copy(_L(""));

    ret = ChangeAutoLockPeriodParamsL(aPeriod, iOldPassword, iFlags, iCaption, iShowError);

    RDEBUG("ret", ret);

    return ret;

    }

//

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

// CSecuritySettings::ChangeRemoteLockStatusL()

// Changes remote lock status (on/off)

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

// no qtdone

EXPORT_C TInt CSecuritySettings::ChangeRemoteLockStatusL(TBool& aRemoteLockStatus, TDes& aRemoteLockCode, TInt aAutoLockPeriod)

    {

    TInt retValue(KErrNone);

    RDEBUG("aRemoteLockStatus", aRemoteLockStatus);

    RDEBUG("aAutoLockPeriod", aAutoLockPeriod);

    if (aRemoteLockStatus)

        {

        aRemoteLockStatus = ETrue;

        // If user wishes to enable remote lock

        // a new remote lock code is required.

        // RemoteLockCodeQueryL also 

        retValue = RemoteLockCodeQueryL(aRemoteLockCode);

        }

    else

        {

        aRemoteLockStatus = EFalse;

        retValue = KErrNone;

        // TODO this should calculate aAutoLockPeriod itself, and not trust the input

        // Check whether AutoLock is enabled (timeout value greater 

        // than zero) or not. If AutoLock is enabled the domestic OS 

        // device lock should be left enabled.

        if (aAutoLockPeriod == 0)

            {

            // Disable lock setting from domestic OS

            retValue = RemoteLockSetLockSettingL(EFalse);

            }

        else

            {

            // If AutoLock is enabled, don't disable the DOS device lock

            // Re-set (enable) the domestic OS device lock because as a 

            // side effect it requires the security code from the user

            retValue = RemoteLockSetLockSettingL(ETrue);

            }

        }

    RDEBUG( "retValue", retValue );

    return retValue;

    }

//

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

// CSecuritySettings::RemoteLockCodeQueryL()

// Pops up remote lock code query. Requires user to enter a new remote lock 

// code (RemoteMsg) twice and if they match enables the domestic OS device lock (which as 

// a side effect pops up security code query).

// Note: if the RemoteMsg is cancelled, nevertheless the lock is activated. This is done because the code is askedirst, and the only way to do so is by enabling the lock.

// This is not a problem, because:

// a) first the RemoteMsg is enable, and this function is used to change it

// b) if lock was disabled, the "change RemoteMsg" menu is not available.

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

// qtdone

TInt CSecuritySettings::RemoteLockCodeQueryL(TDes& aRemoteLockCode)

    {

    TInt retValue(KErrNone);

    // This is done because lock-code needs to be asked first.

    // Enable lock setting in domestic OS. It is safe to enable the 

    // lock setting since RemoteLock API requires remote locking to

    // be enabled when changing or setting the remote lock message.

    retValue = RemoteLockSetLockSettingL(ETrue);

    RDEBUG( "retValue", retValue );

    if (retValue != KErrNone)

        return retValue;

    aRemoteLockCode.Zero();

    TInt queryAccepted = KErrCancel;

    queryAccepted = KErrCancel;

    CSecQueryUi * iSecQueryUi;

    iSecQueryUi = CSecQueryUi::NewL();

    // this queries both, and verifies itself

    TBuf<0x100> title;

    title.Zero();

    HBufC* stringHolder = HbTextResolverSymbian::LoadLC(_L("txt_pin_code_dialog_new_rem_code"));

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

    CleanupStack::PopAndDestroy(stringHolder);

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

    HBufC* stringHolder2 = HbTextResolverSymbian::LoadLC(_L("Verify"));

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

    CleanupStack::PopAndDestroy(stringHolder2);

    queryAccepted = iSecQueryUi->SecQueryDialog(title, aRemoteLockCode, SEC_REMOTELOCK_CODE_MIN_LENGTH, SEC_REMOTELOCK_CODE_MAX_LENGTH, ESecUiAlphaSupported

            | ESecUiCancelSupported | ESecUiEmergencyNotSupported | ESecUiNone);

    RDEBUG("aRemoteLockCode", 0);

    RDEBUGSTR(aRemoteLockCode);

    RDEBUG("queryAccepted", queryAccepted);

    delete iSecQueryUi;

    if (queryAccepted != KErrNone)

        return KErrAbort;

    // Check that the new remote lock code doesn't match the security code of the device.

    RMobilePhone::TMobilePhoneSecurityCode secCodeType = RMobilePhone::ESecurityCodePhonePassword;

    RMobilePhone::TMobilePassword securityCode;

    RMobilePhone::TMobilePassword unblockCode; // Required here only as a dummy parameter 

    securityCode = aRemoteLockCode;

    RDEBUG( "EMobilePhoneVerifySecurityCode", EMobilePhoneVerifySecurityCode );

    iWait->SetRequestType(EMobilePhoneVerifySecurityCode);

    RDEBUG( "VerifySecurityCode", 0 );

    iPhone.VerifySecurityCode(iWait->iStatus, secCodeType, securityCode, unblockCode);

    RDEBUG( "WaitForRequestL", 0 );

    TInt res = iWait->WaitForRequestL();

    RDEBUG( "WaitForRequestL res", res );

#ifdef __WINS__

    if (res == KErrNotSupported || res == KErrTimedOut)

        res = KErrGsm0707IncorrectPassword; // KErrGsm0707IncorrectPassword = incorrect code

#endif

    RDEBUG( "KErrGsm0707IncorrectPassword", KErrGsm0707IncorrectPassword );

    if (res == KErrNone)

        {

        // The message is also valid as a lock-code, this means that

        // remote lock code matches the security code 

        // and that is not allowed

        RDEBUG( "return KErrCancel because msg matches code", KErrCancel );

        ShowResultNoteL(R_REMOTELOCK_INVALID_CODE, CAknNoteDialog::EErrorTone);

        return KErrCancel;

        }

    RDEBUG( "retValue", retValue );

    return retValue;

    }

//

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

// CSecuritySettings::RemoteLockSetLockSettingL()

// Changes lock setting in domestic OS. Changing the domestic OS lock setting

// requires user to enter the security code.

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

// qtdone

TInt CSecuritySettings::RemoteLockSetLockSettingL(TBool aLockSetting)

    {

    TInt retValue(KErrNone);

    RDEBUG( "aLockSetting", aLockSetting );

    RMobilePhone::TMobilePhoneLockSetting lockSetting = RMobilePhone::ELockSetEnabled;

    RMobilePhone::TMobilePhoneLock lockType = RMobilePhone::ELockPhoneDevice;

    RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;

    RMobilePhone::TMobilePhoneLockInfoV1Pckg lockInfoPkg(lockInfo);

    //get lock info

    iWait->SetRequestType(EMobilePhoneGetLockInfo);

    RDEBUG("GetLockInfo", 0);

    iPhone.GetLockInfo(iWait->iStatus, lockType, lockInfoPkg);

    RDEBUG("WaitForRequestL", 0);

    TInt status = iWait->WaitForRequestL();

    RDEBUG("WaitForRequestL status", status);

#ifdef __WINS__

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

        {

        lockInfo.iSetting = RMobilePhone::ELockSetDisabled;

        status = KErrNone;

        }

#endif

    User::LeaveIfError(status);

    RDEBUG("current lockInfo.iSetting", lockInfo.iSetting);

    // disabled->disabled   should not happen

    // enabled->enabled     happens because a change of message also forces a code re-validation

    if (aLockSetting)

        {

        lockSetting = RMobilePhone::ELockSetEnabled;

        }

    else

        {

        lockSetting = RMobilePhone::ELockSetDisabled;

        }

    RDEBUG("future lockSetting", lockSetting);

    iWait->SetRequestType(EMobilePhoneSetLockSetting);

    RProperty::Set(KPSUidSecurityUIs, KSecurityUIsQueryRequestCancel, ESecurityUIsQueryRequestOk);

    RDEBUG( "SetLockSetting", 0 );

    iPhone.SetLockSetting(iWait->iStatus, lockType, lockSetting); // this will PassPhraseRequiredL

    RDEBUG( "WaitForRequestL", 0 );

    retValue = iWait->WaitForRequestL();

    RDEBUG( "WaitForRequestL retValue", retValue );

#ifdef __WINS__

    if (retValue == KErrNotSupported || retValue == KErrTimedOut)

        retValue = KErrNone;

#endif

    switch (retValue)

        {

        case KErrNone:

            break;

        case KErrGsmSSPasswordAttemptsViolation:

        case KErrLocked:

        case KErrGsm0707IncorrectPassword:

        case KErrAccessDenied:

            // Security code was entered erroneously

            //Error note is shown in CSecurityHandler::PassPhraseRequired()

            break;