WlanConnect to BSS with given frequency.

chrome/utility/wifi/wifi_service_win.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/utility/wifi/wifi_service.h"
 
 #include <iphlpapi.h>
 #include <objbase.h>
 #include <wlanapi.h>
 
@@ skipping 146 matching lines @@
                              const base::DictionaryValue& properties,
                              const StringResultCallback& callback,
                              const ErrorCallback& error_callback) OVERRIDE;
 
   virtual void GetVisibleNetworks(const NetworkListCallback& callback,
                                   const ErrorCallback& error_callback) OVERRIDE;
 
   virtual void RequestNetworkScan() OVERRIDE;
 
   virtual void StartConnect(const std::string& network_guid,
+                            Frequency frequency,
                             const StringResultCallback& callback,
                             const ErrorCallback& error_callback) OVERRIDE;
 
   virtual void StartDisconnect(const std::string& network_guid,
                                const StringResultCallback& callback,
                                const ErrorCallback& error_callback) OVERRIDE;
 
   virtual void SetNetworksChangedObserver(
       const NetworkGuidListCallback& observer) OVERRIDE;
 
@@ skipping 99 matching lines @@
                                              NetworkProperties* properties);
 
   // Get the list of visible wireless networks.
   DWORD GetVisibleNetworkList(NetworkList* network_list);
 
   // Find currently connected network if any. Populate |connected_network_guid|
   // on success.
   DWORD FindConnectedNetwork(std::string* connected_network_guid);
 
   // Connect to network |network_guid| using previosly stored profile if exists,
-  // or just network sid.
-  DWORD Connect(const std::string& network_guid);
+  // or just network sid. If |frequency| is not |kFrequencyUnknown| then
+  // connects only to BSS which uses that frequency and returns
+  // |ERROR_NOT_FOUND| if such BSS cannot be found.
+  DWORD Connect(const std::string& network_guid, Frequency frequency);
 
   // Disconnect from currently connected network if any.
   DWORD Disconnect();
 
+  // Get DOT11_BSSID_LIST of desired BSSIDs to connect to |ssid| network on
+  // given |frequency|.
+  DWORD GetDesiredBssList(DOT11_SSID& ssid,
+                          Frequency frequency,
+                          scoped_ptr<DOT11_BSSID_LIST>* desired_list);
+
   // Save temporary wireless profile for |network_guid|.
   DWORD SaveTempProfile(const std::string& network_guid);
 
   // Get previously stored |profile_xml| for |network_guid|.
   DWORD GetProfile(const std::string& network_guid, std::string* profile_xml);
 
   // Return true if there is previously stored profile xml for |network_guid|.
   bool HaveProfile(const std::string& network_guid);
 
   // Notify |network_list_changed_observer_| that list of visible networks has
@@ skipping 147 matching lines @@
 }
 
 void WiFiServiceImpl::RequestNetworkScan() {
   DWORD error = EnsureInitialized();
   if (error == ERROR_SUCCESS) {
     WlanScan_function_(client_, &interface_guid_, NULL, NULL, NULL);
   }
 }
 
 void WiFiServiceImpl::StartConnect(const std::string& network_guid,
+                                   Frequency frequency,
                                    const StringResultCallback& callback,
                                    const ErrorCallback& error_callback) {
-  DLOG(INFO) << "Start Connect: " << network_guid;
+  DLOG(INFO) << "Start Connect: " << network_guid << " " << frequency << " MHz";
   DWORD error = EnsureInitialized();
   if (error == ERROR_SUCCESS) {
     std::string connected_network_guid;
     error = SaveCurrentConnectedNetwork(&connected_network_guid);
     if (error == ERROR_SUCCESS) {
       // Connect only if network |network_guid| is not connected already.
       if (network_guid != connected_network_guid)
-        error = Connect(network_guid);
+        error = Connect(network_guid, frequency);
       if (error == ERROR_SUCCESS) {
-        DisableNwCategoryWizard();
         callback.Run(network_guid);
         // Notify that previously connected network has changed.
         NotifyNetworkChanged(connected_network_guid);
         // Start waiting for network connection state change.
         if (!networks_changed_observer_.is_null()) {
+          DisableNwCategoryWizard();
           // Disable automatic network change notifications as they get fired
           // when network is just connected, but not yet accessible (doesn't
           // have valid IP address).
           enable_notify_network_changed_ = false;
           WaitForNetworkConnect(network_guid, 0);
           return;
         }
       }
     }
   }
@@ skipping 568 matching lines @@
   }
 
   // clean up
   if (available_network_list != NULL) {
     WlanFreeMemory_function_(available_network_list);
   }
 
   return error;
 }
 
-DWORD WiFiServiceImpl::Connect(const std::string& network_guid) {
+DWORD WiFiServiceImpl::GetDesiredBssList(
+    DOT11_SSID& ssid,
+    Frequency frequency,
+    scoped_ptr<DOT11_BSSID_LIST>* desired_list) {
+  if (client_ == NULL) {
+    NOTREACHED();
+    return ERROR_NOINTERFACE;
+  }
+
+  desired_list->reset();
+
+  if (frequency == kFrequencyAny)
+    return ERROR_SUCCESS;
+
+  // TODO(mef): WlanGetNetworkBssList is not available on XP. If XP support is
+  // needed, then different method of getting BSS (e.g. OID query) will have
+  // to be used.
+  if (!WlanGetNetworkBssList_function_)
+    return ERROR_NOT_SUPPORTED;
+
+  DWORD error = ERROR_SUCCESS;
+  PWLAN_BSS_LIST bss_list = NULL;
+
+  error = WlanGetNetworkBssList_function_(client_,
+                                          &interface_guid_,
+                                          NULL,
+                                          dot11_BSS_type_any,
+                                          FALSE,
+                                          NULL,
+                                          &bss_list);
+  if (error == ERROR_SUCCESS && NULL != bss_list) {
+    unsigned int best_quality = 0u;
+    size_t best_index = 0;
+    Frequency bss_frequency;
+
+    // Go through bss_list and find best quality BSSID with matching frequency.
+    for (size_t bss = 0; bss < bss_list->dwNumberOfItems; ++bss) {
+      const WLAN_BSS_ENTRY& bss_entry(bss_list->wlanBssEntries[bss]);
+      if (bss_entry.dot11Ssid.uSSIDLength != ssid.uSSIDLength ||
+          0 != memcmp(bss_entry.dot11Ssid.ucSSID,
+                      ssid.ucSSID,
+                      bss_entry.dot11Ssid.uSSIDLength))
+        continue;
+
+      if (bss_entry.ulChCenterFrequency < 3000000)
+        bss_frequency = kFrequency2400;
+      else
+        bss_frequency = kFrequency5000;
+
+      if (bss_frequency == frequency &&
+          bss_entry.uLinkQuality > best_quality) {
+        best_quality = bss_entry.uLinkQuality;
+        best_index = bss;
+      }
+    }
+
+    // If any matching BSS were found, prepare the header.
+    if (best_quality > 0) {
+      const WLAN_BSS_ENTRY& bss_entry(bss_list->wlanBssEntries[best_index]);
+      scoped_ptr<DOT11_BSSID_LIST> selected_list(new DOT11_BSSID_LIST);
+
+      selected_list->Header.Revision = DOT11_BSSID_LIST_REVISION_1;
+      selected_list->Header.Size = sizeof(DOT11_BSSID_LIST);
+      selected_list->Header.Type = NDIS_OBJECT_TYPE_DEFAULT;
+      selected_list->uNumOfEntries = 1;
+      selected_list->uTotalNumOfEntries = 1;
+      std::copy(bss_entry.dot11Bssid,
+                bss_entry.dot11Bssid+sizeof(bss_entry.dot11Bssid),
+                selected_list->BSSIDs[0]);
+      desired_list->swap(selected_list);
+      DLOG(INFO) << "Quality: " << best_quality << " BSS: "
+          << NetworkProperties::MacAddressAsString(bss_entry.dot11Bssid);
+    } else {
+      error = ERROR_NOT_FOUND;
+    }
+  }
+
+  // clean up
+  if (bss_list != NULL) {
+    WlanFreeMemory_function_(bss_list);
+  }
+  return error;
+}
+
+
+DWORD WiFiServiceImpl::Connect(const std::string& network_guid,
+                               Frequency frequency) {
   if (client_ == NULL) {
     NOTREACHED();
     return ERROR_NOINTERFACE;
   }
 
   DWORD error = ERROR_SUCCESS;
-  base::string16 profile_name = ProfileNameFromGUID(network_guid);
-
-  if (HaveProfile(network_guid)) {
-    WLAN_CONNECTION_PARAMETERS wlan_params = {
-        wlan_connection_mode_profile,
-        profile_name.c_str(),
-        NULL,
-        NULL,
-        dot11_BSS_type_any,
-        0};
-    error = WlanConnect_function_(
-        client_, &interface_guid_, &wlan_params, NULL);
-  } else {
-    // TODO(mef): wlan_connection_mode_discovery_unsecure is not available on
-    // XP. If XP support is needed, then temporary profile will have to be
-    // created.
-    DOT11_SSID ssid = SSIDFromGUID(network_guid);
-    WLAN_CONNECTION_PARAMETERS wlan_params = {
-        wlan_connection_mode_discovery_unsecure,
-        NULL,
-        &ssid,
-        NULL,
-        dot11_BSS_type_infrastructure,
-        0};
-    error = WlanConnect_function_(
-        client_, &interface_guid_, &wlan_params, NULL);
+  DOT11_SSID ssid = SSIDFromGUID(network_guid);
+  scoped_ptr<DOT11_BSSID_LIST> desired_bss_list;
+  error = GetDesiredBssList(ssid, frequency, &desired_bss_list);
+  if (error == ERROR_SUCCESS) {
+    if (HaveProfile(network_guid)) {
+      base::string16 profile_name = ProfileNameFromGUID(network_guid);
+      WLAN_CONNECTION_PARAMETERS wlan_params = {
+          wlan_connection_mode_profile,
+          profile_name.c_str(),
+          NULL,
+          desired_bss_list.get(),
+          dot11_BSS_type_any,
+          0};
+      error = WlanConnect_function_(
+          client_, &interface_guid_, &wlan_params, NULL);
+    } else {
+      // TODO(mef): wlan_connection_mode_discovery_unsecure is not available on
+      // XP. If XP support is needed, then temporary profile will have to be
+      // created.
+      WLAN_CONNECTION_PARAMETERS wlan_params = {
+          wlan_connection_mode_discovery_unsecure,
+          NULL,
+          &ssid,
+          desired_bss_list.get(),
+          dot11_BSS_type_infrastructure,
+          0};
+      error = WlanConnect_function_(
+          client_, &interface_guid_, &wlan_params, NULL);
+    }
   }
 
   return error;
 }
 
 DWORD WiFiServiceImpl::Disconnect() {
   if (client_ == NULL) {
     NOTREACHED();
     return ERROR_NOINTERFACE;
   }
@@ skipping 80 matching lines @@
   if (enable_notify_network_changed_ && !networks_changed_observer_.is_null()) {
     DLOG(INFO) << "NotifyNetworkChanged: " << network_guid;
     NetworkGuidList changed_networks(1, network_guid);
     networks_changed_observer_.Run(changed_networks);
   }
 }
 
 WiFiService* WiFiService::CreateService() { return new WiFiServiceImpl(); }
 
 }  // namespace wifi