1 /*

     2 * Copyright (c) 2010 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: 

    15 * Symbian platform specific implementation of WLAN scanning.

    16 */

    17 

    18 // System includes

    19 

    20 #include <QList>

    21 #include <cmmanagerdefines_shim.h>

    22 #include <utf.h>

    23 

    24 // User includes

    25 

    26 #include "wlanqtutils.h"

    27 #include "wlanqtutilsap.h"

    28 #include "wlanqtutilsscan.h"

    29 #include "wlanqtutilsscan_symbian.h"

    30 

    31 #include "OstTraceDefinitions.h"

    32 #ifdef OST_TRACE_COMPILER_IN_USE

    33 #include "wlanqtutilsscan_symbianTraces.h"

    34 #endif

    35 

    36 

    37 /*!

    38     \class WlanQtUtilsScanPrivate

    39     \brief Symbian platform specific implementation of WLAN scanning.

    40 

    41     Symbian platform specific implementation of WLAN scanning. 

    42 */

    43 

    44 

    45 // External function prototypes

    46 

    47 // Local constants

    48 

    49 // Information Element ID for SSID as specified in 802.11.

    50 static const TUint8 KWlan802Dot11SsidIE = 0;

    51 

    52 // Bit mask for Capability info field to get type (Infra/AdHoc).

    53 static const TUint8 KWlan802Dot11CapabilityEssMask = 0x0001;

    54 

    55 // ======== LOCAL FUNCTIONS ========

    56 

    57 // ======== MEMBER FUNCTIONS ========

    58 

    59 /*!

    60     Static factory constructor.

    61     

    62     @param [in,out] wrapper Public implementation class reference.

    63     

    64     @return New instance of the class.

    65 */

    66 

    67 WlanQtUtilsScanPrivate *WlanQtUtilsScanPrivate::NewL(WlanQtUtilsScan *wrapper)

    68 {

    69     OstTraceFunctionEntry0(WLANQTUTILSSCANPRIVATE_NEWL_ENTRY);

    70     

    71     WlanQtUtilsScanPrivate *self = new (ELeave) WlanQtUtilsScanPrivate(wrapper);

    72     CleanupStack::PushL(self);

    73     self->ConstructL();

    74     CleanupStack::Pop(self);

    75     

    76     OstTraceFunctionExit0(WLANQTUTILSSCANPRIVATE_NEWL_EXIT);

    77     return self;

    78 }

    79 

    80 /*!

    81     Destructor.

    82 */

    83 

    84 WlanQtUtilsScanPrivate::~WlanQtUtilsScanPrivate()

    85 {

    86     OstTraceFunctionEntry0(WLANQTUTILSSCANPRIVATE_WLANQTUTILSSCANPRIVATE_ENTRY);

    87     

    88     Cancel();

    89     delete mWlanMgmtClient;

    90     mWlanMgmtClient = NULL;

    91     delete mResults;

    92     mResults = NULL;

    93     

    94     OstTraceFunctionExit0(WLANQTUTILSSCANPRIVATE_WLANQTUTILSSCANPRIVATE_EXIT);

    95 }

    96 

    97 /*!

    98     Starts a broadcast scan of available access points.

    99 */

   100 

   101 void WlanQtUtilsScanPrivate::Scan()

   102 {

   103     OstTraceFunctionEntry0(WLANQTUTILSSCANPRIVATE_SCAN_ENTRY);

   104     

   105     // Scanning while previous scan is not complete is not supported

   106     Q_ASSERT(!IsActive());

   107     

   108     // Make the scan

   109     mWlanMgmtClient->GetScanResults(iStatus, *mResults);

   110     SetActive();

   111     

   112     OstTraceFunctionExit0(WLANQTUTILSSCANPRIVATE_SCAN_EXIT);

   113 }

   114 

   115 /*!

   116     Starts a direct scan of available access points having given SSID.

   117     

   118     @param ssid SSID to scan.

   119 */

   120 

   121 void WlanQtUtilsScanPrivate::Scan(const QString &ssid)

   122 {

   123     OstTraceFunctionEntry0(WLANQTUTILSSCANPRIVATE_SCAN_SSID_ENTRY);

   124     

   125     // Scanning while previous scan is not complete is not supported

   126     Q_ASSERT(!IsActive());

   127     

   128     // Convert from QString to TBuf8

   129     TBuf<KWlanMaxSsidLength> buffer(ssid.utf16());

   130     TInt error = CnvUtfConverter::ConvertFromUnicodeToUtf8(mWlanSsid, buffer);

   131     qt_symbian_throwIfError(error);

   132 

   133     OstTraceExt1(

   134         TRACE_NORMAL,

   135         WLANQTUTILSSCANPRIVATE_SCAN_SSID,

   136         "WlanQtUtilsScanPrivate::Scan;mWlanSsid=%s",

   137         mWlanSsid);

   138 

   139     // Make the scan

   140     mWlanMgmtClient->GetScanResults(mWlanSsid, iStatus, *mResults);

   141     SetActive();

   142 

   143     OstTraceFunctionExit0(WLANQTUTILSSCANPRIVATE_SCAN_SSID_EXIT);

   144 }

   145 

   146 /*!

   147     Stops an ongoing scan.

   148 */

   149 

   150 void WlanQtUtilsScanPrivate::StopScan()

   151 {

   152     OstTraceFunctionEntry0(WLANQTUTILSSCANPRIVATE_STOPSCAN_ENTRY);

   153     

   154     Cancel();

   155     

   156     OstTraceFunctionExit0(WLANQTUTILSSCANPRIVATE_STOPSCAN_EXIT);

   157 }

   158 

   159 /*!

   160     Scan results handler.

   161 */

   162 

   163 void WlanQtUtilsScanPrivate::RunL()

   164 {

   165     OstTraceFunctionEntry0(WLANQTUTILSSCANPRIVATE_RUNL_ENTRY);

   166     

   167     QT_TRYCATCH_LEAVING(

   168         if (iStatus != KErrNone) {

   169             emit q_ptr->scanFailed(WlanQtUtils::ScanStatusError);

   170         } else {

   171             QList< QSharedPointer<WlanQtUtilsAp> > scanResults;

   172             ExtractScanResults(scanResults);

   173             

   174             // Inform about the results 

   175             emit q_ptr->availableWlanAps(scanResults);

   176         }

   177     );

   178     

   179     OstTraceFunctionExit0(WLANQTUTILSSCANPRIVATE_RUNL_EXIT);

   180 }

   181 

   182 /*!

   183     Cancels an outstanding request.

   184 */

   185 

   186 void WlanQtUtilsScanPrivate::DoCancel()

   187 {

   188     OstTraceFunctionEntry0(WLANQTUTILSSCANPRIVATE_DOCANCEL_ENTRY);

   189     

   190     mWlanMgmtClient->CancelGetScanResults();

   191 

   192     OstTraceFunctionExit0(WLANQTUTILSSCANPRIVATE_DOCANCEL_EXIT);

   193 }

   194 

   195 /*!

   196     Constructor.

   197     

   198     @param [in,out] wrapper Public implementation class reference.

   199 */

   200 

   201 WlanQtUtilsScanPrivate::WlanQtUtilsScanPrivate(WlanQtUtilsScan *wrapper) :

   202     CActive(EPriorityStandard),

   203     q_ptr(wrapper),

   204     mWlanMgmtClient(NULL),

   205     mResults(NULL)

   206 {

   207     OstTraceFunctionEntry0(DUP1_WLANQTUTILSSCANPRIVATE_WLANQTUTILSSCANPRIVATE_ENTRY);

   208     OstTraceFunctionExit0(DUP1_WLANQTUTILSSCANPRIVATE_WLANQTUTILSSCANPRIVATE_EXIT);

   209 }

   210 

   211 /*!

   212     Second phase constructor.

   213 */

   214 

   215 void WlanQtUtilsScanPrivate::ConstructL()

   216 {

   217     OstTraceFunctionEntry0(WLANQTUTILSSCANPRIVATE_CONSTRUCTL_ENTRY);

   218     

   219     CActiveScheduler::Add(this);

   220     mWlanMgmtClient = CWlanMgmtClient::NewL();

   221     mResults = CWlanScanInfo::NewL();

   222     

   223     OstTraceFunctionExit0(WLANQTUTILSSCANPRIVATE_CONSTRUCTL_EXIT);

   224 }

   225 

   226 /*

   227     Extracts scan results and stores them into the given AP list.

   228     

   229     @param [out] scanResults Scan result list.

   230 */

   231 

   232 void WlanQtUtilsScanPrivate::ExtractScanResults(

   233     QList< QSharedPointer<WlanQtUtilsAp> > &scanResults)

   234 {

   235     for (mResults->First(); !mResults->IsDone(); mResults->Next()) {

   236         // Create an access point for each result

   237         QSharedPointer<WlanQtUtilsAp> ap(new WlanQtUtilsAp());

   238         

   239         // SSID

   240         QString ssid = ExtractSsid();

   241 

   242         // Skip over hidden networks. There is no spec for what

   243         // their names will contain, but at least names with only

   244         // null characters and whitespace characters are seen

   245         // in real life.

   246         if (ssid.trimmed().isEmpty()) {

   247             continue;

   248         }

   249         ap->setValue(WlanQtUtilsAp::ConfIdSsid, ssid);

   250         

   251         // BSSID

   252         QByteArray bssid = ExtractBssid();

   253         ap->setValue(WlanQtUtilsAp::ConfIdBssid, bssid);

   254         

   255         // Signal strength

   256         ap->setValue(

   257             WlanQtUtilsAp::ConfIdSignalStrength,

   258             (int)mResults->RXLevel());

   259 

   260         // Connection Mode

   261         CMManagerShim::WlanConnMode connMode;

   262         if (mResults->Capability() & KWlan802Dot11CapabilityEssMask) {

   263             connMode = CMManagerShim::Infra;

   264         } else {

   265             connMode = CMManagerShim::Adhoc;

   266         }

   267         ap->setValue(WlanQtUtilsAp::ConfIdConnectionMode, (int)connMode);

   268 

   269         // Security Mode parameters

   270         StoreSecMode(ap, mResults->ExtendedSecurityMode());

   271         

   272         // Hidden attribute

   273         // These scan results do not tell if the AP is hidden or not

   274         ap->setValue(WlanQtUtilsAp::ConfIdHidden, false);

   275         

   276         // WPS support

   277         TBool wpsSupported = mResults->IsProtectedSetupSupported();

   278         ap->setValue(

   279             WlanQtUtilsAp::ConfIdWpsSupported,

   280             (wpsSupported == EFalse) ? false : true);

   281 

   282         // Append the AP to scan result list

   283         scanResults.append(ap);

   284     }

   285 }

   286 

   287 /*!

   288     Extracts and cleans up the WLAN SSID from current scan result element.

   289     

   290     @return SSID string.

   291 */

   292 

   293 QString WlanQtUtilsScanPrivate::ExtractSsid()

   294 {

   295     // Get the SSID in raw data format

   296     TUint8 ieLen;

   297     const TUint8* ieData;

   298     TInt ret = mResults->InformationElement(KWlan802Dot11SsidIE, ieLen, &ieData);

   299     

   300     // Convert into QString

   301     QString ssid;

   302     if (ret == KErrNone && ieLen > 0) {

   303         // Trace the buffer as data to ease low level debugging

   304         OstTraceData(

   305             TRACE_DUMP,

   306             WLANQTUTILSSCANPRIVATE_EXTRACTSSID_DATA,

   307             "WlanQtUtilsScanPrivate::ExtractSsid data 0x%{hex8[]}",

   308             ieData,

   309             ieLen);

   310 

   311         ssid = QString::fromUtf8((char *)ieData, ieLen);

   312 

   313 #ifdef OST_TRACE_COMPILER_IN_USE

   314         TPtrC16 string(ssid.utf16(), ssid.length());

   315         OstTraceExt1(

   316             TRACE_DUMP,

   317             WLANQTUTILSSCANPRIVATE_EXTRACTSSID_STRING,

   318             "WlanQtUtilsScanPrivate::ExtractSsid string;ssid=%S",

   319             string);

   320 #endif

   321     }

   322     

   323     // Remove nul characters

   324     ssid.remove(QChar());

   325     

   326     return ssid;

   327 }

   328 

   329 /*!

   330     Extracts the WLAN BSSID from current scan result element.

   331     

   332     @return BSSID array.

   333 */

   334 

   335 QByteArray WlanQtUtilsScanPrivate::ExtractBssid()

   336 {

   337     TWlanBssid wlanBssid;

   338     mResults->Bssid(wlanBssid);

   339     QByteArray bssid;

   340     for (int i = 0; i < (int)wlanBssid.Length(); i++) {

   341         bssid[i] = (char)wlanBssid[i];

   342     }

   343 

   344 #ifdef OST_TRACE_COMPILER_IN_USE

   345     QString bssidHex(bssid.toHex());

   346     TPtrC16 string(bssidHex.utf16(), bssidHex.length());

   347 

   348     OstTraceExt1(

   349         TRACE_DUMP,

   350         WLANQTUTILSSCANPRIVATE_EXTRACTBSSID,

   351         "WlanQtUtilsScanPrivate::ExtractBssid;bssid=%S",

   352         string);

   353 #endif

   354 

   355     return bssid;

   356 }

   357 

   358 /*!

   359     Stores Security mode parameters to \a ap class.

   360 

   361     @param [in,out] ap Access Point object to where the configuration is stored.

   362     @param [in] secMode Security mode to store.

   363 */

   364 

   365 void WlanQtUtilsScanPrivate::StoreSecMode(

   366     QSharedPointer<WlanQtUtilsAp> ap,

   367     TUint wlanSecMode)

   368 {

   369     CMManagerShim::WlanSecMode secMode = CMManagerShim::WlanSecModeOpen;

   370     ap->setValue(WlanQtUtilsAp::ConfIdWpaPskUse, false);

   371     

   372     switch (wlanSecMode) {

   373     case EWlanConnectionExtentedSecurityModeWepOpen:

   374     case EWlanConnectionExtentedSecurityModeWepShared:

   375         secMode = CMManagerShim::WlanSecModeWep;

   376         break;

   377     

   378     case EWlanConnectionExtentedSecurityMode802d1x:

   379         secMode = CMManagerShim::WlanSecMode802_1x;

   380         break;

   381         

   382     case EWlanConnectionExtentedSecurityModeWpa:

   383         secMode = CMManagerShim::WlanSecModeWpa;

   384         break;

   385         

   386     case EWlanConnectionExtentedSecurityModeWpaPsk:

   387         secMode = CMManagerShim::WlanSecModeWpa;

   388         ap->setValue(WlanQtUtilsAp::ConfIdWpaPskUse, true);

   389         break;

   390         

   391     case EWlanConnectionExtentedSecurityModeWpa2:

   392         secMode = CMManagerShim::WlanSecModeWpa2;

   393         break;

   394         

   395     case EWlanConnectionExtentedSecurityModeWpa2Psk:

   396         secMode = CMManagerShim::WlanSecModeWpa2;

   397         ap->setValue(WlanQtUtilsAp::ConfIdWpaPskUse, true);

   398         break;

   399 

   400     case EWlanConnectionExtentedSecurityModeWapi:

   401     case EWlanConnectionExtentedSecurityModeWapiPsk:

   402         secMode = CMManagerShim::WlanSecModeWapi;

   403         break;

   404 

   405     case EWlanConnectionExtentedSecurityModeOpen:

   406         secMode = CMManagerShim::WlanSecModeOpen;

   407         break;

   408         

   409 #ifndef QT_NO_DEBUG

   410     default:

   411         // Invalid security mode detected

   412         Q_ASSERT(0);

   413         break;

   414 #endif        

   415     }

   416     

   417     ap->setValue(WlanQtUtilsAp::ConfIdSecurityMode, secMode);

   418 }