diff -r bad0cc58d154 -r c74b3d9f6b9e wlansecuritysettings/wifiprotectedsetup/pluginsrc/wifiprotactiverunner.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wlansecuritysettings/wifiprotectedsetup/pluginsrc/wifiprotactiverunner.cpp Wed Sep 01 12:23:57 2010 +0100 @@ -0,0 +1,2056 @@ +/* +* Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Implements a state - machine like active object that controls Wi-Fi Protected Setup Process. +* +*/ + +/* +* %version: tr1cfwln#29 % +*/ + +//SYSTEM INCLUDES +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +//USER INCLUDES +#include "wifiprotlogger.h" +#include "wifiprotactiverunner.h" +#include "wifiprotconfirmationnotedlg.h" +#include "wifiprotselectnetworkdlg.h" +#include "wifiprotenterpindlg.h" +#include "wifiprotinitiateeasysetupdlg.h" + +#include "featmgr.h" + +// valid Wep key lengths, to check wep key format +// (wep key format depends on key length) +const TInt KConnUiUtilsWepLengthASCII5 = 5; +const TInt KConnUiUtilsWepLengthASCII13 = 13; +const TInt KConnUiUtilsWepLengthASCII29 = 29; +const TInt KConnUiUtilsWepLengthHEX10 = 10; +const TInt KConnUiUtilsWepLengthHEX26 = 26; +const TInt KConnUiUtilsWepLengthHEX58 = 58; +#ifdef __WINS__ +const TInt KNumberOfEmulatedAvailableNetworks = 2; +const TInt KIndexOfFirstEmulatedAvailableNetwork = 0; +const TInt KIndexOfSecondEmulatedAvailableNetwork = 1; +#endif + +/** +* Management frame information element IDs. +* needed to determine coverage +*/ +enum T802Dot11InformationElementID + { + E802Dot11SsidIE = 0, + E802Dot11SupportedRatesIE = 1, + E802Doi11FhParameterSetIE = 2, + E802Dot11DsParameterSetIE = 3, + E802Dot11CfParameterSetIE = 4, + E802Dot11TimIE = 5, + E802Dot11IbssParameterSetIE = 6, + E802Dot11CountryIE = 7, + E802Dot11HoppingPatternParamIE = 8, + E802Dot11HoppingPatternTableIE = 9, + E802Dot11RequestIE = 10, + + E802Dot11ChallengeTextIE = 16, + // Reserved for challenge text extension 17 - 31 + E802Dot11ErpInformationIE = 42, + E802Dot11ExtendedRatesIE = 50, + E802Dot11AironetIE = 133, + E802Dot11ApIpAddressIE = 149, + E802Dot11RsnIE = 221 + }; + +const TInt KArrayGranularity = 10; +const TInt KIconsGranularity = 4; + +_LIT( KWiFiFileIcons, "z:wifiprot.mbm" ); + +_LIT8( KEapWsc, "\xFE\x00\x37\x2A\x00\x00\x00\x01"); + +_LIT( KWiFiPanic, "Wi-Fi Protected Setup"); + +using namespace CMManager; + +// ================= MEMBER FUNCTIONS ======================= +// +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::NewL +// -------------------------------------------------------------------------- +// +CWiFiProtActiveRunner* CWiFiProtActiveRunner::NewL( + CWiFiProtDlgsPlugin* aParent, TInt aPriority ) + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::NewL" ); + + CWiFiProtActiveRunner* self = + new(ELeave) CWiFiProtActiveRunner( aParent, aPriority ); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop(); // self + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::NewL" ); + + return self; + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::~CWiFiProtActiveRunner +// -------------------------------------------------------------------------- +// +CWiFiProtActiveRunner::~CWiFiProtActiveRunner() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::~CWiFiProtActiveRunner" ); + + // Close notifier + iNotifier.Close(); + + Cancel(); + + // If the cancel has been initiated by the client, temp IAP cannot be deleted until + // after the RNotifier Cancel() call has returned (deadlock between MPM and CMM). + // Therefore, temp IAP cleanup must be done later. + if ( !iClientCancelled ) + { + TRAP_IGNORE( DeleteTempIapL() ); //we can't do much if delete fails + } + + delete iWlanMgmtEngine; + + // if cancelled from client, wait note may still be visible + if ( iWaitDlg ) + { + CLOG_WRITE( "iWaitDlg->SetCallback( NULL );" ); + iWaitDlg->SetCallback( NULL ); + CLOG_WRITE( "iWaitDlg->ProcessFinishedL( );" ); + TRAP_IGNORE( iWaitDlg->ProcessFinishedL() ); + delete iWaitDlg; + } + + if ( iPinDlg ) + { + delete iPinDlg; + } + + TBool cleanupCms = EFalse; + if ( iReturn == EWiFiCancel ) + { + cleanupCms = ETrue; + } + + for ( TInt i = 0; i < iCmArray.Count();i++ ) + { + // if we are setting up a connection, we save the settings into + // easy wlan iap (connection method), which we shouldn't ever delete! + if ( ( !iIsConnectionNeeded ) && cleanupCms ) + { + //we can't do much if delete fails + TRAP_IGNORE( iCmArray[i]->DeleteL() ); + } + iCmArray[i]->Close(); + delete iCmArray[i]; + iCmArray[i] = NULL; + } + + iCmArray.ResetAndDestroy(); + iAvailableNetworks.Close(); + delete iIapParametersArray; + delete iScanInfo; + CLOG_LEAVEFN( "CWiFiProtActiveRunner::~CWiFiProtActiveRunner" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::StartProtectedSetupL +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::StartProtectedSetupAsyncL ( + const TWlanSsid& aSSid, + RArray& aUids, + RCmManagerExt& aCmManagerToUse ) + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::StartProtectedSetupAsyncL" ); + + iIsConnectionNeeded = EFalse; + iUids = &aUids; + iCmManagerExt = &aCmManagerToUse; + iSsid.Copy( aSSid ); + ShowInitialDialogL(); + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::StartProtectedSetupAsyncL" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::StartProtectedSetupConnL +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::StartProtectedSetupConnL ( + const TWlanSsid& aSSid, + TWlanProtectedSetupCredentialAttribute& + aNetworkSettings, + RCmManagerExt& aCmManagerToUse ) + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::StartProtectedSetupConnL" ); + + iIsConnectionNeeded = ETrue; + iNetworkSettings = &aNetworkSettings; + iCmManagerExt = &aCmManagerToUse; + iSsid.Copy( aSSid ); + ShowInitialDialogL(); + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::StartProtectedSetupConnL" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::StartProtectedSetupL +// -------------------------------------------------------------------------- +// +WiFiProt::TWiFiReturn CWiFiProtActiveRunner::StartProtectedSetupL ( + const TWlanSsid& aSSid, + RArray& aUids, + RCmManagerExt& aCmManagerToUse ) + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::StartProtectedSetupL" ); + + iSyncMode = ETrue; + iIsConnectionNeeded = EFalse; + iUids = &aUids; + iCmManagerExt = &aCmManagerToUse; + iSsid.Copy( aSSid ); + ShowInitialDialogL(); + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::StartProtectedSetupL" ); + + return iReturn; + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::CancelByClient() +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::CancelByClient() + { + iClientCancelled = ETrue; + Cancel(); + if ( iWaitDlg ) + { + CLOG_WRITE( "Removing wait note( );" ); + iWaitDlg->SetCallback( NULL ); + + TRAPD(err, iWaitDlg->ProcessFinishedL()); + if (err) + { + CLOG_WRITE( "LEAVE: iWaitDlg->ProcessFinishedL" ); + + } + delete iWaitDlg; + iWaitDlg = NULL; + } + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::ShowInitialDialogL() +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::ShowInitialDialogL() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowInitialDialogL" ); + + if ( IsActive() == EFalse ) + { + + // Check if offline mode is on: + iInOfflineMode = EFalse; + if ( FeatureManager::FeatureSupported( KFeatureIdOfflineMode ) ) + { + TInt connAllowed; + CRepository* repository = CRepository::NewLC( + KCRUidCoreApplicationUIs ); + repository->Get( KCoreAppUIsNetworkConnectionAllowed, connAllowed ); + CleanupStack::PopAndDestroy(repository); // repository + if ( connAllowed == 0 ) + { + iInOfflineMode = ETrue; + } + } + + if ( iInOfflineMode && iSyncMode ) + { + // If in offline mode, query about offline mode first. + iNextWiFiProtState = EWifiProtOfflineQuery; + } + else + { + // Else initiate easy setup. + iNextWiFiProtState = EWiFiProtInitiateEasySetup; + } + + iConfirmationDialog = + new ( ELeave ) CWiFiProtConfirmationNoteDlg( iStatus ); + iConfirmationDialog->ExecuteLD( R_WIFIPROT_CONFIGURE_AUTO_DIALOG ); + iORequest = EWiFiProtReqConfirmDialog; + SetActive( ); + if ( iSyncMode ) + { + CLOG_WRITE( "CActiveSchedulerWait Started" ); + iWait.Start(); + CLOG_WRITE( "CActiveSchedulerWait Returned" ); + } + + }// do nothing if already active + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::ShowInitialDialogL" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::ShowInitiateEasySetupDialogL() +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::ShowInitiateEasySetupDialogL() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowInitiateEasySetupDialogL" ); + + iDestroyInitDialogLater = EFalse; + iNextWiFiProtState = EWiFiProtUsePinCode; + //store it, but not own it + iInitDialog = new ( ELeave ) CWiFiProtInitiateEasySetupDlg( iStatus ); + iInitDialog->PrepareLC( R_WIFIPROT_INITIATE_EASY_SETUP_DIALOG ); + _LIT( KLinkStartTag, "\n" ); + _LIT( KLinkEndTag, "" ); + + HBufC *messageBase = + StringLoader::LoadLC( R_QTN_NETW_CONSET_WPS_MSG_PBC ); + HBufC* linkString1 = StringLoader::LoadLC( + R_QTN_NETW_CONSET_WPS_MSG_LINK_USE_PIN ); + + TInt lenMsg = messageBase->Des().Length()+ + linkString1->Des().Length()+ + KLinkStartTag().Length()+ + KLinkEndTag().Length(); + + HBufC* message = HBufC::NewLC( lenMsg ); + TPtr messagePtr = message->Des(); + + messagePtr.Append( messageBase->Des() ); + + messagePtr.Append( KLinkStartTag ); + messagePtr.Append( linkString1->Des() ); + messagePtr.Append( KLinkEndTag ); + + iInitDialog->SetMessageTextL( messagePtr ); + CleanupStack::PopAndDestroy( message ); + + CleanupStack::PopAndDestroy( linkString1 ); + CleanupStack::PopAndDestroy( messageBase ); + TCallBack callBackLink( CWiFiProtActiveRunner::UsePinCodeLinkSelectedL, + this ); + + iInitDialog->SetLink( callBackLink ); + iInitDialog->RunLD(); + iORequest = EWiFiProtReqInitDialog; + SetActive( ); + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::ShowInitiateEasySetupDialogL" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::ShowEnterPinOnStationDialogL() +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::ShowEnterPinOnStationDialogL() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowEnterPinOnStationDialogL" ); + + iNextWiFiProtState = EWiFiProtStartingWaitDlg; + TInt pin = 0; + TTime t; + t.HomeTime(); + TInt64 seed = t.Int64(); + do { + pin = Math::Rand( seed ); + } + while ( pin <(10^(KMaxPINLength-2)) + || ( ((pin / 1000000) % 10) ) == 0 ); + //last digit is checksum, so we need 7 digits + //and the first shouldn't be 0 + pin = pin % 10000000; + TInt checkSum = ComputeChecksum(pin); + pin *= 10; + pin += checkSum; + _LIT(KPinFormat,"%d"); + iPIN.Format(KPinFormat, pin); + + CLOG_WRITE( "Enter pin code note" ); + + HBufC* prompt = + StringLoader::LoadLC( R_QTN_NETW_CONSET_WPS_INFO_ENTER_PIN_CODE, pin ); + CWiFiProtEnterPinDlg* pinDlg = new ( ELeave ) CWiFiProtEnterPinDlg( *this ); + + CleanupStack::PushL(pinDlg); + pinDlg->SetPromptL( *prompt ); + CleanupStack::Pop(pinDlg); + + CleanupStack::PopAndDestroy( prompt ); + iPinDlg = pinDlg; + iPinDlg->ExecuteLD( R_WIFIPROT_ENTER_PIN_CODE_DIALOG ); + iPinQueryActive = ETrue; + SetActive( ); + SetNextStateAndComplete( EWiFiProtConfiguring ); + CLOG_LEAVEFN( "CWiFiProtActiveRunner::ShowEnterPinOnStationDialogL" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::ShowWaitingDialogL() +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::ShowWaitingDialogL() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowWaitingDialogL" ); + HBufC* text = StringLoader::LoadLC( + R_QTN_NETW_CONSET_WAIT_WPS_CONFIGURING ); + iWaitDlg = new ( ELeave ) CAknWaitDialog( + ( REINTERPRET_CAST( CEikDialog**, &iWaitDlg )), + ETrue ); + iWaitDlg->SetTextL( *text ); + CleanupStack::PopAndDestroy( text ); + iWaitDlg->SetCallback( this ); + iWaitDlg->SetTone( CAknNoteDialog::EConfirmationTone ); + iWaitDlg->ExecuteLD( R_WIFIPROT_WAIT_NOTE ); + CLOG_LEAVEFN( "CWiFiProtActiveRunner::ShowWaitingDialogL" ); + } + + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::ShowWaitingDialogAndProceedL() +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::ShowWaitingDialogAndProceedL() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowWaitingDialogAndProceedL" ); + + iStatus = KRequestPending; //should be set by service provider + ShowWaitingDialogL(); + SetActive( ); + SetNextStateAndComplete( EWiFiProtConfiguring ); + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::ShowWaitingDialogAndProceedL" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::ShowFinalNoteL() +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::ShowFinalNoteL() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowFinalNoteL" ); + + const TInt KSettingsConfNone = 0; + const TInt KSettingsConfOne = 1; + const TInt KSettingsConfMulti = 2; + const TInt KResourceIdInvalid = 0; + + HBufC* text = NULL; + TInt resId = KResourceIdInvalid; + CAknNoteDialog::TTone tone = CAknNoteDialog::ENoTone; + TInt numberOfNetworksConfigured = 0; + if ( iIsConnectionNeeded ) + { + // we have one network configured if we are here + numberOfNetworksConfigured = 1; + } + else + { + numberOfNetworksConfigured = iCmArray.Count(); + } + + + //more than one = multiple + if ( numberOfNetworksConfigured > KSettingsConfOne) + { + numberOfNetworksConfigured = KSettingsConfMulti; + } + switch ( numberOfNetworksConfigured ) + { + case KSettingsConfOne : + { + CLOG_WRITE( "Show one network configured note " ); + HBufC* name; + if ( iIsConnectionNeeded ) + { + // We have to convert the 8-bit SSID to 16-bit + HBufC* ssid16 = HBufC::NewLC( (*iIapParametersArray) + [iAvailableNetworks[ + iSelectedNetworkIndex]].iSsid.Length()+1 ); + TPtr ssid16Ptr( ssid16->Des() ); + CnvUtfConverter::ConvertToUnicodeFromUtf8( ssid16Ptr, + (*iIapParametersArray)[iAvailableNetworks[ + iSelectedNetworkIndex]].iSsid ); + ssid16Ptr.ZeroTerminate(); + name = ssid16Ptr.AllocL(); + CleanupStack::PopAndDestroy( ssid16 ); + } + else + { + RCmConnectionMethodExt cm = + iCmManagerExt->ConnectionMethodL( + iCmArray[0]->GetIntAttributeL( ECmId ) ); + CleanupClosePushL( cm ); + name = cm.GetStringAttributeL( EWlanSSID ); + CleanupStack::PopAndDestroy( &cm ); + } + CleanupStack::PushL( name ); + text = StringLoader::LoadL( + R_QTN_NETW_CONSET_CONF_WPS_ONE_NETWORK_CONFIGURED , *name); + CleanupStack::PopAndDestroy( name ); + CleanupStack::PushL( text ); + resId = R_WIFIPROT_OK_NOTE; + tone = CAknNoteDialog::EConfirmationTone; + break; + } + case KSettingsConfMulti: + { + CLOG_WRITE( "Show multiple networks configured note " ); + text = StringLoader::LoadLC( + R_QTN_NETW_CONSET_CONF_WPS_MULTIPLE_NETWORKS_CONFIG ); + resId = R_WIFIPROT_OK_NOTE; + tone = CAknNoteDialog::EConfirmationTone; + break; + } + case KSettingsConfNone : + { + CLOG_WRITE( "Show no networks configured note " ); + text = StringLoader::LoadLC( + R_QTN_NETW_CONSET_CONF_WPS_NO_NETWORKS_CONFIGURED ); + resId = R_WIFIPROT_INFO_NOTE; + break; + } + default: + { + //should not ever get here + CLOG_WRITE( "Unhandled Final Note!!!" ); + User::Leave( KErrGeneral ); + break; + } + } + + CAknNoteDialog* dlg = new (ELeave) CAknNoteDialog( + tone, + CAknNoteDialog::ELongTimeout ); + dlg->SetTextL( *text ); + CleanupStack::PopAndDestroy( text ); + iStatus = KRequestPending; //should be set by service provider + SetActive( ); + dlg->ExecuteLD( resId ); + SetNextStateAndComplete( EWiFiProtFinished ); + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::ShowFinalNoteL" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::DialogDismissedL +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::DialogDismissedL( TInt aButtonId ) + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::DialogDismissedL" ); + + //wait dialog cancelled + if ( aButtonId == EAknSoftkeyCancel ) + { + CLOG_WRITE( "Cancel pressed!" ); + if (iWaitDlg) + { + iWaitDlgCancelled = ETrue; + } + iUserCancelled = ETrue; + CancelOngoingRequest(); + } + // iWaitDlg is destroyed, so we can null it + iWaitDlg = NULL; + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::DialogDismissedL" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::CreateTempIapL +// -------------------------------------------------------------------------- +// +TUint32 CWiFiProtActiveRunner::CreateTempIapL( TUint32& aTempServId ) + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::CreateTempIapL" ); + + RCmConnectionMethodExt cm; + cm = iCmManagerExt->CreateConnectionMethodL( KUidWlanBearerType ); + CleanupClosePushL(cm); + + // We have to convert the 8-bit SSID to 16-bit for CommsDat. + HBufC* ssid16 = HBufC::NewLC( iSsid.Length() ); + TPtr ssid16Ptr( ssid16->Des() ); + CnvUtfConverter::ConvertToUnicodeFromUtf8( ssid16Ptr , iSsid ); + cm.SetStringAttributeL( EWlanSSID, *ssid16 ); + cm.SetStringAttributeL( ECmName, *ssid16 ); + CLOG_WRITEF( _L("SSid: ") ); + CLOG_WRITEF( *ssid16 ); + CleanupStack::PopAndDestroy( ssid16 ); + + + cm.SetIntAttributeL( EWlanSecurityMode, EWlanSecModeWpa2 ); + cm.UpdateL(); + + aTempServId = cm.GetIntAttributeL( ECmIapServiceId ); + TInt32 iapID = cm.GetIntAttributeL( ECmId ); + + CommsDat::CMDBSession* db = + CommsDat::CMDBSession::NewL( CommsDat::CMDBSession::LatestVersion() ); + CleanupStack::PushL( db ); + CWPASecuritySettings* wpaSecSettings = + CWPASecuritySettings::NewL( ESecurityModeWpa ); + CleanupStack::PushL( wpaSecSettings ); + User::LeaveIfError( wpaSecSettings->SetWPAEnabledEAPPlugin( KEapWsc ) ); + CLOG_WRITEF( _L("Enabled EAP plugin set: EAP WSC")); + if (iPIN != KNullDesC) + { + User::LeaveIfError( wpaSecSettings->SetWPAPreSharedKey( iPIN ) ); + CLOG_WRITEF( _L("Pin set as WPA key: ")); + CLOG_WRITEF( iPIN ); + } + + CLOG_WRITEF( _L("WPA settings save - ECmIapServiceId in aTempServId %d"), aTempServId ); + wpaSecSettings->SaveL( aTempServId , *db, ESavingBrandNewAP, 0 ); + CLOG_WRITEF( _L("WPA settings saved!")); + CleanupStack::PopAndDestroy( wpaSecSettings ); + db->Close(); + CleanupStack::PopAndDestroy( db ); + CleanupStack::PopAndDestroy( &cm ); + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::CreateTempIapL" ); + + return iapID; + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::RunProtectedSetup +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::RunProtectedSetup ( const TInt32 aIapId ) + { + + CLOG_ENTERFN( "CWiFiProtActiveRunner::RunProtectedSetup" ); + + iNextWiFiProtState = EWiFiProtWlanMgmtEngineReturned; + if ( iWlanMgmtEngine ) + { + CLOG_WRITEF(_L( + "We have a wlanmgmt engine, calling RunProtectedSetup with uid %d") + , aIapId ); + iWlanMgmtEngine->RunProtectedSetup( iStatus, aIapId, + *iIapParametersArray ); + iORequest = EWiFiProtReqWPS; + SetActive( ); + } + else + { + // we complete ourselves after creating these cms synchronously + //just for wins testing + //add 1 conneciton method; +#ifdef __WINS__ + CLOG_WRITE( "No wlanmgmt engine, simulating... " ); + TWlanProtectedSetupCredentialAttribute tmpCred; + tmpCred.iOperatingMode = EWlanOperatingModeInfrastructure; + tmpCred.iAuthenticationMode = EWlanAuthenticationModeOpen; + tmpCred.iSecurityMode = EWlanIapSecurityModeAllowUnsecure; + tmpCred.iSsid = _L8("Available Network"); + + TRAP_IGNORE( iIapParametersArray->AppendL(tmpCred) ); + + tmpCred.iOperatingMode = EWlanOperatingModeInfrastructure; + tmpCred.iAuthenticationMode = EWlanAuthenticationModeOpen; + tmpCred.iSecurityMode = EWlanIapSecurityModeAllowUnsecure; + tmpCred.iSsid = _L8("Available Network 2"); + + TRAP_IGNORE( iIapParametersArray->AppendL(tmpCred) ); + + tmpCred.iOperatingMode = EWlanOperatingModeInfrastructure; + tmpCred.iAuthenticationMode = EWlanAuthenticationModeOpen; + tmpCred.iSecurityMode = EWlanIapSecurityModeAllowUnsecure; + tmpCred.iSsid = _L8("Unavailable Network"); + + TRAP_IGNORE( iIapParametersArray->AppendL(tmpCred) ); + + iStatus = KRequestPending; + SetActive( ); + SetNextStateAndComplete(EWiFiProtWlanMgmtEngineReturned ); +#else + //no engine in hardware, should not ever get here! + User::Panic( KWiFiPanic , KErrNotFound ); +#endif + } + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::RunProtectedSetup" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::CWiFiProtActiveRunner +// -------------------------------------------------------------------------- +// +CWiFiProtActiveRunner::CWiFiProtActiveRunner( + CWiFiProtDlgsPlugin* aParent, TInt aPriority ) + : CActive( aPriority ), + iParent( aParent ), + iIsConnectionNeeded( EFalse ), + iWaitDlgCancelled( EFalse ), + iSsid( KNullDesC8 ), + iPIN( KNullDesC ), + iNextWiFiProtState( EWiFiProtAskConfigureAutomatically ), + iReturn( EWiFiCancel ), + iUsePin( EFalse ), + iError( KErrNone ), + iPinQueryActive( EFalse ), + iWaitNoteNeeded( EFalse ), + iInitDialog( NULL ), + iClientCancelled( EFalse ) + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::CWiFiProtActiveRunner" ); + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::CWiFiProtActiveRunner" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::ConstructL +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::ConstructL() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::ConstructL" ); + + CActiveScheduler::Add( this ); +#ifndef __WINS__ + iWlanMgmtEngine = CWlanMgmtClient::NewL(); + iScanInfo = CWlanScanInfo::NewL(); +#endif // !__WINS__ + iIapParametersArray = new (ELeave) + CArrayFixSeg + ( KArrayGranularity ); + + User::LeaveIfError(iNotifier.Connect()); // Connects to the extended notifier server + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::ConstructL" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::DoCancel +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::DoCancel() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::DoCancel" ); + + CancelOngoingRequest(); + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::DoCancel" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::RunL +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::RunL() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::RunL" ); + + // reset the async request id + iORequest = EWiFiProtReqNone; + + if ( iClientCancelled ) + { + // no further actions needed here, message completion taken care of + // in the notifier + return; + } + + CLOG_WRITEF( _L(" iNextWiFiProtState: %d"), iNextWiFiProtState ); + if ( iNextWiFiProtState == EWiFiProtWlanMgmtEngineReturned ) + { + iORequest = EWiFiProtReqNone; + //if we have a dialog and configuration is finished, + // store error code for destroying dialog + iError = iStatus.Int(); + CleanupTempIapL(); + } + else if ( iNextWiFiProtState == EWiFiProtDestroyWaitNote ) + { + DestroyWaitDialog(); + } + else + { + if ( iUserCancelled ) + { + iStatus = KErrCancel; + } + + if ( iStatus.Int() == KErrNone ) //no error + { + HandleNoErrorL(); + } + // error or cancel + // try to handle error, if can't, just cancel + else if ( !HandleErrorL( iStatus.Int() ) ) + { + if ( (iStatus.Int() != KErrAbort) && + (iNextWiFiProtState == EWifiProtOfflineQuery || iNextWiFiProtState == EWiFiProtInitiateEasySetup) ) + { + // Use WPS to configure or connect in offline mode? -> No -> Continue the traditional way without WPS + iReturn = EWifiNoAuto; + } + else + { + iReturn = EWiFiCancel; + } + + if ( iSyncMode ) + { + if ( iWait.IsStarted() ) + { + iWait.AsyncStop(); + } + } + else + { + iParent->CompleteProcessL( iReturn ); + } + } + } + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::RunL" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::SetNextStateAndComplete +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::SetNextStateAndComplete( + TWiFiProtStates aNextState, + TInt aError ) + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::SetNextStateAndComplete" ); + + iNextWiFiProtState = aNextState; + CLOG_WRITEF( _L(" aNextState: %d"), aNextState ); + TRequestStatus* pS = &iStatus; + User::RequestComplete( pS, aError ); + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::SetNextStateAndComplete" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::ConfigureL() +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::ConfigureL() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::ConfigureL" ); + iWaitNoteNeeded = ETrue; + iTempIapId = CreateTempIapL( iTempServId ); + CLOG_WRITEF( _L("Temp Iap created! Id: %d"), iTempIapId ); + RunProtectedSetup( iTempServId ); + // do not complete self, waiting for engine or user cancel to complete us + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::ConfigureL" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::EvaluateResult +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::EvaluateResult() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::EvaluateResult" ); + if (iError == KErrNone) + { + if ( iIsConnectionNeeded ) + { + TRAPD(err, CheckNetworkAvailabilityL()); + if (err) + { + CLOG_WRITE( + "LEAVE: CheckNetworkAvailabilityL" ); + } + } + else + { + CLOG_WRITE( + "SetNextStateAndComplete( EWiFiProtSettingsConfNote );" ); + SetNextStateAndComplete( EWiFiProtSettingsConfNote ); + } + } + else + { //now we complete with the error code as dialog is finished + CLOG_WRITE( "SetNextStateAndComplete( EWiFiProtFinished, iError );" ); + SetNextStateAndComplete( EWiFiProtFinished , iError ); + } + CLOG_LEAVEFN( "CWiFiProtActiveRunner::EvaluateResult" ); + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::DestroyWaitDialog +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::DestroyWaitDialog() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::DestroyWaitDialog" ); + + CLOG_WRITE( "SetActive();" ); + SetActive(); + iStatus = KRequestPending; //should be set by service provider + iWaitNoteNeeded = EFalse; + if( !iWaitDlgCancelled ) + { + // iWaitDlg possibly wasn't even shown... + if ( iWaitDlg ) + { + CLOG_WRITE( "iWaitDlg->SetCallback( NULL );" ); + iWaitDlg->SetCallback( NULL ); + CLOG_WRITE( "iWaitDlg->ProcessFinishedL( );" ); + + TRAPD(err, iWaitDlg->ProcessFinishedL()); + if (err) + { + CLOG_WRITE( "LEAVE: iWaitDlg->ProcessFinishedL( );" ); + } + + CLOG_WRITE( "delete iWaitDlg;" ); + delete iWaitDlg; + iWaitDlg = NULL; + } + if ( iPinQueryActive ) //waiting for PIN Query + { + CLOG_WRITE( + "SetNextStateAndComplete( EWiFiProtWaitForPINQuery );" ); + // if pin query is still active, remove the cancel... + if ( iPinQueryActive && iPinDlg) + { + iPinDlg->RemoveCancel(); + } + iNextWiFiProtState = EWiFiProtWaitForPINQuery; + } + else + { + EvaluateResult(); + } + } + else + { + CLOG_WRITE( + "SetNextStateAndComplete( EWiFiProtFinished, KErrCancel );" ); + SetNextStateAndComplete( EWiFiProtFinished , KErrCancel ); + } + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::DestroyWaitDialog" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::ComputeChecksum +// -------------------------------------------------------------------------- +// +TInt CWiFiProtActiveRunner::ComputeChecksum(TInt aPin) + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::ComputeChecksum" ); + + TInt accum = 0; + aPin *= 10; + accum += 3 * ((aPin / 10000000) % 10); + accum += 1 * ((aPin / 1000000) % 10); + accum += 3 * ((aPin / 100000) % 10); + accum += 1 * ((aPin / 10000) % 10); + accum += 3 * ((aPin / 1000) % 10); + accum += 1 * ((aPin / 100) % 10); + accum += 3 * ((aPin / 10) % 10); + TInt digit = (accum % 10); + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::ComputeChecksum" ); + + return (10 - digit) % 10; + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::CreateAllIapsL +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::CreateAllIapsL() + { + CreateIapL(0); + iStatus = KRequestPending; //should be set by service provider + SetActive(); + if ( iIapParametersArray->Count() ) + { + //another cm, another round + SetNextStateAndComplete( EWiFiProtCreateAllIaps ); + } + else + { + //cm creation finished + SetNextStateAndComplete( EWiFiProtDestroyWaitNote ); + } + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::CreateIapL +// -------------------------------------------------------------------------- +// +TUint32 CWiFiProtActiveRunner::CreateIapL( const TInt aIndex ) + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::CreateIapL" ); + + TInt32 iapID = 0; + if ( iIapParametersArray->Count() ) + { + RCmConnectionMethodExt cm; + cm = iCmManagerExt->CreateConnectionMethodL( KUidWlanBearerType ); + CleanupClosePushL(cm); + iapID = SetIapDataL( aIndex, cm ); + CleanupStack::Pop( &cm ); + + RCmConnectionMethodExt* cmToAppend = + new (ELeave) RCmConnectionMethodExt(cm); + CleanupStack::PushL(cmToAppend); + iCmArray.Append( cmToAppend ); //ownership transferred + CleanupStack::Pop( cmToAppend ); + CLOG_WRITEF( _L("Cm appended to array: ") ); + + + (*iIapParametersArray).Delete(aIndex); + } + + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::CreateIapL" ); + + return iapID; + } + + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::SetIapDataL +// -------------------------------------------------------------------------- +// +TUint32 CWiFiProtActiveRunner::SetIapDataL( const TInt aIndex, + RCmConnectionMethodExt& aCmToSet ) + { + // We have to convert the 8-bit SSID to 16-bit for CommsDat. + HBufC* ssid16 = + HBufC::NewLC( ( *iIapParametersArray)[aIndex].iSsid.Length() ); + TPtr ssid16Ptr( ssid16->Des() ); + CnvUtfConverter::ConvertToUnicodeFromUtf8( + ssid16Ptr , (*iIapParametersArray)[aIndex].iSsid ); + + aCmToSet.SetStringAttributeL( ECmName, *ssid16 ); + aCmToSet.SetStringAttributeL( EWlanSSID, *ssid16 ); + CLOG_WRITEF( _L("Parameters from wlan mgmt engine: ") ); + CLOG_WRITEF( _L("SSid: ") ); + CLOG_WRITEF( *ssid16 ); + CleanupStack::PopAndDestroy( ssid16 ); + + TInt connMode = EAdhoc; + switch ( (*iIapParametersArray)[aIndex].iOperatingMode ) + { + case EWlanOperatingModeAdhoc: + { + CLOG_WRITEF( _L("Operating Mode: Adhoc") ); + break; + } + case EWlanOperatingModeInfrastructure: + { + CLOG_WRITEF( _L("Operating Mode: Infra") ); + connMode = EInfra; + break; + } + default: + { + CLOG_WRITEF( _L("Operating Mode: Not Supported") ); + User::Leave( KErrNotSupported ); + break; + } + } + aCmToSet.SetIntAttributeL( EWlanConnectionMode, connMode ); + + CMManager::TWlanSecMode secMode = EWlanSecModeOpen; + switch( (*iIapParametersArray)[aIndex].iSecurityMode ) + { + case EWlanIapSecurityModeAllowUnsecure: + { + CLOG_WRITEF( _L("Security Mode: Open") ); + secMode = EWlanSecModeOpen; + break; + } + + case EWlanIapSecurityModeWep: + { + CLOG_WRITEF( _L("Security Mode: Wep") ); + secMode = EWlanSecModeWep; + break; + } + + case EWlanIapSecurityMode802d1x: + { + CLOG_WRITEF( _L("Security Mode: 802_1x") ); + secMode = EWlanSecMode802_1x; + break; + } + + // EWlanIapSecurityModeWpa and + // EWlanIapSecurityModeWpa2Only are handled as wpa + case EWlanIapSecurityModeWpa: + case EWlanIapSecurityModeWpa2Only: + { + CLOG_WRITEF( _L("Security Mode: wpa") ); + secMode = EWlanSecModeWpa; + break; + } + + default: + { + User::Leave( KErrNotSupported ); + } + } + + aCmToSet.SetIntAttributeL( EWlanSecurityMode, secMode ); + + aCmToSet.UpdateL(); + TInt32 wlanServId = aCmToSet.GetIntAttributeL( ECmIapServiceId ); + TInt32 iapID = aCmToSet.GetIntAttributeL( ECmId ); + + CommsDat::CMDBSession* db = + CommsDat::CMDBSession::NewL( + CommsDat::CMDBSession::LatestVersion() ); + CleanupStack::PushL( db ); + + switch( (*iIapParametersArray)[aIndex].iSecurityMode ) + { + case EWlanIapSecurityModeWep: + { + SaveWepSecuritySettingsL( + ( *iIapParametersArray )[aIndex], wlanServId, *db ); + break; + } + // EWlanIapSecurityModeWpa and + // EWlanIapSecurityModeWpa2Only are handled as wpa + case EWlanIapSecurityModeWpa: + case EWlanIapSecurityModeWpa2Only: + { + CWPASecuritySettings* wpaSecSettings = + CWPASecuritySettings::NewL( ESecurityModeWpa ); + CleanupStack::PushL( wpaSecSettings ); + if ((*iIapParametersArray) + [aIndex].iWpaPreSharedKey != KNullDesC8) + { + TBuf wpaBuf16; + wpaBuf16.Copy((*iIapParametersArray) + [aIndex].iWpaPreSharedKey); + User::LeaveIfError( + wpaSecSettings->SetWPAPreSharedKey( wpaBuf16 ) ); + CLOG_WRITEF( _L("wpa psk set: ") ); + CLOG_WRITEF( wpaBuf16 ); + + } + + TTypeOfSaving typeOfSaving = ESavingBrandNewAP; + + if ( iapID == iCmManagerExt->EasyWlanIdL() ) + { + typeOfSaving = ESavingEditedAP; + } + + wpaSecSettings->SaveL( wlanServId, *db, + typeOfSaving, 0 ) ; + + CleanupStack::PopAndDestroy( wpaSecSettings ); + break; + } + // EWlanIapSecurityMode802d1x and + // EWlanConnectionSecurityOpen - no key needs to be saved + case EWlanIapSecurityMode802d1x: + case EWlanConnectionSecurityOpen: + default: + { + break; + } + } + + db->Close(); + CleanupStack::PopAndDestroy( db ); + return iapID; + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::CleanupTempIapL() +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::CleanupTempIapL() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::CleanupTempIapL" ); + + //we don't need the temp iap anymore, delete it + //shouldn't be any errors, because nobody else knows about our temp iap + DeleteTempIapL(); + SetActive(); + iStatus = KRequestPending; //should be set by service provider + if ( iError == KErrNone ) + { + if ( iIsConnectionNeeded ) + { + StartWlanScan(); //scan wlan before we close the wait dialog + } + else + { + //start creating iaps + SetNextStateAndComplete( EWiFiProtCreateAllIaps ); + } + } + else + { + //don't create iaps or scan wlan, we had an error! + SetNextStateAndComplete( EWiFiProtDestroyWaitNote ); + } + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::CleanupTempIapL" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::DeleteTempIapL() +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::DeleteTempIapL() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::DeleteTempIapL" ); + + if ( iTempIapId ) + { + const TInt KInvalidUid = 0; + + CLOG_WRITE( "Calling iCmManagerExt->ConnectionMethodL" ); + + RCmConnectionMethodExt cm = + iCmManagerExt->ConnectionMethodL(iTempIapId); + + CLOG_WRITE( "Calling cm.DeleteL" ); + + TRAPD(err, cm.DeleteL()); + CLOG_WRITEF( _L("Temp Iap deleted! Error code: %d"), err ); + cm.Close(); + iTempIapId = KInvalidUid; + } + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::DeleteTempIapL" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::IsWepFormatHexL +// -------------------------------------------------------------------------- +// +TBool CWiFiProtActiveRunner::IsWepFormatHexL( TInt aLength ) + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::IsWepFormatHexL" ); + + if ( ( aLength == KConnUiUtilsWepLengthASCII5 ) || + ( aLength == KConnUiUtilsWepLengthASCII13 ) || + ( aLength == KConnUiUtilsWepLengthASCII29 ) ) + { + return EFalse; + } + else if ( ( aLength == KConnUiUtilsWepLengthHEX10 ) || + ( aLength == KConnUiUtilsWepLengthHEX26 ) || + ( aLength == KConnUiUtilsWepLengthHEX58 ) ) + { + return ETrue; + } + else + { + User::Leave( KErrNotSupported ); + } + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::IsWepFormatHexL" ); + + return EFalse; + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::SaveWepSecuritySettingsL +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::SaveWepSecuritySettingsL( + TWlanProtectedSetupCredentialAttribute + aCredentialAttribute, + TUint32 aWlanServiceId, + CommsDat::CMDBSession& aDb ) + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::SaveWepSecuritySettingsL" ); + + CWEPSecuritySettings* wepSecSettings = CWEPSecuritySettings::NewL( ); + CleanupStack::PushL( wepSecSettings ); + TInt keyIndex = 0; + // wep key 1 + SetWepKeyL( *wepSecSettings, aCredentialAttribute.iWepKey1, keyIndex ); + keyIndex++; + // wep key 2 + SetWepKeyL( *wepSecSettings, aCredentialAttribute.iWepKey2, keyIndex ); + keyIndex++; + // wep key 3 + SetWepKeyL( *wepSecSettings, aCredentialAttribute.iWepKey3, keyIndex ); + keyIndex++; + // wep key 4 + SetWepKeyL( *wepSecSettings, aCredentialAttribute.iWepKey4, keyIndex ); + + //should be the same enum + wepSecSettings->SetKeyInUse( (CWEPSecuritySettings::TWEPKeyInUse) + aCredentialAttribute.iWepDefaultKey ); + CLOG_WRITEF( _L("Wep key in use %d:"), + aCredentialAttribute.iWepDefaultKey ); + + CWEPSecuritySettings::TWEPAuthentication auth = + CWEPSecuritySettings::EAuthOpen; + + switch( aCredentialAttribute.iAuthenticationMode ) + { + case EWlanAuthenticationModeOpen: + { + CLOG_WRITEF( _L("Authentication mode: open") ); + break; + } + case EWlanAuthenticationModeShared: + { + CLOG_WRITEF( _L("Authentication mode: shared") ); + auth = CWEPSecuritySettings::EAuthShared; + break; + } + default: + { + break; + } + } + + //should be the same enum + wepSecSettings->SetAuthentication( + (CWEPSecuritySettings::TWEPAuthentication) auth ); + wepSecSettings->SaveL( aWlanServiceId, aDb ) ; + CleanupStack::PopAndDestroy( wepSecSettings ); + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::SaveWepSecuritySettingsL" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::HandleErrorL() +// -------------------------------------------------------------------------- +// +TBool CWiFiProtActiveRunner::HandleErrorL( TInt aErrorCode ) + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::HandleErrorL" ); + + CLOG_WRITEF( _L("Error code: %d"), aErrorCode ); + if (iWaitDlg) //close dialog first + { + TInt error = iStatus.Int(); + iStatus = KRequestPending; //should be set by service provider + SetActive( ); + SetNextStateAndComplete( EWiFiProtDestroyWaitNote , error ); + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::HandleErrorL" ); + + return ETrue; + } + else + { + TWiFiProtStates nextState = EWiFiProtFinished; + TInt textResId = 0; + TInt status = KErrCancel; + TBool ret = ETrue; + switch (aErrorCode) + { + // Error codes are in the original order + case KErrWlanProtectedSetupOOBInterfaceReadError: + case KErrWlanProtectedSetupDecryptionCRCFailure: + // the same handling here for this error code too + { + textResId = R_QTN_ERR_WLAN_SC_CONFIG_FAILED_TRY_AGAIN; + break; + } + case KErrWlanProtectedSetup5_0ChannelNotSupported: + case KErrWlanProtectedSetup2_4ChannelNotSupported: + // the same handling here for this error code too + { + textResId = R_QTN_ERR_WLAN_SC_CONFIG_FAILED; + break; + } + case KErrWlanSignalTooWeak: + { + textResId = R_QTN_ERR_WLAN_SIGNAL_TOO_WEAK; + break; + } + case KErrWlanProtectedSetupNetworkAuthFailure: + { + status = KErrNone; + textResId = R_QTN_ERR_WLAN_SC_CONFIG_FAILED_TRY_AGAIN; + if ( iUsePin ) + { + // ...pin code dialog if pin code was used + nextState = EWiFiProtUsePinCode; + } + else + { + // ... or initiate WPS dialog if push button was used + nextState = EWiFiProtInitiateEasySetup; + } + break; + } + case KErrWlanProtectedSetupNetworkAssociationFailure: + { + textResId = R_QTN_ERR_WLAN_NETWORK_NOT_FOUND; + break; + } + case KErrWlanProtectedSetupNoDHCPResponse: + case KErrWlanProtectedSetupFailedDHCPConfig: + // the same handling here for this error code too + case KErrWlanProtectedSetupIPAddressConflict: + // the same handling here for this error code too + case KErrWlanProtectedSetupCouldNotConnectToRegistrar: + // the same handling here for this error code too + { + textResId = R_QTN_ERR_WLAN_SC_CONFIG_FAILED; + break; + } + case KErrWlanProtectedSetupMultiplePBCSessionsDetected: + { + nextState = EWiFiProtInitiateEasySetup; + status = KErrNone; + textResId = + R_QTN_ERR_WLAN_SC_CONFIG_FAILED_MULTIPLE_PB_SESSIONS; + break; + } + case KErrWlanProtectedSetupRogueActivitySuspected: + { + nextState = EWiFiProtUsePinCode; + iUsePin = ETrue; + status = KErrNone; + textResId = + R_QTN_ERR_WLAN_SC_CONFIG_FAILED_ROGUE_ACTIVITY; + break; + } + case KErrWlanProtectedSetupDeviceBusy: + case KErrWlanProtectedSetupSetupLocked: + // the same handling here for this error code too + case KErrWlanProtectedSetupMessageTimeout: + // the same handling here for this error code too + { + textResId = R_QTN_ERR_WLAN_SC_CONFIG_FAILED_TRY_AGAIN; + break; + } + case KErrWlanProtectedSetupRegistrationSessionTimeout: + { + textResId = R_QTN_ERR_WLAN_SC_CONFIG_FAILED_TRY_AGAIN; + status = KErrNone; + // Registration session timeout, return to ... + if ( iUsePin ) + { + // ...pin code dialog if pin code was used + nextState = EWiFiProtUsePinCode; + } + else + { + // ... or initiate WPS dialog if push button was used + nextState = EWiFiProtInitiateEasySetup; + } + break; + } + case KErrWlanProtectedSetupDevicePasswordAuthFailure: + { + status = KErrNone; + textResId = R_QTN_ERR_WLAN_SC_CONFIG_FAILED_TRY_AGAIN; + if ( iUsePin ) + { + // ...pin code dialog if pin code was used + nextState = EWiFiProtUsePinCode; + } + else + { + // ... or initiate WPS dialog if push button was used + nextState = EWiFiProtInitiateEasySetup; + } + break; + } + case KErrWlanProtectedSetupPINMethodNotSupported: + { + textResId = + R_QTN_ERR_WLAN_SC_CONFIG_FAILED_PIN_NOT_SUPPORTED; + break; + } + case KErrWlanProtectedSetupPBMethodNotSupported: + { + textResId = + R_QTN_ERR_WLAN_SC_CONFIG_FAILED_PB_NOT_SUPPORTED; + break; + } + case KErrWlanConnAlreadyActive: + { + textResId = R_QTN_WLAN_INFO_CONNECTION_ALREADY_ACTIVE; + break; + } + default: + { + ret = EFalse; + } + } + if (ret) + { + HBufC* text = StringLoader::LoadLC( textResId ); + CLOG_WRITEF( *text ); + CAknNoteDialog* dlg = new (ELeave) CAknNoteDialog( + CAknNoteDialog::EErrorTone, + CAknNoteDialog::ELongTimeout ); + dlg->SetTextL( *text ); + CleanupStack::PopAndDestroy( text ); + iStatus = KRequestPending; //should be set by service provider + SetActive( ); + dlg->ExecuteLD( R_WIFIPROT_ERROR_NOTE ); + SetNextStateAndComplete( nextState , status ); + } + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::HandleErrorL" ); + + return ret; + } + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::ShowOfflineQuery +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::ShowOfflineQuery() + { + iNextWiFiProtState = EWiFiProtInitiateEasySetup; + + iNotifier.StartNotifierAndGetResponse(iStatus,KUidCOfflineWlanNoteDlg, + KNullDesC8(), + iOfflineReply ); + SetActive(); + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::HandleNoErrorL +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::HandleNoErrorL() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::HandleNoErrorL" ); + + switch (iNextWiFiProtState) + { + case EWifiProtOfflineQuery : + { + ShowOfflineQuery(); + break; + } + case EWiFiProtInitiateEasySetup : + { + ShowInitiateEasySetupDialogL(); + break; + } + case EWiFiProtUsePinCode : + { + if ( iUsePin ) + { + // dismiss the link dialog now + if ( iDestroyInitDialogLater ) + { + iInitDialog->TryExitL( EAknSoftkeyView ); + iDestroyInitDialogLater = EFalse; + } + ShowEnterPinOnStationDialogL(); + } + else + { + iStatus = KRequestPending; + SetActive( ); + SetNextStateAndComplete( EWiFiProtStartingWaitDlg ); + } + break; + } + case EWiFiProtStartingWaitDlg : + { + ShowWaitingDialogAndProceedL( ); + break; + } + case EWiFiProtConfiguring : + { + ConfigureL(); + break; + } + case EWiFiProtCreateAllIaps : + { + CreateAllIapsL(); + break; + } + + // when we are here, wlan scan is finished + case EWiFiProtWlanScan : + { + iORequest = EWiFiProtReqNone; + iStatus = KRequestPending; + SetActive( ); + SetNextStateAndComplete( EWiFiProtDestroyWaitNote ); + break; + } + case EWiFiProtSelectConnection : + { + SelectConnectionL(); + break; + } + + case EWiFiProtSettingsConfNote : + { + ShowFinalNoteL( ); + break; + } + case EWiFiProtFinished : + { + iReturn = EWiFiOK; + + if ( iIsConnectionNeeded ) + { + *iNetworkSettings = (*iIapParametersArray)[ + iAvailableNetworks[iSelectedNetworkIndex] ]; + } + else + { + // Copy the results into the output array + for (TInt i = 0; i< iCmArray.Count();i++ ) + { + CLOG_WRITEF( _L( + "Copy the results into the output array, i == %d"), i ); + if ( iUids == NULL) + { + User::Panic( KWiFiPanic, KErrNotSupported ); + } + iUids->Append( iCmArray[i]->GetIntAttributeL( ECmId ) ); + } + } + + if ( iSyncMode ) + { + if (iWait.IsStarted() ) + { + iWait.AsyncStop(); + } + } + else + { + iParent->CompleteProcessL( iReturn ); + } + break; + } + default: + { + //should not ever get here + CLOG_WRITE( "Unhandled WiFiProtState!!!" ); + User::Leave( KErrGeneral ); + break; + } + } + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::HandleNoErrorL" ); + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::PinQueryExitL +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::PinQueryExitL( TInt aResponse ) + { + iPinQueryActive = EFalse; + iPinDlg = NULL; + if ( aResponse == KErrNone ) + { + + if ( iWaitNoteNeeded ) + { + ShowWaitingDialogL(); + } + else + { + EvaluateResult(); //we were just waiting for PIN query to exit + } + } + else + { + iUserCancelled = ETrue; + CancelOngoingRequest(); + } + } + +// -------------------------------------------------------------------------- +// void CWiFiProtActiveRunner::DoUsePinCodeLinkSelectedL() +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::DoUsePinCodeLinkSelectedL() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::DoUsePinCodeLinkSelectedL" ); + if ( !iDestroyInitDialogLater ) + { + iUsePin = ETrue; + TRequestStatus* pS = &iStatus; + User::RequestComplete( pS, KErrNone ); + iDestroyInitDialogLater = ETrue; + } + CLOG_LEAVEFN( "CWiFiProtActiveRunner::DoUsePinCodeLinkSelectedL" ); + } + +// -------------------------------------------------------------------------- +// void CWiFiProtActiveRunner::StartWlanScan() +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::StartWlanScan() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::StartWlanScan" ); + // this flag is needed to store the cancel because we cannot + // cancel wlan scan itself +#ifdef __WINS__ + SetNextStateAndComplete( EWiFiProtWlanScan ); +#else + iORequest = EWiFiProtReqWlanScan; + iNextWiFiProtState = EWiFiProtWlanScan; + iWlanMgmtEngine->GetScanResults( iStatus, *iScanInfo ); +#endif + CLOG_LEAVEFN( "CWiFiProtActiveRunner::StartWlanScan" ); + } + +// -------------------------------------------------------------------------- +// void CWiFiProtActiveRunner::CheckNetworkAvailabilityL() +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::CheckNetworkAvailabilityL() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::CheckNetworkAvailabilityL" ); + + iAvailableNetworks.Reset(); + TBool found = EFalse; + for (TInt i = 0; i < iIapParametersArray->Count(); i++ ) + { + found = EFalse; +#ifdef __WINS__ + for (TInt j = 0; jFirst(); (!iScanInfo->IsDone()) + && (!found); iScanInfo->Next() ) +#endif + { + TUint8 ieLen( 0 ); + const TUint8* ieData; + TBuf8 ssid8; +#ifdef __WINS__ + TBuf8 ssidData; + ieData = ssidData.PtrZ(); + switch (j) + { + case KIndexOfFirstEmulatedAvailableNetwork: + { + ssidData = _L8("Available Network"); + break; + } + case KIndexOfSecondEmulatedAvailableNetwork: + { + ssidData = _L8("Available Network 2"); + break; + } + default: + { + User::Panic( KWiFiPanic , KErrNotFound ); + break; + } + } + ieLen = ssidData.Length(); + TInt ret = KErrNone; +#else + TInt ret = iScanInfo->InformationElement( E802Dot11SsidIE, ieLen, + &ieData ); +#endif + User::LeaveIfError( ret ); + if ( ieLen ) + { + CLOG_WRITE( "Starting copying ssid" ); + // get the ssid + ssid8.Copy( ieData, ieLen ); + CLOG_WRITE( "SSID copied" ); + if ( !(*iIapParametersArray)[i].iSsid.Compare( ssid8 ) ) + { + iAvailableNetworks.Append(i); + found = ETrue; + } + } + } + } + + if (iAvailableNetworks.Count() == 1) + { + // only one network available, go to confirmation note + iSelectedNetworkIndex = 0; + SetNextStateAndComplete( EWiFiProtSettingsConfNote ); + } + else if (iAvailableNetworks.Count() > 1) + { + // more are available, select connection dialog + SetNextStateAndComplete( EWiFiProtSelectConnection ); + } + else + { + // no wlan networks found note + ShowNoWlanNetworksNoteL(); + } + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::CheckNetworkAvailabilityL" ); + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::SelectConnection +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::SelectConnectionL( ) + { + CDesCArrayFlat* items = + new ( ELeave ) CDesCArrayFlat( KArrayGranularity ); + CleanupStack::PushL( items ); + + _LIT( KListBoxItemFormat, "%d\t%s\t" ); + const TInt KListBoxItemFormatLength = 4; + TBuf buf; + for (TInt i = 0; i < iAvailableNetworks.Count(); i++ ) + { + // We have to convert the 8-bit SSID to 16-bit + HBufC* ssid16 = HBufC::NewLC( (*iIapParametersArray) + [iAvailableNetworks[i]].iSsid.Length()+1 ); + TPtr ssid16Ptr( ssid16->Des() ); + CnvUtfConverter::ConvertToUnicodeFromUtf8( ssid16Ptr, + (*iIapParametersArray)[iAvailableNetworks[i]].iSsid ); + ssid16Ptr.ZeroTerminate(); + buf.Format( KListBoxItemFormat, + 0/*we use only one icon*/, ssid16->Ptr() ); + CleanupStack::PopAndDestroy( ssid16 ); + items->AppendL(buf); + } + CAknIconArray* icons = new( ELeave ) CAknIconArray( KIconsGranularity ); + CleanupStack::PushL( icons ); + //creating icon + TAknsItemID id; + MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance(); + + TParse mbmFile; + User::LeaveIfError( mbmFile.Set( KWiFiFileIcons, + &KDC_BITMAP_DIR, + NULL ) ); + + CGulIcon* icon = AknsUtils::CreateGulIconL( + skinInstance, + id, + mbmFile.FullName(), + EMbmWifiprotQgn_prop_wlan_bearer, + EMbmWifiprotQgn_prop_wlan_bearer_mask ); + /// + + CleanupStack::PushL(icon); + icons->AppendL( icon ); + CleanupStack::Pop(); //icon array takes ownership + // we are finished, don't create any iaps in connection mode! + iNextWiFiProtState = EWiFiProtFinished; + CWiFiProtSelectNetworkDlg* dlg = + new ( ELeave ) CWiFiProtSelectNetworkDlg(iStatus , + iSelectedNetworkIndex, + items, icons ); + CleanupStack::Pop( icons ); // list takes ownership + CleanupStack::Pop( items );// list takes ownership + dlg->PrepareAndRunLD( ); + SetActive(); + } + +// -------------------------------------------------------------------------- +// void CWiFiProtActiveRunner::ShowNoWlanNetworksNoteL() +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::ShowNoWlanNetworksNoteL() + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::ShowNoWlanNetworksNoteL" ); + HBufC* stringLabel = StringLoader::LoadLC( + R_QTN_WLAN_INFO_NO_NETWORKS_FOUND ); + + RAknUiServer* globalNote = CAknSgcClient::AknSrv(); + if ( globalNote->Handle() ) + { + globalNote->ShowGlobalNoteL( *stringLabel, + EAknGlobalInformationNote ); + } + CleanupStack::PopAndDestroy( stringLabel ); + SetNextStateAndComplete( EWiFiProtFinished ); + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::ShowNoWlanNetworksNoteL" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::CancelOngoingRequest +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::CancelOngoingRequest() + { + + CLOG_ENTERFN( "CWiFiProtActiveRunner::CancelOngoingRequest" ); + + switch ( iORequest ) + { + case EWiFiProtReqConfirmDialog: + { + // Remove the showing dialog and cancel the request + delete iConfirmationDialog; + iConfirmationDialog = NULL; + TRequestStatus* pS = &iStatus; + User::RequestComplete( pS, KErrCancel ); + break; + } + case EWiFiProtReqInitDialog: + { + // Remove the showing dialog and cancel the request + delete iInitDialog; + iInitDialog = NULL; + TRequestStatus* pS = &iStatus; + User::RequestComplete( pS, KErrCancel ); + break; + } + case EWiFiProtReqWPS : + { + if ( iPinQueryActive ) + { + delete iPinDlg; + iPinDlg = NULL; + } + if ( iWlanMgmtEngine ) + { + CLOG_WRITE( "Calling WPS cancel!" ); + iWlanMgmtEngine->CancelProtectedSetup(); + CLOG_WRITE( "WPS cancel called!" ); + } + break; + } + case EWiFiProtReqWlanScan : + { + iWlanMgmtEngine->CancelGetScanResults(); + break; + } + case EWiFiProtReqNone : + { + // it is possible, especially in emulator, that the pin dialog + // is still visible at this point + if ( iPinQueryActive ) + { + delete iPinDlg; + iPinDlg = NULL; + TRequestStatus* pS = &iStatus; + User::RequestComplete( pS, KErrCancel ); + } + // set CancelCalled flag to make RunL start shutdown next time + iUserCancelled = ETrue; + break; + } + + default: + { + // should not ever get here + } + } + + CLOG_LEAVEFN( "CWiFiProtActiveRunner::CancelOngoingRequest" ); + + } + +// -------------------------------------------------------------------------- +// CWiFiProtActiveRunner::SetWepKeyL +// -------------------------------------------------------------------------- +// +void CWiFiProtActiveRunner::SetWepKeyL( CWEPSecuritySettings& + aWepSecSettings, + TWlanWepKey& aWepKey, + TInt aKeyNumber ) + { + if ( aWepKey != KNullDesC8) + { + TBool wepKeyInAsciiFormat = IsWepFormatHexL( aWepKey.Length() ); + TBuf wepBuf16; + wepBuf16.Copy( aWepKey ); + User::LeaveIfError(aWepSecSettings.SetKeyDataL( aKeyNumber, wepBuf16, + wepKeyInAsciiFormat ) ); + CLOG_WRITEF( _L("Wep key: %d"), aKeyNumber ); + CLOG_WRITEF( wepBuf16 ); + } + } + +// -------------------------------------------------------------------------- +// TInt CWiFiProtActiveRunner::UsePinCodeLinkSelectedL() +// -------------------------------------------------------------------------- +// +TInt CWiFiProtActiveRunner::UsePinCodeLinkSelectedL( TAny* aObject ) + { + CLOG_ENTERFN( "CWiFiProtActiveRunner::UsePinCodeLinkSelectedL" ); + CWiFiProtActiveRunner* myself = + static_cast( aObject ); + myself->DoUsePinCodeLinkSelectedL(); + CLOG_LEAVEFN( "CWiFiProtActiveRunner::UsePinCodeLinkSelectedL" ); + + return 1; + } +// End of File