2 * Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). 

     2  * Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     3  * All rights reserved.

     4 * This component and the accompanying materials are made available

     4  * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     5  * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     6  * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     8  *

     9 * Initial Contributors:

     9  * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    10  * Nokia Corporation - initial contribution.

    11 *

    11  *

    12 * Contributors:

    12  * Contributors:

    13 *

    13  *

    14 * Description:  Provides api for changing security settings.

    14  * Description:  Provides api for changing security settings.

    15 *

    15  *

    16 *

    16  *

    17 */

    17  */

    18 

    40 

    38 #include <hb/hbcore/hbtextresolversymbian.h>

    41 #ifdef RD_REMOTELOCK

    48     /*****************************************************

    43 

    49     *    Series 60 Customer / TSY

    44 #include "SecQueryUi.h"

    50     *    Needs customer TSY implementation

    45 #include <hb/hbwidgets/hbdevicemessageboxsymbian.h>

    51     *****************************************************/

    46 

    47 /*****************************************************

    48  *    Series 60 Customer / TSY

    49  *    Needs customer TSY implementation

    50  *****************************************************/

    54 const TInt KTriesToConnectServer( 2 );

    53 const TInt KTriesToConnectServer(2);

    55 const TInt KTimeBeforeRetryingServerConnection( 50000 );

    54 const TInt KTimeBeforeRetryingServerConnection(50000);

    56 const TInt PhoneIndex( 0 );

    55 const TInt PhoneIndex(0);

    57 

    56 

    58 const TInt KMaxNumberOfPINAttempts(3);

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

    59 const TInt KLastRemainingInputAttempt(1);

    58 

    59 #define ESecUiTypeLock                  0x00100000

    60 #define KErrTDevicelockPolicies					0x10207837

    66 //

    67 // qtdone

    80 //

    81 // qtdone

    89 //

    90 // qtdone

    93     *    Series 60 Customer / ETel

    94      *    Series 60 Customer / ETel

    94     *    Series 60  ETel API

    95      *    Series 60  ETel API

    95     *****************************************************/

    96      *****************************************************/

    97     *    Series 60 Customer / TSY

    98      *    Series 60 Customer / TSY

    98     *    Needs customer TSY implementation

    99      *    Needs customer TSY implementation

    99     *****************************************************/

   100      *****************************************************/

   100 

   101 

   101     TInt err( KErrGeneral );

   102     RDEBUG("0", 0);

   102     TInt thisTry( 0 );

   103     TInt err(KErrGeneral);

   104     TInt thisTry(0);

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

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

   107     #if defined(_DEBUG)

   109 

   108     RDebug::Print(_L("(SECUI)CSecuritySettings::ConstructL()"));

   109     #endif

   110     

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

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

   114         {

   113         {

   115         User::After( KTimeBeforeRetryingServerConnection );

   114         User::After( KTimeBeforeRetryingServerConnection);

   116         }

   115         }

   117     User::LeaveIfError( err );

   116     User::LeaveIfError(err);

   120     err = iServer.LoadPhoneModule( KMmTsyModuleName );

   119     err = iServer.LoadPhoneModule(KMmTsyModuleName);

   121     if ( err != KErrAlreadyExists )

   120     if (err != KErrAlreadyExists)

   126         User::LeaveIfError( err );

   125         User::LeaveIfError(err);

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

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

   135     iSecurityHandler = new( ELeave ) CSecurityHandler( iPhone );

   134     iSecurityHandler = new (ELeave) CSecurityHandler(iPhone);

   135     _LIT(KFileName, "secui_");

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

   137     RDEBUG("HbTextResolverSymbian", 0);

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

   139     RDEBUG("result", result);

   140 

   142 //

   147 // qtdone

   146     *    Series 60 Customer / ETel

   151      *    Series 60 Customer / ETel

   147     *    Series 60  ETel API

   152      *    Series 60  ETel API

   148     *****************************************************/

   153      *****************************************************/

   150     *    Series 60 Customer / TSY

   155      *    Series 60 Customer / TSY

   151     *    Needs customer TSY implementation

   156      *    Needs customer TSY implementation

   152     *****************************************************/

   157      *****************************************************/

   156     if(iWait->IsActive())

   161     if (iWait->IsActive())

   157     {

   162         {

   158         #if defined(_DEBUG)

   163         RDEBUG("CancelAsyncRequest", 0);

   159 	    RDebug::Print(_L("(SECUI)CManualSecuritySettings::~CSecuritySettings() CANCEL REQ"));

   160 	    #endif

   162         

   165 

   163         switch(iWait->GetRequestType())

   166         switch (iWait->GetRequestType())

   164             {   //inform query that it has beeen canceled

   167             { //inform query that it has beeen canceled

   165                 case EMobilePhoneSetLockSetting:

   168             case EMobilePhoneSetLockSetting:

   166                 case EMobilePhoneSetFdnSetting:

   169             case EMobilePhoneSetFdnSetting:

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

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

   168                     break;

   171                 break;

   169                 default:

   172             default:

   170                     break;

   173                 break;

   171             }                            

   174             }

   172         

   175 

   173     }

   176         }

   195 EXPORT_C void CSecuritySettings::ChangePinL()

   215 // ----------------------------------------------------------

   196     {

   216 // CSecuritySettings::ChangeUPinL()

   197     /*****************************************************

   217 // Changes Universal PIN

   198     *    Series 60 Customer / ETel

   218 // ----------------------------------------------------------

   199     *    Series 60  ETel API

   219 // qtdone

   200     *****************************************************/

   220 EXPORT_C void CSecuritySettings::ChangeUPinL()

   201     

   221     {

   202     TInt simState;

   222     RDEBUG("0", 0);

   203     TInt err( KErrGeneral );

   223     RMobilePhone::TMobilePassword iOldPassword;

   204     err = RProperty::Get(KPSUidStartup, KPSSimStatus, simState);

   224     RMobilePhone::TMobilePassword iNewPassword;

   205     User::LeaveIfError( err );

   225     TInt iFlags = ESecUiTypeLock;

   206     TBool simRemoved(simState == ESimNotPresent);

   226     iOldPassword.Copy(_L(""));

   207 

   227     iNewPassword.Copy(_L(""));

   208     if ( simRemoved )

   228 

   209         {

   229     TBuf<0x80> iCaption;

   210         ShowResultNoteL(R_INSERT_SIM, CAknNoteDialog::EErrorTone);

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

   211         return;

   231     TInt iShowError = 1;

   212         }

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

   213 

   233     RDEBUG("err", err);

   214     #if defined(_DEBUG)

   234 

   215     RDebug::Print(_L("(SECUI)CSecuritySettings::ChangePinL()"));

   235     }

   216     #endif    

   236 

   217     RMobilePhone::TMobilePhoneSecurityCode secCodeType;

   237 //

   218     secCodeType = RMobilePhone::ESecurityCodePin1;

   238 // ----------------------------------------------------------

   219 

   239 // CSecuritySettings::ChangePin2L()

   220     RMobilePhone::TMobilePassword oldPassword;

   240 // Changes PIN2

   221     RMobilePhone::TMobilePassword newPassword;

   241 // ----------------------------------------------------------

   222     RMobilePhone::TMobilePassword verifcationPassword;

   242 // qtdone

   223     RMobilePhone::TMobilePhonePasswordChangeV1 passwords;

   243 EXPORT_C void CSecuritySettings::ChangePin2L()

   224     RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeInfo;

   244     {

   225     RMobilePhone::TMobilePhoneSecurityCodeInfoV5Pckg codeInfoPkg(codeInfo);

   245     RDEBUG("0", 0);

   226 

   246     RMobilePhone::TMobilePassword iOldPassword;

   227     CCodeQueryDialog* verdlg = new (ELeave) CCodeQueryDialog (verifcationPassword,SEC_C_PIN_CODE_MIN_LENGTH,SEC_C_PIN_CODE_MAX_LENGTH,ESecUiNone);

   247     RMobilePhone::TMobilePassword iNewPassword;

   228     CleanupStack::PushL(verdlg);

   248     TInt iFlags = ESecUiTypeLock;

   229 

   249     iOldPassword.Copy(_L(""));

   230     CCodeQueryDialog* newdlg = new (ELeave) CCodeQueryDialog(newPassword,SEC_C_PIN_CODE_MIN_LENGTH,SEC_C_PIN_CODE_MAX_LENGTH,ESecUiNone);

   250     iNewPassword.Copy(_L(""));

   231     CleanupStack::PushL(newdlg);

   251 

   232 

   252     TBuf<0x80> iCaption;

   233     CCodeQueryDialog* dlg = new (ELeave) CCodeQueryDialog (oldPassword,SEC_C_PIN_CODE_MIN_LENGTH,SEC_C_PIN_CODE_MAX_LENGTH,ESecUiNone);       

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

   234     CleanupStack::PushL(dlg);

   254     TInt iShowError = 1;

   235 

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

   236     RMobilePhone::TMobilePhoneLock lockType;

   256     RDEBUG("err", err);

   257     }

   258 //

   259 // ----------------------------------------------------------

   260 // CSecuritySettings::ChangeSecCodeL()

   261 // Changes security code 

   262 // ----------------------------------------------------------

   263 // qtdone

   264 EXPORT_C void CSecuritySettings::ChangeSecCodeL()

   265     {

   266     RDEBUG("0", 0);

   267     RMobilePhone::TMobilePassword iOldPassword;

   268     RMobilePhone::TMobilePassword iNewPassword;

   269     TInt iFlags = 0;

   270     iOldPassword.Copy(_L(""));

   271     iNewPassword.Copy(_L(""));

   272 

   273     TBuf<0x80> iCaption;

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

   275     TInt iShowError = 1;

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

   277     RDEBUG("err", err);

   278     }

   279 //

   280 // ----------------------------------------------------------

   281 // CSecuritySettings::ChangeAutoLockPeriodL()

   282 // Changes autolock period

   283 // ----------------------------------------------------------

   284 // qtdone

   285 EXPORT_C TInt CSecuritySettings::ChangeAutoLockPeriodL(TInt aPeriod)

   286     {

   287     TInt ret = 0;

   288     RDEBUG("aPeriod", aPeriod);

   289     RMobilePhone::TMobilePassword iOldPassword;

   290     TInt iFlags = 0;

   291     TInt iShowError = 1;

   292     TBuf<0x80> iCaption;

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

   294     iOldPassword.Copy(_L(""));

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

   296     RDEBUG("ret", ret);

   297     return ret;

   298     }

   299 

   300 //

   301 // ----------------------------------------------------------

   302 // CSecuritySettings::ChangeRemoteLockStatusL()

   303 // Changes remote lock status (on/off)

   304 // ----------------------------------------------------------

   305 // no qtdone

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

   307     {

   308     TInt retValue(KErrNone);

   309     RDEBUG("aRemoteLockStatus", aRemoteLockStatus);

   310     RDEBUG("aAutoLockPeriod", aAutoLockPeriod);

   311 

   312     if (aRemoteLockStatus)

   313         {

   314         aRemoteLockStatus = ETrue;

   315 

   316         // If user wishes to enable remote lock

   317         // a new remote lock code is required.

   318         // RemoteLockCodeQueryL also 

   319         retValue = RemoteLockCodeQueryL(aRemoteLockCode);

   320         }

   321     else

   322         {

   323         aRemoteLockStatus = EFalse;

   324         retValue = KErrNone;

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

   326 

   327         // Check whether AutoLock is enabled (timeout value greater 

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

   329         // device lock should be left enabled.

   330         if (aAutoLockPeriod == 0)

   331             {

   332             // Disable lock setting from domestic OS

   333             retValue = RemoteLockSetLockSettingL(EFalse);

   334             }

   335         else

   336             {

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

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

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

   340             retValue = RemoteLockSetLockSettingL(ETrue);

   341             }

   342         }

   343     RDEBUG( "retValue", retValue );

   344     return retValue;

   345     }

   346 //

   347 // ----------------------------------------------------------

   348 // CSecuritySettings::RemoteLockCodeQueryL()

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

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

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

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

   353 // This is not a problem, because:

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

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

   356 // ----------------------------------------------------------

   357 // qtdone

   358 TInt CSecuritySettings::RemoteLockCodeQueryL(TDes& aRemoteLockCode)

   359     {

   360 

   361     TInt retValue(KErrNone);

   362 

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

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

   365     // lock setting since RemoteLock API requires remote locking to

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

   367     retValue = RemoteLockSetLockSettingL(ETrue);

   368     RDEBUG( "retValue", retValue );

   369     if (retValue != KErrNone)

   370         return retValue;

   371     aRemoteLockCode.Zero();

   372 

   373     TInt queryAccepted = KErrCancel;

   374     queryAccepted = KErrCancel;

   375     CSecQueryUi * iSecQueryUi;

   376     iSecQueryUi = CSecQueryUi::NewL();

   377     // this queries both, and verifies itself

   378     TBuf<0x100> title;

   379     title.Zero();

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

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

   382     CleanupStack::PopAndDestroy(stringHolder);

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

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

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

   386     CleanupStack::PopAndDestroy(stringHolder2);

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

   388             | ESecUiCancelSupported | ESecUiEmergencyNotSupported | ESecUiNone);

   389     RDEBUG("aRemoteLockCode", 0);

   390     RDEBUGSTR(aRemoteLockCode);

   391     RDEBUG("queryAccepted", queryAccepted);

   392     delete iSecQueryUi;

   393     if (queryAccepted != KErrNone)

   394         return KErrAbort;

   395 

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

   397     RMobilePhone::TMobilePhoneSecurityCode secCodeType = RMobilePhone::ESecurityCodePhonePassword;

   398     RMobilePhone::TMobilePassword securityCode;

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

   400 

   401 

   402     securityCode = aRemoteLockCode;

   403     RDEBUG( "EMobilePhoneVerifySecurityCode", EMobilePhoneVerifySecurityCode );

   404     iWait->SetRequestType(EMobilePhoneVerifySecurityCode);

   405     RDEBUG( "VerifySecurityCode", 0 );

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

   407     RDEBUG( "WaitForRequestL", 0 );

   408     TInt res = iWait->WaitForRequestL();

   409     RDEBUG( "WaitForRequestL res", res );

   410 #ifdef __WINS__

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

   412         res = KErrGsm0707IncorrectPassword; // KErrGsm0707IncorrectPassword = incorrect code

   413 #endif

   414     RDEBUG( "KErrGsm0707IncorrectPassword", KErrGsm0707IncorrectPassword );

   415     if (res == KErrNone)

   416         {

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

   418         // remote lock code matches the security code 

   419         // and that is not allowed

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

   421         ShowResultNoteL(R_REMOTELOCK_INVALID_CODE, CAknNoteDialog::EErrorTone);

   422         return KErrCancel;

   423         }

   424 

   425     RDEBUG( "retValue", retValue );

   426     return retValue;

   427     }

   428 //

   429 // ----------------------------------------------------------

   430 // CSecuritySettings::RemoteLockSetLockSettingL()

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

   432 // requires user to enter the security code.

   433 // ----------------------------------------------------------

   434 // qtdone

   435 TInt CSecuritySettings::RemoteLockSetLockSettingL(TBool aLockSetting)

   436     {

   437     TInt retValue(KErrNone);

   438     RDEBUG( "aLockSetting", aLockSetting );

   439 

   440     RMobilePhone::TMobilePhoneLockSetting lockSetting = RMobilePhone::ELockSetEnabled;

   441     RMobilePhone::TMobilePhoneLock lockType = RMobilePhone::ELockPhoneDevice;

   442 

   244     TInt res = iWait->WaitForRequestL();

   450     RDEBUG("WaitForRequestL", 0);

   245     User::LeaveIfError(res);

   451     TInt status = iWait->WaitForRequestL();

   246 

   452     RDEBUG("WaitForRequestL status", status);

   247     if (lockInfo.iSetting == RMobilePhone::ELockSetDisabled)

   453 

   248         {    

   454 #ifdef __WINS__

   249         CleanupStack::PopAndDestroy(3,verdlg);

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

   250         ShowResultNoteL(R_PIN_NOT_ALLOWED, CAknNoteDialog::EErrorTone);

   456         {

   251         return;

   457         lockInfo.iSetting = RMobilePhone::ELockSetDisabled;

   252         }

   458         status = KErrNone;

   253     

   459         }

   254     CleanupStack::Pop(); // dlg

   460 #endif

   255     iWait->SetRequestType(EMobilePhoneGetSecurityCodeInfo);

   461     User::LeaveIfError(status);

   256     iPhone.GetSecurityCodeInfo(iWait->iStatus, secCodeType, codeInfoPkg);

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

   257     res = iWait->WaitForRequestL();

   463 

   258     User::LeaveIfError(res);

   464     // disabled->disabled   should not happen

   259     // ask pin

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

   260     if( codeInfo.iRemainingEntryAttempts >= KMaxNumberOfPINAttempts )

   466     if (aLockSetting)

   261             res = dlg->ExecuteLD(R_PIN_QUERY);

   467         {

   262     else if(codeInfo.iRemainingEntryAttempts > KLastRemainingInputAttempt)

   468         lockSetting = RMobilePhone::ELockSetEnabled;

   263        {

   469         }

   264          HBufC* queryPrompt = StringLoader::LoadLC(R_SECUI_REMAINING_PIN_ATTEMPTS, codeInfo.iRemainingEntryAttempts);

   265          res = dlg->ExecuteLD(R_PIN_QUERY, *queryPrompt);

   266          CleanupStack::PopAndDestroy(queryPrompt);

   267        }

   269        {

   471         {

   270          HBufC* queryPrompt = StringLoader::LoadLC(R_SECUI_FINAL_PIN_ATTEMPT);

   472         lockSetting = RMobilePhone::ELockSetDisabled;

   271          res = dlg->ExecuteLD(R_PIN_QUERY, *queryPrompt);

   473         }

   272          CleanupStack::PopAndDestroy(queryPrompt);   

   474     RDEBUG("future lockSetting", lockSetting);

   273        }  

   475 

   274     

   476     iWait->SetRequestType(EMobilePhoneSetLockSetting);

   275       if( !res )

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

   276         {

   478     RDEBUG( "SetLockSetting", 0 );

   277         CleanupStack::PopAndDestroy(2,verdlg);

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

   278         return;

   480     RDEBUG( "WaitForRequestL", 0 );

   279         }      

   481     retValue = iWait->WaitForRequestL();

   280     CleanupStack::Pop(); // newdlg

   482     RDEBUG( "WaitForRequestL retValue", retValue );

   281     // new pin code query

   483 #ifdef __WINS__

   282      if (!(newdlg->ExecuteLD(R_NEW_PIN_CODE_QUERY)))

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

   283         {

   485         retValue = KErrNone;

   284         CleanupStack::PopAndDestroy(verdlg);

   486 #endif

   285         return;

   487 

   286         }

   488     switch (retValue)

   287 

   288     CleanupStack::Pop(); // verdlg

   289     // verification code query

   290     if (!(verdlg->ExecuteLD(R_VERIFY_NEW_PIN_CODE_QUERY)))

   291             return;

   292         

   293     while (newPassword.CompareF(verifcationPassword) != 0) 

   294         {

   295         // codes do not match -> note -> ask new pin and verification codes again  

   296         ShowResultNoteL(R_CODES_DONT_MATCH, CAknNoteDialog::EErrorTone);

   297     

   298         newPassword = _L("");

   299         verifcationPassword = _L("");

   300 

   301         // new pin code query

   302         CCodeQueryDialog* newdlg = new (ELeave) CCodeQueryDialog (newPassword,SEC_C_PIN_CODE_MIN_LENGTH,SEC_C_PIN_CODE_MAX_LENGTH,ESecUiNone);

   303         if (!(newdlg->ExecuteLD(R_NEW_PIN_CODE_QUERY)))

   304               return;

   305         

   306         // verification code query

   307         CCodeQueryDialog* verdlg = new (ELeave) CCodeQueryDialog (verifcationPassword,SEC_C_PIN_CODE_MIN_LENGTH,SEC_C_PIN_CODE_MAX_LENGTH,ESecUiNone);

   308         if (!(verdlg->ExecuteLD(R_VERIFY_NEW_PIN_CODE_QUERY)))

   309             return;

   310         }            

   311         

   312     // send code

   313     passwords.iOldPassword = oldPassword;

   314     passwords.iNewPassword = newPassword;

   315     iWait->SetRequestType(EMobilePhoneChangeSecurityCode);

   316     iPhone.ChangeSecurityCode(iWait->iStatus, secCodeType, passwords);

   317     res = iWait->WaitForRequestL();

   318     #if defined(_DEBUG)

   319     RDebug::Print( _L("(SECUI)CSecuritySettings::ChangePinL(): RETURN CODE: %d"), res);

   320     #endif

   321     switch(res)

   324             {

   491             break;

   325             // code changed 

   492 

   326             ShowResultNoteL(R_PIN_CODE_CHANGED_NOTE, CAknNoteDialog::EConfirmationTone);

   493         case KErrGsmSSPasswordAttemptsViolation:

   327             break;

   494         case KErrLocked:

   328             }        

   331             {    

   497             // Security code was entered erroneously

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

   499             break;

   500 

   501         case KErrAbort:

   502             break;

   503 

   504         default:

   505             break;

   506         }

   507 

   508     RDEBUG( "retValue", retValue );

   509     return retValue;

   510     }

   511 

   512 //

   513 // ----------------------------------------------------------

   514 // CSecuritySettings::ChangeSimSecurityL()

   515 // Changes SIM security

   516 // ----------------------------------------------------------

   517 // qtdone

   518 EXPORT_C TBool CSecuritySettings::ChangeSimSecurityL()

   519     {

   520     /*****************************************************

   521      *    Series 60 Customer / ETel

   522      *    Series 60  ETel API

   523      *****************************************************/

   524     RDEBUG("0", 0);

   525     RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;

   526     RMobilePhone::TMobilePhoneLockInfoV1Pckg lockInfoPkg(lockInfo);

   527     RMobilePhone::TMobilePhoneLock lockType = RMobilePhone::ELockPhoneToICC;

   528     RMobilePhone::TMobilePhoneLockSetting lockChangeSetting;

   529 

   530     //get lock info

   531     iWait->SetRequestType(EMobilePhoneGetLockInfo);

   532     RDEBUG("GetLockInfo", 0);

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

   534     RDEBUG("WaitForRequestL", 0);

   535     TInt status = iWait->WaitForRequestL();

   536     RDEBUG("WaitForRequestL status", status);

   537 

   538 #ifdef __WINS__

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

   540         {

   541         lockInfo.iSetting = RMobilePhone::ELockSetDisabled;

   542         status = KErrNone;

   543         }

   544 #endif

   545     User::LeaveIfError(status);

   546     TInt currentItem = 0;

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

   548     if (lockInfo.iSetting == RMobilePhone::ELockSetDisabled)

   549         {

   550         currentItem = 1; // off

   551         }

   552 

   553     if (currentItem == 0) // switch the flag

   554         {

   555         lockChangeSetting = RMobilePhone::ELockSetDisabled;

   556         }

   557     else

   558         {

   559         lockChangeSetting = RMobilePhone::ELockSetEnabled;

   560         }

   561     RDEBUG("lockChangeSetting", lockChangeSetting);

   562 

   563     iWait->SetRequestType(EMobilePhoneSetLockSetting);

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

   565     RDEBUG("SetLockSetting", 0);

   566     iPhone.SetLockSetting(iWait->iStatus, lockType, lockChangeSetting); // this invokes the handler

   567     RDEBUG("WaitForRequestL", 0);

   568     status = iWait->WaitForRequestL();

   569     RDEBUG("WaitForRequestL status", status);

   570 #ifdef __WINS__

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

   572         status = KErrNone;

   573 #endif

   574 

   575     // the error was displayed in the handler

   576     RDEBUG("status", status);

   577     switch (status)

   578         {

   579         case KErrNone:

   580             {

   581             break;

   582             }

   583         case KErrGsm0707IncorrectPassword:

   584         case KErrAccessDenied:

   585             {

   333             ShowResultNoteL(R_CODE_ERROR, CAknNoteDialog::EErrorTone);

   587             return ChangeSimSecurityL();

   334             ChangePinL();

   588             }

   335             break;

   336             }    

   340             // Pin1 blocked! 

   592             return ChangeSimSecurityL();

   341             return;

   342             }

   343         case KErrGsm0707OperationNotAllowed:

   344             {

   345             // not allowed with this sim

   346             ShowResultNoteL(R_OPERATION_NOT_ALLOWED, CAknNoteDialog::EErrorTone);

   347             return;

   351             break;

   596             return EFalse;

   355             ShowErrorNoteL(res);

   600             ShowErrorNoteL(status);

   356             ChangePinL();

   601             return ChangeSimSecurityL();

   357             break;

   602             }

   358             }

   603         }

   359         }

   604 

   360 

   605     return ETrue;

   361     }

   606     }

   362 

   365 // CSecuritySettings::ChangeUPinL()

   609 // CSecuritySettings::ChangePinRequestL()

   366 // Changes Universal PIN

   610 // Changes PIN1 request

   367 // ----------------------------------------------------------

   611 // ----------------------------------------------------------

   612 // qtdone

   613 EXPORT_C TBool CSecuritySettings::ChangePinRequestL()

   614     {

   615     RDEBUG("0", 0);

   616 

   617     RMobilePhone::TMobilePassword iOldPassword;

   618     TInt iFlags = 0;

   619     iOldPassword.Copy(_L(""));

   620 

   621     TBuf<0x80> iCaption;

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

   623     TInt iShowError = 1;

   624     TInt err = ChangePinRequestParamsL(1/* it's imposible to know if we want to set or clear*/, iOldPassword, iFlags, iCaption, iShowError);

   625     RDEBUG("err", err);

   626     if (err == KErrNone)

   627         return ETrue;

   628     else

   629         return EFalse;

   630     }

   631 

   369 EXPORT_C void CSecuritySettings::ChangeUPinL()

   633 // ----------------------------------------------------------

   370     {

   634 // CSecuritySettings::ChangeUPinRequestL()

   371     TBool wcdmaSupported(FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma ));

   635 // Changes UPIN request on/off

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

   636 // ----------------------------------------------------------

   373     if(wcdmaSupported || upinSupported)

   637 // qtdone

   374       {

   638 EXPORT_C TBool CSecuritySettings::ChangeUPinRequestL()

   375         #if defined(_DEBUG)

   639     {

   376         RDebug::Print(_L("(SECUI)CSecuritySettings::ChangeUPinL()"));

   640     TBool wcdmaSupported(FeatureManager::FeatureSupported(KFeatureIdProtocolWcdma));

   377         #endif

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

   642     RDEBUG("wcdmaSupported", wcdmaSupported);

   643     RDEBUG("upinSupported", upinSupported);

   644     if (wcdmaSupported || upinSupported)

   645         {

   379         TInt err( KErrGeneral );

   647         TInt err(KErrGeneral);

   381         User::LeaveIfError( err );

   649         User::LeaveIfError(err);

   383     

   651 

   384         if ( simRemoved )

   652         if (simRemoved)

   387             return;

   655             return EFalse;

   388             }

   656             }

   389     

   657 

   390         RMobilePhone::TMobilePhoneSecurityCode secCodeType;

   391         secCodeType = RMobilePhone::ESecurityUniversalPin;

   392     

   393         RMobilePhone::TMobilePassword oldPassword;

   394         RMobilePhone::TMobilePassword newPassword;

   395         RMobilePhone::TMobilePassword verifcationPassword;

   396         RMobilePhone::TMobilePhonePasswordChangeV1 passwords;

   397         RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeInfo;

   398         RMobilePhone::TMobilePhoneSecurityCodeInfoV5Pckg codeInfoPkg(codeInfo);

   399     

   400         CCodeQueryDialog* verdlg = new (ELeave) CCodeQueryDialog (verifcationPassword,SEC_C_PIN_CODE_MIN_LENGTH,SEC_C_PIN_CODE_MAX_LENGTH,ESecUiNone);

   401         CleanupStack::PushL(verdlg);

   402     

   403         CCodeQueryDialog* newdlg = new (ELeave) CCodeQueryDialog(newPassword,SEC_C_PIN_CODE_MIN_LENGTH,SEC_C_PIN_CODE_MAX_LENGTH,ESecUiNone);

   404         CleanupStack::PushL(newdlg);

   405     

   406         CCodeQueryDialog* dlg = new (ELeave) CCodeQueryDialog (oldPassword,SEC_C_PIN_CODE_MIN_LENGTH,SEC_C_PIN_CODE_MAX_LENGTH,ESecUiNone);       

   407         CleanupStack::PushL(dlg);

   408     

   409         RMobilePhone::TMobilePhoneLock lockType;

   417         TInt res = iWait->WaitForRequestL();

   668         RDEBUG("WaitForRequestL", 0);

   418         User::LeaveIfError(res);

   669         TInt status = iWait->WaitForRequestL();

   419     

   670         RDEBUG("WaitForRequestL status", status);

   671 #ifdef __WINS__

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

   673             status = KErrNone;

   674 #endif

   675         User::LeaveIfError(status);

   676         TInt currentItem = 0;

   677 

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

   421             {    

   680             {

   422             CleanupStack::PopAndDestroy(3,verdlg);

   681             currentItem = 1; // off

   423             ShowResultNoteL(R_UPIN_NOT_ALLOWED, CAknNoteDialog::EErrorTone);

   682             }

   424             return;

   683 

   425             }

   684         if (currentItem == 0) // switch the flag

   426         

   685             {

   427         CleanupStack::Pop(); // dlg

   686             lockChangeSetting = RMobilePhone::ELockSetDisabled;

   428         // ask pin

   429         iWait->SetRequestType(EMobilePhoneGetSecurityCodeInfo);

   430         iPhone.GetSecurityCodeInfo(iWait->iStatus, secCodeType, codeInfoPkg);

   431         res = iWait->WaitForRequestL();

   432         User::LeaveIfError(res);

   433             

   434         if( codeInfo.iRemainingEntryAttempts >= KMaxNumberOfPINAttempts )

   435             res = dlg->ExecuteLD(R_UPIN_QUERY);

   436         else if(codeInfo.iRemainingEntryAttempts > KLastRemainingInputAttempt)

   437             {

   438               HBufC* queryPrompt = StringLoader::LoadLC(R_SECUI_REMAINING_UPIN_ATTEMPTS, codeInfo.iRemainingEntryAttempts);

   439               res = dlg->ExecuteLD(R_UPIN_QUERY, *queryPrompt);

   440               CleanupStack::PopAndDestroy(queryPrompt);

   444               HBufC* queryPrompt = StringLoader::LoadLC(R_SECUI_FINAL_UPIN_ATTEMPT);

   690             lockChangeSetting = RMobilePhone::ELockSetEnabled;

   445               res = dlg->ExecuteLD(R_UPIN_QUERY, *queryPrompt);

   691             }

   446               CleanupStack::PopAndDestroy(queryPrompt);   

   692         RDEBUG("lockChangeSetting", lockChangeSetting);

   447             }        

   693         // Raise a flag to indicate that the UPIN

   448         

   694         // request coming from ETEL has originated from SecUi and not from Engine.

   449         

   695         RProperty::Set(KPSUidSecurityUIs, KSecurityUIsSecUIOriginatedQuery, ESecurityUIsSecUIOriginated);

   450         

   696         // Change the lock setting

   451          if( !res )

   697         iWait->SetRequestType(EMobilePhoneSetLockSetting);

   452             {

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

   453             CleanupStack::PopAndDestroy(2,verdlg);

   699         RDEBUG("SetLockSetting", 0);

   454             return;

   700         iPhone.SetLockSetting(iWait->iStatus, lockType, lockChangeSetting); // this calls something in the handler

   455             }      

   701         RDEBUG("WaitForRequestL", 0);

   456         CleanupStack::Pop(); // newdlg

   702         status = iWait->WaitForRequestL();

   457         // new pin code query

   703         RDEBUG("WaitForRequestL status", status);

   458          if (!(newdlg->ExecuteLD(R_NEW_UPIN_CODE_QUERY)))

   704         // Lower the flag                           

   459             {

   705         RProperty::Set(KPSUidSecurityUIs, KSecurityUIsSecUIOriginatedQuery, ESecurityUIsSecUIOriginatedUninitialized);

   460             CleanupStack::PopAndDestroy(verdlg);

   706 #ifdef __WINS__

   461             return;

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

   462             }

   708             status = KErrNone;

   463     

   709 #endif

   464         CleanupStack::Pop(); // verdlg

   710 

   465         // verification code query

   711         // no need to show errors because they were displayed in the Handler

   466         if (!(verdlg->ExecuteLD(R_VERIFY_NEW_UPIN_CODE_QUERY)))

   712         switch (status)

   467                 return;

   468             

   469         while (newPassword.CompareF(verifcationPassword) != 0) 

   470             {

   471             // codes do not match -> note -> ask new pin and verification codes again  

   472             ShowResultNoteL(R_CODES_DONT_MATCH, CAknNoteDialog::EErrorTone);

   473         

   474             newPassword = _L("");

   475             verifcationPassword = _L("");

   476     

   477             // new pin code query

   478             CCodeQueryDialog* newdlg = new (ELeave) CCodeQueryDialog (newPassword,SEC_C_PIN_CODE_MIN_LENGTH,SEC_C_PIN_CODE_MAX_LENGTH,ESecUiNone);

   479             if (!(newdlg->ExecuteLD(R_NEW_UPIN_CODE_QUERY)))

   480                   return;

   481             

   482             // verification code query

   483             CCodeQueryDialog* verdlg = new (ELeave) CCodeQueryDialog (verifcationPassword,SEC_C_PIN_CODE_MIN_LENGTH,SEC_C_PIN_CODE_MAX_LENGTH,ESecUiNone);

   484             if (!(verdlg->ExecuteLD(R_VERIFY_NEW_UPIN_CODE_QUERY)))

   485                 return;

   486             }            

   487             

   488         // send code

   489         passwords.iOldPassword = oldPassword;

   490         passwords.iNewPassword = newPassword;

   491         iWait->SetRequestType(EMobilePhoneChangeSecurityCode);

   492         iPhone.ChangeSecurityCode(iWait->iStatus, secCodeType, passwords);

   493         res = iWait->WaitForRequestL();

   494         #if defined(_DEBUG)

   495         RDebug::Print( _L("(SECUI)CSecuritySettings::ChangePinL(): RETURN CODE: %d"), res);

   496         #endif

   497         switch(res)

   522                 return;

   722                 return EFalse;

   723                 }

   724             case KErrGsm0707IncorrectPassword:

   725             case KErrAccessDenied:

   726                 {

   727                 // code was entered erroneously

   728                 return ChangeUPinRequestL();

   729                 }

   730             case KErrGsmSSPasswordAttemptsViolation:

   731             case KErrLocked:

   732                 {

   733                 return EFalse;

   526                 break;

   737                 return EFalse;

   530                 ShowErrorNoteL(res);

   741                 ShowErrorNoteL(status);

   531                 ChangeUPinL();

   742                 return ChangeUPinRequestL();

   743                 }

   744             }

   745 

   746         return ETrue;

   747         }

   748     else

   749         return EFalse;

   750 

   751     }

   752 

   753 //

   754 // ----------------------------------------------------------

   755 // CSecuritySettings::SwitchPinCodesL()

   756 // Changes the pin code currently in use (PIN/UPIN)

   757 // ----------------------------------------------------------

   758 // qtdone

   759 EXPORT_C TBool CSecuritySettings::SwitchPinCodesL()

   760     {

   761     TBool wcdmaSupported(FeatureManager::FeatureSupported(KFeatureIdProtocolWcdma));

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

   763     RDEBUG("wcdmaSupported", wcdmaSupported);

   764     RDEBUG("upinSupported", upinSupported);

   765     if (wcdmaSupported || upinSupported)

   766         {

   767         // If we are in simless offline mode the PIN codes can't obviously be switched

   768         TInt simState;

   769         TInt err(KErrGeneral);

   770         err = RProperty::Get(KPSUidStartup, KPSSimStatus, simState);

   771         User::LeaveIfError(err);

   772         TBool simRemoved(simState == ESimNotPresent);

   773 

   774         if (simRemoved)

   775             {

   776             ShowResultNoteL(R_INSERT_SIM, CAknNoteDialog::EErrorTone);

   777             return EFalse;

   778             }

   779 

   780         RMobilePhone::TMobilePhoneLock lockType = RMobilePhone::ELockUniversalPin;

   781         RMobilePhone::TMobilePhoneLockSetting lockChangeSetting = RMobilePhone::ELockReplaced;

   782         RMobilePhone::TMobilePhoneSecurityCode activeCode;

   783 

   784         iCustomPhone.GetActivePin(activeCode);

   785 

   786         RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;

   787         RMobilePhone::TMobilePhoneLockInfoV1Pckg lockInfoPkg(lockInfo);

   788         RDEBUG("EMobilePhoneGetLockInfo", EMobilePhoneGetLockInfo);

   789         iWait->SetRequestType(EMobilePhoneGetLockInfo);

   790 

   791         if (activeCode == RMobilePhone::ESecurityUniversalPin)

   792             {

   793             lockType = RMobilePhone::ELockUniversalPin;

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

   795             RDEBUG("WaitForRequestL", 0);

   796             TInt res = iWait->WaitForRequestL();

   797             RDEBUG("WaitForRequestL res", res);

   798 #ifdef __WINS__

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

   800                 res = KErrNone;

   801 #endif

   802             User::LeaveIfError(res);

   803             }

   804         else

   805             {

   806             lockType = RMobilePhone::ELockICC;

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

   808             RDEBUG("WaitForRequestL", 0);

   809             TInt res = iWait->WaitForRequestL();

   810             RDEBUG("WaitForRequestL res", res);

   811 #ifdef __WINS__

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

   813                 res = KErrNone;

   814 #endif

   815             User::LeaveIfError(res);

   816             }

   817 

   818         // code request must be ON to change active code.

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

   820         if (lockInfo.iSetting == RMobilePhone::ELockSetDisabled)

   821             {

   822 

   823             if (activeCode != RMobilePhone::ESecurityUniversalPin)

   824                 {

   825                 ShowResultNoteL(R_UPIN_NOT_ALLOWED, CAknNoteDialog::EErrorTone);

   826                 }

   827             else

   828                 {

   829                 ShowResultNoteL(R_PIN_NOT_ALLOWED, CAknNoteDialog::EErrorTone);

   830                 }

   831             return EFalse;

   832             }

   833 

   834         iCustomPhone.GetActivePin(activeCode);

   835         TInt currentItem = 0;

   836 

   837         RDEBUG("activeCode", activeCode);

   838         if (activeCode == RMobilePhone::ESecurityUniversalPin)

   839             {

   840             currentItem = 1; // UPIN

   841             }

   842         if (currentItem == 0) // switch the flag

   843             {

   844             lockType = RMobilePhone::ELockUniversalPin;

   845             }

   846         else

   847             {

   848             lockType = RMobilePhone::ELockICC;

   849             }

   850         RDEBUG("lockType", lockType);

   851 

   852         // Raise a flag to indicate that the code

   853         // request coming from ETEL has originated from SecUi and not from Engine.

   854         RProperty::Set(KPSUidSecurityUIs, KSecurityUIsSecUIOriginatedQuery, ESecurityUIsSecUIOriginated);

   855         // Change the lock setting

   856         iWait->SetRequestType(EMobilePhoneSetLockSetting);

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

   858         RDEBUG("SetLockSetting", 0);

   859         iPhone.SetLockSetting(iWait->iStatus, lockType, lockChangeSetting); // request from handler

   860         RDEBUG("WaitForRequestL", 0);

   861         TInt status = iWait->WaitForRequestL();

   862         RDEBUG("WaitForRequestL status", status);

   863         // Lower the flag                            

   864         RProperty::Set(KPSUidSecurityUIs, KSecurityUIsSecUIOriginatedQuery, ESecurityUIsSecUIOriginatedUninitialized);

   865 #ifdef __WINS__

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

   867             status = KErrNone;

   868 #endif

   869 

   870         // errors are shown in the handler

   871         switch (status)

   872             {

   873             case KErrNone:

   874                 {

   534             }

   877             case KErrGsm0707OperationNotAllowed:

   535       }

   878                 {

   536 

   879                 // not allowed with this sim

   880                 ShowResultNoteL(R_OPERATION_NOT_ALLOWED, CAknNoteDialog::EErrorTone);

   881                 return EFalse;

   882                 }

   883             case KErrGsm0707IncorrectPassword:

   884             case KErrAccessDenied:

   885                 {

   886                 // code was entered erroneously

   887                 return SwitchPinCodesL();

   888                 }

   889             case KErrGsmSSPasswordAttemptsViolation:

   890             case KErrLocked:

   891                 {

   892                 return EFalse;

   893                 }

   894             case KErrAbort:

   895                 {

   896                 return EFalse;

   897                 }

   898             default:

   899                 {

   900                 ShowErrorNoteL(status);

   901                 return SwitchPinCodesL();

   902                 }

   903             }

   904 

   905         return ETrue;

   906         }

   907     else

   908         return EFalse;

   541 // CSecuritySettings::ChangePin2L()

   913 // CSecuritySettings::IsLockEnabledL()

   542 // Changes PIN2

   914 // Return is lock enabled/disabled

   543 // ----------------------------------------------------------

   915 // ----------------------------------------------------------

   916 // qtdone

   917 EXPORT_C TBool CSecuritySettings::IsLockEnabledL(RMobilePhone::TMobilePhoneLock aLockType)

   918     {

   919     TBool ret = EFalse;

   920     RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;

   921     //get lock info

   922     RMobilePhone::TMobilePhoneLockInfoV1Pckg lockInfoPkg(lockInfo);

   923     iWait->SetRequestType(EMobilePhoneGetLockInfo);

   924     RDEBUG("GetLockInfo", 0);

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

   926     RDEBUG("WaitForRequestL", 0);

   927     TInt res = iWait->WaitForRequestL();

   928     RDEBUG("WaitForRequestL res", res);

   929 

   930     if (res != KErrNone)

   931         ret = ETrue;

   932     //lock is enabled return true

   933     else if (lockInfo.iSetting == RMobilePhone::ELockSetEnabled)

   934         {

   935         ret = ETrue;

   936         }

   937     RDEBUG("ret", ret);

   938     return ret;

   939     }

   545 EXPORT_C void CSecuritySettings::ChangePin2L()

   941 // ----------------------------------------------------------

   942 // CSecuritySettings::AskSecCodeL()

   943 // For asking security code e.g in settings

   944 // ----------------------------------------------------------

   945 // qtdone

   946 EXPORT_C TBool CSecuritySettings::AskSecCodeL()

   947     {

   948     return iSecurityHandler->AskSecCodeL();

   949     }

   950 //

   951 // ----------------------------------------------------------

   952 // CSecuritySettings::AskPin2L()

   953 // Asks PIN2

   954 // ----------------------------------------------------------

   955 // qtdone

   956 EXPORT_C TBool CSecuritySettings::AskPin2L()

   548     *    Series 60 Customer / ETel

   959      *    Series 60 Customer / ETel

   549     *    Series 60  ETel API

   960      *    Series 60  ETel API

   550     *****************************************************/

   961      *****************************************************/

   551     #if defined(_DEBUG)

   962     RDEBUG("0", 0);

   552     RDebug::Print(_L("(SECUI)CSecuritySettings::ChangePin2L()"));

   963     TInt retPhone = 0;

   553     #endif

   964     // check if pin2 is blocked...

   554     TInt simState;

   965     RMmCustomAPI::TSecurityCodeType secCodeType = RMmCustomAPI::ESecurityCodePin2;

   555     TInt err( KErrGeneral );

   966     RMobilePhone::TMobilePhoneSecurityCode etelsecCodeType(RMobilePhone::ESecurityCodePin2);

   556     err = RProperty::Get(KPSUidStartup, KPSSimStatus, simState);

   557     User::LeaveIfError( err );

   558     TBool simRemoved(simState == ESimNotPresent);

   559 

   560     if ( simRemoved )

   561         {

   562         ShowResultNoteL(R_INSERT_SIM, CAknNoteDialog::EErrorTone);

   563         return;

   564         }

   565 

   566     RMmCustomAPI::TSecurityCodeType secCodeType;

   567     RMobilePhone::TMobilePhoneSecurityCode EtelsecCodeType;

   568     secCodeType = RMmCustomAPI::ESecurityCodePin2;

   569     RMobilePhone::TMobilePassword oldPassword;

   570     RMobilePhone::TMobilePassword newPassword;

   571     RMobilePhone::TMobilePassword verifcationPassword;

   572     RMobilePhone::TMobilePhonePasswordChangeV1 passwords;

   575     

   969     RMobilePhone::TMobilePassword password;

   576     // check if pin2 is blocked...

   578 

   971     TInt queryAccepted = KErrCancel;

   579     TInt ret = iCustomPhone.IsBlocked(secCodeType,isBlocked);

   972     //Check whether PIN2 is blocked

   580     

   973     retPhone = iCustomPhone.IsBlocked(secCodeType, isBlocked);

   581     if(isBlocked)

   974 

   975     RDEBUG("retPhone", retPhone);

   976     RDEBUG("isBlocked", isBlocked);

   977 #ifdef __WINS__

   978     if (retPhone == KErrNotSupported || retPhone == KErrTimedOut)

   979         retPhone = KErrNone;

   980 #endif

   981     if (isBlocked)

   982         return EFalse;