1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: Implements a state - machine like active object that controls Wi-Fi Protected Setup Process. 

    15 *

    16 */

    17 

    18 /*

    19 * %version: tr1cfwln#30 %

    20 */

    21 

    22 //SYSTEM INCLUDES

    23 #include <wlanmgmtclient.h>

    24 #include <wifiprotplugin.rsg>

    25 #include <StringLoader.h>

    26 #include <AknWaitDialog.h>

    27 #include <cmpluginwlandef.h>

    28 #include <commdb.h>

    29 #include <WPASecuritySettingsUI.h>

    30 #include <WEPSecuritySettingsUI.h>

    31 #include <e32math.h>

    32 #include <cmconnectionmethoddef.h>

    33 #include <wlanerrorcodes.h>

    34 #include <utf.h>

    35 #include <AknIconArray.h>

    36 #include <AknGlobalNote.h>

    37 #include <AknSgcc.h>

    38 #include <uikon/eiksrvui.h>

    39 #include <AknsUtils.h>

    40 #include <data_caging_path_literals.hrh>

    41 #include <wifiprot.mbg>

    42 

    43 #include <CoreApplicationUIsSDKCRKeys.h>

    44 #include <e32std.h>

    45 

    46 //USER INCLUDES

    47 #include "wifiprotlogger.h"

    48 #include "wifiprotactiverunner.h"

    49 #include "wifiprotconfirmationnotedlg.h"

    50 #include "wifiprotselectnetworkdlg.h"

    51 #include "wifiprotenterpindlg.h"

    52 #include "wifiprotinitiateeasysetupdlg.h"

    53 

    54 #include "featmgr.h"

    55 

    56 // valid Wep key lengths, to check wep key format

    57 // (wep key format depends on key length)

    58 const TInt KConnUiUtilsWepLengthASCII5 = 5;

    59 const TInt KConnUiUtilsWepLengthASCII13 = 13;

    60 const TInt KConnUiUtilsWepLengthASCII29 = 29;

    61 const TInt KConnUiUtilsWepLengthHEX10 = 10;

    62 const TInt KConnUiUtilsWepLengthHEX26 = 26;

    63 const TInt KConnUiUtilsWepLengthHEX58 = 58; 

    64 #ifdef __WINS__

    65 const TInt KNumberOfEmulatedAvailableNetworks = 2; 

    66 const TInt KIndexOfFirstEmulatedAvailableNetwork = 0;

    67 const TInt KIndexOfSecondEmulatedAvailableNetwork = 1;

    68 #endif

    69 

    70 /**

    71 * Management frame information element IDs.

    72 * needed to determine coverage

    73 */

    74 enum T802Dot11InformationElementID

    75     {

    76     E802Dot11SsidIE                 = 0,

    77     E802Dot11SupportedRatesIE       = 1,

    78     E802Doi11FhParameterSetIE       = 2,

    79     E802Dot11DsParameterSetIE       = 3,

    80     E802Dot11CfParameterSetIE       = 4,

    81     E802Dot11TimIE                  = 5,

    82     E802Dot11IbssParameterSetIE     = 6,

    83     E802Dot11CountryIE              = 7,

    84     E802Dot11HoppingPatternParamIE  = 8,

    85     E802Dot11HoppingPatternTableIE  = 9,

    86     E802Dot11RequestIE              = 10,

    87 

    88     E802Dot11ChallengeTextIE        = 16,

    89     // Reserved for challenge text extension 17 - 31

    90     E802Dot11ErpInformationIE       = 42,

    91     E802Dot11ExtendedRatesIE        = 50,

    92     E802Dot11AironetIE              = 133,

    93     E802Dot11ApIpAddressIE          = 149,

    94     E802Dot11RsnIE                  = 221

    95     };

    96 

    97 const TInt KArrayGranularity = 10; 

    98 const TInt KIconsGranularity = 4;

    99 

   100 _LIT( KWiFiFileIcons, "z:wifiprot.mbm" );

   101 

   102 _LIT8( KEapWsc, "\xFE\x00\x37\x2A\x00\x00\x00\x01");

   103 

   104 _LIT( KWiFiPanic, "Wi-Fi Protected Setup");

   105 

   106 using namespace CMManager;

   107 

   108 // ================= MEMBER FUNCTIONS =======================

   109 //

   110 // --------------------------------------------------------------------------

   111 // CWiFiProtActiveRunner::NewL

   112 // --------------------------------------------------------------------------

   113 //

   114 CWiFiProtActiveRunner* CWiFiProtActiveRunner::NewL(

   115         CWiFiProtDlgsPlugin* aParent, TInt aPriority )

   116     {

   117     CLOG_ENTERFN( "CWiFiProtActiveRunner::NewL" );

   118     

   119     CWiFiProtActiveRunner* self =

   120          new(ELeave) CWiFiProtActiveRunner( aParent, aPriority );

   121     CleanupStack::PushL( self );

   122     self->ConstructL();

   123     CleanupStack::Pop(); // self

   124     

   125     CLOG_LEAVEFN( "CWiFiProtActiveRunner::NewL" );

   126     

   127     return self;

   128     }

   129 

   130 // --------------------------------------------------------------------------

   131 // CWiFiProtActiveRunner::~CWiFiProtActiveRunner

   132 // --------------------------------------------------------------------------

   133 //

   134 CWiFiProtActiveRunner::~CWiFiProtActiveRunner()

   135     {

   136     CLOG_ENTERFN( "CWiFiProtActiveRunner::~CWiFiProtActiveRunner" );

   137 

   138     // Close notifier

   139     iNotifier.Close();

   140 

   141     Cancel();

   142     

   143     // If the cancel has been initiated by the client, temp IAP cannot be deleted until

   144     // after the RNotifier Cancel() call has returned (deadlock between MPM and CMM).

   145     // Therefore, temp IAP cleanup must be done later.

   146     if ( !iClientCancelled )

   147         {

   148         TRAP_IGNORE( DeleteTempIapL() ); //we can't do much if delete fails

   149         }

   150     

   151     delete iWlanMgmtEngine;

   152     

   153     // if cancelled from client, wait note may still be visible

   154     if ( iWaitDlg )

   155         {

   156         CLOG_WRITE( "iWaitDlg->SetCallback( NULL );" );

   157         iWaitDlg->SetCallback( NULL );

   158         CLOG_WRITE( "iWaitDlg->ProcessFinishedL( );" );

   159         TRAP_IGNORE( iWaitDlg->ProcessFinishedL() );

   160         delete iWaitDlg;

   161         }

   162     

   163     if ( iPinDlg )

   164         {

   165         delete iPinDlg;

   166         }

   167     

   168     TBool cleanupCms = EFalse;

   169     if ( iReturn == EWiFiCancel )

   170         {

   171         cleanupCms = ETrue;

   172         }

   173         

   174     for ( TInt i = 0; i < iCmArray.Count();i++ )

   175         {

   176         // if we are setting up a connection, we save the settings into

   177         // easy wlan iap (connection method), which we shouldn't ever delete!

   178         if ( ( !iIsConnectionNeeded ) && cleanupCms )

   179             {

   180             //we can't do much if delete fails

   181             TRAP_IGNORE( iCmArray[i]->DeleteL() );

   182             }

   183         iCmArray[i]->Close();

   184         delete iCmArray[i];

   185         iCmArray[i] = NULL;

   186         }

   187         

   188     iCmArray.ResetAndDestroy();

   189     iAvailableNetworks.Close();

   190     delete iIapParametersArray;

   191     delete iScanInfo;

   192     CLOG_LEAVEFN( "CWiFiProtActiveRunner::~CWiFiProtActiveRunner" );

   193     

   194     }

   195 

   196 // --------------------------------------------------------------------------

   197 // CWiFiProtActiveRunner::StartProtectedSetupL

   198 // --------------------------------------------------------------------------

   199 //

   200 void CWiFiProtActiveRunner::StartProtectedSetupAsyncL (

   201                                             const TWlanSsid& aSSid,

   202                                             RArray<TUint32>& aUids,

   203                                             RCmManagerExt& aCmManagerToUse )

   204     {

   205     CLOG_ENTERFN( "CWiFiProtActiveRunner::StartProtectedSetupAsyncL" );

   206     

   207     iIsConnectionNeeded = EFalse;

   208     iUids = &aUids;

   209     iCmManagerExt = &aCmManagerToUse;    

   210     iSsid.Copy( aSSid );

   211     ShowInitialDialogL();

   212     

   213     CLOG_LEAVEFN( "CWiFiProtActiveRunner::StartProtectedSetupAsyncL" );

   214     

   215     }

   216     

   217 // --------------------------------------------------------------------------

   218 // CWiFiProtActiveRunner::StartProtectedSetupConnL

   219 // --------------------------------------------------------------------------

   220 //

   221 void CWiFiProtActiveRunner::StartProtectedSetupConnL (

   222                                      const TWlanSsid& aSSid,

   223                                      TWlanProtectedSetupCredentialAttribute&

   224                                           aNetworkSettings,

   225                                      RCmManagerExt& aCmManagerToUse )

   226     {

   227     CLOG_ENTERFN( "CWiFiProtActiveRunner::StartProtectedSetupConnL" );

   228     

   229     iIsConnectionNeeded = ETrue;

   230     iNetworkSettings = &aNetworkSettings;

   231     iCmManagerExt = &aCmManagerToUse;    

   232     iSsid.Copy( aSSid );

   233     ShowInitialDialogL();

   234     

   235     CLOG_LEAVEFN( "CWiFiProtActiveRunner::StartProtectedSetupConnL" );

   236     

   237     }

   238 

   239 // --------------------------------------------------------------------------

   240 // CWiFiProtActiveRunner::StartProtectedSetupL

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

   242 //

   243 WiFiProt::TWiFiReturn CWiFiProtActiveRunner::StartProtectedSetupL (

   244                                             const TWlanSsid& aSSid,

   245                                             RArray<TUint32>& aUids,

   246                                             RCmManagerExt& aCmManagerToUse )

   247     {

   248     CLOG_ENTERFN( "CWiFiProtActiveRunner::StartProtectedSetupL" );

   249     

   250     iSyncMode = ETrue;

   251     iIsConnectionNeeded = EFalse;

   252     iUids = &aUids;

   253     iCmManagerExt = &aCmManagerToUse;    

   254     iSsid.Copy( aSSid );

   255     ShowInitialDialogL();

   256     

   257     CLOG_LEAVEFN( "CWiFiProtActiveRunner::StartProtectedSetupL" );

   258     

   259     return iReturn;

   260     }

   261 

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

   263 // CWiFiProtActiveRunner::CancelByClient()

   264 // --------------------------------------------------------------------------

   265 //

   266 void CWiFiProtActiveRunner::CancelByClient()

   267     {

   268     iClientCancelled = ETrue;

   269     Cancel();

   270     if ( iWaitDlg )

   271         {

   272         CLOG_WRITE( "Removing wait note( );" );

   273         iWaitDlg->SetCallback( NULL );

   274         

   275         TRAPD(err, iWaitDlg->ProcessFinishedL());

   276         if (err)

   277             {

   278             CLOG_WRITE( "LEAVE: iWaitDlg->ProcessFinishedL" );

   279             

   280             }

   281         delete iWaitDlg;

   282         iWaitDlg = NULL;

   283         }

   284     }

   285 

   286 // --------------------------------------------------------------------------

   287 // CWiFiProtActiveRunner::ShowInitialDialogL()

   288 // --------------------------------------------------------------------------

   289 //

   290 void CWiFiProtActiveRunner::ShowInitialDialogL()

   291     {

   292     CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowInitialDialogL" );

   293     

   294     if ( IsActive() == EFalse ) 

   295         {

   296         

   297         // Check if offline mode is on:

   298         iInOfflineMode = EFalse;

   299         if ( FeatureManager::FeatureSupported( KFeatureIdOfflineMode ) )

   300                {

   301                TInt connAllowed;

   302                CRepository* repository = CRepository::NewLC( 

   303                                                            KCRUidCoreApplicationUIs );

   304                repository->Get( KCoreAppUIsNetworkConnectionAllowed, connAllowed );

   305                CleanupStack::PopAndDestroy(repository);  // repository

   306                if ( connAllowed == 0 )

   307                    {

   308                    iInOfflineMode = ETrue;

   309                    }

   310                }

   311 

   312         if ( iInOfflineMode && iSyncMode )

   313             {

   314             // If in offline mode, query about offline mode first.

   315             iNextWiFiProtState = EWifiProtOfflineQuery;

   316             }

   317         else

   318             {

   319             // Else initiate easy setup.

   320             iNextWiFiProtState = EWiFiProtInitiateEasySetup;

   321             }

   322         

   323         iConfirmationDialog =

   324                      new ( ELeave ) CWiFiProtConfirmationNoteDlg( iStatus );

   325         iConfirmationDialog->ExecuteLD( R_WIFIPROT_CONFIGURE_AUTO_DIALOG );

   326         iORequest = EWiFiProtReqConfirmDialog;

   327         SetActive( );

   328         if ( iSyncMode )

   329             {

   330             CLOG_WRITE(  "CActiveSchedulerWait Started" );

   331             iWait.Start();

   332             CLOG_WRITE(  "CActiveSchedulerWait Returned" );

   333             }

   334                         

   335         }// do nothing if already active

   336         

   337     CLOG_LEAVEFN( "CWiFiProtActiveRunner::ShowInitialDialogL" );

   338     

   339     }

   340     

   341 // --------------------------------------------------------------------------

   342 // CWiFiProtActiveRunner::ShowInitiateEasySetupDialogL()

   343 // --------------------------------------------------------------------------

   344 //

   345 void CWiFiProtActiveRunner::ShowInitiateEasySetupDialogL()

   346     {

   347     CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowInitiateEasySetupDialogL" );

   348     

   349     iDestroyInitDialogLater = EFalse;

   350     iNextWiFiProtState = EWiFiProtUsePinCode;

   351     //store it, but not own it

   352     iInitDialog = new ( ELeave ) CWiFiProtInitiateEasySetupDlg( iStatus ); 

   353     iInitDialog->PrepareLC( R_WIFIPROT_INITIATE_EASY_SETUP_DIALOG );

   354     _LIT( KLinkStartTag, "\n<AknMessageQuery Link>" );

   355     _LIT( KLinkEndTag, "</AknMessageQuery Link>" );

   356 

   357     HBufC *messageBase =

   358              StringLoader::LoadLC( R_QTN_NETW_CONSET_WPS_MSG_PBC );

   359     HBufC* linkString1 = StringLoader::LoadLC( 

   360                             R_QTN_NETW_CONSET_WPS_MSG_LINK_USE_PIN );

   361 

   362     TInt lenMsg = messageBase->Des().Length()+

   363                   linkString1->Des().Length()+

   364                   KLinkStartTag().Length()+

   365                   KLinkEndTag().Length();    

   366     

   367     HBufC* message = HBufC::NewLC( lenMsg );

   368     TPtr messagePtr = message->Des();

   369 

   370     messagePtr.Append( messageBase->Des() ); 

   371 

   372     messagePtr.Append( KLinkStartTag ); 

   373     messagePtr.Append( linkString1->Des() );

   374     messagePtr.Append( KLinkEndTag );    

   375     

   376     iInitDialog->SetMessageTextL( messagePtr );

   377     CleanupStack::PopAndDestroy( message );

   378     

   379     CleanupStack::PopAndDestroy( linkString1 );

   380     CleanupStack::PopAndDestroy( messageBase );    

   381     TCallBack callBackLink( CWiFiProtActiveRunner::UsePinCodeLinkSelectedL,

   382                                                                      this );

   383 

   384     iInitDialog->SetLink( callBackLink  );    

   385     iInitDialog->RunLD();

   386     iORequest = EWiFiProtReqInitDialog;

   387     SetActive( );

   388     

   389     CLOG_LEAVEFN( "CWiFiProtActiveRunner::ShowInitiateEasySetupDialogL" );

   390     

   391     }

   392     

   393 // --------------------------------------------------------------------------

   394 // CWiFiProtActiveRunner::ShowEnterPinOnStationDialogL()

   395 // --------------------------------------------------------------------------

   396 //

   397 void CWiFiProtActiveRunner::ShowEnterPinOnStationDialogL()

   398     {

   399     CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowEnterPinOnStationDialogL" );

   400     

   401     iNextWiFiProtState = EWiFiProtStartingWaitDlg;

   402     TInt pin = 0;

   403     TTime t;

   404     t.HomeTime();

   405     TInt64 seed = t.Int64();

   406     do  {

   407          pin = Math::Rand( seed );

   408         }

   409         while ( pin <(10^(KMaxPINLength-2))

   410              || ( ((pin / 1000000) % 10) ) == 0 );

   411     //last digit is checksum, so we need 7 digits

   412     //and the first shouldn't be 0

   413     pin = pin % 10000000; 

   414     TInt checkSum = ComputeChecksum(pin);

   415     pin *= 10;

   416     pin += checkSum;

   417     _LIT(KPinFormat,"%d");

   418     iPIN.Format(KPinFormat, pin);

   419     

   420     CLOG_WRITE( "Enter pin code note" );

   421     

   422     HBufC* prompt =

   423      StringLoader::LoadLC( R_QTN_NETW_CONSET_WPS_INFO_ENTER_PIN_CODE, pin );

   424     CWiFiProtEnterPinDlg* pinDlg = new ( ELeave ) CWiFiProtEnterPinDlg( *this );

   425     

   426     CleanupStack::PushL(pinDlg);

   427     pinDlg->SetPromptL( *prompt );

   428     CleanupStack::Pop(pinDlg);

   429 

   430     CleanupStack::PopAndDestroy( prompt );

   431     iPinDlg = pinDlg;

   432     iPinDlg->ExecuteLD( R_WIFIPROT_ENTER_PIN_CODE_DIALOG );

   433     iPinQueryActive = ETrue;

   434     SetActive( );

   435     SetNextStateAndComplete( EWiFiProtConfiguring );

   436     CLOG_LEAVEFN( "CWiFiProtActiveRunner::ShowEnterPinOnStationDialogL" );

   437     

   438     }

   439 

   440 // --------------------------------------------------------------------------

   441 // CWiFiProtActiveRunner::ShowWaitingDialogL()

   442 // --------------------------------------------------------------------------

   443 //

   444 void CWiFiProtActiveRunner::ShowWaitingDialogL()

   445     {

   446     CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowWaitingDialogL" );

   447     HBufC* text = StringLoader::LoadLC(

   448             R_QTN_NETW_CONSET_WAIT_WPS_CONFIGURING );

   449     iWaitDlg = new ( ELeave ) CAknWaitDialog(

   450                           ( REINTERPRET_CAST( CEikDialog**, &iWaitDlg )),

   451                             ETrue );

   452     iWaitDlg->SetTextL( *text );

   453     CleanupStack::PopAndDestroy( text );

   454     iWaitDlg->SetCallback( this );

   455     iWaitDlg->SetTone( CAknNoteDialog::EConfirmationTone );

   456     iWaitDlg->ExecuteLD( R_WIFIPROT_WAIT_NOTE  );

   457     CLOG_LEAVEFN( "CWiFiProtActiveRunner::ShowWaitingDialogL" );

   458     }

   459 

   460 

   461 // --------------------------------------------------------------------------

   462 // CWiFiProtActiveRunner::ShowWaitingDialogAndProceedL()

   463 // --------------------------------------------------------------------------

   464 //

   465 void CWiFiProtActiveRunner::ShowWaitingDialogAndProceedL()

   466     {

   467     CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowWaitingDialogAndProceedL" );

   468     

   469     iStatus = KRequestPending; //should be set by service provider

   470     ShowWaitingDialogL();

   471     SetActive( );

   472     SetNextStateAndComplete( EWiFiProtConfiguring );

   473     

   474     CLOG_LEAVEFN( "CWiFiProtActiveRunner::ShowWaitingDialogAndProceedL" );

   475     

   476     }

   477 

   478 // --------------------------------------------------------------------------

   479 // CWiFiProtActiveRunner::ShowFinalNoteL()

   480 // --------------------------------------------------------------------------

   481 //

   482 void CWiFiProtActiveRunner::ShowFinalNoteL()

   483     {

   484     CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowFinalNoteL" );

   485     

   486     const TInt KSettingsConfNone = 0;

   487     const TInt KSettingsConfOne = 1;

   488     const TInt KSettingsConfMulti = 2;

   489     const TInt KResourceIdInvalid = 0;

   490     

   491     HBufC* text = NULL;

   492     TInt resId = KResourceIdInvalid;

   493     CAknNoteDialog::TTone tone = CAknNoteDialog::ENoTone;

   494     TInt numberOfNetworksConfigured = 0;

   495     if ( iIsConnectionNeeded )

   496         {

   497         // we have one network configured if we are here

   498         numberOfNetworksConfigured = 1;

   499         }

   500     else

   501         {

   502         numberOfNetworksConfigured = iCmArray.Count();

   503         }

   504         

   505     

   506     //more than one = multiple

   507     if ( numberOfNetworksConfigured > KSettingsConfOne) 

   508         {

   509         numberOfNetworksConfigured = KSettingsConfMulti;

   510         }

   511     switch ( numberOfNetworksConfigured )

   512         {

   513         case KSettingsConfOne :

   514             {

   515             CLOG_WRITE( "Show one network configured note " );

   516             HBufC* name;

   517             if ( iIsConnectionNeeded )

   518                 {

   519                 // We have to convert the 8-bit SSID to 16-bit 

   520                 HBufC* ssid16 = HBufC::NewLC( (*iIapParametersArray)

   521                     [iAvailableNetworks[

   522                             iSelectedNetworkIndex]].iSsid.Length()+1 );

   523                 TPtr ssid16Ptr( ssid16->Des() );

   524                 CnvUtfConverter::ConvertToUnicodeFromUtf8( ssid16Ptr,

   525                     (*iIapParametersArray)[iAvailableNetworks[

   526                                         iSelectedNetworkIndex]].iSsid );

   527                 ssid16Ptr.ZeroTerminate();

   528                 name = ssid16Ptr.AllocL();

   529                 CleanupStack::PopAndDestroy( ssid16 );             

   530                 }

   531             else

   532                 {

   533                 RCmConnectionMethodExt cm =

   534                      iCmManagerExt->ConnectionMethodL(

   535                                     iCmArray[0]->GetIntAttributeL( ECmId ) );

   536                 CleanupClosePushL( cm );

   537                 name =  cm.GetStringAttributeL( EWlanSSID );

   538                 CleanupStack::PopAndDestroy( &cm );

   539                 }

   540             CleanupStack::PushL( name );

   541             text = StringLoader::LoadL(

   542                  R_QTN_NETW_CONSET_CONF_WPS_ONE_NETWORK_CONFIGURED , *name);

   543             CleanupStack::PopAndDestroy( name );

   544             CleanupStack::PushL( text );

   545             resId = R_WIFIPROT_OK_NOTE;

   546             tone = CAknNoteDialog::EConfirmationTone;

   547             break;

   548             }

   549         case KSettingsConfMulti:

   550             {

   551             CLOG_WRITE( "Show multiple networks configured note " );

   552             text = StringLoader::LoadLC(

   553                  R_QTN_NETW_CONSET_CONF_WPS_MULTIPLE_NETWORKS_CONFIG );

   554             resId = R_WIFIPROT_OK_NOTE;

   555             tone = CAknNoteDialog::EConfirmationTone;

   556             break;

   557             }

   558         case KSettingsConfNone :

   559             {

   560             CLOG_WRITE( "Show no networks configured note " );

   561             text = StringLoader::LoadLC(

   562                  R_QTN_NETW_CONSET_CONF_WPS_NO_NETWORKS_CONFIGURED );

   563             resId = R_WIFIPROT_INFO_NOTE;

   564             break;

   565             }

   566         default:

   567             {

   568             //should not ever get here

   569             CLOG_WRITE( "Unhandled Final Note!!!" );

   570             User::Leave( KErrGeneral );

   571             break;            

   572             }

   573         }

   574 

   575     CAknNoteDialog* dlg = new (ELeave) CAknNoteDialog(

   576                              tone,

   577                              CAknNoteDialog::ELongTimeout );

   578     dlg->SetTextL( *text );

   579     CleanupStack::PopAndDestroy( text );   

   580     iStatus = KRequestPending; //should be set by service provider

   581     SetActive( );

   582     dlg->ExecuteLD( resId  ); 

   583     SetNextStateAndComplete( EWiFiProtFinished );

   584     

   585     CLOG_LEAVEFN( "CWiFiProtActiveRunner::ShowFinalNoteL" );

   586     

   587     }

   588 

   589 // --------------------------------------------------------------------------

   590 // CWiFiProtActiveRunner::DialogDismissedL

   591 // --------------------------------------------------------------------------

   592 //

   593 void CWiFiProtActiveRunner::DialogDismissedL( TInt aButtonId )

   594     {

   595     CLOG_ENTERFN( "CWiFiProtActiveRunner::DialogDismissedL" );

   596     

   597     //wait dialog cancelled

   598     if ( aButtonId == EAknSoftkeyCancel )

   599         {    

   600         CLOG_WRITE( "Cancel pressed!" );

   601         if (iWaitDlg)

   602             {

   603             iWaitDlgCancelled = ETrue;

   604             }

   605         iUserCancelled = ETrue;   

   606         CancelOngoingRequest();        

   607         }

   608     // iWaitDlg is destroyed, so we can null it

   609     iWaitDlg = NULL; 

   610  

   611     CLOG_LEAVEFN( "CWiFiProtActiveRunner::DialogDismissedL" );

   612     

   613     }

   614 

   615 // --------------------------------------------------------------------------

   616 // CWiFiProtActiveRunner::CreateTempIapL

   617 // --------------------------------------------------------------------------

   618 //

   619 TUint32 CWiFiProtActiveRunner::CreateTempIapL( TUint32& aTempServId )

   620     {

   621     CLOG_ENTERFN( "CWiFiProtActiveRunner::CreateTempIapL" );

   622     

   623     RCmConnectionMethodExt cm;

   624     cm = iCmManagerExt->CreateConnectionMethodL( KUidWlanBearerType );

   625     CleanupClosePushL(cm);

   626 

   627     // We have to convert the 8-bit SSID to 16-bit for CommsDat.

   628     HBufC* ssid16 = HBufC::NewLC( iSsid.Length() );

   629     TPtr ssid16Ptr( ssid16->Des() );

   630     CnvUtfConverter::ConvertToUnicodeFromUtf8( ssid16Ptr , iSsid ); 

   631     cm.SetStringAttributeL( EWlanSSID, *ssid16 ); 

   632     cm.SetStringAttributeL( ECmName, *ssid16 ); 

   633     CLOG_WRITEF( _L("SSid: ") );

   634     CLOG_WRITEF( *ssid16 );

   635     CleanupStack::PopAndDestroy( ssid16 ); 

   636     

   637     

   638     cm.SetIntAttributeL( EWlanSecurityMode, EWlanSecModeWpa2 );

   639     cm.UpdateL();

   640     

   641     aTempServId = cm.GetIntAttributeL( ECmIapServiceId );

   642     TInt32 iapID = cm.GetIntAttributeL( ECmId );

   643     

   644     CommsDat::CMDBSession* db =

   645        CommsDat::CMDBSession::NewL( CommsDat::CMDBSession::LatestVersion() );

   646     CleanupStack::PushL( db );

   647     CWPASecuritySettings* wpaSecSettings =

   648          CWPASecuritySettings::NewL( ESecurityModeWpa );

   649     CleanupStack::PushL( wpaSecSettings );      

   650     User::LeaveIfError( wpaSecSettings->SetWPAEnabledEAPPlugin( KEapWsc ) );

   651     CLOG_WRITEF( _L("Enabled EAP plugin set: EAP WSC"));

   652     if (iPIN != KNullDesC)

   653         { 

   654         User::LeaveIfError( wpaSecSettings->SetWPAPreSharedKey( iPIN ) );

   655         CLOG_WRITEF( _L("Pin set as WPA key: "));

   656         CLOG_WRITEF( iPIN );

   657         }    

   658 

   659     CLOG_WRITEF( _L("WPA settings save - ECmIapServiceId in aTempServId %d"), aTempServId );

   660     wpaSecSettings->SaveL( aTempServId , *db, ESavingBrandNewAP, 0 );

   661     CLOG_WRITEF( _L("WPA settings saved!"));

   662     CleanupStack::PopAndDestroy( wpaSecSettings );         

   663     db->Close();

   664     CleanupStack::PopAndDestroy( db ); 

   665     CleanupStack::PopAndDestroy( &cm ); 

   666     

   667     CLOG_LEAVEFN( "CWiFiProtActiveRunner::CreateTempIapL" );

   668     

   669     return iapID;

   670     }

   671 

   672 // --------------------------------------------------------------------------

   673 // CWiFiProtActiveRunner::RunProtectedSetup

   674 // --------------------------------------------------------------------------

   675 //

   676 void CWiFiProtActiveRunner::RunProtectedSetup ( const TInt32 aIapId )

   677     {

   678     

   679     CLOG_ENTERFN( "CWiFiProtActiveRunner::RunProtectedSetup" );

   680     

   681     iNextWiFiProtState = EWiFiProtWlanMgmtEngineReturned;

   682     if ( iWlanMgmtEngine ) 

   683         {

   684         CLOG_WRITEF(_L(

   685          "We have a wlanmgmt engine, calling RunProtectedSetup with uid %d")

   686          , aIapId );

   687         iWlanMgmtEngine->RunProtectedSetup( iStatus, aIapId,

   688                                             *iIapParametersArray );

   689         iORequest = EWiFiProtReqWPS;

   690         SetActive( );

   691         }

   692     else

   693         {

   694         // we complete ourselves after creating these cms synchronously

   695         //just for wins testing

   696         //add 1 conneciton method;

   697 #ifdef __WINS__

   698         CLOG_WRITE( "No wlanmgmt engine, simulating... " );

   699         TWlanProtectedSetupCredentialAttribute tmpCred;

   700         tmpCred.iOperatingMode = EWlanOperatingModeInfrastructure;

   701         tmpCred.iAuthenticationMode = EWlanAuthenticationModeOpen;

   702         tmpCred.iSecurityMode = EWlanIapSecurityModeAllowUnsecure;

   703         tmpCred.iSsid = _L8("Available Network");

   704        

   705         TRAP_IGNORE( iIapParametersArray->AppendL(tmpCred) );

   706 

   707         tmpCred.iOperatingMode = EWlanOperatingModeInfrastructure;

   708         tmpCred.iAuthenticationMode = EWlanAuthenticationModeOpen;

   709         tmpCred.iSecurityMode = EWlanIapSecurityModeAllowUnsecure;

   710         tmpCred.iSsid = _L8("Available Network 2");

   711         

   712         TRAP_IGNORE( iIapParametersArray->AppendL(tmpCred) );

   713         

   714         tmpCred.iOperatingMode = EWlanOperatingModeInfrastructure;

   715         tmpCred.iAuthenticationMode = EWlanAuthenticationModeOpen;

   716         tmpCred.iSecurityMode = EWlanIapSecurityModeAllowUnsecure;

   717         tmpCred.iSsid = _L8("Unavailable Network");

   718         

   719         TRAP_IGNORE( iIapParametersArray->AppendL(tmpCred) );

   720         

   721         iStatus = KRequestPending;

   722         SetActive( );

   723         SetNextStateAndComplete(EWiFiProtWlanMgmtEngineReturned );

   724 #else

   725         //no engine in hardware, should not ever get here!

   726         User::Panic( KWiFiPanic , KErrNotFound );

   727 #endif

   728         }

   729         

   730     CLOG_LEAVEFN( "CWiFiProtActiveRunner::RunProtectedSetup" );

   731     

   732     }

   733 

   734 // --------------------------------------------------------------------------

   735 // CWiFiProtActiveRunner::CWiFiProtActiveRunner

   736 // --------------------------------------------------------------------------

   737 //

   738 CWiFiProtActiveRunner::CWiFiProtActiveRunner( 

   739                     CWiFiProtDlgsPlugin* aParent,  TInt aPriority ) 

   740                     : CActive( aPriority ),

   741                     iParent( aParent ),

   742                     iIsConnectionNeeded( EFalse ),

   743                     iWaitDlgCancelled( EFalse ),

   744                     iSsid( KNullDesC8 ),

   745                     iPIN( KNullDesC ),

   746                     iNextWiFiProtState( EWiFiProtAskConfigureAutomatically ),

   747                     iReturn( EWiFiCancel ),

   748                     iUsePin( EFalse ),

   749                     iError( KErrNone ),

   750                     iPinQueryActive( EFalse ),

   751                     iWaitNoteNeeded( EFalse ),

   752                     iInitDialog( NULL ),

   753                     iClientCancelled( EFalse )

   754     {

   755     CLOG_ENTERFN( "CWiFiProtActiveRunner::CWiFiProtActiveRunner" );

   756     

   757     CLOG_LEAVEFN( "CWiFiProtActiveRunner::CWiFiProtActiveRunner" );

   758     

   759     }

   760 

   761 // --------------------------------------------------------------------------

   762 // CWiFiProtActiveRunner::ConstructL

   763 // --------------------------------------------------------------------------

   764 //

   765 void CWiFiProtActiveRunner::ConstructL()

   766     {

   767     CLOG_ENTERFN( "CWiFiProtActiveRunner::ConstructL" );   

   768     

   769     CActiveScheduler::Add( this );

   770 #ifndef __WINS__

   771     iWlanMgmtEngine = CWlanMgmtClient::NewL();

   772     iScanInfo = CWlanScanInfo::NewL();

   773 #endif // !__WINS__    

   774     iIapParametersArray = new (ELeave)

   775      CArrayFixSeg<TWlanProtectedSetupCredentialAttribute>

   776                                     ( KArrayGranularity );

   777 

   778     User::LeaveIfError(iNotifier.Connect()); // Connects to the extended notifier server

   779     

   780     CLOG_LEAVEFN( "CWiFiProtActiveRunner::ConstructL" );

   781     

   782     }

   783 

   784 // --------------------------------------------------------------------------

   785 // CWiFiProtActiveRunner::DoCancel

   786 // --------------------------------------------------------------------------

   787 //

   788 void CWiFiProtActiveRunner::DoCancel()

   789     { 

   790     CLOG_ENTERFN( "CWiFiProtActiveRunner::DoCancel" );

   791     

   792     CancelOngoingRequest();

   793                

   794     CLOG_LEAVEFN( "CWiFiProtActiveRunner::DoCancel" );

   795     

   796     }

   797 

   798 // --------------------------------------------------------------------------

   799 // CWiFiProtActiveRunner::RunL

   800 // --------------------------------------------------------------------------

   801 //

   802 void CWiFiProtActiveRunner::RunL()

   803     {

   804     CLOG_ENTERFN( "CWiFiProtActiveRunner::RunL" );

   805     

   806     // reset the async request id

   807     iORequest = EWiFiProtReqNone;

   808     

   809     if ( iClientCancelled )

   810         {

   811         // no further actions needed here, message completion taken care of

   812         // in the notifier

   813         return;

   814         }

   815     

   816     CLOG_WRITEF(  _L(" iNextWiFiProtState: %d"), iNextWiFiProtState );

   817     if ( iNextWiFiProtState == EWiFiProtWlanMgmtEngineReturned ) 

   818         {

   819         iORequest = EWiFiProtReqNone;

   820         //if we have a dialog and configuration is finished,

   821         // store error code for destroying dialog         

   822         iError = iStatus.Int();

   823         CleanupTempIapL();

   824         }

   825     else if ( iNextWiFiProtState == EWiFiProtDestroyWaitNote )         

   826         {

   827         DestroyWaitDialog();

   828         }

   829     else

   830         {

   831         if ( iUserCancelled )        

   832             {

   833             iStatus = KErrCancel;

   834             }

   835             

   836         if ( iStatus.Int() == KErrNone ) //no error

   837             {

   838             HandleNoErrorL();

   839             } 

   840          // error or cancel           

   841          // try to handle error, if can't, just cancel 

   842          else if ( !HandleErrorL( iStatus.Int() ) )  

   843                 {

   844                 if ( (iStatus.Int() != KErrAbort) && 

   845                      (iNextWiFiProtState == EWifiProtOfflineQuery || iNextWiFiProtState == EWiFiProtInitiateEasySetup) )

   846                     {

   847                     // Use WPS to configure or connect in offline mode? -> No -> Continue the traditional way without WPS

   848                     iReturn = EWifiNoAuto;

   849                     }

   850                  else

   851                     {

   852                     iReturn = EWiFiCancel;

   853                     }

   854                 

   855                 if ( iSyncMode )

   856                     {

   857                     if ( iWait.IsStarted() )

   858                         {

   859                         iWait.AsyncStop();

   860                         }

   861                     }

   862                 else

   863                     {

   864                     iParent->CompleteProcessL( iReturn );

   865                     }

   866                 }

   867         }

   868         

   869     CLOG_LEAVEFN( "CWiFiProtActiveRunner::RunL" );

   870     

   871     }

   872 

   873 // --------------------------------------------------------------------------

   874 // CWiFiProtActiveRunner::SetNextStateAndComplete

   875 // --------------------------------------------------------------------------

   876 //

   877 void CWiFiProtActiveRunner::SetNextStateAndComplete(

   878                                                  TWiFiProtStates aNextState,

   879                                                             TInt aError )

   880     { 

   881     CLOG_ENTERFN( "CWiFiProtActiveRunner::SetNextStateAndComplete" );

   882     

   883     iNextWiFiProtState = aNextState;

   884     CLOG_WRITEF(  _L(" aNextState: %d"), aNextState );

   885     TRequestStatus* pS = &iStatus;                

   886     User::RequestComplete( pS, aError ); 

   887     

   888     CLOG_LEAVEFN( "CWiFiProtActiveRunner::SetNextStateAndComplete" );

   889 

   890     }

   891     

   892 // --------------------------------------------------------------------------

   893 // CWiFiProtActiveRunner::ConfigureL()

   894 // --------------------------------------------------------------------------

   895 //

   896 void CWiFiProtActiveRunner::ConfigureL()

   897     {

   898     CLOG_ENTERFN( "CWiFiProtActiveRunner::ConfigureL" );

   899     iWaitNoteNeeded = ETrue;

   900     iTempIapId = CreateTempIapL( iTempServId );

   901     CLOG_WRITEF( _L("Temp Iap created! Id: %d"), iTempIapId );

   902     RunProtectedSetup( iTempServId );

   903     // do not complete self, waiting for engine or user cancel to complete us 

   904     

   905     CLOG_LEAVEFN( "CWiFiProtActiveRunner::ConfigureL" );

   906     

   907     }        

   908     

   909 // --------------------------------------------------------------------------

   910 // CWiFiProtActiveRunner::EvaluateResult

   911 // --------------------------------------------------------------------------

   912 //

   913 void CWiFiProtActiveRunner::EvaluateResult()

   914     {

   915     CLOG_ENTERFN( "CWiFiProtActiveRunner::EvaluateResult" );

   916     if (iError == KErrNone)

   917         {

   918         if ( iIsConnectionNeeded )

   919             {

   920             TRAPD(err, CheckNetworkAvailabilityL());

   921             if (err)

   922                 {

   923                 CLOG_WRITE(

   924                      "LEAVE: CheckNetworkAvailabilityL" );

   925                 }

   926             }

   927         else

   928             {

   929             CLOG_WRITE(

   930                  "SetNextStateAndComplete( EWiFiProtSettingsConfNote );" );

   931             SetNextStateAndComplete( EWiFiProtSettingsConfNote );

   932             }

   933         }

   934     else

   935         { //now we complete with the error code as dialog is finished

   936         CLOG_WRITE( "SetNextStateAndComplete( EWiFiProtFinished, iError );" );

   937         SetNextStateAndComplete( EWiFiProtFinished , iError );

   938         }

   939     CLOG_LEAVEFN( "CWiFiProtActiveRunner::EvaluateResult" );

   940     }

   941     

   942 // --------------------------------------------------------------------------

   943 // CWiFiProtActiveRunner::DestroyWaitDialog

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

   945 //

   946 void CWiFiProtActiveRunner::DestroyWaitDialog()

   947     {

   948     CLOG_ENTERFN( "CWiFiProtActiveRunner::DestroyWaitDialog" );

   949     

   950     CLOG_WRITE( "SetActive();" );

   951     SetActive();    

   952     iStatus = KRequestPending; //should be set by service provider

   953     iWaitNoteNeeded = EFalse;

   954     if( !iWaitDlgCancelled )

   955         {

   956         // iWaitDlg possibly wasn't even shown...

   957         if ( iWaitDlg )

   958             {

   959             CLOG_WRITE( "iWaitDlg->SetCallback( NULL );" );

   960             iWaitDlg->SetCallback( NULL );

   961             CLOG_WRITE( "iWaitDlg->ProcessFinishedL( );" );

   962             

   963             TRAPD(err, iWaitDlg->ProcessFinishedL());

   964             if (err)

   965                 {

   966                 CLOG_WRITE( "LEAVE: iWaitDlg->ProcessFinishedL( );" );

   967                 }

   968             

   969             CLOG_WRITE( "delete iWaitDlg;" );

   970             delete iWaitDlg;

   971             iWaitDlg = NULL;

   972             }

   973         if ( iPinQueryActive )   //waiting for PIN Query

   974             {

   975             CLOG_WRITE(

   976              "SetNextStateAndComplete( EWiFiProtWaitForPINQuery );" );

   977             // if pin query is still active, remove the cancel...

   978             if ( iPinQueryActive && iPinDlg)

   979                 {

   980                 iPinDlg->RemoveCancel();

   981                 }            

   982             iNextWiFiProtState = EWiFiProtWaitForPINQuery;

   983             }

   984         else

   985             {

   986             EvaluateResult();

   987             }

   988         }

   989     else

   990         {

   991         CLOG_WRITE(

   992          "SetNextStateAndComplete( EWiFiProtFinished, KErrCancel );" );

   993         SetNextStateAndComplete( EWiFiProtFinished , KErrCancel );

   994         }

   995     

   996     CLOG_LEAVEFN( "CWiFiProtActiveRunner::DestroyWaitDialog" );

   997     

   998     }

   999     

  1000 // --------------------------------------------------------------------------

  1001 // CWiFiProtActiveRunner::ComputeChecksum

  1002 // --------------------------------------------------------------------------

  1003 //

  1004 TInt CWiFiProtActiveRunner::ComputeChecksum(TInt aPin)

  1005     {

  1006     CLOG_ENTERFN( "CWiFiProtActiveRunner::ComputeChecksum" );

  1007     

  1008     TInt accum = 0;

  1009     aPin *= 10;

  1010     accum += 3 * ((aPin / 10000000) % 10);

  1011     accum += 1 * ((aPin / 1000000) % 10);

  1012     accum += 3 * ((aPin / 100000) % 10);

  1013     accum += 1 * ((aPin / 10000) % 10);

  1014     accum += 3 * ((aPin / 1000) % 10);

  1015     accum += 1 * ((aPin / 100) % 10);

  1016     accum += 3 * ((aPin / 10) % 10);

  1017     TInt digit = (accum % 10);

  1018         

  1019     CLOG_LEAVEFN( "CWiFiProtActiveRunner::ComputeChecksum" );

  1020     

  1021     return (10 - digit) % 10;

  1022     }

  1023 

  1024 // --------------------------------------------------------------------------

  1025 // CWiFiProtActiveRunner::CreateAllIapsL

  1026 // --------------------------------------------------------------------------

  1027 //

  1028 void CWiFiProtActiveRunner::CreateAllIapsL()

  1029     {

  1030     CreateIapL(0);

  1031     iStatus = KRequestPending; //should be set by service provider

  1032     SetActive();   

  1033     if ( iIapParametersArray->Count() )

  1034         {

  1035         //another cm, another round

  1036         SetNextStateAndComplete( EWiFiProtCreateAllIaps ); 

  1037         }

  1038      else

  1039         {

  1040         //cm creation finished

  1041         SetNextStateAndComplete( EWiFiProtDestroyWaitNote ); 

  1042         }    

  1043     }

  1044 

  1045 // --------------------------------------------------------------------------

  1046 // CWiFiProtActiveRunner::CreateIapL

  1047 // --------------------------------------------------------------------------

  1048 //

  1049 TUint32 CWiFiProtActiveRunner::CreateIapL( const TInt aIndex )

  1050     {

  1051     CLOG_ENTERFN( "CWiFiProtActiveRunner::CreateIapL" );

  1052     

  1053     TInt32 iapID = 0;

  1054     if ( iIapParametersArray->Count() )

  1055         {

  1056         RCmConnectionMethodExt cm;

  1057         cm = iCmManagerExt->CreateConnectionMethodL( KUidWlanBearerType );

  1058         CleanupClosePushL(cm);

  1059         iapID = SetIapDataL( aIndex, cm );

  1060         CleanupStack::Pop( &cm ); 

  1061         

  1062         RCmConnectionMethodExt* cmToAppend =

  1063                  new (ELeave) RCmConnectionMethodExt(cm);

  1064         CleanupStack::PushL(cmToAppend);

  1065         iCmArray.Append( cmToAppend ); //ownership transferred

  1066         CleanupStack::Pop( cmToAppend ); 

  1067         CLOG_WRITEF( _L("Cm appended to array: ") );

  1068 

  1069 

  1070         (*iIapParametersArray).Delete(aIndex);

  1071         }

  1072     

  1073        

  1074     CLOG_LEAVEFN( "CWiFiProtActiveRunner::CreateIapL" );

  1075     

  1076     return iapID;

  1077     }

  1078 

  1079 

  1080 // --------------------------------------------------------------------------

  1081 // CWiFiProtActiveRunner::SetIapDataL

  1082 // --------------------------------------------------------------------------

  1083 //

  1084 TUint32 CWiFiProtActiveRunner::SetIapDataL( const TInt aIndex,

  1085                                            RCmConnectionMethodExt& aCmToSet )

  1086     {

  1087             // We have to convert the 8-bit SSID to 16-bit for CommsDat.

  1088         HBufC* ssid16 =

  1089              HBufC::NewLC( ( *iIapParametersArray)[aIndex].iSsid.Length() );

  1090         TPtr ssid16Ptr( ssid16->Des() );

  1091         CnvUtfConverter::ConvertToUnicodeFromUtf8(

  1092                  ssid16Ptr , (*iIapParametersArray)[aIndex].iSsid ); 

  1093         

  1094         aCmToSet.SetStringAttributeL( ECmName, *ssid16 );

  1095         aCmToSet.SetStringAttributeL( EWlanSSID, *ssid16 );

  1096         CLOG_WRITEF( _L("Parameters from wlan mgmt engine: ") );

  1097         CLOG_WRITEF( _L("SSid: ") );

  1098         CLOG_WRITEF( *ssid16 );

  1099         CleanupStack::PopAndDestroy( ssid16 );

  1100 

  1101         TInt connMode = EAdhoc;

  1102         switch ( (*iIapParametersArray)[aIndex].iOperatingMode )

  1103             {

  1104             case EWlanOperatingModeAdhoc:

  1105                 {

  1106                 CLOG_WRITEF( _L("Operating Mode: Adhoc") );

  1107                 break;

  1108                 }

  1109             case EWlanOperatingModeInfrastructure:

  1110                 {

  1111                 CLOG_WRITEF( _L("Operating Mode: Infra") );

  1112                 connMode = EInfra;

  1113                 break;

  1114                 }

  1115             default:

  1116                 {

  1117                 CLOG_WRITEF( _L("Operating Mode: Not Supported") );

  1118                 User::Leave( KErrNotSupported );            

  1119                 break;

  1120                 }

  1121             }

  1122         aCmToSet.SetIntAttributeL( EWlanConnectionMode, connMode );

  1123 

  1124         CMManager::TWlanSecMode secMode = EWlanSecModeOpen;

  1125         switch( (*iIapParametersArray)[aIndex].iSecurityMode )

  1126             {

  1127             case EWlanIapSecurityModeAllowUnsecure:

  1128                 {

  1129                 CLOG_WRITEF( _L("Security Mode: Open") );

  1130                 secMode = EWlanSecModeOpen;

  1131                 break;

  1132                 }

  1133