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     LOG_ENTERFN( "CWsfWlanScanner::AddConnectedWLANInfoL" );

   363     // Get the possible connection

   364     if ( iConnectionDetailsProvider )

   365         {

   366         TWlanSsid connectedSsid;

   367         TInt error = iWlanMgmtClient->GetConnectionSsid( connectedSsid );

   368         

   369         LOG_WRITEF( "GetConnectionSsid returned=%d", error );

   370         

   371         TBool connected = ( error == KErrNone && connectedSsid.Length() );

   372     

   373         if ( !connected && !iConnectionDetailsProvider->IsConnected() )

   374             {

   375             LOG_WRITEF( "Not connected [connected=%d]", connected );

   376             return;

   377             }

   378         

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

   380         CleanupStack::PushL( connectedInfo );

   381         

   382         if ( iConnectionDetailsProvider->ConnectedWlanConnectionDetailsL(

   383                 connectedInfo) )

   384             {

   385             TBuf8<KWlanMaxAccessPointNameLength> connectedSsidOrIap;

   386             connectedSsidOrIap.Copy( connectedInfo->iSsid );

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

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

   389             

   390             connectedInfo->iRawSsid.Copy( connectedSsid );

   391             connectedInfo->iSsid.Copy( connectedSsid );

   392             connectedInfo->iCoverage = 0;

   393             connectedInfo->iVisibility = 1;

   394 

   395             TBool connectedInfoAppended = EFalse;

   396 

   397             RPointerArray<TWsfWlanInfo> matchArray;

   398             CleanupClosePushL( matchArray );

   399 

   400             if ( connectedInfo->iIapId )

   401                 {

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

   403                 iScanArray->MatchWithIapIDL( connectedInfo->iIapId,

   404                         iScanArray->Count(), matchArray );

   405                 

   406                 if ( !matchArray.Count() )

   407                     {

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

   409                     iScanArray->MatchL( connectedInfo->iSsid,

   410                                         connectedInfo->iSecurityMode,

   411                                         connectedInfo->iNetMode, 

   412                                         iScanArray->Count(),

   413                                         matchArray );

   414                     }

   415                 

   416                 }

   417             else

   418                 {

   419                 LOG_WRITE( "Easy WLAN connection" );

   420                 iScanArray->MatchL( connectedInfo->iSsid,

   421                         connectedInfo->iSecurityMode,

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

   423                         matchArray );

   424                 }

   425 

   426             if ( matchArray.Count() )

   427                 {

   428                 LOG_WRITE( "Info found" );

   429                 TWsfWlanInfo* temp = matchArray[0];

   430                 temp->iConnectionState = EConnected;

   431                 temp->iSsid.Copy( connectedSsidOrIap );

   432                 temp->iNetworkName.Zero();

   433                 }

   434             else

   435                 {

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

   437                 connectedInfo->iSsid.Copy( connectedSsidOrIap );

   438                 iScanArray->AppendL( connectedInfo );

   439                 connectedInfoAppended = ETrue;

   440                 }

   441 

   442             CleanupStack::PopAndDestroy( &matchArray );

   443             if ( connectedInfoAppended )

   444                 {

   445                 CleanupStack::Pop( connectedInfo );

   446                 }

   447             else

   448                 {

   449                 CleanupStack::PopAndDestroy( connectedInfo );

   450                 }

   451             }

   452         else

   453             {

   454             CleanupStack::PopAndDestroy( connectedInfo );

   455             }

   456         }

   457     else

   458         {

   459         LOG_WRITE( "No connection details provider" );

   460         }

   461     }

   462 

   463 

   464 #ifdef _DEBUG

   465 // ---------------------------------------------------------------------------

   466 // CWsfWlanScanner::DumpScanResultsL

   467 // ---------------------------------------------------------------------------

   468 //    

   469 void CWsfWlanScanner::DumpScanResultsL( CWsfWlanInfoArray* aArray )

   470     {

   471     _LIT( Kopen, "open" );

   472     _LIT( Kwep, "wep" );

   473     _LIT( Kwpa, "wpa" );

   474     _LIT( Kwpa2, "wpa2" );        

   475     _LIT( K802, "802.1x" );

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

   477     _LIT( Kpsk, "psk" );

   478     _LIT( Keap, "eap" );

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

   480 

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

   482         {

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

   484         const TDesC* sm( 0 );

   485 

   486         switch ( wi->iSecurityMode )

   487             {

   488             case EWlanSecModeOpen:

   489                 sm = &Kopen;

   490                 break;

   491             case EWlanSecModeWep:

   492                 sm = &Kwep;

   493                 break;

   494             case EWlanSecModeWpa:

   495                 sm = &Kwpa;

   496                 break;

   497             case EWlanSecModeWpa2:

   498                 sm = &Kwpa2;

   499                 break;

   500             case EWlanSecMode802_1x:

   501                 sm = &K802;

   502             }

   503         

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

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

   506                                    wi->iSecurityMode == EWlanSecModeWpa ||

   507                                    wi->iSecurityMode == EWlanSecModeWpa2 )? 

   508                                       &Keap: &KNullDesC );

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

   510         

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

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

   513         CleanupStack::PopAndDestroy( ssid );

   514         }

   515     

   516     }

   517 #endif // _DEBUG

   518 

   519 

   520 // ---------------------------------------------------------------------------

   521 // CWsfWlanScanner::RunError

   522 // ---------------------------------------------------------------------------

   523 //    

   524 TInt CWsfWlanScanner::RunError( TInt aError )

   525     {

   526     LOG_ENTERFN( "CWsfWlanScanner::RunError" );

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

   528     

   529     iScanArray->Reset();

   530     

   531     if ( iObserver && aError != KErrNotReady )

   532         {

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

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

   535         iObserver->NotifyError( aError );    

   536         }

   537 

   538     iScanState = EIdle;

   539     

   540     if ( !iShowAvailability )

   541         {

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

   543         iTimer.Cancel();

   544         iTimer.After( iStatus, 

   545                       TTimeIntervalMicroSeconds32( iScanningInterval ) );

   546         SetActive();    

   547         }

   548         

   549     return KErrNone;    

   550     }

   551 

   552 

   553 // ---------------------------------------------------------------------------

   554 // CWsfWlanScanner::SetObserver

   555 // ---------------------------------------------------------------------------

   556 //    

   557 void CWsfWlanScanner::SetObserver( MWsfWlanScannerObserver& aObserver )

   558     {

   559     iObserver = &aObserver;

   560     }

   561 

   562 

   563 // ---------------------------------------------------------------------------

   564 // CWsfWlanScanner::StartScanningL

   565 // ---------------------------------------------------------------------------

   566 //    

   567 void CWsfWlanScanner::StartScanningL()

   568     {

   569     LOG_ENTERFN( "CWsfWlanScanner::StartScanningL" );

   570 

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

   572         {

   573         LOG_WRITE( "request notifications" );

   574 #ifndef __WINS__

   575         iWlanMgmtClient->CancelNotifications();

   576         iWlanMgmtClient->ActivateNotificationsL( *this );

   577 #endif

   578         iWlanSettingsAccessor->RequestNotificationL( *this );

   579         

   580         iScanState = EIdle;

   581 

   582         if ( !iShowAvailability )

   583             {

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

   585             SetActive();

   586             TRequestStatus* status = &iStatus;

   587             User::RequestComplete( status, KErrNone );

   588             }

   589         }

   590     }

   591 

   592 

   593 // ---------------------------------------------------------------------------

   594 // CWsfWlanScanner::StartScanningL

   595 // ---------------------------------------------------------------------------

   596 //    

   597 void CWsfWlanScanner::StopScanning()

   598     {

   599     LOG_ENTERFN( "CWsfWlanScanner::StopScanning" );

   600 

   601     Cancel();

   602 

   603 #ifndef __WINS__       

   604     if ( iWlanMgmtClient )

   605         {

   606         iWlanMgmtClient->CancelNotifications();

   607         }

   608 #endif

   609   

   610     if ( iWlanSettingsAccessor )

   611         {

   612         iWlanSettingsAccessor->CancelNotifications();

   613         }

   614     }

   615 

   616 

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

   618 // CWsfWlanScanner::RestartScanning

   619 // ---------------------------------------------------------------------------

   620 //    

   621 TBool CWsfWlanScanner::RestartScanning()

   622     {

   623     LOG_ENTERFN( "CWsfWlanScanner::RestartScanning" );

   624 

   625     TBool restarted( EFalse );

   626     

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

   628         {

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

   630         // cancel it manually

   631         Cancel();

   632         

   633         // then complete ourselves

   634         SetActive();

   635         TRequestStatus* status = &iStatus;

   636         User::RequestComplete( status, KErrNone );

   637         restarted = ETrue;

   638         }

   639     

   640     return restarted;

   641     }

   642 

   643 

   644 // ---------------------------------------------------------------------------

   645 // CWsfWlanScanner::AbortScanning

   646 // ---------------------------------------------------------------------------

   647 //    

   648 void CWsfWlanScanner::AbortScanning()

   649     {

   650     LOG_ENTERFN( "CWsfWlanScanner::AbortScanning" );

   651     

   652     if ( iScanState != EIdle )

   653         {

   654         // cancel the current scanning

   655         Cancel();

   656 

   657         if ( !iShowAvailability )

   658             {

   659             // still, life goes on

   660             iTimer.After( iStatus, TTimeIntervalMicroSeconds32( 

   661                                                         iScanningInterval ) );

   662             SetActive();        

   663             }

   664         }

   665     }

   666 

   667 

   668 // ---------------------------------------------------------------------------

   669 // CWsfWlanScanner::ConnectionStateChanged

   670 // ---------------------------------------------------------------------------

   671 //    

   672 void CWsfWlanScanner::ConnectionStateChanged( 

   673                                             TWlanConnectionMode /*aNewState*/ )

   674     {

   675     LOG_ENTERFN( "CWsfWlanScanner::ConnectionStateChanged" );

   676     }

   677     

   678 

   679 // ---------------------------------------------------------------------------

   680 // CWsfWlanScanner::BssidChanged

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

   682 //    

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

   684     {

   685     LOG_ENTERFN( "CWsfWlanScanner::BssidChanged" );

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

   687         {

   688         // complete ourselves

   689         SetActive();

   690         TRequestStatus* status = &iStatus;

   691         User::RequestComplete( status, KErrNone );

   692         }

   693     }

   694 

   695 

   696 // ---------------------------------------------------------------------------

   697 // CWsfWlanScanner::BssLost

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

   699 //    

   700 void CWsfWlanScanner::BssLost()

   701     {

   702     LOG_ENTERFN( "CWsfWlanScanner::BssLost" );

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

   704         {

   705         // complete ourselves

   706         SetActive();

   707         TRequestStatus* status = &iStatus;

   708         User::RequestComplete( status, KErrNone );

   709         }

   710     }

   711 

   712 

   713 // ---------------------------------------------------------------------------

   714 // CWsfWlanScanner::BssRegained

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

   716 //    

   717 void CWsfWlanScanner::BssRegained()

   718     {

   719     LOG_ENTERFN( "CWsfWlanScanner::BssRegained" );

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

   721         {

   722         // complete ourselves

   723         SetActive();

   724         TRequestStatus* status = &iStatus;

   725         User::RequestComplete( status, KErrNone );

   726         }

   727     }

   728 

   729 

   730 // ---------------------------------------------------------------------------

   731 // CWsfWlanScanner::NewNetworksDetected

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

   733 //    

   734 void CWsfWlanScanner::NewNetworksDetected()

   735     {

   736     LOG_ENTERFN( "CWsfWlanScanner::NewNetworksDetected" );

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

   738         {

   739         // complete ourselves

   740         SetActive();

   741         TRequestStatus* status = &iStatus;

   742         User::RequestComplete( status, KErrNone );

   743         }

   744     }

   745 

   746 

   747 // ---------------------------------------------------------------------------

   748 // CWsfWlanScanner::OldNetworksLost

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

   750 //    

   751 void CWsfWlanScanner::OldNetworksLost()

   752     {

   753     LOG_ENTERFN( "CWsfWlanScanner::OldNetworksLost" );

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

   755         {

   756         // complete ourselves

   757         SetActive();

   758         TRequestStatus* status = &iStatus;

   759         User::RequestComplete( status, KErrNone );

   760         }

   761     }

   762 

   763 

   764 // ---------------------------------------------------------------------------

   765 // CWsfWlanScanner::TransmitPowerChanged

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

   767 //    

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

   769     {

   770     LOG_ENTERFN( "CWsfWlanScanner::TransmitPowerChanged" );

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

   772         {

   773         // complete ourselves

   774         SetActive();

   775         TRequestStatus* status = &iStatus;

   776         User::RequestComplete( status, KErrNone );

   777         }

   778     }

   779         

   780 

   781 // ---------------------------------------------------------------------------

   782 // CWsfWlanScanner::RssChanged

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

   784 //    

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

   786     {

   787     LOG_ENTERFN( "CWsfWlanScanner::RssChanged" );

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

   789         {

   790         // complete ourselves

   791         SetActive();

   792         TRequestStatus* status = &iStatus;

   793         User::RequestComplete( status, KErrNone );

   794         }

   795     }

   796 

   797 

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

   799 // CWsfWlanScanner::PrepareDirectScan

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

   801 //    

   802 void CWsfWlanScanner::PrepareDirectScan()

   803     {

   804     LOG_ENTERFN( "CWsfWlanScanner::PrepareDirectScanL" );

   805 

   806     // flush the arrays

   807     iDirectScanSsids.Reset();

   808     iDirectScanIapIDs.Reset();

   809     }

   810     

   811     

   812 // ---------------------------------------------------------------------------

   813 // CWsfWlanScanner::ProcessDirectScanResultL

   814 // ---------------------------------------------------------------------------

   815 //   

   816 void CWsfWlanScanner::ProcessDirectScanResultL()

   817     {

   818     LOG_ENTERFN( "CWsfWlanScanner::ProcessDirectScanResultL" );

   819     

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

   821         {

   822         RPointerArray<TWsfWlanInfo> matchArray;

   823         CleanupClosePushL(matchArray);

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

   825   

   826         TInt matchcount = matchArray.Count();

   827 

   828         if ( matchcount == 0 )

   829             {

   830             // not found yet

   831 #ifdef _DEBUG

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

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

   834             CleanupStack::PopAndDestroy( ssid );

   835 #endif       

   836             }

   837         else

   838             {

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

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

   841             	{

   842             	//if already found increase coverage

   843                 TWsfWlanInfo* temp = matchArray[i];

   844                 ++temp->iCoverage;

   845                 RefreshSignalStrength( *temp );

   846                 RefreshMaxRate( *temp );

   847              	}

   848             }

   849         // Close() for matchArray

   850         CleanupStack::PopAndDestroy( &matchArray );  

   851         } // for iScanInfo              

   852     }

   853 

   854 

   855 // ---------------------------------------------------------------------------

   856 // CWsfWlanScanner::ReplaceSsidsWithIapName

   857 // ---------------------------------------------------------------------------

   858 //   

   859 void CWsfWlanScanner::ReplaceSsidsWithIapName(TWsfWlanInfo& aWlanInfo)

   860     {	

   861     LOG_ENTERFN( "CWsfWlanScanner::ReplaceSsidsWithIapName" );

   862     if ( aWlanInfo.iNetworkName.Length() )

   863         {

   864         LOG_WRITE( "Replace ssid" );

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

   866         aWlanInfo.iNetworkName.Zero();

   867         }

   868     }

   869 

   870 

   871 // ---------------------------------------------------------------------------

   872 // CWsfWlanScanner::UpdatePriorityL

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

   874 //    

   875 void CWsfWlanScanner::UpdatePriorityL( TWsfWlanInfo& aWlanInfo )

   876     {

   877     LOG_WRITE( "CWsfWlanScanner::updatePriority" );

   878 

   879     TUint32 priority( 0 );

   880     TInt exists( KErrNotFound );

   881     TInt count( 0 );   

   882 

   883     // search for the destination of it                                                        

   884     RArray<TUint32> destinations;                                                              

   885     CleanupClosePushL( destinations );

   886 

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

   888     iCmManagerExt.AllDestinationsL(destinations);                                              

   889 

   890     count = destinations.Count();                                                         

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

   892 

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

   894         {

   895         RCmDestinationExt destination;                                                              

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

   897         CleanupClosePushL( destination );  

   898 

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

   900 

   901         RCmConnectionMethodExt connectionMethod;

   902         TRAP( exists,                                                                      

   903                 connectionMethod = destination.ConnectionMethodByIDL(                            

   904                         aWlanInfo.iIapId ) ); 

   905 

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

   907         if( exists == KErrNone )                                                           

   908             {   

   909             CleanupClosePushL( connectionMethod ); 

   910             // correct destination found                                                   

   911             priority = destination.PriorityL( connectionMethod );

   912             aWlanInfo.SetPriority( priority );

   913 

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

   915             CleanupStack::PopAndDestroy( &connectionMethod ); 

   916             }

   917         CleanupStack::PopAndDestroy( &destination );                                           

   918         }                                                                                      

   919     CleanupStack::PopAndDestroy( &destinations );

   920     }

   921 

   922 

   923 #ifndef __WINS__

   924 // ---------------------------------------------------------------------------

   925 // CWsfWlanScanner::DoScanForNetworksL

   926 // ---------------------------------------------------------------------------

   927 //   

   928 void CWsfWlanScanner::DoScanForNetworksL()

   929     {

   930     LOG_ENTERFN( "CWsfWlanScanner::DoScanForNetworksL" );

   931         

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

   933     iScanArray->Reset();    

   934 

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

   936     

   937     if ( iStatus.Int() )

   938         {

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

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

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

   942         }

   943    

   944     TInt nElem = 0;

   945     TBool isHidden( EFalse );

   946 

   947     // get available iaps

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

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

   950     RArray<TUint> availableIaps;

   951     iWlanMgmtClient->GetAvailableIaps(availableIaps);

   952     TInt avIapCount = availableIaps.Count();

   953 

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

   955 

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

   957         {

   958         TBool addToArray( ETrue ); 

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

   960         CleanupStack::PushL( availableInfo );

   961         availableInfo->iIapId = availableIaps[i];

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

   963 

   964         if ( error == KErrNotFound )

   965             {

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

   967             addToArray = EFalse;

   968             }

   969         else if ( error )

   970             {

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

   972             User::Leave( error );

   973             }

   974 

   975         if( addToArray )

   976             { 

   977             LOG_WRITE( "Add to array" );

   978             availableInfo->iCoverage = 0;

   979             availableInfo->iVisibility = 1;

   980             availableInfo->iStrengthLevel = EWlanSignalUnavailable;

   981             availableInfo->iTransferRate = 0;

   982             availableInfo->iConnectionState = ENotConnected;

   983             iScanArray->AppendL(availableInfo);

   984             nElem++;

   985 

   986             if ( availableInfo->iIapId )

   987                 {

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

   989                 iDirectScanIapIDs.Append( availableInfo->iIapId );

   990                 iDirectScanSsids.Append( availableInfo->iSsid );

   991                 }

   992 

   993             CleanupStack::Pop( availableInfo );

   994             }

   995         else

   996             {

   997             LOG_WRITE( "Info not added" );

   998             CleanupStack::PopAndDestroy( availableInfo );

   999             }

  1000         }

  1001       

  1002     // Process the scanned results

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

  1004         {

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

  1006         if ( !wlanInfo )

  1007             {

  1008             wlanInfo = new ( ELeave ) TWsfWlanInfo();

  1009             CleanupStack::PushL( wlanInfo );

  1010             iScanArray->AppendL( wlanInfo );

  1011             CleanupStack::Pop( wlanInfo );

  1012             }

  1013         isHidden = RefreshNetworkNameL( *wlanInfo );

  1014         wlanInfo->iVisibility = !isHidden;

  1015         wlanInfo->iStrengthLevel = EWlanSignalUnavailable;

  1016         wlanInfo->iTransferRate = 0;

  1017         wlanInfo->iConnectionState = ENotConnected;

  1018 

  1019         if( !isHidden )

  1020             {

  1021             // not hidden

  1022             RefreshNetworkMode( *wlanInfo );

  1023             RefreshSecurityMode( *wlanInfo );

  1024             RefreshMaxRate( *wlanInfo );

  1025 

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

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

  1028             // found several iaps configured for same wlan)

  1029             RPointerArray<TWsfWlanInfo> matchArray;

  1030             CleanupClosePushL(matchArray);

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

  1032                     wlanInfo->iNetMode, nElem, matchArray );

  1033 

  1034             TInt matchcount = matchArray.Count();

  1035 

  1036             // if not found

  1037             if( matchcount == 0 )

  1038                 {

  1039                 wlanInfo->iCoverage = 1;

  1040                 RefreshSignalStrength( *wlanInfo );

  1041                 RefreshMaxRate( *wlanInfo );

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

  1043                 }

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

  1045                 {

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

  1047                     {

  1048                     TWsfWlanInfo* temp = matchArray[i];

  1049                     ++temp->iCoverage;

  1050                     RefreshSignalStrength( *temp );

  1051                     RefreshMaxRate( *temp );

  1052 

  1053                     if ( temp->iIapId )

  1054                         {

  1055                         TInt index( KErrNone );

  1056                         do {

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

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

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

  1060                             if ( index != KErrNotFound )

  1061                                 {

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

  1063                                 iDirectScanSsids.Remove( index );

  1064                                 iDirectScanIapIDs.Remove( index );

  1065                                 }

  1066                         } while ( index != KErrNotFound );

  1067                         }

  1068                     }

  1069                 }

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

  1071             }

  1072         }

  1073     //get rid of excess items

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

  1075     }

  1076 

  1077 #else // __WINS__

  1078 

  1079 // ---------------------------------------------------------------------------

  1080 // CWsfWlanScanner::DoScanForNetworksL

  1081 // ---------------------------------------------------------------------------

  1082 //   

  1083 void CWsfWlanScanner::DoScanForNetworksL()

  1084     {

  1085     LOG_ENTERFN( "CWsfWlanScanner::DoScanForNetworksL" );

  1086         

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

  1088     iScanArray->Reset();    

  1089 

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

  1091     CleanupStack::PushL( wlan0 );    

  1092     wlan0->iConnectionState = EConnected;

  1093     wlan0->iIapId = 666;

  1094     wlan0->iNetMode = EInfra;

  1095     wlan0->iSecurityMode = EWlanSecModeWep;

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

  1097     wlan0->iStrengthLevel = EWlanSignalStrengthMax;  

  1098     wlan0->iVisibility = ETrue;

  1099     wlan0->iCoverage = 1;

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

  1101         {

  1102         iScanArray->AppendL( wlan0 );

  1103         }

  1104     else 

  1105         {

  1106         delete wlan0;

  1107         }

  1108         

  1109     CleanupStack::Pop( wlan0 );

  1110 

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

  1112     CleanupStack::PushL( wlan1 );    

  1113     wlan1->iConnectionState = ENotConnected;

  1114     wlan1->iIapId = 666;

  1115     wlan1->iNetMode = EInfra;

  1116     wlan1->iSecurityMode = EWlanSecModeOpen;

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

  1118     wlan1->iStrengthLevel = EWlanSignalStrengthMin;  

  1119     wlan1->iVisibility = ETrue;

  1120     wlan1->iCoverage = 3;

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

  1122         {

  1123         iScanArray->AppendL( wlan1 );

  1124         }

  1125     else

  1126         {

  1127         delete wlan1;

  1128         }

  1129 

  1130     CleanupStack::Pop( wlan1 );

  1131 

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

  1133     CleanupStack::PushL( wlan2 );    

  1134     wlan2->iConnectionState = ENotConnected;