--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/wlanutilities/wlansniffer/engine/server/src/wsfwlanscanner.cpp Wed Sep 01 12:20:32 2010 +0100
@@ -0,0 +1,1960 @@
+/*
+* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Implementation of CWsfWlanScanner
+*
+*/
+
+
+
+// EXTERNAL INCLUDES
+#include <wlanmgmtclient.h>
+#include <centralrepository.h>
+#include <utf.h>
+#include <wlancontainer.h>
+#include <commsdattypeinfov1_1.h>
+#include <wlanscaninfo.h>
+#include <cmdestinationext.h>
+#include <commdb.h>
+
+#ifdef __WINS__
+#include <e32math.h>
+#endif
+
+// CLASS HEADER
+#include "wsfwlanscanner.h"
+
+// INTERNAL INCLUDES
+#include "wsfwlaninfoarray.h"
+#include "wsfwlanscaninfodefines.h"
+#include "wsfwlanconnectiondetailsprovider.h"
+#include "wsfwlansettingsaccessor.h"
+
+#include "wsflogger.h"
+
+// LOCAL DEFINITIONS
+using namespace CMManager;
+
+
+/**
+* Microseconds in a second
+*/
+static const TInt KMicrosecPerSecond = 1000 * 1000;
+
+
+// CONSTRUCTION AND DESTRUCTION
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::NewL
+// ---------------------------------------------------------------------------
+//
+CWsfWlanScanner* CWsfWlanScanner::NewL( CommsDat::CMDBSession& aDbSession )
+ {
+ CWsfWlanScanner* self = CWsfWlanScanner::NewLC( aDbSession );
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::NewLC
+// ---------------------------------------------------------------------------
+//
+CWsfWlanScanner* CWsfWlanScanner::NewLC( CommsDat::CMDBSession& aDbSession )
+ {
+ CWsfWlanScanner* self = new( ELeave ) CWsfWlanScanner( aDbSession );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ return self;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::~CWsfWlanScanner
+// ---------------------------------------------------------------------------
+//
+CWsfWlanScanner::~CWsfWlanScanner()
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::~CWsfWlanScanner" );
+ StopScanning();
+ Cancel();
+ iTimer.Close();
+ iCmManagerExt.Close();
+ delete iActiveConnectionName;
+ delete iScanResults;
+ delete iWlanMgmtClient;
+ delete iWlanSettingsAccessor;
+ delete iScanInfo;
+ delete iScanArray;
+ iDirectScanSsids.Close();
+ iDirectScanIapIDs.Close();
+ iAvailableIaps.Close();
+ iDbSession = NULL; // not owning
+ iConnectionDetailsProvider = NULL;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::CWsfWlanScanner
+// ---------------------------------------------------------------------------
+//
+CWsfWlanScanner::CWsfWlanScanner( CommsDat::CMDBSession& aDbSession ):
+ CActive( EPriorityStandard ),
+ iDbSession( &aDbSession ),
+ iScanState( EIdle )
+ {
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::ConstructL
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::ConstructL()
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::ConstructL" );
+
+#ifndef __WINS__ // client is not available on wins
+ iWlanMgmtClient = CWlanMgmtClient::NewL();
+
+ iScanInfo = CWlanScanInfo::NewL();
+#endif
+
+ iCmManagerExt.OpenL();
+
+ iScanArray = CWsfWlanInfoArray::NewL();
+
+ User::LeaveIfError( iTimer.CreateLocal() );
+ iScanResults = KNullDesC8().AllocL();
+
+ iWlanSettingsAccessor = CWsfWlanSettingsAccessor::NewL( *iDbSession );
+ iScanningInterval = iWlanSettingsAccessor->ScanInterval() *
+ KMicrosecPerSecond;
+ iShowAvailability = iWlanSettingsAccessor->ShowAvailability();
+
+ LOG_WRITEF( "initial bgScanInterval = %d sec",
+ iWlanSettingsAccessor->ScanInterval() );
+ LOG_WRITEF( "initial showAvailability = %d", iShowAvailability );
+
+ CActiveScheduler::Add( this );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::DoCancel
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::DoCancel()
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::DoCancel" );
+ iTimer.Cancel();
+#ifndef __WINS__
+ iWlanMgmtClient->CancelGetAvailableIaps();
+ iWlanMgmtClient->CancelGetScanResults();
+#endif
+ iScanState = EIdle;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::RunL
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::RunL()
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::RunL" );
+
+ /*
+ * Scan logic
+ * 1. Get available IAPs - state = EIdle
+ * 2. Do broadcast scan - state = EBroadcastScan
+ * 3. Process broadcast scan results - state = EProcessBroadcastScan
+ * 4. Do direct scans for remaining known networks
+ * from step 2. Get available IAPs - state = EDirectScan
+ * 5. Add connected network - state = EFinished
+ * 6. Set names and priorities for known networks - state = EFinished
+ */
+
+ if ( iScanState == EIdle )
+ {
+ LOG_WRITE( "Get available IAPs scan phase" );
+
+ // prepare things for direct scans
+ PrepareDirectScan();
+
+ // notify clients
+ if ( iObserver )
+ {
+ iObserver->WlanScanStarted();
+ }
+
+#ifndef __WINS__
+ // get available iaps
+ // (this only shows iaps with security mode matching to scan results
+ // and also finds hidden wlans for which an iap has been configured)
+ iAvailableIaps.Reset();
+ iWlanMgmtClient->GetAvailableIaps( iCacheLifetime,
+ iMaxDelay,
+ EFalse,
+ iStatus,
+ iAvailableIaps );
+ SetActive();
+#else
+ // for testing
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+#endif
+ iScanState = EBroadcastScan;
+ }
+
+ else if ( iScanState == EBroadcastScan )
+ {
+ LOG_WRITEF( "GetAvailableIaps returned iStatus=%d", iStatus.Int() );
+ if ( iStatus.Int() )
+ {
+ LOG_WRITE( "Error in getting available IAPs - leave" );
+ User::Leave( iStatus.Int() );
+ }
+
+#ifdef _DEBUG
+ for ( TInt i = 0; i < iAvailableIaps.Count(); ++i )
+ {
+ LOG_WRITEF( "iAvailableIaps array index[%d] IapId[%d] rssi[%d]", i,
+ iAvailableIaps[i].iIapId, iAvailableIaps[i].iRssi );
+ }
+#endif
+
+#ifndef __WINS__
+ // do broadcast scan
+ iWlanMgmtClient->GetScanResults( iStatus, *iScanInfo );
+ SetActive();
+#else
+ // for testing
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+#endif
+ iScanState = EProcessBroadcastScan;
+ }
+
+ else if ( iScanState == EProcessBroadcastScan )
+ {
+ // process broadcast scan results
+ DoScanForNetworksL();
+
+ // now it's time to initiate direct scan
+ // for remaining known networks
+ if ( iDirectScanSsids.Count() )
+ {
+#ifdef _DEBUG
+ HBufC* ssid = TWsfWlanInfo::GetSsidAsUnicodeLC(
+ iDirectScanSsids[0] );
+ LOG_WRITEF( "requesting direct scan for [%S]", ssid );
+ CleanupStack::PopAndDestroy( ssid );
+#endif
+
+#ifndef __WINS__
+ // run direct scan
+ iWlanMgmtClient->GetScanResults( iDirectScanSsids[0],
+ iStatus, *iScanInfo );
+ SetActive();
+#else
+ // for testing
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+#endif
+
+ iScanState = EDirectScan;
+ }
+ else
+ {
+ LOG_WRITE( "direct scan skipped" );
+ iScanState = EFinished;
+ }
+ }
+
+ else if ( iScanState == EDirectScan )
+ {
+ LOG_WRITE( "direct scan results" );
+
+#ifndef __WINS__
+ ProcessDirectScanResultL();
+#endif
+
+ // delete the processed item (first)
+ iDirectScanSsids.Remove( 0 );
+ iDirectScanIapIDs.Remove( 0 );
+
+ if ( iDirectScanSsids.Count() )
+ {
+ // repeated direct scans for known networks
+#ifdef _DEBUG
+ HBufC* ssid = TWsfWlanInfo::GetSsidAsUnicodeLC(
+ iDirectScanSsids[0] );
+ LOG_WRITEF( "requesting direct scan for [%S]", ssid );
+ CleanupStack::PopAndDestroy( ssid );
+#endif
+
+#ifndef __WINS__
+ // run direct scan
+ iWlanMgmtClient->GetScanResults( iDirectScanSsids[0],
+ iStatus, *iScanInfo );
+ SetActive();
+#else
+ // for testing
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+#endif
+ }
+ else
+ {
+ // there is nothing more to do
+ iScanState = EFinished;
+ }
+ }
+
+ if ( iScanState == EFinished )
+ {
+ LOG_WRITE( "scanning finished" );
+#ifndef __WINS__
+ AddConnectedWLANInfoL();
+
+ TWsfWlanInfo* info(NULL);
+ TInt scanArrayCount( iScanArray->Count() );
+
+ for ( TInt i(0) ; i < scanArrayCount ; i++ )
+ {
+ info = (*iScanArray)[ i ];
+
+ if( info->iIapId )
+ {
+ TRAPD( error, UpdatePriorityL( *info ) );
+ if ( error )
+ {
+ // Ignore error and just continue
+ LOG_WRITE( "Prio update failed" );
+ }
+ }
+
+ if( info->iIapId && info->iConnectionState != EConnected )
+ {
+ ReplaceSsidsWithIapName( *info );
+ }
+ }
+#endif //_WINS_
+
+ // sort the array
+ iScanArray->SortArrayL();
+
+ HBufC8* results = iScanArray->SerializeContentLC();
+ CleanupStack::Pop( results );
+ delete iScanResults;
+ iScanResults = results;
+
+#ifdef _DEBUG
+ DumpScanResultsL( iScanArray );
+#endif
+
+ // we may let go the scan array contents...
+ iScanArray->Reset();
+
+ // notify clients that data is ready
+ if ( iObserver )
+ {
+ iObserver->WlanScanCompleteL();
+ }
+
+ if ( !iShowAvailability )
+ {
+ // reset the timer if we are responsible for scheduling scans
+ iTimer.Cancel();
+ iTimer.After( iStatus,
+ TTimeIntervalMicroSeconds32( iScanningInterval ) );
+ Cancel();
+ iCacheLifetime = 0;
+ iMaxDelay = 0;
+ SetActive();
+ }
+
+ iScanState = EIdle;
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::AddConnectedWLANInfo
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::AddConnectedWLANInfoL()
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::AddConnectedWLANInfoL" );
+ // Get the possible connection
+ if ( iConnectionDetailsProvider )
+ {
+ TWlanSsid connectedSsid;
+ TInt error = iWlanMgmtClient->GetConnectionSsid( connectedSsid );
+
+ LOG_WRITEF( "GetConnectionSsid returned=%d", error );
+
+ TBool connected = ( error == KErrNone && connectedSsid.Length() );
+
+ if ( !connected && !iConnectionDetailsProvider->IsConnected() )
+ {
+ LOG_WRITEF( "Not connected [connected=%d]", connected );
+ return;
+ }
+
+ TWsfWlanInfo* connectedInfo = new (ELeave) TWsfWlanInfo();
+ CleanupStack::PushL( connectedInfo );
+
+ if ( iConnectionDetailsProvider->ConnectedWlanConnectionDetailsL(
+ connectedInfo) )
+ {
+ TBuf8<KWlanMaxAccessPointNameLength> connectedSsidOrIap;
+ connectedSsidOrIap.Copy( connectedInfo->iSsid );
+ // ConnectedWlanConnectionDetailsL() may have returned an IAP name instead of SSID.
+ // make sure that we really have SSID in connectedInfo->iSSID at this phase.
+
+ connectedInfo->iRawSsid.Copy( connectedSsid );
+ connectedInfo->iSsid.Copy( connectedSsid );
+ connectedInfo->iCoverage = 0;
+ connectedInfo->iVisibility = 1;
+
+ TBool connectedInfoAppended = EFalse;
+
+ RPointerArray<TWsfWlanInfo> matchArray;
+ CleanupClosePushL( matchArray );
+
+ if ( connectedInfo->iIapId )
+ {
+ LOG_WRITEF( "Connected iap [%d]", connectedInfo->iIapId );
+ iScanArray->MatchWithIapIDL( connectedInfo->iIapId,
+ iScanArray->Count(), matchArray );
+
+ if ( !matchArray.Count() )
+ {
+ LOG_WRITE( "Not found with Iap id" );
+ iScanArray->MatchL( connectedInfo->iSsid,
+ connectedInfo->iSecurityMode,
+ connectedInfo->iNetMode,
+ connectedInfo->UsesPreSharedKey(),
+ iScanArray->Count(),
+ matchArray );
+ }
+
+ }
+ else
+ {
+ LOG_WRITE( "Easy WLAN connection" );
+ iScanArray->MatchL( connectedInfo->iSsid,
+ connectedInfo->iSecurityMode,
+ connectedInfo->iNetMode,
+ connectedInfo->UsesPreSharedKey(),
+ iScanArray->Count(),
+ matchArray );
+ }
+
+ if ( matchArray.Count() )
+ {
+ LOG_WRITE( "Info found" );
+ TWsfWlanInfo* temp = matchArray[0];
+ temp->iConnectionState = EConnected;
+ temp->iIapId = connectedInfo->iIapId;
+ temp->iSsid.Copy( connectedSsidOrIap );
+ temp->iNetworkName.Zero();
+ }
+ else
+ {
+ LOG_WRITE( "Info not found - append" );
+ connectedInfo->iSsid.Copy( connectedSsidOrIap );
+ iScanArray->AppendL( connectedInfo );
+ connectedInfoAppended = ETrue;
+ }
+
+ CleanupStack::PopAndDestroy( &matchArray );
+ if ( connectedInfoAppended )
+ {
+ CleanupStack::Pop( connectedInfo );
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy( connectedInfo );
+ }
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy( connectedInfo );
+ }
+ }
+ else
+ {
+ LOG_WRITE( "No connection details provider" );
+ }
+ }
+
+
+#ifdef _DEBUG
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::DumpScanResultsL
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::DumpScanResultsL( CWsfWlanInfoArray* aArray )
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::DumpScanResultsL" );
+ _LIT( Kopen, "open" );
+ _LIT( Kwep, "wep" );
+ _LIT( Kwpa, "wpa" );
+ _LIT( Kwpa2, "wpa2" );
+ _LIT( K802, "802.1x" );
+ _LIT( KWAPI, "WAPI" );
+ _LIT( KUnknown, "Unknown" );
+
+ _LIT( Kpsk, "psk" );
+ _LIT( Keap, "eap" );
+ _LIT( Khidden, "<hidden>" );
+
+ for ( TInt i( 0 ); i < aArray->Count(); ++i )
+ {
+ TWsfWlanInfo* wi( (*aArray)[i] );
+ const TDesC* sm( 0 );
+
+ switch ( wi->iSecurityMode )
+ {
+ case EWlanSecModeOpen:
+ sm = &Kopen;
+ break;
+ case EWlanSecModeWep:
+ sm = &Kwep;
+ break;
+ case EWlanSecModeWpa:
+ sm = &Kwpa;
+ break;
+ case EWlanSecModeWpa2:
+ sm = &Kwpa2;
+ break;
+ case EWlanSecMode802_1x:
+ sm = &K802;
+ break;
+ case EWlanSecModeWAPI:
+ sm = &KWAPI;
+ break;
+ default:
+ sm = &KUnknown;
+ break;
+ }
+
+ const TDesC* psk = wi->UsesPreSharedKey()? &Kpsk:
+ ( ( wi->iSecurityMode == EWlanSecMode802_1x ||
+ wi->iSecurityMode == EWlanSecModeWpa ||
+ wi->iSecurityMode == EWlanSecModeWpa2 )?
+ &Keap: &KNullDesC );
+ HBufC16 *ssid = TWsfWlanInfo::GetSsidAsUnicodeLC( wi->iSsid );
+
+ LOG_WRITEF( "[%S] IapId=%d %S %S %S", ssid, wi->iIapId, sm, psk,
+ wi->iVisibility? &KNullDesC: &Khidden );
+ CleanupStack::PopAndDestroy( ssid );
+ }
+
+ }
+#endif // _DEBUG
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::RunError
+// ---------------------------------------------------------------------------
+//
+TInt CWsfWlanScanner::RunError( TInt aError )
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::RunError" );
+ LOG_WRITEF( "error = %d", aError );
+
+ iScanArray->Reset();
+
+ if ( iObserver && aError != KErrNotReady )
+ {
+ // KErrNotReady is excluded as it indicates that the WLAN engine
+ // has not yet set up itself, which we cannot help
+ iObserver->NotifyError( aError );
+ }
+
+ iScanState = EIdle;
+
+ if ( !iShowAvailability )
+ {
+ // the scanning has failed, re-issue the scan timer
+ iTimer.Cancel();
+ iTimer.After( iStatus,
+ TTimeIntervalMicroSeconds32( iScanningInterval ) );
+ iCacheLifetime = 0;
+ iMaxDelay = 0;
+ SetActive();
+ }
+
+ return KErrNone;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::SetObserver
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::SetObserver( MWsfWlanScannerObserver& aObserver )
+ {
+ iObserver = &aObserver;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::StartScanningL
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::StartScanningL()
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::StartScanningL" );
+
+ if ( iScanState == EIdle && !IsActive() )
+ {
+ LOG_WRITE( "request notifications" );
+#ifndef __WINS__
+ iWlanMgmtClient->CancelNotifications();
+ iWlanMgmtClient->ActivateNotificationsL( *this );
+#endif
+ iWlanSettingsAccessor->RequestNotificationL( *this );
+
+ iScanState = EIdle;
+
+ if ( !iShowAvailability )
+ {
+ // in case show wlan availability is off, carry out a scan now
+ iCacheLifetime = 0;
+ iMaxDelay = 0;
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ }
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::StartScanningL
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::StopScanning()
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::StopScanning" );
+
+ Cancel();
+
+#ifndef __WINS__
+ if ( iWlanMgmtClient )
+ {
+ iWlanMgmtClient->CancelNotifications();
+ }
+#endif
+
+ if ( iWlanSettingsAccessor )
+ {
+ iWlanSettingsAccessor->CancelNotifications();
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::RestartScanning
+// ---------------------------------------------------------------------------
+//
+TBool CWsfWlanScanner::RestartScanning()
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::RestartScanning" );
+
+ TBool restarted( EFalse );
+ LOG_WRITEF( "iScanState = %d isActive = %d iShowAvailability = %d",
+ iScanState, IsActive(), iShowAvailability );
+
+ if ( iScanState == EIdle && ( IsActive() || iShowAvailability ) )
+ {
+ // we have been waiting for the timer to complete
+ // cancel it manually
+ Cancel();
+ iCacheLifetime = 0;
+ iMaxDelay = 0;
+ // then complete ourselves
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ restarted = ETrue;
+ }
+
+ LOG_WRITEF( "restarted = %d", restarted );
+ return restarted;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::AbortScanning
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::AbortScanning()
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::AbortScanning" );
+
+ if ( iScanState != EIdle )
+ {
+ // cancel the current scanning
+ Cancel();
+
+ if ( !iShowAvailability )
+ {
+ // still, life goes on
+ iTimer.After( iStatus, TTimeIntervalMicroSeconds32(
+ iScanningInterval ) );
+ iCacheLifetime = 0;
+ iMaxDelay = 0;
+ SetActive();
+ }
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::ConnectionStateChanged
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::ConnectionStateChanged(
+ TWlanConnectionMode /*aNewState*/ )
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::ConnectionStateChanged" );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::BssidChanged
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::BssidChanged( TWlanBssid& /*aNewBSsid*/ )
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::BssidChanged" );
+ if ( iScanState == EIdle && !IsActive() )
+ {
+ iCacheLifetime = -1;
+ iMaxDelay = 0;
+ // complete ourselves
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::BssLost
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::BssLost()
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::BssLost" );
+ if ( iScanState == EIdle && !IsActive() )
+ {
+ iCacheLifetime = -1;
+ iMaxDelay = 0;
+ // complete ourselves
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::BssRegained
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::BssRegained()
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::BssRegained" );
+ if ( iScanState == EIdle && !IsActive() )
+ {
+ iCacheLifetime = -1;
+ iMaxDelay = 0;
+ // complete ourselves
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::NewNetworksDetected
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::NewNetworksDetected()
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::NewNetworksDetected" );
+ if ( iScanState == EIdle && !IsActive() )
+ {
+ iCacheLifetime = -1;
+ iMaxDelay = 0;
+ // complete ourselves
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::OldNetworksLost
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::OldNetworksLost()
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::OldNetworksLost" );
+ if ( iScanState == EIdle && !IsActive() )
+ {
+ iCacheLifetime = -1;
+ iMaxDelay = 0;
+ // complete ourselves
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::TransmitPowerChanged
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::TransmitPowerChanged( TUint /*aPower*/ )
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::TransmitPowerChanged" );
+ if ( iScanState == EIdle && !IsActive() )
+ {
+ iCacheLifetime = -1;
+ iMaxDelay = 0;
+ // complete ourselves
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::RssChanged
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::RssChanged( TWlanRssClass /*aRssClass*/, TUint /*aRss*/ )
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::RssChanged" );
+ if ( iScanState == EIdle && !IsActive() )
+ {
+ iCacheLifetime = -1;
+ iMaxDelay = 0;
+ // complete ourselves
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::PrepareDirectScan
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::PrepareDirectScan()
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::PrepareDirectScanL" );
+
+ // flush the arrays
+ iDirectScanSsids.Reset();
+ iDirectScanIapIDs.Reset();
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::ProcessDirectScanResultL
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::ProcessDirectScanResultL()
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::ProcessDirectScanResultL" );
+
+ for ( iScanInfo->First(); !iScanInfo->IsDone(); iScanInfo->Next() )
+ {
+ RPointerArray<TWsfWlanInfo> matchArray;
+ CleanupClosePushL(matchArray);
+ iScanArray->MatchWithIapIDL( iDirectScanIapIDs[0], iScanArray->Count(), matchArray );
+
+ TInt matchcount = matchArray.Count();
+
+ if ( matchcount == 0 )
+ {
+ // not found yet
+#ifdef _DEBUG
+ HBufC* ssid = TWsfWlanInfo::GetSsidAsUnicodeLC( iDirectScanSsids[0] );
+ LOG_WRITEF( "[%S] found in direct scan", ssid );
+ CleanupStack::PopAndDestroy( ssid );
+#endif
+ }
+ else
+ {
+ LOG_WRITEF( "[%d] iap id is in scanarray", iDirectScanIapIDs[0] );
+ for( TInt i(0); i < matchcount; i++ )
+ {
+ //if already found increase coverage
+ TWsfWlanInfo* temp = matchArray[i];
+ ++temp->iCoverage;
+ RefreshSignalStrength( *temp );
+ RefreshTechnology( *temp );
+ }
+ }
+ // Close() for matchArray
+ CleanupStack::PopAndDestroy( &matchArray );
+ } // for iScanInfo
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::ReplaceSsidsWithIapName
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::ReplaceSsidsWithIapName(TWsfWlanInfo& aWlanInfo)
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::ReplaceSsidsWithIapName" );
+ if ( aWlanInfo.iNetworkName.Length() )
+ {
+ LOG_WRITE( "Replace ssid" );
+ aWlanInfo.iSsid.Copy( aWlanInfo.iNetworkName );
+ aWlanInfo.iNetworkName.Zero();
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::UpdatePriorityL
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::UpdatePriorityL( TWsfWlanInfo& aWlanInfo )
+ {
+ LOG_WRITE( "CWsfWlanScanner::updatePriority" );
+
+ TUint32 priority( 0 );
+ TInt exists( KErrNotFound );
+ TInt count( 0 );
+
+ // search for the destination of it
+ RArray<TUint32> destinations;
+ CleanupClosePushL( destinations );
+
+ LOG_WRITE( "CWsfWlanScanner::updatePriority get all destinations" );
+ iCmManagerExt.AllDestinationsL(destinations);
+
+ count = destinations.Count();
+ LOG_WRITEF( "destination count %d", count);
+
+ for( TInt i = 0; i < count && exists != KErrNone; i++ )
+ {
+ RCmDestinationExt destination;
+ destination = iCmManagerExt.DestinationL( destinations[ i ] );
+ CleanupClosePushL( destination );
+
+ LOG_WRITE( "check if connection method belongs to destination" );
+
+ RCmConnectionMethodExt connectionMethod;
+ TRAP( exists,
+ connectionMethod = destination.ConnectionMethodByIDL(
+ aWlanInfo.iIapId ) );
+
+ LOG_WRITEF( "exists %d", exists );
+ if( exists == KErrNone )
+ {
+ CleanupClosePushL( connectionMethod );
+ // correct destination found
+ priority = destination.PriorityL( connectionMethod );
+ aWlanInfo.SetPriority( priority );
+
+ LOG_WRITEF( "priority %d", priority );
+ CleanupStack::PopAndDestroy( &connectionMethod );
+ }
+ CleanupStack::PopAndDestroy( &destination );
+ }
+ CleanupStack::PopAndDestroy( &destinations );
+ }
+
+
+#ifndef __WINS__
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::DoScanForNetworksL
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::DoScanForNetworksL()
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::DoScanForNetworksL" );
+
+ // start by making sure the scan array is empty
+ iScanArray->Reset();
+
+ LOG_WRITEF( "GetScanResults returned iStatus=%d", iStatus.Int() );
+
+ if ( iStatus.Int() )
+ {
+ // if the status is not KErrNone, we cannot be sure that iScanInfo
+ // doesn't cause a crash, so it's better to leave
+ LOG_WRITE( "Error in getting scan result - leave" );
+ User::Leave( iStatus.Int() );
+ }
+
+ TInt nElem = 0;
+ TBool isHidden( EFalse );
+
+ TInt avIapCount = iAvailableIaps.Count();
+
+ LOG_WRITEF( "Available iap count %d", avIapCount );
+
+ for( TInt i(0); i < avIapCount; i++ )
+ {
+ TBool addToArray( ETrue );
+ TWsfWlanInfo* availableInfo = new ( ELeave ) TWsfWlanInfo();
+ CleanupStack::PushL( availableInfo );
+ availableInfo->iIapId = iAvailableIaps[i].iIapId;
+ TRAPD( error, GetWlanInfoFromIapL( *availableInfo ) );
+
+ if ( error == KErrNotFound )
+ {
+ LOG_WRITEF( "Iap id = %d does not exist", availableInfo->iIapId );
+ addToArray = EFalse;
+ }
+ else if ( error )
+ {
+ LOG_WRITEF( "GetWlanInfoFromIapL failed err = %d", error );
+ User::Leave( error );
+ }
+
+ if( addToArray )
+ {
+ LOG_WRITE( "Add to array" );
+ availableInfo->iCoverage = 0;
+ availableInfo->iVisibility = 1;
+ availableInfo->iStrengthLevel = iAvailableIaps[i].iRssi;
+ availableInfo->iTransferRate = 0;
+ availableInfo->iConnectionState = ENotConnected;
+ iScanArray->AppendL(availableInfo);
+ nElem++;
+
+ if ( availableInfo->iIapId )
+ {
+ LOG_WRITEF( "Append available iap[%d] rssi[%d] for direct scan",
+ availableInfo->iIapId, availableInfo->iStrengthLevel );
+ iDirectScanIapIDs.Append( availableInfo->iIapId );
+ iDirectScanSsids.Append( availableInfo->iSsid );
+ }
+
+ CleanupStack::Pop( availableInfo );
+ }
+ else
+ {
+ LOG_WRITE( "Info not added" );
+ CleanupStack::PopAndDestroy( availableInfo );
+ }
+ }
+
+#ifdef _DEBUG
+ LOG_WRITE( "Dump scan results - available IAPs" );
+ DumpScanResultsL( iScanArray );
+#endif
+
+ // Process the scanned results
+ for( iScanInfo->First(); !iScanInfo->IsDone(); iScanInfo->Next() )
+ {
+ TWsfWlanInfo* wlanInfo = iScanArray->At( nElem );
+ if ( !wlanInfo )
+ {
+ wlanInfo = new ( ELeave ) TWsfWlanInfo();
+ CleanupStack::PushL( wlanInfo );
+ iScanArray->AppendL( wlanInfo );
+ CleanupStack::Pop( wlanInfo );
+ }
+ isHidden = RefreshNetworkNameL( *wlanInfo );
+ wlanInfo->iVisibility = !isHidden;
+ wlanInfo->iStrengthLevel = EWlanSignalUnavailable;
+ wlanInfo->iTransferRate = 0;
+ wlanInfo->iConnectionState = ENotConnected;
+
+ if( !isHidden )
+ {
+ // not hidden
+ RefreshNetworkMode( *wlanInfo );
+ RefreshSecurityMode( *wlanInfo );
+ RefreshTechnology( *wlanInfo );
+
+ // check if we already have an entry/entries corresponding to a scan result
+ // (multiple entries for one scan result possible if GetAvailableIaps()
+ // found several iaps configured for same wlan)
+ RPointerArray<TWsfWlanInfo> matchArray;
+ CleanupClosePushL(matchArray);
+ iScanArray->MatchL( wlanInfo->iSsid,
+ wlanInfo->iSecurityMode,
+ wlanInfo->iNetMode,
+ wlanInfo->UsesPreSharedKey(),
+ nElem,
+ matchArray );
+
+ TInt matchcount = matchArray.Count();
+
+ // if not found
+ if( matchcount == 0 )
+ {
+ wlanInfo->iCoverage = 1;
+ RefreshSignalStrength( *wlanInfo );
+ RefreshTechnology( *wlanInfo );
+ ++nElem; // new entry, inc index in array
+ }
+ else // if found inc coverage and refresh signal strength and rate
+ {
+ for( TInt i(0); i < matchcount; i++ )
+ {
+ TWsfWlanInfo* temp = matchArray[i];
+ ++temp->iCoverage;
+ RefreshSignalStrength( *temp );
+ RefreshTechnology( *temp );
+
+ if ( temp->iIapId )
+ {
+ TInt index( KErrNone );
+ do {
+ LOG_WRITE( "Not hidden - Searching from direct scan list.." );
+ // remove this item from the direct scan list, if found
+ index = iDirectScanIapIDs.Find( temp->iIapId );
+ if ( index != KErrNotFound )
+ {
+ LOG_WRITEF( "Found - removing iap id [%d]", iDirectScanIapIDs[index] );
+ iDirectScanSsids.Remove( index );
+ iDirectScanIapIDs.Remove( index );
+ }
+ } while ( index != KErrNotFound );
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy(); // results in Close() being called on matchArray
+ }
+ }
+ //get rid of excess items
+ iScanArray->DeleteFromTail(iScanArray->Count() - nElem);
+ }
+
+#else // __WINS__
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::DoScanForNetworksL
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::DoScanForNetworksL()
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::DoScanForNetworksL" );
+
+ // start by making sure the scan array is empty
+ iScanArray->Reset();
+
+ TWsfWlanInfo* wlan0 = new (ELeave) TWsfWlanInfo();
+ CleanupStack::PushL( wlan0 );
+ wlan0->iConnectionState = EConnected;
+ wlan0->iIapId = 666;
+ wlan0->iNetMode = EInfra;
+ wlan0->iSecurityMode = EWlanSecModeWep;
+ wlan0->iSsid = _L8("[C]Known WEP");
+ wlan0->iStrengthLevel = EWlanSignalStrengthMax;
+ wlan0->iVisibility = ETrue;
+ wlan0->iCoverage = 1;
+ if ( Math::Random() % 2 == 0 )
+ {
+ iScanArray->AppendL( wlan0 );
+ }
+ else
+ {
+ delete wlan0;
+ }
+
+ CleanupStack::Pop( wlan0 );
+
+ TWsfWlanInfo* wlan1 = new (ELeave) TWsfWlanInfo();
+ CleanupStack::PushL( wlan1 );
+ wlan1->iConnectionState = ENotConnected;
+ wlan1->iIapId = 666;
+ wlan1->iNetMode = EInfra;
+ wlan1->iSecurityMode = EWlanSecModeOpen;
+ wlan1->iSsid = _L8("Known open");
+ wlan1->iStrengthLevel = EWlanSignalStrengthMin;
+ wlan1->iVisibility = ETrue;
+ wlan1->iCoverage = 3;
+ if ( Math::Random() % 2 == 0 )
+ {
+ iScanArray->AppendL( wlan1 );
+ }
+ else
+ {
+ delete wlan1;
+ }
+
+ CleanupStack::Pop( wlan1 );
+
+ TWsfWlanInfo* wlan2 = new (ELeave) TWsfWlanInfo();
+ CleanupStack::PushL( wlan2 );
+ wlan2->iConnectionState = ENotConnected;
+ wlan2->iIapId = 0;
+ wlan2->iNetMode = EInfra;
+ wlan2->iSecurityMode = EWlanSecModeWpa2;
+ wlan2->iSsid = _L8("Known WPA2 PSK");
+ wlan2->iStrengthLevel = EWlanSignalStrengthLow-7;
+ wlan2->iVisibility = ETrue;
+ wlan2->iCoverage = 1;
+ wlan2->SetUsesPreSharedKey( ETrue );
+ if ( Math::Random() % 2 == 0 )
+ {
+ iScanArray->AppendL( wlan2 );
+ }
+ else
+ {
+ delete wlan2;
+ }
+ CleanupStack::Pop( wlan2 );
+
+ TWsfWlanInfo* wlan3 = new (ELeave) TWsfWlanInfo();
+ CleanupStack::PushL( wlan3 );
+ wlan3->iConnectionState = ENotConnected;
+ wlan3->iIapId = 0;
+ wlan3->iNetMode = EInfra;
+ wlan3->iSecurityMode = EWlanSecModeOpen;
+ wlan3->iSsid = _L8("Unknown open");
+ wlan3->iStrengthLevel = EWlanSignalStrengthMax;
+ wlan3->iVisibility = 1;
+ wlan3->iCoverage = 1;
+ if ( Math::Random() % 2 == 0 )
+ {
+ iScanArray->AppendL( wlan3 );
+ }
+ else
+ {
+ delete wlan3;
+ }
+ CleanupStack::Pop( wlan3 );
+
+ TWsfWlanInfo* wlan4 = new (ELeave) TWsfWlanInfo();
+ CleanupStack::PushL( wlan4 );
+ wlan4->iConnectionState = ENotConnected;
+ wlan4->iIapId = 0;
+ wlan4->iNetMode = EAdhoc;
+ wlan4->iSecurityMode = EWlanSecModeWpa;
+ wlan4->iSsid = _L8("Unknown WPA");
+ wlan4->iStrengthLevel = EWlanSignalStrengthMin;
+ wlan4->iVisibility = 1;
+ wlan4->iCoverage = 1;
+ wlan2->SetUsesPreSharedKey( ETrue );
+
+ if ( Math::Random() % 2 == 0 )
+ {
+ iScanArray->AppendL( wlan4 );
+ }
+ else
+ {
+ delete wlan4;
+ }
+ CleanupStack::Pop( wlan4 );
+
+ TWsfWlanInfo* wlan5 = new (ELeave) TWsfWlanInfo();
+ CleanupStack::PushL( wlan5 );
+ wlan5->iConnectionState = ENotConnected;
+ wlan5->iIapId = 12;
+ wlan5->iNetMode = EInfra;
+ wlan5->iSecurityMode = EWlanSecModeOpen;
+ wlan5->iSsid = _L8("SES");
+ wlan5->iStrengthLevel = EWlanSignalStrengthLow-5;
+ wlan5->iVisibility = 0;
+ wlan5->iCoverage = 1;
+ if ( Math::Random() % 2 == 0 )
+ {
+ iScanArray->AppendL( wlan5 );
+ }
+ else
+ {
+ delete wlan5;
+ }
+
+ CleanupStack::Pop( wlan5 );
+
+ TWsfWlanInfo* wlan6 = new (ELeave) TWsfWlanInfo();
+ CleanupStack::PushL( wlan6 );
+ wlan6->iConnectionState = ENotConnected;
+ wlan6->iIapId = 666;
+ wlan6->iNetMode = EInfra;
+ wlan6->iSecurityMode = EWlanSecModeWpa;
+ wlan6->iSsid = _L8("Sunny 22");
+ wlan6->iStrengthLevel = EWlanSignalStrengthMin;
+ wlan6->iVisibility = 1;
+ wlan6->iCoverage = 2;
+ if ( Math::Random() % 2 == 0 )
+ {
+ iScanArray->AppendL( wlan6 );
+ }
+ else
+ {
+ delete wlan6;
+ }
+ CleanupStack::Pop( wlan6 );
+
+
+ wlan5 = new (ELeave) TWsfWlanInfo();
+ CleanupStack::PushL( wlan5 );
+ wlan5->iConnectionState = ENotConnected;
+ wlan5->iIapId = 0;
+ wlan5->iNetMode = EInfra;
+ wlan5->iSecurityMode = EWlanSecModeOpen;
+ wlan5->iSsid = _L8("FON_accesspoint");
+ wlan5->iStrengthLevel = EWlanSignalStrengthLow-8;
+ wlan5->iVisibility = 1;
+ wlan5->iCoverage = 1;
+ if ( Math::Random() % 2 == 0 )
+ {
+ iScanArray->AppendL( wlan5 );
+ }
+ else
+ {
+ delete wlan5;
+ }
+ CleanupStack::Pop( wlan5 );
+
+
+ TWsfWlanInfo* wlan7 = new (ELeave) TWsfWlanInfo();
+ CleanupStack::PushL( wlan7 );
+ wlan7->iConnectionState = ENotConnected;
+ wlan7->iIapId = 667;
+ wlan7->iNetMode = EAdhoc;
+ wlan7->iSecurityMode = EWlanSecModeWpa;
+ wlan7->iSsid = _L8("Ad-hoc WPA");
+ wlan7->iStrengthLevel = EWlanSignalStrengthMax;
+ wlan7->iVisibility = ETrue;
+ wlan7->iCoverage = 1;
+ if ( Math::Random() % 2 == 0 )
+ {
+ iScanArray->AppendL( wlan7 );
+ }
+ else
+ {
+ delete wlan7;
+ }
+ CleanupStack::Pop( wlan7 );
+
+ TWsfWlanInfo* wlan8 = new (ELeave) TWsfWlanInfo();
+ CleanupStack::PushL( wlan8 );
+ wlan8->iConnectionState = ENotConnected;
+ wlan8->iIapId = 667;
+ wlan8->iNetMode = EInfra;
+ wlan8->iSecurityMode = EWlanSecModeOpen;
+ wlan8->iSsid = _L8("Known pri 1");
+ wlan8->iStrengthLevel = EWlanSignalStrengthMax;
+ wlan8->iVisibility = ETrue;
+ wlan8->iCoverage = 1;
+ wlan8->iPriority = 1;
+ if ( Math::Random() % 2 == 0 )
+ {
+ iScanArray->AppendL( wlan8 );
+ }
+ else
+ {
+ delete wlan8;
+ }
+ CleanupStack::Pop( wlan8 );
+
+ TWsfWlanInfo* wlan9 = new (ELeave) TWsfWlanInfo();
+ CleanupStack::PushL( wlan9 );
+ wlan9->iConnectionState = ENotConnected;
+ wlan9->iIapId = 668;
+ wlan9->iNetMode = EInfra;
+ wlan9->iSecurityMode = EWlanSecModeOpen;
+ wlan9->iSsid = _L8("Known pri 2");
+ wlan9->iStrengthLevel = EWlanSignalStrengthMax;
+ wlan9->iVisibility = ETrue;
+ wlan9->iCoverage = 1;
+ wlan9->iPriority = 2;
+ if ( Math::Random() % 2 == 0 )
+ {
+ iScanArray->AppendL( wlan9 );
+ }
+ else
+ {
+ delete wlan9;
+ }
+ CleanupStack::Pop( wlan9 );
+
+
+ }
+
+#endif // __WINS__
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::GetWlanInfoFromIapL()
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::GetWlanInfoFromIapL( TWsfWlanInfo& aWlanInfo )
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::GetWlanInfoFromIapL" );
+ LOG_WRITEF( "Iap Id = %d", aWlanInfo.iIapId );
+
+ CCommsDatabase* commsDb = CCommsDatabase::NewL();
+ CleanupStack::PushL( commsDb );
+
+ CCommsDbTableView* commsDbIapTableView = commsDb->OpenViewMatchingUintLC(
+ TPtrC( IAP ), TPtrC( COMMDB_ID ), aWlanInfo.iIapId );
+ User::LeaveIfError( commsDbIapTableView->GotoFirstRecord() );
+
+ // network name
+ TBuf<KCommsDbSvrMaxFieldLength> iapName;
+ commsDbIapTableView->ReadTextL( TPtrC( COMMDB_NAME ), iapName);
+
+ TInt error = CnvUtfConverter::ConvertFromUnicodeToUtf8(
+ aWlanInfo.iNetworkName,
+ iapName );
+ if ( error )
+ {
+ LOG_WRITE( "ConvertFromUnicodeToUtf8 failed");
+ aWlanInfo.iNetworkName.Copy( iapName );
+ }
+
+ // service Id
+ TUint32 serviceId(0);
+ commsDbIapTableView->ReadUintL(TPtrC( IAP_SERVICE), serviceId);
+ CCommsDbTableView* wlanTableView = commsDb->OpenViewMatchingUintLC(
+ TPtrC( WLAN_SERVICE), TPtrC( WLAN_SERVICE_ID), serviceId);
+ User::LeaveIfError(wlanTableView->GotoFirstRecord() );
+
+ // ssid
+ wlanTableView->ReadTextL( TPtrC( NU_WLAN_SSID ), aWlanInfo.iSsid );
+ aWlanInfo.iRawSsid.Copy( aWlanInfo.iSsid );
+
+ // security mode
+ TUint32 secMode(0);
+ wlanTableView->ReadUintL(TPtrC( WLAN_SECURITY_MODE), secMode);
+ // Map Wpa2 to Wpa
+ secMode = ( secMode == EWlanSecModeWpa2 )? EWlanSecModeWpa : secMode;
+ aWlanInfo.iSecurityMode = static_cast<TWlanSecMode>(secMode);
+
+ TUint32 usePsk(0);
+ TRAP_IGNORE( wlanTableView->ReadUintL(TPtrC( WLAN_ENABLE_WPA_PSK ),
+ usePsk ) );
+
+ aWlanInfo.SetUsesPreSharedKey( usePsk );
+
+ // net mode
+ TUint32 netMode(0);
+ wlanTableView->ReadUintL(TPtrC( WLAN_CONNECTION_MODE), netMode);
+ aWlanInfo.iNetMode = static_cast<TWlanNetMode>(netMode);
+
+ CleanupStack::PopAndDestroy(wlanTableView);
+ CleanupStack::PopAndDestroy(commsDbIapTableView);
+ CleanupStack::PopAndDestroy(commsDb);
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::SsidIdentity
+// ---------------------------------------------------------------------------
+//
+TBool CWsfWlanScanner::SsidIdentity( const TWlanSsid& aSsid1,
+ const TWlanSsid& aSsid2 )
+ {
+ return !aSsid1.Compare( aSsid2 );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::RefreshNetworkNameL
+// ---------------------------------------------------------------------------
+//
+TBool CWsfWlanScanner::RefreshNetworkNameL( TWsfWlanInfo& aWlanInfo )
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::RefreshNetworkNameL" );
+
+ TBool isHidden( EFalse );
+
+ TUint8 ieLen( 0 );
+ const TUint8* ieData;
+ TBuf8<KWlanMaxSsidLength> ssid8;
+
+ TInt ret = iScanInfo->InformationElement( E802Dot11SsidIE, ieLen,
+ &ieData );
+
+ if ( ret == KErrNone )
+ {
+ isHidden = IsHiddenSsid( ieLen, ieData );
+
+ if ( ieLen )
+ {
+ ssid8.Copy( ieData, ieLen );
+ aWlanInfo.iSsid.Copy( ssid8 );
+ aWlanInfo.iRawSsid.Copy( ssid8 );
+ TBuf<KWlanMaxSsidLength> ssid16;
+ ssid16.Copy( ssid8 );
+ LOG_WRITEF( "SSID: [%S]", &ssid16 );
+ }
+ else
+ {
+ LOG_WRITE( "SSID: <hidden>" );
+ }
+ }
+ else
+ {
+ User::Leave( ret );
+ }
+
+ return isHidden;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::IsHiddenSsid
+// ---------------------------------------------------------------------------
+//
+TBool CWsfWlanScanner::IsHiddenSsid( TUint aSsidLength, const TUint8* aSsid )
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::IsHiddenSsid" );
+
+
+ if ( !aSsidLength )
+ {
+ LOG_WRITEF( "result: %d", ETrue );
+ return ETrue;
+ }
+
+ TInt count( 0 );
+ for ( TUint i( 0 ); i < aSsidLength; ++i )
+ {
+ count |= aSsid[i]; // in hidden networks characters are: 0x00
+ }
+
+ LOG_WRITEF( "result: %d", !count );
+
+ return !count;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::RefreshSignalStrength
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::RefreshSignalStrength( TWsfWlanInfo& aWlanInfo )
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::RefreshSignalStrength" );
+
+ TInt rxLevel = iScanInfo->RXLevel();
+
+ LOG_WRITEF( "rxLevel = %d", rxLevel );
+
+ // yes, it is < and not >, because smaller value means stronger signal
+
+ if ( rxLevel < aWlanInfo.iStrengthLevel )
+ {
+ LOG_WRITEF( "updating %d to %d", aWlanInfo.iStrengthLevel, rxLevel );
+ aWlanInfo.iStrengthLevel = rxLevel;
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::RefreshNetworkMode
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::RefreshNetworkMode( TWsfWlanInfo& aWlanInfo )
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::RefreshNetworkMode" );
+
+ aWlanInfo.iNetMode = ( iScanInfo->Capability() &
+ E802Dot11CapabilityEssMask ) ?
+ EInfra : EAdhoc ;
+
+ LOG_WRITEF( "netmode = %d", TInt( aWlanInfo.iNetMode ) );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::RefreshSecurityMode
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::RefreshSecurityMode( TWsfWlanInfo& aWlanInfo )
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::RefreshSecurityMode" );
+
+ TWlanConnectionExtentedSecurityMode extSecMode = iScanInfo->ExtendedSecurityMode();
+
+ switch ( extSecMode )
+ {
+ case EWlanConnectionExtentedSecurityModeWepOpen:
+ case EWlanConnectionExtentedSecurityModeWepShared:
+ {
+ aWlanInfo.iSecurityMode = EWlanSecModeWep;
+ break;
+ }
+
+ case EWlanConnectionExtentedSecurityMode802d1x:
+ {
+ aWlanInfo.iSecurityMode = EWlanSecMode802_1x;
+ break;
+ }
+
+ case EWlanConnectionExtentedSecurityModeWpa:
+ case EWlanConnectionExtentedSecurityModeWpa2:
+ {
+ aWlanInfo.iSecurityMode = EWlanSecModeWpa;
+ break;
+ }
+
+ case EWlanConnectionExtentedSecurityModeWpaPsk:
+ case EWlanConnectionExtentedSecurityModeWpa2Psk:
+ {
+ aWlanInfo.iSecurityMode = EWlanSecModeWpa;
+ break;
+ }
+
+ case EWlanConnectionExtentedSecurityModeWapi:
+ case EWlanConnectionExtentedSecurityModeWapiPsk:
+ {
+ aWlanInfo.iSecurityMode = EWlanSecModeWAPI;
+ break;
+ }
+
+ case EWlanConnectionExtentedSecurityModeOpen:
+ default:
+ {
+ aWlanInfo.iSecurityMode = EWlanSecModeOpen;
+ }
+ }
+
+ aWlanInfo.SetUsesPreSharedKey(
+ extSecMode == EWlanConnectionExtentedSecurityModeWpa2Psk ||
+ extSecMode == EWlanConnectionExtentedSecurityModeWpaPsk );
+
+ LOG_WRITEF( "security mode %d (PSK: %d)",
+ (TInt)aWlanInfo.iSecurityMode,
+ (TInt)aWlanInfo.UsesPreSharedKey() );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CWsfWlanScanner::ConvertTxRateToTxRateEnum
+// -----------------------------------------------------------------------------
+//
+core_tx_rate_e CWsfWlanScanner::ConvertTxRateToTxRateEnum( TUint8 aRate )
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::ConvertTxRateToTxRateEnum" );
+
+ switch ( aRate )
+ {
+ case core_tx_rate_value_1mbit:
+ return core_tx_rate_1mbit;
+ case core_tx_rate_value_2mbit:
+ return core_tx_rate_2mbit;
+ case core_tx_rate_value_5p5mbit:
+ return core_tx_rate_5p5mbit;
+ case core_tx_rate_value_6mbit:
+ return core_tx_rate_6mbit;
+ case core_tx_rate_value_9mbit:
+ return core_tx_rate_9mbit;
+ case core_tx_rate_value_11mbit:
+ return core_tx_rate_11mbit;
+ case core_tx_rate_value_12mbit:
+ return core_tx_rate_12mbit;
+ case core_tx_rate_value_18mbit:
+ return core_tx_rate_18mbit;
+ case core_tx_rate_value_22mbit:
+ return core_tx_rate_22mbit;
+ case core_tx_rate_value_24mbit:
+ return core_tx_rate_24mbit;
+ case core_tx_rate_value_33mbit:
+ return core_tx_rate_33mbit;
+ case core_tx_rate_value_36mbit:
+ return core_tx_rate_36mbit;
+ case core_tx_rate_value_48mbit:
+ return core_tx_rate_48mbit;
+ case core_tx_rate_value_54mbit:
+ return core_tx_rate_54mbit;
+ default:
+ return core_tx_rate_none;
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::RefreshTechnology
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::RefreshTechnology( TWsfWlanInfo& aWlanInfo )
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::RefreshTechnology" );
+
+ TUint8 ieLen(0);
+ const TUint8* ieData;
+ TUint8 dataRates[KMaxNumberOfRates];
+
+ if ( iScanInfo->InformationElement( E802Dot11HtCapabilitiesIE, ieLen,
+ &ieData ) == 0 )
+ {
+ // 802.11n supported
+ aWlanInfo.iTransferRate = 0x8;
+ }
+ else
+ {
+ Mem::FillZ( &dataRates[0], sizeof( dataRates ) );
+ core_tx_rate_e rate( core_tx_rate_none );
+ TUint32 basic_rates( 0 );
+ TUint32 supported_rates( 0 );
+
+ // Supported Rates
+ iScanInfo->InformationElement( E802Dot11SupportedRatesIE, ieLen,
+ &ieData );
+
+ Mem::Copy( dataRates, ieData, ieLen );
+
+ TUint32 temp_basic_rates( 0 );
+ TUint32 temp_supported_rates( 0 );
+
+ for ( TInt a = 0; a < ieLen; a++ )
+ {
+ rate = ConvertTxRateToTxRateEnum( dataRates[a]
+ & ~TX_RATE_BASIC_MASK );
+
+ temp_supported_rates |= rate;
+
+ if ( dataRates[a] & TX_RATE_BASIC_MASK )
+ {
+ /**
+ * The highest bit is enabled, the rate is both a basic rate
+ * and a supported rate.
+ */
+ temp_basic_rates |= rate;
+ }
+ }
+
+ basic_rates |= temp_basic_rates;
+ supported_rates |= temp_supported_rates;
+
+ // Extended Supported Rates
+ Mem::FillZ( &dataRates[0], sizeof( dataRates ) );
+
+ iScanInfo->InformationElement( E802Dot11ExtendedRatesIE, ieLen,
+ &ieData );
+
+ Mem::Copy( dataRates, ieData, ieLen );
+
+ if ( ieData )
+ {
+ temp_basic_rates = 0;
+ temp_supported_rates = 0;
+
+ for ( TInt a = 0; a < ieLen; a++ )
+ {
+ rate = ConvertTxRateToTxRateEnum( dataRates[a]
+ & ~TX_RATE_BASIC_MASK );
+
+ temp_supported_rates |= rate;
+
+ if ( dataRates[a] & TX_RATE_BASIC_MASK )
+ {
+ /**
+ * The highest bit is enabled, the rate is both a basic rate
+ * and a supported rate.
+ */
+ temp_basic_rates |= rate;
+ }
+ }
+
+ basic_rates |= temp_basic_rates;
+ supported_rates |= temp_supported_rates;
+ }
+
+ aWlanInfo.iTransferRate = 0x4; // 802.11bg
+
+ // AP is 802.11b only if only 802.11b rates
+ // are advertised as supported rates.
+ if ( !( supported_rates & ~CORE_TX_RATES_802P11B ) )
+ {
+ aWlanInfo.iTransferRate = 0x1; // 802.11b
+ }
+ // AP is 802.11g only if any of the 802.11g rates is a basic rate.
+ else if ( basic_rates & CORE_TX_RATES_802P11G )
+ {
+ aWlanInfo.iTransferRate = 0x2; // 802.11g
+ }
+ }
+
+ LOG_WRITEF( "technology = %d", aWlanInfo.iTransferRate );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::ConnectionEstablishedL
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::ConnectionEstablishedL( const TDesC& aConnectionName )
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::ConnectionEstablishedL" );
+ LOG_WRITEF( "aConnectionName: [%S]", &aConnectionName );
+
+ HBufC* temp = aConnectionName.AllocL();
+ if ( iActiveConnectionName )
+ {
+ delete iActiveConnectionName;
+ iActiveConnectionName = NULL;
+ }
+ iActiveConnectionName = temp;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::ConnectionLostL
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::ConnectionLostL()
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::ConnectionLostL" );
+ if ( iActiveConnectionName )
+ {
+ delete iActiveConnectionName;
+ iActiveConnectionName = NULL;
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::ConnectingFailedL
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::ConnectingFailedL( TInt /*aError*/ )
+ {
+ // no implementation required
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::ConnectedIapReleasedL
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::ConnectedIapReleasedL()
+ {
+ // no implementation required
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::ScanResults
+// ---------------------------------------------------------------------------
+//
+HBufC8* CWsfWlanScanner::ScanResults()
+ {
+ return iScanResults;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::SetConnectionDetailProvider
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::SetConnectionDetailProvider(
+ MWsfWlanConnectionDetailsProvider& aProvider )
+ {
+ iConnectionDetailsProvider = &aProvider;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CWsfWlanScanner::WlanScanIntervalChangedL
+// ---------------------------------------------------------------------------
+//
+void CWsfWlanScanner::WlanScanIntervalChangedL( TUint aNewScanInterval,
+ TBool aShowAvailability )
+ {
+ LOG_ENTERFN( "CWsfWlanScanner::WlanScanIntervalChangedL" );
+ LOG_WRITEF( "bgScanInterval = %d sec", aNewScanInterval );
+ LOG_WRITEF( "showAvailability = %d", aShowAvailability );
+ iScanningInterval = aNewScanInterval * KMicrosecPerSecond;
+
+ if ( iShowAvailability != aShowAvailability )
+ {
+ // background WLAN scanning status changed
+ iShowAvailability = aShowAvailability;
+
+ if ( iShowAvailability )
+ {
+ // bgscan is now enabled
+ // no reissuing, we rely on the WLAN engine callbacks
+ // from now on
+ LOG_WRITE( "background scan enabled" );
+
+ if ( iScanState == EIdle && IsActive() )
+ {
+ // reset the timer only if we are not in the middle
+ // of another scanning
+ iTimer.Cancel();
+ }
+ }
+ else
+ {
+ // bgscan is now disabled
+ // reset the timer with the new interval
+ LOG_WRITE( "background scan disabled" );
+
+ if ( iScanState == EIdle )
+ {
+ LOG_WRITE( "reissuing timer request" );
+ // reset the timer only if we are not in the middle
+ // of another scanning
+ // otherwise RunL will take care of the timer
+ // doCancel resets timer
+ if ( IsActive() )
+ {
+ Cancel();
+ }
+ iTimer.After( iStatus, TTimeIntervalMicroSeconds32(
+ iScanningInterval ) );
+ iCacheLifetime = 0;
+ iMaxDelay = 0;
+ SetActive();
+ }
+ }
+ }
+ else if ( !iShowAvailability )
+ {
+ // only the scan interval has changed
+ LOG_WRITE( "scan interval changed" );
+ if ( iScanState == EIdle && IsActive() )
+ {
+ // reset the timer only if we are not in the middle of
+ // another scanning
+ // doCancel resets timer
+ LOG_WRITE( "reissuing timer request" );
+ Cancel();
+ iTimer.After( iStatus, TTimeIntervalMicroSeconds32(
+ iScanningInterval ) );
+ iCacheLifetime = 0;
+ iMaxDelay = 0;
+ SetActive();
+ }
+ }
+ }
+
+// End of file
+