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 41 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 100 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 101 matching lines @@
 }
 
 void WiFiServiceImpl::RequestNetworkScan() {
   DWORD error = EnsureInitialized();
   if (error == ERROR_SUCCESS) {
     WlanScan(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 32 matching lines @@
 
 void WiFiServiceImpl::OnWlanNotificationCallback(
     PWLAN_NOTIFICATION_DATA wlan_notification_data,
     PVOID context) {
   WiFiServiceImpl* service = reinterpret_cast<WiFiServiceImpl*>(context);
   service->OnWlanNotification(wlan_notification_data);
 }
 
 void WiFiServiceImpl::OnWlanNotification(
     PWLAN_NOTIFICATION_DATA wlan_notification_data) {
+  if (!task_runner_)
+    return;
+
   switch (wlan_notification_data->NotificationCode) {
     case wlan_notification_acm_disconnected:
     case wlan_notification_acm_connection_complete:
     case wlan_notification_acm_connection_attempt_fail: {
       PWLAN_CONNECTION_NOTIFICATION_DATA wlan_connection_data =
           reinterpret_cast<PWLAN_CONNECTION_NOTIFICATION_DATA>(
               wlan_notification_data->pData);
       task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&WiFiServiceImpl::NotifyNetworkChanged,
@@ skipping 100 matching lines @@
   networks->sort(NetworkProperties::OrderByType);
 }
 
 DWORD WiFiServiceImpl::OpenClientHandle() {
   CloseClientHandle();
 
   DWORD error = ERROR_SUCCESS;
   DWORD service_version = 0;
 
   // Open a handle to the service.
-  error = ::WlanOpenHandle(1, NULL, &service_version, &client_);
+  error = ::WlanOpenHandle(WLAN_API_VERSION, NULL, &service_version, &client_);
 
   PWLAN_INTERFACE_INFO_LIST interface_list = NULL;
   if (error == ERROR_SUCCESS) {
     // Enumerate wireless interfaces.
     error = ::WlanEnumInterfaces(client_, NULL, &interface_list);
     if (error == ERROR_SUCCESS) {
       if (interface_list != NULL && interface_list->dwNumberOfItems != 0) {
         // Remember first interface just in case if none are connected.
         interface_guid_ = interface_list->InterfaceInfo[0].InterfaceGuid;
         // Try to find a connected interface.
@@ skipping 262 matching lines @@
   }
 
   // clean up
   if (available_network_list != NULL) {
     ::WlanFreeMemory(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) {

[afontan, 2013/10/24 18:18:20]

I think you should consider adding hidden networks support in the extension as
it is a relatively common scenario.

[mef, 2013/10/24 19:13:54]

Sounds good. I'll keep this CL going as placeholder for additional feature
support.

My current plan is to land http://crrev.com/22295002 first as the plumbing
support, then land https://codereview.chromium.org/27722003/ second as basic
Windows support, and then land this CL to support advanced scenarios.

+  if (client_ == NULL) {
+    NOTREACHED();
+    return ERROR_NOINTERFACE;
+  }
+
+  desired_list->reset();
+
+  if (frequency == kFrequencyUnknown)
+    return ERROR_SUCCESS;
+
+  DWORD error = ERROR_SUCCESS;
+  PWLAN_BSS_LIST bss_list = NULL;
+
+  // 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.
+  error = ::WlanGetNetworkBssList(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(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(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(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(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(client_, &interface_guid_, &wlan_params, NULL);
+    }
   }
 
   return error;
 }
 
 DWORD WiFiServiceImpl::Disconnect() {
   if (client_ == NULL) {
     NOTREACHED();
     return ERROR_NOINTERFACE;
   }
@@ skipping 76 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