1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Implementation of CWsfWlanScanner

    15 *

    16 */

    17 

    18 

    19 

    20 //  EXTERNAL INCLUDES

    21 #include <wlanmgmtclient.h>

    22 #include <centralrepository.h>

    23 #include <utf.h>

    24 #include <wlancontainer.h>

    25 #include <commsdattypeinfov1_1.h>

    26 #include <wlanscaninfo.h>

    27 #include <cmdestinationext.h>

    28 #include <commdb.h>

    29 

    30 #ifdef __WINS__

    31 #include <e32math.h>

    32 #endif

    33 

    34 //  CLASS HEADER

    35 #include "wsfwlanscanner.h"

    36 

    37 //  INTERNAL INCLUDES

    38 #include "wsfwlaninfoarray.h"

    39 #include "wsfwlanscaninfodefines.h"

    40 #include "wsfwlanconnectiondetailsprovider.h"

    41 #include "wsfwlansettingsaccessor.h"

    42 

    43 #include "wsflogger.h"

    44 

    45 //  LOCAL DEFINITIONS

    46 using namespace CMManager;

    47 

    48 

    49 /**

    50 * Microseconds in a second 

    51 */

    52 static const TInt KMicrosecPerSecond = 1000 * 1000;

    53 

    54 

    55 //  CONSTRUCTION AND DESTRUCTION

    56 

    57 // ---------------------------------------------------------------------------

    58 // CWsfWlanScanner::NewL

    59 // ---------------------------------------------------------------------------

    60 //    

    61 CWsfWlanScanner* CWsfWlanScanner::NewL( CommsDat::CMDBSession& aDbSession )

    62     {

    63     CWsfWlanScanner* self = CWsfWlanScanner::NewLC( aDbSession );

    64     CleanupStack::Pop( self );

    65     return self;

    66     }

    67 

    68 

    69 // ---------------------------------------------------------------------------

    70 // CWsfWlanScanner::NewLC

    71 // ---------------------------------------------------------------------------

    72 //    

    73 CWsfWlanScanner* CWsfWlanScanner::NewLC( CommsDat::CMDBSession& aDbSession )

    74     {

    75     CWsfWlanScanner* self = new( ELeave ) CWsfWlanScanner( aDbSession );

    76     CleanupStack::PushL( self );

    77     self->ConstructL();

    78     return self;

    79     }

    80 

    81 

    82 // ---------------------------------------------------------------------------

    83 // CWsfWlanScanner::~CWsfWlanScanner

    84 // ---------------------------------------------------------------------------

    85 //    

    86 CWsfWlanScanner::~CWsfWlanScanner()

    87     {

    88     LOG_ENTERFN( "CWsfWlanScanner::~CWsfWlanScanner" );

    89     StopScanning();

    90     Cancel();

    91     iTimer.Close();

    92     iCmManagerExt.Close();

    93     delete iActiveConnectionName;

    94     delete iScanResults;

    95     delete iWlanMgmtClient;

    96     delete iWlanSettingsAccessor;

    97     delete iScanInfo;

    98     delete iScanArray;

    99     iDirectScanSsids.Close();

   100     iDirectScanIapIDs.Close();

   101     iDbSession = NULL; // not owning

   102     iConnectionDetailsProvider = NULL;

   103     }

   104 

   105 

   106 // ---------------------------------------------------------------------------

   107 // CWsfWlanScanner::CWsfWlanScanner

   108 // ---------------------------------------------------------------------------

   109 //    

   110 CWsfWlanScanner::CWsfWlanScanner( CommsDat::CMDBSession& aDbSession ): 

   111     CActive( EPriorityStandard ),

   112     iDbSession( &aDbSession ),

   113     iScanState( EIdle )

   114     {

   115     }

   116 

   117 

   118 // ---------------------------------------------------------------------------

   119 // CWsfWlanScanner::ConstructL

   120 // ---------------------------------------------------------------------------

   121 //    

   122 void CWsfWlanScanner::ConstructL()

   123     {

   124     LOG_ENTERFN( "CWsfWlanScanner::ConstructL" );

   125     

   126 #ifndef __WINS__ // client is not available on wins

   127     iWlanMgmtClient = CWlanMgmtClient::NewL();

   128 

   129     iScanInfo = CWlanScanInfo::NewL();

   130 #endif

   131 

   132     iCmManagerExt.OpenL();

   133     

   134     iScanArray = CWsfWlanInfoArray::NewL();

   135     

   136     User::LeaveIfError( iTimer.CreateLocal() );

   137     iScanResults = KNullDesC8().AllocL();

   138 

   139     iWlanSettingsAccessor = CWsfWlanSettingsAccessor::NewL( *iDbSession );

   140     iScanningInterval = iWlanSettingsAccessor->ScanInterval() * 

   141                                                           KMicrosecPerSecond;

   142     iShowAvailability = iWlanSettingsAccessor->ShowAvailability();

   143     

   144     LOG_WRITEF( "initial bgScanInterval = %d sec", 

   145                 iWlanSettingsAccessor->ScanInterval() );

   146     LOG_WRITEF( "initial showAvailability = %d", iShowAvailability );

   147     

   148     CActiveScheduler::Add( this );

   149     }

   150 

   151 

   152 // ---------------------------------------------------------------------------

   153 // CWsfWlanScanner::DoCancel

   154 // ---------------------------------------------------------------------------

   155 //    

   156 void CWsfWlanScanner::DoCancel()

   157     {

   158     LOG_ENTERFN( "CWsfWlanScanner::DoCancel" );

   159     iTimer.Cancel();

   160 #ifndef __WINS__

   161     iWlanMgmtClient->CancelGetScanResults();

   162 #endif    

   163     iScanState = EIdle;    

   164     }

   165  

   166 

   167 // ---------------------------------------------------------------------------

   168 // CWsfWlanScanner::RunL

   169 // ---------------------------------------------------------------------------

   170 //    

   171 void CWsfWlanScanner::RunL()

   172     {

   173     LOG_ENTERFN( "CWsfWlanScanner::RunL" );

   174     

   175     /*

   176      * Scan logic

   177      * 1. Do broadcast scan - state = EIdle

   178      * 2. Get available IAPs - state = EBroadcastScan

   179      * 3. Process broadcast scan results state = EBroadcastScan

   180      * 4. Do direct scans for remaining known networks

   181      *    from step 2. Get available IAPs - state = EDirectScan

   182      * 5. Add connected network - state = EFinished

   183      * 6. Set names and priorities for known networks - state = EFinished

   184      */

   185 

   186     if ( iScanState == EIdle )

   187         {

   188         LOG_WRITE( "broadcast scan phase" );

   189 

   190         // prepare things for direct scans

   191         PrepareDirectScan();

   192           

   193         // notify clients

   194         if ( iObserver )

   195             {

   196             iObserver->WlanScanStarted();

   197             }

   198 

   199         // do broadcast scan

   200 #ifndef __WINS__

   201         iWlanMgmtClient->GetScanResults( iStatus, *iScanInfo );

   202         SetActive();

   203 #else

   204         // for testing

   205         SetActive();

   206         TRequestStatus* status = &iStatus;

   207         User::RequestComplete( status, KErrNone );

   208 #endif     

   209         

   210         iScanState = EBroadcastScan;

   211         }

   212         

   213     else if ( iScanState == EBroadcastScan )

   214         {

   215         // process broadcast scan results

   216         DoScanForNetworksL();

   217         

   218         // now it's time to initiate direct scan 

   219         // for remaining known networks

   220         if ( iDirectScanSsids.Count() )

   221             {

   222 #ifdef _DEBUG

   223             HBufC* ssid = TWsfWlanInfo::GetSsidAsUnicodeLC( 

   224                                                         iDirectScanSsids[0] );

   225             LOG_WRITEF( "requesting direct scan for [%S]", ssid );

   226             CleanupStack::PopAndDestroy( ssid );

   227 #endif

   228             

   229 #ifndef __WINS__

   230             // run direct scan

   231             iWlanMgmtClient->GetScanResults( iDirectScanSsids[0], 

   232                                              iStatus, *iScanInfo );

   233             SetActive();

   234 #else

   235             // for testing

   236             SetActive();

   237             TRequestStatus* status = &iStatus;

   238             User::RequestComplete( status, KErrNone );

   239 #endif                                             

   240 

   241             iScanState = EDirectScan;

   242             }

   243         else

   244             {

   245             LOG_WRITE( "direct scan skipped" );

   246             iScanState = EFinished;

   247             }

   248         }

   249         

   250     else if ( iScanState == EDirectScan )

   251         {

   252         LOG_WRITE( "direct scan results" );

   253 

   254 #ifndef __WINS__

   255         ProcessDirectScanResultL();

   256 #endif

   257  

   258         // delete the processed item (first)

   259         iDirectScanSsids.Remove( 0 );

   260         iDirectScanIapIDs.Remove( 0 );

   261 

   262         if ( iDirectScanSsids.Count() )

   263             {

   264             // repeated direct scans for known networks

   265 #ifdef _DEBUG

   266             HBufC* ssid = TWsfWlanInfo::GetSsidAsUnicodeLC( 

   267                                                         iDirectScanSsids[0] );

   268             LOG_WRITEF( "requesting direct scan for [%S]", ssid );

   269             CleanupStack::PopAndDestroy( ssid );

   270 #endif

   271             

   272 #ifndef __WINS__

   273             // run direct scan

   274             iWlanMgmtClient->GetScanResults( iDirectScanSsids[0], 

   275                                              iStatus, *iScanInfo );        

   276             SetActive();

   277 #else

   278             // for testing

   279             SetActive();

   280             TRequestStatus* status = &iStatus;

   281             User::RequestComplete( status, KErrNone );

   282 #endif                                             

   283             }

   284         else

   285             {

   286             // there is nothing more to do

   287             iScanState = EFinished;

   288             }

   289         }

   290     

   291     if ( iScanState == EFinished )

   292         {

   293         LOG_WRITE( "scanning finished" );

   294 #ifndef __WINS__

   295         AddConnectedWLANInfoL();

   296         

   297         TWsfWlanInfo* info(NULL);

   298         TInt scanArrayCount( iScanArray->Count() );

   299         

   300         for ( TInt i(0) ; i < scanArrayCount ; i++ )

   301             {  

   302             info = (*iScanArray)[ i ];

   303             

   304             if( info->iIapId )

   305                 {

   306                 TRAPD( error, UpdatePriorityL( *info ) );

   307                 if ( error )

   308                     {

   309                     // Ignore error and just continue

   310                     LOG_WRITE( "Prio update failed" );

   311                     }

   312                 }

   313             

   314             if( info->iIapId && info->iConnectionState != EConnected )

   315                 {

   316                 ReplaceSsidsWithIapName( *info );

   317                 }

   318             }

   319 #endif //_WINS_

   320         

   321         // sort the array

   322         iScanArray->SortArrayL();

   323         

   324         HBufC8* results = iScanArray->SerializeContentLC();

   325         CleanupStack::Pop( results );

   326         delete iScanResults;

   327         iScanResults = results;

   328 

   329         // we may let go the scan array contents...

   330         iScanArray->Reset();

   331     

   332 #ifdef _DEBUG

   333         DumpScanResultsL( iScanArray );

   334 #endif

   335         // notify clients that data is ready

   336         if ( iObserver )

   337             {

   338             iObserver->WlanScanCompleteL();

   339             }

   340 

   341         if ( !iShowAvailability )

   342             {

   343             // reset the timer if we are responsible for scheduling scans

   344             iTimer.Cancel();

   345             iTimer.After( iStatus, 

   346                           TTimeIntervalMicroSeconds32( iScanningInterval ) );

   347             Cancel();

   348             SetActive();

   349             }

   350         

   351         iScanState = EIdle;

   352         }

   353     }

   354 

   355 

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

   357 // CWsfWlanScanner::AddConnectedWLANInfo

   358 // ---------------------------------------------------------------------------

   359 //    

   360 void CWsfWlanScanner::AddConnectedWLANInfoL()

   361     {

   362     // Get the possible connection

   363     if ( iConnectionDetailsProvider )

   364         {

   365         TWsfWlanInfo* connectedInfo = new (ELeave) TWsfWlanInfo();

   366         CleanupStack::PushL( connectedInfo );

   367         if ( iConnectionDetailsProvider->ConnectedWlanConnectionDetailsL(

   368                 connectedInfo) )

   369             {

   370             TBuf8<KWlanMaxAccessPointNameLength> connectedSsidOrIap;

   371             connectedSsidOrIap.Copy( connectedInfo->iSsid );

   372             // ConnectedWlanConnectionDetailsL() may have returned an IAP name instead of SSID.

   373             // make sure that we really have SSID in connectedInfo->iSSID at this phase.

   374             TWlanSsid connectedSsid;

   375             iWlanMgmtClient->GetConnectionSsid( connectedSsid );

   376             connectedInfo->iSsid.Copy( connectedSsid );

   377             connectedInfo->iCoverage = 0;

   378             connectedInfo->iVisibility = 1;

   379 

   380             TBool connectedInfoAppended = EFalse;

   381 

   382             RPointerArray<TWsfWlanInfo> matchArray;

   383             CleanupClosePushL( matchArray );

   384 

   385             if ( connectedInfo->iIapId )

   386                 {

   387                 LOG_WRITEF( "Connected iap [%d]", connectedInfo->iIapId );

   388                 iScanArray->MatchWithIapIDL( connectedInfo->iIapId,

   389                         iScanArray->Count(), matchArray );

   390                 

   391                 if ( !matchArray.Count() )

   392                     {

   393                     LOG_WRITE( "Not found with Iap id" );

   394                     iScanArray->MatchL( connectedInfo->iSsid,

   395                                         connectedInfo->iSecurityMode,

   396                                         connectedInfo->iNetMode, 

   397                                         iScanArray->Count(),

   398                                         matchArray );

   399                     }

   400                 

   401                 }

   402             else

   403                 {

   404                 LOG_WRITE( "Easy WLAN connection" );

   405                 iScanArray->MatchL( connectedInfo->iSsid,

   406                         connectedInfo->iSecurityMode,

   407                         connectedInfo->iNetMode, iScanArray->Count(),

   408                         matchArray );

   409                 }

   410 

   411             if ( matchArray.Count() )

   412                 {

   413                 LOG_WRITE( "Info found" );

   414                 TWsfWlanInfo* temp = matchArray[0];

   415                 temp->iConnectionState = EConnected;

   416                 temp->iSsid.Copy( connectedSsidOrIap );

   417                 temp->iNetworkName.Zero();

   418                 }

   419             else

   420                 {

   421                 LOG_WRITE( "Info not found - append" );

   422                 connectedInfo->iSsid.Copy( connectedSsidOrIap );

   423                 iScanArray->AppendL( connectedInfo );

   424                 connectedInfoAppended = ETrue;

   425                 }

   426 

   427             CleanupStack::PopAndDestroy( &matchArray );

   428             if ( connectedInfoAppended )

   429                 {

   430                 CleanupStack::Pop( connectedInfo );

   431                 }

   432             else

   433                 {

   434                 CleanupStack::PopAndDestroy( connectedInfo );

   435                 }

   436             }

   437         else

   438             {

   439             CleanupStack::PopAndDestroy( connectedInfo );

   440             }

   441         }

   442     else

   443         {

   444         LOG_WRITE( "No connection details provider" );

   445         }

   446     }

   447 

   448 

   449 #ifdef _DEBUG

   450 // ---------------------------------------------------------------------------

   451 // CWsfWlanScanner::DumpScanResultsL

   452 // ---------------------------------------------------------------------------

   453 //    

   454 void CWsfWlanScanner::DumpScanResultsL( CWsfWlanInfoArray* aArray )

   455     {

   456     _LIT( Kopen, "open" );

   457     _LIT( Kwep, "wep" );

   458     _LIT( Kwpa, "wpa" );

   459     _LIT( Kwpa2, "wpa2" );        

   460     _LIT( K802, "802.1x" );

   461     const TDesC* secModes[4] = { &Kopen, &Kwep, &K802, &Kwpa };

   462     _LIT( Kpsk, "psk" );

   463     _LIT( Keap, "eap" );

   464     _LIT( Khidden, "<hidden>" );

   465 

   466     for ( TInt i( 0 ); i < aArray->Count(); ++i )

   467         {

   468         TWsfWlanInfo* wi( (*aArray)[i] );

   469         const TDesC* sm( 0 );

   470 

   471         switch ( wi->iSecurityMode )

   472             {

   473             case EWlanSecModeOpen:

   474                 sm = &Kopen;

   475                 break;

   476             case EWlanSecModeWep:

   477                 sm = &Kwep;

   478                 break;

   479             case EWlanSecModeWpa:

   480                 sm = &Kwpa;

   481                 break;

   482             case EWlanSecModeWpa2:

   483                 sm = &Kwpa2;

   484                 break;

   485             case EWlanSecMode802_1x:

   486                 sm = &K802;

   487             }

   488         

   489         const TDesC* psk = wi->UsesPreSharedKey()? &Kpsk:             

   490                                ( ( wi->iSecurityMode == EWlanSecMode802_1x || 

   491                                    wi->iSecurityMode == EWlanSecModeWpa ||

   492                                    wi->iSecurityMode == EWlanSecModeWpa2 )? 

   493                                       &Keap: &KNullDesC );

   494         HBufC16 *ssid = TWsfWlanInfo::GetSsidAsUnicodeLC( wi->iSsid );

   495         

   496         LOG_WRITEF( "[%S] %S %S %S", ssid, sm, psk, 

   497                     wi->iVisibility? &KNullDesC: &Khidden );

   498         CleanupStack::PopAndDestroy( ssid );

   499         }

   500     

   501     }

   502 #endif // _DEBUG

   503 

   504 

   505 // ---------------------------------------------------------------------------

   506 // CWsfWlanScanner::RunError

   507 // ---------------------------------------------------------------------------

   508 //    

   509 TInt CWsfWlanScanner::RunError( TInt aError )

   510     {

   511     LOG_ENTERFN( "CWsfWlanScanner::RunError" );

   512     LOG_WRITEF( "error = %d", aError );

   513     

   514     iScanArray->Reset();

   515     

   516     if ( iObserver && aError != KErrNotReady )

   517         {

   518         // KErrNotReady is excluded as it indicates that the WLAN engine

   519         // has not yet set up itself, which we cannot help

   520         iObserver->NotifyError( aError );    

   521         }

   522 

   523     iScanState = EIdle;

   524     

   525     if ( !iShowAvailability )

   526         {

   527         // the scanning has failed, re-issue the scan timer

   528         iTimer.Cancel();

   529         iTimer.After( iStatus, 

   530                       TTimeIntervalMicroSeconds32( iScanningInterval ) );

   531         SetActive();    

   532         }

   533         

   534     return KErrNone;    

   535     }

   536 

   537 

   538 // ---------------------------------------------------------------------------

   539 // CWsfWlanScanner::SetObserver

   540 // ---------------------------------------------------------------------------

   541 //    

   542 void CWsfWlanScanner::SetObserver( MWsfWlanScannerObserver& aObserver )

   543     {

   544     iObserver = &aObserver;

   545     }

   546 

   547 

   548 // ---------------------------------------------------------------------------

   549 // CWsfWlanScanner::StartScanningL

   550 // ---------------------------------------------------------------------------

   551 //    

   552 void CWsfWlanScanner::StartScanningL()

   553     {

   554     LOG_ENTERFN( "CWsfWlanScanner::StartScanningL" );

   555 

   556     if ( iScanState == EIdle && !IsActive() )

   557         {

   558         LOG_WRITE( "request notifications" );

   559 #ifndef __WINS__

   560         iWlanMgmtClient->CancelNotifications();

   561         iWlanMgmtClient->ActivateNotificationsL( *this );

   562 #endif

   563         iWlanSettingsAccessor->RequestNotificationL( *this );

   564         

   565         iScanState = EIdle;

   566 

   567         if ( !iShowAvailability )

   568             {

   569             // in case show wlan availability is off, carry out a scan now

   570             SetActive();

   571             TRequestStatus* status = &iStatus;

   572             User::RequestComplete( status, KErrNone );

   573             }

   574         }

   575     }

   576 

   577 

   578 // ---------------------------------------------------------------------------

   579 // CWsfWlanScanner::StartScanningL

   580 // ---------------------------------------------------------------------------

   581 //    

   582 void CWsfWlanScanner::StopScanning()

   583     {

   584     LOG_ENTERFN( "CWsfWlanScanner::StopScanning" );

   585 

   586     Cancel();

   587 

   588 #ifndef __WINS__       

   589     if ( iWlanMgmtClient )

   590         {

   591         iWlanMgmtClient->CancelNotifications();

   592         }

   593 #endif

   594   

   595     if ( iWlanSettingsAccessor )

   596         {

   597         iWlanSettingsAccessor->CancelNotifications();

   598         }

   599     }

   600 

   601 

   602 // ---------------------------------------------------------------------------

   603 // CWsfWlanScanner::RestartScanning

   604 // ---------------------------------------------------------------------------

   605 //    

   606 TBool CWsfWlanScanner::RestartScanning()

   607     {

   608     LOG_ENTERFN( "CWsfWlanScanner::RestartScanning" );

   609 

   610     TBool restarted( EFalse );

   611     

   612     if ( iScanState == EIdle && ( IsActive() || iShowAvailability ) )

   613         {

   614         // we have been waiting for the timer to complete

   615         // cancel it manually

   616         Cancel();

   617         

   618         // then complete ourselves

   619         SetActive();

   620         TRequestStatus* status = &iStatus;

   621         User::RequestComplete( status, KErrNone );

   622         restarted = ETrue;

   623         }

   624     

   625     return restarted;

   626     }

   627 

   628 

   629 // ---------------------------------------------------------------------------

   630 // CWsfWlanScanner::AbortScanning

   631 // ---------------------------------------------------------------------------

   632 //    

   633 void CWsfWlanScanner::AbortScanning()

   634     {

   635     LOG_ENTERFN( "CWsfWlanScanner::AbortScanning" );

   636     

   637     if ( iScanState != EIdle )

   638         {

   639         // cancel the current scanning

   640         Cancel();

   641 

   642         if ( !iShowAvailability )

   643             {

   644             // still, life goes on

   645             iTimer.After( iStatus, TTimeIntervalMicroSeconds32( 

   646                                                         iScanningInterval ) );

   647             SetActive();        

   648             }

   649         }

   650     }

   651 

   652 

   653 // ---------------------------------------------------------------------------

   654 // CWsfWlanScanner::ConnectionStateChanged

   655 // ---------------------------------------------------------------------------

   656 //    

   657 void CWsfWlanScanner::ConnectionStateChanged( 

   658                                             TWlanConnectionMode /*aNewState*/ )

   659     {

   660     LOG_ENTERFN( "CWsfWlanScanner::ConnectionStateChanged" );

   661     }

   662     

   663 

   664 // ---------------------------------------------------------------------------

   665 // CWsfWlanScanner::BssidChanged

   666 // ---------------------------------------------------------------------------

   667 //    

   668 void CWsfWlanScanner::BssidChanged( TWlanBssid& /*aNewBSsid*/ )

   669     {

   670     LOG_ENTERFN( "CWsfWlanScanner::BssidChanged" );

   671     if ( iScanState == EIdle && !IsActive() )

   672         {

   673         // complete ourselves

   674         SetActive();

   675         TRequestStatus* status = &iStatus;

   676         User::RequestComplete( status, KErrNone );

   677         }

   678     }

   679 

   680 

   681 // ---------------------------------------------------------------------------

   682 // CWsfWlanScanner::BssLost

   683 // ---------------------------------------------------------------------------

   684 //    

   685 void CWsfWlanScanner::BssLost()

   686     {

   687     LOG_ENTERFN( "CWsfWlanScanner::BssLost" );

   688     if ( iScanState == EIdle && !IsActive() )

   689         {

   690         // complete ourselves

   691         SetActive();

   692         TRequestStatus* status = &iStatus;

   693         User::RequestComplete( status, KErrNone );

   694         }

   695     }

   696 

   697 

   698 // ---------------------------------------------------------------------------

   699 // CWsfWlanScanner::BssRegained

   700 // ---------------------------------------------------------------------------

   701 //    

   702 void CWsfWlanScanner::BssRegained()

   703     {

   704     LOG_ENTERFN( "CWsfWlanScanner::BssRegained" );

   705     if ( iScanState == EIdle && !IsActive() )

   706         {

   707         // complete ourselves

   708         SetActive();

   709         TRequestStatus* status = &iStatus;

   710         User::RequestComplete( status, KErrNone );

   711         }

   712     }

   713 

   714 

   715 // ---------------------------------------------------------------------------

   716 // CWsfWlanScanner::NewNetworksDetected

   717 // ---------------------------------------------------------------------------

   718 //    

   719 void CWsfWlanScanner::NewNetworksDetected()

   720     {

   721     LOG_ENTERFN( "CWsfWlanScanner::NewNetworksDetected" );

   722     if ( iScanState == EIdle && !IsActive() )

   723         {

   724         // complete ourselves

   725         SetActive();

   726         TRequestStatus* status = &iStatus;

   727         User::RequestComplete( status, KErrNone );

   728         }

   729     }

   730 

   731 

   732 // ---------------------------------------------------------------------------

   733 // CWsfWlanScanner::OldNetworksLost

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

   735 //    

   736 void CWsfWlanScanner::OldNetworksLost()

   737     {

   738     LOG_ENTERFN( "CWsfWlanScanner::OldNetworksLost" );

   739     if ( iScanState == EIdle && !IsActive() )

   740         {

   741         // complete ourselves

   742         SetActive();

   743         TRequestStatus* status = &iStatus;

   744         User::RequestComplete( status, KErrNone );

   745         }

   746     }

   747 

   748 

   749 // ---------------------------------------------------------------------------

   750 // CWsfWlanScanner::TransmitPowerChanged

   751 // ---------------------------------------------------------------------------

   752 //    

   753 void CWsfWlanScanner::TransmitPowerChanged( TUint /*aPower*/ )

   754     {

   755     LOG_ENTERFN( "CWsfWlanScanner::TransmitPowerChanged" );

   756     if ( iScanState == EIdle && !IsActive() )

   757         {

   758         // complete ourselves

   759         SetActive();

   760         TRequestStatus* status = &iStatus;

   761         User::RequestComplete( status, KErrNone );

   762         }

   763     }

   764         

   765 

   766 // ---------------------------------------------------------------------------

   767 // CWsfWlanScanner::RssChanged

   768 // ---------------------------------------------------------------------------

   769 //    

   770 void CWsfWlanScanner::RssChanged( TWlanRssClass /*aRssClass*/, TUint /*aRss*/ )

   771     {

   772     LOG_ENTERFN( "CWsfWlanScanner::RssChanged" );

   773     if ( iScanState == EIdle && !IsActive() )

   774         {

   775         // complete ourselves

   776         SetActive();

   777         TRequestStatus* status = &iStatus;

   778         User::RequestComplete( status, KErrNone );

   779         }

   780     }

   781 

   782 

   783 // ---------------------------------------------------------------------------

   784 // CWsfWlanScanner::PrepareDirectScan

   785 // ---------------------------------------------------------------------------

   786 //    

   787 void CWsfWlanScanner::PrepareDirectScan()

   788     {

   789     LOG_ENTERFN( "CWsfWlanScanner::PrepareDirectScanL" );

   790 

   791     // flush the arrays

   792     iDirectScanSsids.Reset();

   793     iDirectScanIapIDs.Reset();

   794     }

   795     

   796     

   797 // ---------------------------------------------------------------------------

   798 // CWsfWlanScanner::ProcessDirectScanResultL

   799 // ---------------------------------------------------------------------------

   800 //   

   801 void CWsfWlanScanner::ProcessDirectScanResultL()

   802     {

   803     LOG_ENTERFN( "CWsfWlanScanner::ProcessDirectScanResultL" );

   804     

   805     for ( iScanInfo->First(); !iScanInfo->IsDone(); iScanInfo->Next() )

   806         {

   807         RPointerArray<TWsfWlanInfo> matchArray;

   808         CleanupClosePushL(matchArray);

   809         iScanArray->MatchWithIapIDL( iDirectScanIapIDs[0], iScanArray->Count(), matchArray );

   810   

   811         TInt matchcount = matchArray.Count();

   812 

   813         if ( matchcount == 0 )

   814             {

   815             // not found yet

   816 #ifdef _DEBUG

   817             HBufC* ssid = TWsfWlanInfo::GetSsidAsUnicodeLC( iDirectScanSsids[0] );

   818             LOG_WRITEF( "[%S] found in direct scan", ssid ); 

   819             CleanupStack::PopAndDestroy( ssid );

   820 #endif       

   821             }

   822         else

   823             {

   824             LOG_WRITEF( "[%d] iap id is in scanarray", iDirectScanIapIDs[0] ); 

   825             for( TInt i(0); i < matchcount; i++ )

   826             	{

   827             	//if already found increase coverage

   828                 TWsfWlanInfo* temp = matchArray[i];

   829                 ++temp->iCoverage;

   830                 RefreshSignalStrength( *temp );

   831                 RefreshMaxRate( *temp );

   832              	}

   833             }

   834         // Close() for matchArray

   835         CleanupStack::PopAndDestroy( &matchArray );  

   836         } // for iScanInfo              

   837     }

   838 

   839 

   840 // ---------------------------------------------------------------------------

   841 // CWsfWlanScanner::ReplaceSsidsWithIapName

   842 // ---------------------------------------------------------------------------

   843 //   

   844 void CWsfWlanScanner::ReplaceSsidsWithIapName(TWsfWlanInfo& aWlanInfo)

   845     {	

   846     LOG_ENTERFN( "CWsfWlanScanner::ReplaceSsidsWithIapName" );

   847     if ( aWlanInfo.iNetworkName.Length() )

   848         {

   849         LOG_WRITE( "Replace ssid" );

   850         aWlanInfo.iSsid.Copy( aWlanInfo.iNetworkName );

   851         aWlanInfo.iNetworkName.Zero();

   852         }

   853     }

   854 

   855 

   856 // ---------------------------------------------------------------------------

   857 // CWsfWlanScanner::UpdatePriorityL

   858 // ---------------------------------------------------------------------------

   859 //    

   860 void CWsfWlanScanner::UpdatePriorityL( TWsfWlanInfo& aWlanInfo )

   861     {

   862     LOG_WRITE( "CWsfWlanScanner::updatePriority" );

   863 

   864     TUint32 priority( 0 );

   865     TInt exists( KErrNotFound );

   866     TInt count( 0 );   

   867 

   868     // search for the destination of it                                                        

   869     RArray<TUint32> destinations;                                                              

   870     CleanupClosePushL( destinations );

   871 

   872     LOG_WRITE( "CWsfWlanScanner::updatePriority get all destinations" );

   873     iCmManagerExt.AllDestinationsL(destinations);                                              

   874 

   875     count = destinations.Count();                                                         

   876     LOG_WRITEF( "destination count %d", count);

   877 

   878     for( TInt i = 0; i < count && exists != KErrNone; i++ )                                    

   879         {

   880         RCmDestinationExt destination;                                                              

   881         destination = iCmManagerExt.DestinationL( destinations[ i ] );                         

   882         CleanupClosePushL( destination );  

   883 

   884         LOG_WRITE( "check if connection method belongs to destination" );

   885 

   886         RCmConnectionMethodExt connectionMethod;

   887         TRAP( exists,                                                                      

   888                 connectionMethod = destination.ConnectionMethodByIDL(                            

   889                         aWlanInfo.iIapId ) ); 

   890 

   891         LOG_WRITEF( "exists %d", exists );

   892         if( exists == KErrNone )                                                           

   893             {   

   894             CleanupClosePushL( connectionMethod ); 

   895             // correct destination found                                                   

   896             priority = destination.PriorityL( connectionMethod );

   897             aWlanInfo.SetPriority( priority );

   898 

   899             LOG_WRITEF( "priority %d", priority );

   900             CleanupStack::PopAndDestroy( &connectionMethod ); 

   901             }

   902         CleanupStack::PopAndDestroy( &destination );                                           

   903         }                                                                                      

   904     CleanupStack::PopAndDestroy( &destinations );

   905     }

   906 

   907 

   908 #ifndef __WINS__

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

   910 // CWsfWlanScanner::DoScanForNetworksL

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

   912 //   

   913 void CWsfWlanScanner::DoScanForNetworksL()

   914     {

   915     LOG_ENTERFN( "CWsfWlanScanner::DoScanForNetworksL" );

   916         

   917     // start by making sure the scan array is empty

   918     iScanArray->Reset();    

   919 

   920     LOG_WRITEF( "GetScanResults returned %d", iStatus.Int() );

   921     

   922     if ( iStatus.Int() )

   923         {

   924         // if the status is not KErrNone, we cannot be sure that iScanInfo

   925         // doesn't cause a crash, so it's better to leave

   926         User::Leave( iStatus.Int() );

   927         }

   928    

   929     TInt nElem = 0;

   930     TBool isHidden( EFalse );

   931 

   932     // get available iaps

   933     // (this only shows iaps with security mode matching to scan results

   934     // and  also finds hidden wlans for which an iap has been configured)

   935     RArray<TUint> availableIaps;

   936     iWlanMgmtClient->GetAvailableIaps(availableIaps);

   937     TInt avIapCount = availableIaps.Count();

   938 

   939     LOG_WRITEF( "Available iap count %d", avIapCount ); 

   940 

   941     for( TInt i(0); i < avIapCount; i++ )

   942         {

   943         TBool addToArray( ETrue ); 

   944         TWsfWlanInfo* availableInfo = new ( ELeave ) TWsfWlanInfo();       

   945         CleanupStack::PushL( availableInfo );

   946         availableInfo->iIapId = availableIaps[i];

   947         TRAPD( error, GetWlanInfoFromIapL( *availableInfo ) );

   948 

   949         if ( error == KErrNotFound )

   950             {

   951             LOG_WRITEF( "Iap id = %d does not exist", availableInfo->iIapId );

   952             addToArray = EFalse;

   953             }

   954         else if ( error )

   955             {

   956             LOG_WRITEF( "GetWlanInfoFromIapL failed err = %d", error );

   957             User::Leave( error );

   958             }

   959 

   960         if( addToArray )

   961             { 

   962             LOG_WRITE( "Add to array" );

   963             availableInfo->iCoverage = 0;

   964             availableInfo->iVisibility = 1;

   965             availableInfo->iStrengthLevel = EWlanSignalUnavailable;

   966             availableInfo->iTransferRate = 0;

   967             availableInfo->iConnectionState = ENotConnected;

   968             iScanArray->AppendL(availableInfo);

   969             nElem++;

   970 

   971             if ( availableInfo->iIapId )

   972                 {

   973                 LOG_WRITEF( "Append available iap [%d] for direct scan", availableInfo->iIapId );

   974                 iDirectScanIapIDs.Append( availableInfo->iIapId );

   975                 iDirectScanSsids.Append( availableInfo->iSsid );

   976                 }

   977 

   978             CleanupStack::Pop( availableInfo );

   979             }

   980         else

   981             {

   982             LOG_WRITE( "Info not added" );

   983             CleanupStack::PopAndDestroy( availableInfo );

   984             }

   985         }

   986       

   987     // Process the scanned results

   988     for( iScanInfo->First(); !iScanInfo->IsDone(); iScanInfo->Next() )

   989         {

   990         TWsfWlanInfo* wlanInfo = iScanArray->At( nElem );

   991         if ( !wlanInfo )

   992             {

   993             wlanInfo = new ( ELeave ) TWsfWlanInfo();

   994             CleanupStack::PushL( wlanInfo );

   995             iScanArray->AppendL( wlanInfo );

   996             CleanupStack::Pop( wlanInfo );

   997             }

   998         isHidden = RefreshNetworkNameL( *wlanInfo );

   999         wlanInfo->iVisibility = !isHidden;

  1000         wlanInfo->iStrengthLevel = EWlanSignalUnavailable;

  1001         wlanInfo->iTransferRate = 0;

  1002         wlanInfo->iConnectionState = ENotConnected;

  1003 

  1004         if( !isHidden )

  1005             {

  1006             // not hidden

  1007             RefreshNetworkMode( *wlanInfo );

  1008             RefreshSecurityMode( *wlanInfo );

  1009             RefreshMaxRate( *wlanInfo );

  1010 

  1011             // check if we already have an entry/entries corresponding to a scan result

  1012             // (multiple entries for one scan result possible if GetAvailableIaps()

  1013             // found several iaps configured for same wlan)

  1014             RPointerArray<TWsfWlanInfo> matchArray;

  1015             CleanupClosePushL(matchArray);

  1016             iScanArray->MatchL( wlanInfo->iSsid, wlanInfo->iSecurityMode, 

  1017                     wlanInfo->iNetMode, nElem, matchArray );

  1018 

  1019             TInt matchcount = matchArray.Count();

  1020 

  1021             // if not found

  1022             if( matchcount == 0 )

  1023                 {

  1024                 wlanInfo->iCoverage = 1;

  1025                 RefreshSignalStrength( *wlanInfo );

  1026                 RefreshMaxRate( *wlanInfo );

  1027                 ++nElem; // new entry, inc index in array

  1028                 }

  1029             else // if found inc coverage and refresh signal strength and rate

  1030                 {

  1031                 for( TInt i(0); i < matchcount; i++ )

  1032                     {

  1033                     TWsfWlanInfo* temp = matchArray[i];

  1034                     ++temp->iCoverage;

  1035                     RefreshSignalStrength( *temp );

  1036                     RefreshMaxRate( *temp );

  1037 

  1038                     if ( temp->iIapId )

  1039                         {

  1040                         TInt index( KErrNone );

  1041                         do {

  1042                             LOG_WRITE( "Not hidden - Searching from direct scan list.." );

  1043                             // remove this item from the direct scan list, if found 

  1044                             index = iDirectScanIapIDs.Find( temp->iIapId  );

  1045                             if ( index != KErrNotFound )

  1046                                 {

  1047                                 LOG_WRITEF( "Found - removing iap id [%d]", iDirectScanIapIDs[index] );

  1048                                 iDirectScanSsids.Remove( index );

  1049                                 iDirectScanIapIDs.Remove( index );

  1050                                 }

  1051                         } while ( index != KErrNotFound );

  1052                         }

  1053                     }

  1054                 }

  1055             CleanupStack::PopAndDestroy(); // results in Close() being called on matchArray

  1056             }

  1057         }

  1058     //get rid of excess items

  1059     iScanArray->DeleteFromTail(iScanArray->Count() - nElem);

  1060     }

  1061 

  1062 #else // __WINS__

  1063 

  1064 // ---------------------------------------------------------------------------

  1065 // CWsfWlanScanner::DoScanForNetworksL

  1066 // ---------------------------------------------------------------------------

  1067 //   

  1068 void CWsfWlanScanner::DoScanForNetworksL()

  1069     {

  1070     LOG_ENTERFN( "CWsfWlanScanner::DoScanForNetworksL" );

  1071         

  1072     // start by making sure the scan array is empty

  1073     iScanArray->Reset();    

  1074 

  1075     TWsfWlanInfo* wlan0 = new (ELeave) TWsfWlanInfo();

  1076     CleanupStack::PushL( wlan0 );    

  1077     wlan0->iConnectionState = EConnected;

  1078     wlan0->iIapId = 666;

  1079     wlan0->iNetMode = EInfra;

  1080     wlan0->iSecurityMode = EWlanSecModeWep;

  1081     wlan0->iSsid = _L8("[C]Known WEP");

  1082     wlan0->iStrengthLevel = EWlanSignalStrengthMax;  

  1083     wlan0->iVisibility = ETrue;

  1084     wlan0->iCoverage = 1;

  1085     if ( Math::Random() % 2 == 0 )

  1086         {

  1087         iScanArray->AppendL( wlan0 );

  1088         }

  1089     else 

  1090         {

  1091         delete wlan0;

  1092         }

  1093         

  1094     CleanupStack::Pop( wlan0 );

  1095 

  1096     TWsfWlanInfo* wlan1 = new (ELeave) TWsfWlanInfo();

  1097     CleanupStack::PushL( wlan1 );    

  1098     wlan1->iConnectionState = ENotConnected;

  1099     wlan1->iIapId = 666;

  1100     wlan1->iNetMode = EInfra;

  1101     wlan1->iSecurityMode = EWlanSecModeOpen;

  1102     wlan1->iSsid = _L8("Known open");

  1103     wlan1->iStrengthLevel = EWlanSignalStrengthMin;  

  1104     wlan1->iVisibility = ETrue;

  1105     wlan1->iCoverage = 3;

  1106     if ( Math::Random() % 2 == 0 )

  1107         {

  1108         iScanArray->AppendL( wlan1 );

  1109         }

  1110     else

  1111         {

  1112         delete wlan1;

  1113         }

  1114 

  1115     CleanupStack::Pop( wlan1 );

  1116 

  1117     TWsfWlanInfo* wlan2 = new (ELeave) TWsfWlanInfo();

  1118     CleanupStack::PushL( wlan2 );    

  1119     wlan2->iConnectionState = ENotConnected;

  1120     wlan2->iIapId = 0;

  1121     wlan2->iNetMode = EInfra;

  1122     wlan2->iSecurityMode = EWlanSecModeWpa2;

  1123     wlan2->iSsid = _L8("Known WPA2 PSK");

  1124     wlan2->iStrengthLevel = EWlanSignalStrengthLow-7;  

  1125     wlan2->iVisibility = ETrue;

  1126     wlan2->iCoverage = 1;

  1127     wlan2->SetUsesPreSharedKey( ETrue );

  1128     if ( Math::Random() % 2 == 0 )

  1129         {

  1130         iScanArray->AppendL( wlan2 );

  1131         }

  1132     else

  1133         {

  1134         delete wlan2;