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     iAvailableIaps.Close();

   102     iDbSession = NULL; // not owning

   103     iConnectionDetailsProvider = NULL;

   104     }

   105 

   106 

   107 // ---------------------------------------------------------------------------

   108 // CWsfWlanScanner::CWsfWlanScanner

   109 // ---------------------------------------------------------------------------

   110 //    

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

   112     CActive( EPriorityStandard ),

   113     iDbSession( &aDbSession ),

   114     iScanState( EIdle )

   115     {

   116     }

   117 

   118 

   119 // ---------------------------------------------------------------------------

   120 // CWsfWlanScanner::ConstructL

   121 // ---------------------------------------------------------------------------

   122 //    

   123 void CWsfWlanScanner::ConstructL()

   124     {

   125     LOG_ENTERFN( "CWsfWlanScanner::ConstructL" );

   126     

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

   128     iWlanMgmtClient = CWlanMgmtClient::NewL();

   129 

   130     iScanInfo = CWlanScanInfo::NewL();

   131 #endif

   132 

   133     iCmManagerExt.OpenL();

   134     

   135     iScanArray = CWsfWlanInfoArray::NewL();

   136     

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

   138     iScanResults = KNullDesC8().AllocL();

   139 

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

   141     iScanningInterval = iWlanSettingsAccessor->ScanInterval() * 

   142                                                           KMicrosecPerSecond;

   143     iShowAvailability = iWlanSettingsAccessor->ShowAvailability();

   144     

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

   146                 iWlanSettingsAccessor->ScanInterval() );

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

   148     

   149     CActiveScheduler::Add( this );

   150     }

   151 

   152 

   153 // ---------------------------------------------------------------------------

   154 // CWsfWlanScanner::DoCancel

   155 // ---------------------------------------------------------------------------

   156 //    

   157 void CWsfWlanScanner::DoCancel()

   158     {

   159     LOG_ENTERFN( "CWsfWlanScanner::DoCancel" );

   160     iTimer.Cancel();

   161 #ifndef __WINS__

   162     iWlanMgmtClient->CancelGetAvailableIaps();

   163     iWlanMgmtClient->CancelGetScanResults();

   164 #endif    

   165     iScanState = EIdle;    

   166     }

   167  

   168 

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

   170 // CWsfWlanScanner::RunL

   171 // ---------------------------------------------------------------------------

   172 //    

   173 void CWsfWlanScanner::RunL()

   174     {

   175     LOG_ENTERFN( "CWsfWlanScanner::RunL" );

   176     

   177     /*

   178      * Scan logic

   179      * 1. Get available IAPs - state = EIdle

   180      * 2. Do broadcast scan - state = EBroadcastScan

   181      * 3. Process broadcast scan results - state = EProcessBroadcastScan

   182      * 4. Do direct scans for remaining known networks

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

   184      * 5. Add connected network - state = EFinished

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

   186      */

   187 

   188     if ( iScanState == EIdle )

   189         {

   190         LOG_WRITE( "Get available IAPs scan phase" );

   191 

   192         // prepare things for direct scans

   193         PrepareDirectScan();

   194           

   195         // notify clients

   196         if ( iObserver )

   197             {

   198             iObserver->WlanScanStarted();

   199             }

   200         

   201 #ifndef __WINS__

   202         // get available iaps

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

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

   205         iAvailableIaps.Reset();

   206         iWlanMgmtClient->GetAvailableIaps( iCacheLifetime, 

   207                                            iMaxDelay, 

   208                                            EFalse, 

   209                                            iStatus, 

   210                                            iAvailableIaps );

   211         SetActive();

   212 #else

   213         // for testing

   214         SetActive();

   215         TRequestStatus* status = &iStatus;

   216         User::RequestComplete( status, KErrNone );

   217 #endif 

   218         iScanState = EBroadcastScan;

   219         }

   220         

   221     else if ( iScanState == EBroadcastScan )

   222         {

   223         LOG_WRITEF( "GetAvailableIaps returned iStatus=%d", iStatus.Int() );

   224         if ( iStatus.Int() )

   225             {

   226             LOG_WRITE( "Error in getting available IAPs - leave" );

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

   228             }

   229         

   230 #ifdef _DEBUG

   231         for ( TInt i = 0; i < iAvailableIaps.Count(); ++i )

   232             {

   233             LOG_WRITEF( "iAvailableIaps array index[%d] IapId[%d] rssi[%d]", i,

   234                         iAvailableIaps[i].iIapId, iAvailableIaps[i].iRssi );

   235             }

   236 #endif

   237     

   238 #ifndef __WINS__ 

   239         // do broadcast scan

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

   241         SetActive();

   242 #else

   243         // for testing

   244         SetActive();

   245         TRequestStatus* status = &iStatus;

   246         User::RequestComplete( status, KErrNone );

   247 #endif 

   248         iScanState = EProcessBroadcastScan;

   249         }

   250         

   251     else if ( iScanState == EProcessBroadcastScan )

   252         {

   253         // process broadcast scan results

   254         DoScanForNetworksL();

   255         

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

   257         // for remaining known networks

   258         if ( iDirectScanSsids.Count() )

   259             {

   260 #ifdef _DEBUG

   261             HBufC* ssid = TWsfWlanInfo::GetSsidAsUnicodeLC( 

   262                                                         iDirectScanSsids[0] );

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

   264             CleanupStack::PopAndDestroy( ssid );

   265 #endif

   266             

   267 #ifndef __WINS__

   268             // run direct scan

   269             iWlanMgmtClient->GetScanResults( iDirectScanSsids[0], 

   270                                              iStatus, *iScanInfo );

   271             SetActive();

   272 #else

   273             // for testing

   274             SetActive();

   275             TRequestStatus* status = &iStatus;

   276             User::RequestComplete( status, KErrNone );

   277 #endif                                             

   278 

   279             iScanState = EDirectScan;

   280             }

   281         else

   282             {

   283             LOG_WRITE( "direct scan skipped" );

   284             iScanState = EFinished;

   285             }

   286         }

   287         

   288     else if ( iScanState == EDirectScan )

   289         {

   290         LOG_WRITE( "direct scan results" );

   291 

   292 #ifndef __WINS__

   293         ProcessDirectScanResultL();

   294 #endif

   295  

   296         // delete the processed item (first)

   297         iDirectScanSsids.Remove( 0 );

   298         iDirectScanIapIDs.Remove( 0 );

   299 

   300         if ( iDirectScanSsids.Count() )

   301             {

   302             // repeated direct scans for known networks

   303 #ifdef _DEBUG

   304             HBufC* ssid = TWsfWlanInfo::GetSsidAsUnicodeLC( 

   305                                                         iDirectScanSsids[0] );

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

   307             CleanupStack::PopAndDestroy( ssid );

   308 #endif

   309             

   310 #ifndef __WINS__

   311             // run direct scan

   312             iWlanMgmtClient->GetScanResults( iDirectScanSsids[0], 

   313                                              iStatus, *iScanInfo );        

   314             SetActive();

   315 #else

   316             // for testing

   317             SetActive();

   318             TRequestStatus* status = &iStatus;

   319             User::RequestComplete( status, KErrNone );

   320 #endif                                             

   321             }

   322         else

   323             {

   324             // there is nothing more to do

   325             iScanState = EFinished;

   326             }

   327         }

   328     

   329     if ( iScanState == EFinished )

   330         {

   331         LOG_WRITE( "scanning finished" );

   332 #ifndef __WINS__

   333         AddConnectedWLANInfoL();

   334         

   335         TWsfWlanInfo* info(NULL);

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

   337         

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

   339             {  

   340             info = (*iScanArray)[ i ];

   341             

   342             if( info->iIapId )

   343                 {

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

   345                 if ( error )

   346                     {

   347                     // Ignore error and just continue

   348                     LOG_WRITE( "Prio update failed" );

   349                     }

   350                 }

   351             

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

   353                 {

   354                 ReplaceSsidsWithIapName( *info );

   355                 }

   356             }

   357 #endif //_WINS_

   358         

   359         // sort the array

   360         iScanArray->SortArrayL();

   361         

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

   363         CleanupStack::Pop( results );

   364         delete iScanResults;

   365         iScanResults = results;

   366 

   367 #ifdef _DEBUG

   368         DumpScanResultsL( iScanArray );

   369 #endif

   370         

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

   372         iScanArray->Reset();

   373     

   374         // notify clients that data is ready

   375         if ( iObserver )

   376             {

   377             iObserver->WlanScanCompleteL();

   378             }

   379 

   380         if ( !iShowAvailability )

   381             {

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

   383             iTimer.Cancel();

   384             iTimer.After( iStatus, 

   385                           TTimeIntervalMicroSeconds32( iScanningInterval ) );

   386             Cancel();

   387             iCacheLifetime = 0;

   388             iMaxDelay = 0;

   389             SetActive();

   390             }

   391         

   392         iScanState = EIdle;

   393         }

   394     }

   395 

   396 

   397 // ---------------------------------------------------------------------------

   398 // CWsfWlanScanner::AddConnectedWLANInfo

   399 // ---------------------------------------------------------------------------

   400 //    

   401 void CWsfWlanScanner::AddConnectedWLANInfoL()

   402     {

   403     LOG_ENTERFN( "CWsfWlanScanner::AddConnectedWLANInfoL" );

   404     // Get the possible connection

   405     if ( iConnectionDetailsProvider )

   406         {

   407         TWlanSsid connectedSsid;

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

   409         

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

   411         

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

   413     

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

   415             {

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

   417             return;

   418             }

   419         

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

   421         CleanupStack::PushL( connectedInfo );

   422         

   423         if ( iConnectionDetailsProvider->ConnectedWlanConnectionDetailsL(

   424                 connectedInfo) )

   425             {

   426             TBuf8<KWlanMaxAccessPointNameLength> connectedSsidOrIap;

   427             connectedSsidOrIap.Copy( connectedInfo->iSsid );

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

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

   430             

   431             connectedInfo->iRawSsid.Copy( connectedSsid );

   432             connectedInfo->iSsid.Copy( connectedSsid );

   433             connectedInfo->iCoverage = 0;

   434             connectedInfo->iVisibility = 1;

   435 

   436             TBool connectedInfoAppended = EFalse;

   437 

   438             RPointerArray<TWsfWlanInfo> matchArray;

   439             CleanupClosePushL( matchArray );

   440 

   441             if ( connectedInfo->iIapId )

   442                 {

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

   444                 iScanArray->MatchWithIapIDL( connectedInfo->iIapId,

   445                         iScanArray->Count(), matchArray );

   446                 

   447                 if ( !matchArray.Count() )

   448                     {

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

   450                     iScanArray->MatchL( connectedInfo->iSsid,

   451                                         connectedInfo->iSecurityMode,

   452                                         connectedInfo->iNetMode, 

   453                                         connectedInfo->UsesPreSharedKey(),

   454                                         iScanArray->Count(),

   455                                         matchArray );

   456                     }

   457                 

   458                 }

   459             else

   460                 {

   461                 LOG_WRITE( "Easy WLAN connection" );

   462                 iScanArray->MatchL( connectedInfo->iSsid,

   463                         connectedInfo->iSecurityMode,

   464                         connectedInfo->iNetMode, 

   465                         connectedInfo->UsesPreSharedKey(),

   466                         iScanArray->Count(),

   467                         matchArray );

   468                 }

   469 

   470             if ( matchArray.Count() )

   471                 {

   472                 LOG_WRITE( "Info found" );

   473                 TWsfWlanInfo* temp = matchArray[0];

   474                 temp->iConnectionState = EConnected;

   475                 temp->iIapId = connectedInfo->iIapId;

   476                 temp->iSsid.Copy( connectedSsidOrIap );

   477                 temp->iNetworkName.Zero();

   478                 }

   479             else

   480                 {

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

   482                 connectedInfo->iSsid.Copy( connectedSsidOrIap );

   483                 iScanArray->AppendL( connectedInfo );

   484                 connectedInfoAppended = ETrue;

   485                 }

   486 

   487             CleanupStack::PopAndDestroy( &matchArray );

   488             if ( connectedInfoAppended )

   489                 {

   490                 CleanupStack::Pop( connectedInfo );

   491                 }

   492             else

   493                 {

   494                 CleanupStack::PopAndDestroy( connectedInfo );

   495                 }

   496             }

   497         else

   498             {

   499             CleanupStack::PopAndDestroy( connectedInfo );

   500             }

   501         }

   502     else

   503         {

   504         LOG_WRITE( "No connection details provider" );

   505         }

   506     }

   507 

   508 

   509 #ifdef _DEBUG

   510 // ---------------------------------------------------------------------------

   511 // CWsfWlanScanner::DumpScanResultsL

   512 // ---------------------------------------------------------------------------

   513 //    

   514 void CWsfWlanScanner::DumpScanResultsL( CWsfWlanInfoArray* aArray )

   515     {

   516     LOG_ENTERFN( "CWsfWlanScanner::DumpScanResultsL" );

   517     _LIT( Kopen, "open" );

   518     _LIT( Kwep, "wep" );

   519     _LIT( Kwpa, "wpa" );

   520     _LIT( Kwpa2, "wpa2" );        

   521     _LIT( K802, "802.1x" );

   522     _LIT( KWAPI, "WAPI" );

   523     _LIT( KUnknown, "Unknown" );

   524 

   525     _LIT( Kpsk, "psk" );

   526     _LIT( Keap, "eap" );

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

   528 

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

   530         {

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

   532         const TDesC* sm( 0 );

   533 

   534         switch ( wi->iSecurityMode )

   535             {

   536             case EWlanSecModeOpen:

   537                 sm = &Kopen;

   538                 break;

   539             case EWlanSecModeWep:

   540                 sm = &Kwep;

   541                 break;

   542             case EWlanSecModeWpa:

   543                 sm = &Kwpa;

   544                 break;

   545             case EWlanSecModeWpa2:

   546                 sm = &Kwpa2;

   547                 break;

   548             case EWlanSecMode802_1x:

   549                 sm = &K802;

   550                 break;

   551             case EWlanSecModeWAPI:

   552                 sm = &KWAPI;

   553                 break;

   554             default:

   555                 sm = &KUnknown;

   556                 break;

   557             }

   558         

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

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

   561                                    wi->iSecurityMode == EWlanSecModeWpa ||

   562                                    wi->iSecurityMode == EWlanSecModeWpa2 )? 

   563                                       &Keap: &KNullDesC );

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

   565         

   566         LOG_WRITEF( "[%S] IapId=%d %S %S %S", ssid, wi->iIapId, sm, psk, 

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

   568         CleanupStack::PopAndDestroy( ssid );

   569         }

   570     

   571     }

   572 #endif // _DEBUG

   573 

   574 

   575 // ---------------------------------------------------------------------------

   576 // CWsfWlanScanner::RunError

   577 // ---------------------------------------------------------------------------

   578 //    

   579 TInt CWsfWlanScanner::RunError( TInt aError )

   580     {

   581     LOG_ENTERFN( "CWsfWlanScanner::RunError" );

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

   583     

   584     iScanArray->Reset();

   585     

   586     if ( iObserver && aError != KErrNotReady )

   587         {

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

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

   590         iObserver->NotifyError( aError );    

   591         }

   592 

   593     iScanState = EIdle;

   594     

   595     if ( !iShowAvailability )

   596         {

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

   598         iTimer.Cancel();

   599         iTimer.After( iStatus, 

   600                       TTimeIntervalMicroSeconds32( iScanningInterval ) );

   601         iCacheLifetime = 0;

   602         iMaxDelay = 0;

   603         SetActive();    

   604         }

   605         

   606     return KErrNone;    

   607     }

   608 

   609 

   610 // ---------------------------------------------------------------------------

   611 // CWsfWlanScanner::SetObserver

   612 // ---------------------------------------------------------------------------

   613 //    

   614 void CWsfWlanScanner::SetObserver( MWsfWlanScannerObserver& aObserver )

   615     {

   616     iObserver = &aObserver;

   617     }

   618 

   619 

   620 // ---------------------------------------------------------------------------

   621 // CWsfWlanScanner::StartScanningL

   622 // ---------------------------------------------------------------------------

   623 //    

   624 void CWsfWlanScanner::StartScanningL()

   625     {

   626     LOG_ENTERFN( "CWsfWlanScanner::StartScanningL" );

   627 

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

   629         {

   630         LOG_WRITE( "request notifications" );

   631 #ifndef __WINS__

   632         iWlanMgmtClient->CancelNotifications();

   633         iWlanMgmtClient->ActivateNotificationsL( *this );

   634 #endif

   635         iWlanSettingsAccessor->RequestNotificationL( *this );

   636         

   637         iScanState = EIdle;

   638 

   639         if ( !iShowAvailability )

   640             {

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

   642             iCacheLifetime = 0;

   643             iMaxDelay = 0;

   644             SetActive();

   645             TRequestStatus* status = &iStatus;

   646             User::RequestComplete( status, KErrNone );

   647             }

   648         }

   649     }

   650 

   651 

   652 // ---------------------------------------------------------------------------

   653 // CWsfWlanScanner::StartScanningL

   654 // ---------------------------------------------------------------------------

   655 //    

   656 void CWsfWlanScanner::StopScanning()

   657     {

   658     LOG_ENTERFN( "CWsfWlanScanner::StopScanning" );

   659 

   660     Cancel();

   661 

   662 #ifndef __WINS__       

   663     if ( iWlanMgmtClient )

   664         {

   665         iWlanMgmtClient->CancelNotifications();

   666         }

   667 #endif

   668   

   669     if ( iWlanSettingsAccessor )

   670         {

   671         iWlanSettingsAccessor->CancelNotifications();

   672         }

   673     }

   674 

   675 

   676 // ---------------------------------------------------------------------------

   677 // CWsfWlanScanner::RestartScanning

   678 // ---------------------------------------------------------------------------

   679 //    

   680 TBool CWsfWlanScanner::RestartScanning()

   681     {

   682     LOG_ENTERFN( "CWsfWlanScanner::RestartScanning" );

   683 

   684     TBool restarted( EFalse );

   685     LOG_WRITEF( "iScanState = %d isActive = %d iShowAvailability = %d",

   686                iScanState, IsActive(), iShowAvailability );

   687     

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

   689         {

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

   691         // cancel it manually

   692         Cancel();

   693         iCacheLifetime = 0;

   694         iMaxDelay = 0;

   695         // then complete ourselves

   696         SetActive();

   697         TRequestStatus* status = &iStatus;

   698         User::RequestComplete( status, KErrNone );

   699         restarted = ETrue;

   700         }

   701     

   702     LOG_WRITEF( "restarted = %d", restarted );

   703     return restarted;

   704     }

   705 

   706 

   707 // ---------------------------------------------------------------------------

   708 // CWsfWlanScanner::AbortScanning

   709 // ---------------------------------------------------------------------------

   710 //    

   711 void CWsfWlanScanner::AbortScanning()

   712     {

   713     LOG_ENTERFN( "CWsfWlanScanner::AbortScanning" );

   714     

   715     if ( iScanState != EIdle )

   716         {

   717         // cancel the current scanning

   718         Cancel();

   719 

   720         if ( !iShowAvailability )

   721             {

   722             // still, life goes on

   723             iTimer.After( iStatus, TTimeIntervalMicroSeconds32( 

   724                                                         iScanningInterval ) );

   725             iCacheLifetime = 0;

   726             iMaxDelay = 0;

   727             SetActive();        

   728             }

   729         }

   730     }

   731 

   732 

   733 // ---------------------------------------------------------------------------

   734 // CWsfWlanScanner::ConnectionStateChanged

   735 // ---------------------------------------------------------------------------

   736 //    

   737 void CWsfWlanScanner::ConnectionStateChanged( 

   738                                             TWlanConnectionMode /*aNewState*/ )

   739     {

   740     LOG_ENTERFN( "CWsfWlanScanner::ConnectionStateChanged" );

   741     }

   742     

   743 

   744 // ---------------------------------------------------------------------------

   745 // CWsfWlanScanner::BssidChanged

   746 // ---------------------------------------------------------------------------

   747 //    

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

   749     {

   750     LOG_ENTERFN( "CWsfWlanScanner::BssidChanged" );

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

   752         {

   753         iCacheLifetime = -1;

   754         iMaxDelay = 0;

   755         // complete ourselves

   756         SetActive();

   757         TRequestStatus* status = &iStatus;

   758         User::RequestComplete( status, KErrNone );

   759         }

   760     }

   761 

   762 

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

   764 // CWsfWlanScanner::BssLost

   765 // ---------------------------------------------------------------------------

   766 //    

   767 void CWsfWlanScanner::BssLost()

   768     {

   769     LOG_ENTERFN( "CWsfWlanScanner::BssLost" );

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

   771         {

   772         iCacheLifetime = -1;

   773         iMaxDelay = 0;

   774         // complete ourselves

   775         SetActive();

   776         TRequestStatus* status = &iStatus;

   777         User::RequestComplete( status, KErrNone );

   778         }

   779     }

   780 

   781 

   782 // ---------------------------------------------------------------------------

   783 // CWsfWlanScanner::BssRegained

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

   785 //    

   786 void CWsfWlanScanner::BssRegained()

   787     {

   788     LOG_ENTERFN( "CWsfWlanScanner::BssRegained" );

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

   790         {

   791         iCacheLifetime = -1;

   792         iMaxDelay = 0;

   793         // complete ourselves

   794         SetActive();

   795         TRequestStatus* status = &iStatus;

   796         User::RequestComplete( status, KErrNone );

   797         }

   798     }

   799 

   800 

   801 // ---------------------------------------------------------------------------

   802 // CWsfWlanScanner::NewNetworksDetected

   803 // ---------------------------------------------------------------------------

   804 //    

   805 void CWsfWlanScanner::NewNetworksDetected()

   806     {

   807     LOG_ENTERFN( "CWsfWlanScanner::NewNetworksDetected" );

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

   809         {

   810         iCacheLifetime = -1;

   811         iMaxDelay = 0;

   812         // complete ourselves

   813         SetActive();

   814         TRequestStatus* status = &iStatus;

   815         User::RequestComplete( status, KErrNone );

   816         }

   817     }

   818 

   819 

   820 // ---------------------------------------------------------------------------

   821 // CWsfWlanScanner::OldNetworksLost

   822 // ---------------------------------------------------------------------------

   823 //    

   824 void CWsfWlanScanner::OldNetworksLost()

   825     {

   826     LOG_ENTERFN( "CWsfWlanScanner::OldNetworksLost" );

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

   828         {

   829         iCacheLifetime = -1;

   830         iMaxDelay = 0;

   831         // complete ourselves

   832         SetActive();

   833         TRequestStatus* status = &iStatus;

   834         User::RequestComplete( status, KErrNone );

   835         }

   836     }

   837 

   838 

   839 // ---------------------------------------------------------------------------

   840 // CWsfWlanScanner::TransmitPowerChanged

   841 // ---------------------------------------------------------------------------

   842 //    

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

   844     {

   845     LOG_ENTERFN( "CWsfWlanScanner::TransmitPowerChanged" );

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

   847         {

   848         iCacheLifetime = -1;

   849         iMaxDelay = 0;

   850         // complete ourselves

   851         SetActive();

   852         TRequestStatus* status = &iStatus;

   853         User::RequestComplete( status, KErrNone );

   854         }

   855     }

   856         

   857 

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

   859 // CWsfWlanScanner::RssChanged

   860 // ---------------------------------------------------------------------------

   861 //    

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

   863     {

   864     LOG_ENTERFN( "CWsfWlanScanner::RssChanged" );

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

   866         {

   867         iCacheLifetime = -1;

   868         iMaxDelay = 0;

   869         // complete ourselves

   870         SetActive();

   871         TRequestStatus* status = &iStatus;

   872         User::RequestComplete( status, KErrNone );

   873         }

   874     }

   875 

   876 

   877 // ---------------------------------------------------------------------------

   878 // CWsfWlanScanner::PrepareDirectScan

   879 // ---------------------------------------------------------------------------

   880 //    

   881 void CWsfWlanScanner::PrepareDirectScan()

   882     {

   883     LOG_ENTERFN( "CWsfWlanScanner::PrepareDirectScanL" );

   884 

   885     // flush the arrays

   886     iDirectScanSsids.Reset();

   887     iDirectScanIapIDs.Reset();

   888     }

   889     

   890     

   891 // ---------------------------------------------------------------------------

   892 // CWsfWlanScanner::ProcessDirectScanResultL

   893 // ---------------------------------------------------------------------------

   894 //   

   895 void CWsfWlanScanner::ProcessDirectScanResultL()

   896     {

   897     LOG_ENTERFN( "CWsfWlanScanner::ProcessDirectScanResultL" );

   898     

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

   900         {

   901         RPointerArray<TWsfWlanInfo> matchArray;

   902         CleanupClosePushL(matchArray);

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

   904   

   905         TInt matchcount = matchArray.Count();

   906 

   907         if ( matchcount == 0 )

   908             {

   909             // not found yet

   910 #ifdef _DEBUG

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

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

   913             CleanupStack::PopAndDestroy( ssid );

   914 #endif       

   915             }

   916         else

   917             {

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

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

   920             	{

   921             	//if already found increase coverage

   922                 TWsfWlanInfo* temp = matchArray[i];

   923                 ++temp->iCoverage;

   924                 RefreshSignalStrength( *temp );

   925                 RefreshTechnology( *temp );

   926              	}

   927             }

   928         // Close() for matchArray

   929         CleanupStack::PopAndDestroy( &matchArray );  

   930         } // for iScanInfo              

   931     }

   932 

   933 

   934 // ---------------------------------------------------------------------------

   935 // CWsfWlanScanner::ReplaceSsidsWithIapName

   936 // ---------------------------------------------------------------------------

   937 //   

   938 void CWsfWlanScanner::ReplaceSsidsWithIapName(TWsfWlanInfo& aWlanInfo)

   939     {	

   940     LOG_ENTERFN( "CWsfWlanScanner::ReplaceSsidsWithIapName" );

   941     if ( aWlanInfo.iNetworkName.Length() )

   942         {

   943         LOG_WRITE( "Replace ssid" );

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

   945         aWlanInfo.iNetworkName.Zero();

   946         }

   947     }

   948 

   949 

   950 // ---------------------------------------------------------------------------

   951 // CWsfWlanScanner::UpdatePriorityL

   952 // ---------------------------------------------------------------------------

   953 //    

   954 void CWsfWlanScanner::UpdatePriorityL( TWsfWlanInfo& aWlanInfo )

   955     {

   956     LOG_WRITE( "CWsfWlanScanner::updatePriority" );

   957 

   958     TUint32 priority( 0 );

   959     TInt exists( KErrNotFound );

   960     TInt count( 0 );   

   961 

   962     // search for the destination of it                                                        

   963     RArray<TUint32> destinations;                                                              

   964     CleanupClosePushL( destinations );

   965 

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

   967     iCmManagerExt.AllDestinationsL(destinations);                                              

   968 

   969     count = destinations.Count();                                                         

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

   971 

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

   973         {

   974         RCmDestinationExt destination;                                                              

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

   976         CleanupClosePushL( destination );  

   977 

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

   979 

   980         RCmConnectionMethodExt connectionMethod;

   981         TRAP( exists,                                                                      

   982                 connectionMethod = destination.ConnectionMethodByIDL(                            

   983                         aWlanInfo.iIapId ) ); 

   984 

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

   986         if( exists == KErrNone )                                                           

   987             {   

   988             CleanupClosePushL( connectionMethod ); 

   989             // correct destination found                                                   

   990             priority = destination.PriorityL( connectionMethod );

   991             aWlanInfo.SetPriority( priority );

   992 

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

   994             CleanupStack::PopAndDestroy( &connectionMethod ); 

   995             }

   996         CleanupStack::PopAndDestroy( &destination );                                           

   997         }                                                                                      

   998     CleanupStack::PopAndDestroy( &destinations );

   999     }

  1000 

  1001 

  1002 #ifndef __WINS__

  1003 // ---------------------------------------------------------------------------

  1004 // CWsfWlanScanner::DoScanForNetworksL

  1005 // ---------------------------------------------------------------------------

  1006 //   

  1007 void CWsfWlanScanner::DoScanForNetworksL()

  1008     {

  1009     LOG_ENTERFN( "CWsfWlanScanner::DoScanForNetworksL" );

  1010         

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

  1012     iScanArray->Reset();    

  1013 

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

  1015     

  1016     if ( iStatus.Int() )

  1017         {

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

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

  1020         LOG_WRITE( "Error in getting scan result - leave" );

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

  1022         }

  1023    

  1024     TInt nElem = 0;

  1025     TBool isHidden( EFalse );

  1026 

  1027     TInt avIapCount = iAvailableIaps.Count();

  1028 

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

  1030 

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

  1032         {

  1033         TBool addToArray( ETrue ); 

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

  1035         CleanupStack::PushL( availableInfo );

  1036         availableInfo->iIapId = iAvailableIaps[i].iIapId;

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

  1038 

  1039         if ( error == KErrNotFound )

  1040             {

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

  1042             addToArray = EFalse;

  1043             }

  1044         else if ( error )

  1045             {

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

  1047             User::Leave( error );

  1048             }

  1049 

  1050         if( addToArray )

  1051             { 

  1052             LOG_WRITE( "Add to array" );

  1053             availableInfo->iCoverage = 0;

  1054             availableInfo->iVisibility = 1;

  1055             availableInfo->iStrengthLevel = iAvailableIaps[i].iRssi;

  1056             availableInfo->iTransferRate = 0;

  1057             availableInfo->iConnectionState = ENotConnected;

  1058             iScanArray->AppendL(availableInfo);

  1059             nElem++;

  1060 

  1061             if ( availableInfo->iIapId )

  1062                 {

  1063                 LOG_WRITEF( "Append available iap[%d] rssi[%d] for direct scan", 

  1064                          availableInfo->iIapId, availableInfo->iStrengthLevel );

  1065                 iDirectScanIapIDs.Append( availableInfo->iIapId );

  1066                 iDirectScanSsids.Append( availableInfo->iSsid );

  1067                 }

  1068 

  1069             CleanupStack::Pop( availableInfo );

  1070             }

  1071         else

  1072             {

  1073             LOG_WRITE( "Info not added" );

  1074             CleanupStack::PopAndDestroy( availableInfo );

  1075             }

  1076         }

  1077     

  1078 #ifdef _DEBUG

  1079         LOG_WRITE( "Dump scan results - available IAPs" );

  1080         DumpScanResultsL( iScanArray );

  1081 #endif

  1082       

  1083     // Process the scanned results

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

  1085         {

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

  1087         if ( !wlanInfo )

  1088             {

  1089             wlanInfo = new ( ELeave ) TWsfWlanInfo();

  1090             CleanupStack::PushL( wlanInfo );

  1091             iScanArray->AppendL( wlanInfo );

  1092             CleanupStack::Pop( wlanInfo );

  1093             }

  1094         isHidden = RefreshNetworkNameL( *wlanInfo );

  1095         wlanInfo->iVisibility = !isHidden;

  1096         wlanInfo->iStrengthLevel = EWlanSignalUnavailable;

  1097         wlanInfo->iTransferRate = 0;

  1098         wlanInfo->iConnectionState = ENotConnected;

  1099 

  1100         if( !isHidden )

  1101             {

  1102             // not hidden

  1103             RefreshNetworkMode( *wlanInfo );

  1104             RefreshSecurityMode( *wlanInfo );

  1105             RefreshTechnology( *wlanInfo );

  1106 

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

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

  1109             // found several iaps configured for same wlan)

  1110             RPointerArray<TWsfWlanInfo> matchArray;

  1111             CleanupClosePushL(matchArray);

  1112             iScanArray->MatchL( wlanInfo->iSsid, 

  1113                                 wlanInfo->iSecurityMode, 

  1114                                 wlanInfo->iNetMode, 

  1115                                 wlanInfo->UsesPreSharedKey(), 

  1116                                 nElem, 

  1117                                 matchArray );

  1118 

  1119             TInt matchcount = matchArray.Count();

  1120 

  1121             // if not found

  1122             if( matchcount == 0 )

  1123                 {

  1124                 wlanInfo->iCoverage = 1;

  1125                 RefreshSignalStrength( *wlanInfo );

  1126                 RefreshTechnology( *wlanInfo );

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

  1128                 }

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

  1130                 {

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

  1132                     {

  1133                     TWsfWlanInfo* temp = matchArray[i];

  1134                     ++temp->iCoverage;

  1135                     RefreshSignalStrength( *temp );