Use WiFi.Frequency property to set desired band for networkingPrivateApi.StartConnect()

components/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 "components/wifi/wifi_service.h"
 
 #include <iphlpapi.h>
 #include <objbase.h>
 #include <wlanapi.h>
 
@@ skipping 24 matching lines @@
 // WlanApi function names
 const char kWlanConnect[] = "WlanConnect";
 const char kWlanCloseHandle[] = "WlanCloseHandle";
 const char kWlanDisconnect[] = "WlanDisconnect";
 const char kWlanEnumInterfaces[] = "WlanEnumInterfaces";
 const char kWlanFreeMemory[] = "WlanFreeMemory";
 const char kWlanGetAvailableNetworkList[] = "WlanGetAvailableNetworkList";
 const char kWlanGetNetworkBssList[] = "WlanGetNetworkBssList";
 const char kWlanGetProfile[] = "WlanGetProfile";
 const char kWlanOpenHandle[] = "WlanOpenHandle";
+const char kWlanQueryInterface[] = "WlanQueryInterface";
 const char kWlanRegisterNotification[] = "WlanRegisterNotification";
 const char kWlanSaveTemporaryProfile[] = "WlanSaveTemporaryProfile";
 const char kWlanScan[] = "WlanScan";
 
 // WlanApi function definitions
 typedef DWORD (WINAPI* WlanConnectFunction)(
     HANDLE hClientHandle,
     CONST GUID *pInterfaceGuid,
     CONST PWLAN_CONNECTION_PARAMETERS pConnectionParameters,
     PVOID pReserved);
@@ skipping 39 matching lines @@
     LPWSTR *pstrProfileXml,
     DWORD *pdwFlags,
     DWORD *pdwGrantedAccess);
 
 typedef DWORD (WINAPI* WlanOpenHandleFunction)(
     DWORD dwClientVersion,
     PVOID pReserved,
     PDWORD pdwNegotiatedVersion,
     PHANDLE phClientHandle);
 
+typedef DWORD (WINAPI* WlanQueryInterfaceFunction)(
+    HANDLE hClientHandle,
+    const GUID *pInterfaceGuid,
+    WLAN_INTF_OPCODE OpCode,
+    PVOID pReserved,
+    PDWORD pdwDataSize,
+    PVOID *ppData,
+    PWLAN_OPCODE_VALUE_TYPE pWlanOpcodeValueType);
+
 typedef DWORD (WINAPI* WlanRegisterNotificationFunction)(
     HANDLE hClientHandle,
     DWORD dwNotifSource,
     BOOL bIgnoreDuplicate,
     WLAN_NOTIFICATION_CALLBACK funcCallback,
     PVOID pCallbackContext,
     PVOID pReserved,
     PDWORD pdwPrevNotifSource);
 
 typedef DWORD (WINAPI* WlanSaveTemporaryProfileFunction)(
@@ skipping 172 matching lines @@
 
   // Connect to network |network_guid| using previosly stored profile if exists,
   // 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 Frequency of currently connected network |network_guid|. If network is
+  // not connected, then return |kFrequencyUnknown|.
+  Frequency WiFiServiceImpl::GetConnectedFrequency(
+      const std::string& network_guid);
+
+  // Get desired connection freqency if it was set using |SetProperties|.
+  // Default to |kFrequencyAny|.
+  Frequency GetFrequencyToConnect(const std::string& network_guid) const;
+
   // 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);
 
+  // Normalizes |frequency_in_mhz| into one of |Frequency| values.
+  Frequency GetNormalizedFrequency(int frequency_in_mhz) const;
+
   // 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 12 matching lines @@
   WlanConnectFunction WlanConnect_function_;
   WlanCloseHandleFunction WlanCloseHandle_function_;
   WlanDisconnectFunction WlanDisconnect_function_;
   WlanEnumInterfacesFunction WlanEnumInterfaces_function_;
   WlanFreeMemoryFunction WlanFreeMemory_function_;
   WlanGetAvailableNetworkListFunction WlanGetAvailableNetworkList_function_;
   // WlanGetNetworkBssList function may not be avaiable on Windows XP.
   WlanGetNetworkBssListFunction WlanGetNetworkBssList_function_;
   WlanGetProfileFunction WlanGetProfile_function_;
   WlanOpenHandleFunction WlanOpenHandle_function_;
+  WlanQueryInterfaceFunction WlanQueryInterface_function_;
   WlanRegisterNotificationFunction WlanRegisterNotification_function_;
   WlanScanFunction WlanScan_function_;
   // WlanSaveTemporaryProfile function may not be avaiable on Windows XP.
   WlanSaveTemporaryProfileFunction WlanSaveTemporaryProfile_function_;
 
   // WLAN service handle.
   HANDLE client_;
   // GUID of the currently connected interface, if any, otherwise the GUID of
   // one of the WLAN interfaces.
   GUID interface_guid_;
+  // Temporary storage of network properties indexed by |network_guid|. Persist
+  // only in memory.
+  DictionaryValue connect_properties_;
   // Preserved WLAN profile xml.
   std::map<std::string, std::string> saved_profiles_xml_;
   // Observer to get notified when network(s) have changed (e.g. connect).
   NetworkGuidListCallback networks_changed_observer_;
   // Observer to get notified when network list has changed (scan complete).
   NetworkGuidListCallback network_list_changed_observer_;
   // Saved value of network location wizard show value.
   scoped_ptr<DWORD> saved_nw_category_wizard_;
   // MessageLoopProxy to post events on UI thread.
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
@@ skipping 60 matching lines @@
     }
   }
 
   CheckError(error_code, kWiFiServiceError, error);
 }
 
 void WiFiServiceImpl::SetProperties(
     const std::string& network_guid,
     scoped_ptr<base::DictionaryValue> properties,
     std::string* error) {
-  // This method is not implemented in first version as it is not used by
-  // Google Cast extension.
-  CheckError(ERROR_CALL_NOT_IMPLEMENTED, kWiFiServiceError, error);
+  // Temporary preserve WiFi properties (desired frequency, wifi password) to
+  // use in StartConnect.
+  DCHECK(properties.get());
+  if (!properties->HasKey(onc::network_type::kWiFi)) {
+    DVLOG(0) << "Missing WiFi properties:" << *properties;
+    *error = kWiFiServiceError;
+    return;
+  }
+  connect_properties_.SetWithoutPathExpansion(network_guid,
+                                              properties.release());
 }
 
 void WiFiServiceImpl::GetVisibleNetworks(const std::string& network_type,
                                          ListValue* network_list) {
   if (!network_type.empty() &&
       network_type != onc::network_type::kAllTypes &&
       network_type != onc::network_type::kWiFi) {
     return;
   }
 
@@ skipping 21 matching lines @@
 }
 
 void WiFiServiceImpl::StartConnect(const std::string& network_guid,
                                    std::string* error) {
   DVLOG(1) << "Start Connect: " << network_guid;
   DWORD error_code = EnsureInitialized();
   if (error_code == ERROR_SUCCESS) {
     std::string connected_network_guid;
     error_code = SaveCurrentConnectedNetwork(&connected_network_guid);
     if (error_code == ERROR_SUCCESS) {
-      Frequency frequency = kFrequencyAny;
+      // Check, if the network is already connected on desired frequency.
+      bool already_connected = (network_guid == connected_network_guid);
+      Frequency frequency = GetFrequencyToConnect(network_guid);
+      if (already_connected && frequency != kFrequencyAny) {
+        Frequency connected_frequency = GetConnectedFrequency(network_guid);
+        already_connected = (frequency == connected_frequency);
+      }
       // Connect only if network |network_guid| is not connected already.
-      if (network_guid != connected_network_guid)
+      if (!already_connected)
         error_code = Connect(network_guid, frequency);
       if (error_code == ERROR_SUCCESS) {
         // 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).
@@ skipping 192 matching lines @@
           ::GetProcAddress(wlan_api_library_, kWlanGetAvailableNetworkList));
   WlanGetNetworkBssList_function_ =
       reinterpret_cast<WlanGetNetworkBssListFunction>(
           ::GetProcAddress(wlan_api_library_, kWlanGetNetworkBssList));
   WlanGetProfile_function_ =
       reinterpret_cast<WlanGetProfileFunction>(
           ::GetProcAddress(wlan_api_library_, kWlanGetProfile));
   WlanOpenHandle_function_ =
       reinterpret_cast<WlanOpenHandleFunction>(
           ::GetProcAddress(wlan_api_library_, kWlanOpenHandle));
+  WlanQueryInterface_function_ =
+      reinterpret_cast<WlanQueryInterfaceFunction>(
+          ::GetProcAddress(wlan_api_library_, kWlanQueryInterface));
   WlanRegisterNotification_function_ =
       reinterpret_cast<WlanRegisterNotificationFunction>(
           ::GetProcAddress(wlan_api_library_, kWlanRegisterNotification));
   WlanSaveTemporaryProfile_function_ =
       reinterpret_cast<WlanSaveTemporaryProfileFunction>(
           ::GetProcAddress(wlan_api_library_, kWlanSaveTemporaryProfile));
   WlanScan_function_ =
       reinterpret_cast<WlanScanFunction>(
           ::GetProcAddress(wlan_api_library_, kWlanScan));
 
   if (!WlanConnect_function_ ||
       !WlanCloseHandle_function_ ||
       !WlanDisconnect_function_ ||
       !WlanEnumInterfaces_function_ ||
       !WlanFreeMemory_function_ ||
       !WlanGetAvailableNetworkList_function_ ||
       !WlanGetProfile_function_ ||
       !WlanOpenHandle_function_ ||
+      !WlanQueryInterface_function_ ||
       !WlanRegisterNotification_function_ ||
       !WlanScan_function_) {
     DLOG(ERROR) << "Unable to find required WlanApi function.";
     FreeLibrary(wlan_api_library_);
     wlan_api_library_ = NULL;
     return ERROR_NOT_FOUND;
   }
 
   // Some WlanApi functions may not be available on XP.
   if (!WlanGetNetworkBssList_function_ ||
@@ skipping 35 matching lines @@
                                            WLAN_NOTIFICATION_SOURCE_ALL,
                                            FALSE,
                                            OnWlanNotificationCallback,
                                            this,
                                            NULL,
                                            NULL);
       } else {
         error = ERROR_NOINTERFACE;
       }
     }
-    // Clean up.
+    // Clean up..
     if (interface_list != NULL)
       WlanFreeMemory_function_(interface_list);
   }
   return error;
 }
 
 DWORD WiFiServiceImpl::ResetDHCP() {
   IP_ADAPTER_INDEX_MAP adapter_index_map = {0};
   DWORD error = FindAdapterIndexMapByGUID(interface_guid_, &adapter_index_map);
   if (error == ERROR_SUCCESS) {
@@ skipping 162 matching lines @@
   properties->name = properties->ssid;
   properties->guid = GUIDFromWLAN(wlan);
   properties->type = onc::network_type::kWiFi;
 
   for (size_t bss = 0; bss < wlan_bss_list.dwNumberOfItems; ++bss) {
     const WLAN_BSS_ENTRY& bss_entry(wlan_bss_list.wlanBssEntries[bss]);
     if (bss_entry.dot11Ssid.uSSIDLength == wlan.dot11Ssid.uSSIDLength &&
         0 == memcmp(bss_entry.dot11Ssid.ucSSID,
                     wlan.dot11Ssid.ucSSID,
                     bss_entry.dot11Ssid.uSSIDLength)) {
-      if (bss_entry.ulChCenterFrequency < 3000000)
-        properties->frequency = kFrequency2400;
-      else
-        properties->frequency = kFrequency5000;
+      properties->frequency = GetNormalizedFrequency(
+          bss_entry.ulChCenterFrequency / 1000);
       properties->frequency_list.push_back(properties->frequency);
       properties->bssid = NetworkProperties::MacAddressAsString(
           bss_entry.dot11Bssid);
     }
   }
   properties->frequency_list.sort();
   properties->frequency_list.unique();
   properties->security =
       SecurityFromDot11AuthAlg(wlan.dot11DefaultAuthAlgorithm);
   properties->signal_strength = wlan.wlanSignalQuality;
@@ skipping 52 matching lines @@
                 network_properties.connection_state;
           }
         } else {
           network_list->push_back(network_properties);
         }
         network_guids.insert(network_properties.guid);
       }
     }
   }
 
-  // clean up
+  // Clean up.
   if (available_network_list != NULL) {
     WlanFreeMemory_function_(available_network_list);
   }
   if (bss_list != NULL) {
     WlanFreeMemory_function_(bss_list);
   }
   return error;
 }
 
 // Find currently connected network.
@@ skipping 12 matching lines @@
   if (error == ERROR_SUCCESS && NULL != available_network_list) {
     for (DWORD i = 0; i < available_network_list->dwNumberOfItems; ++i) {
       const WLAN_AVAILABLE_NETWORK& wlan = available_network_list->Network[i];
       if (wlan.dwFlags & WLAN_AVAILABLE_NETWORK_CONNECTED) {
         *connected_network_guid = GUIDFromWLAN(wlan);
         break;
       }
     }
   }
 
-  // clean up
+  // Clean up.
   if (available_network_list != NULL) {
     WlanFreeMemory_function_(available_network_list);
   }
 
   return error;
 }
 
+WiFiService::Frequency WiFiServiceImpl::GetConnectedFrequency(
+    const std::string& network_guid) {
+  if (client_ == NULL) {
+    NOTREACHED();
+    return kFrequencyUnknown;
+  }
+
+  // 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_ == NULL)
+    return kFrequencyUnknown;
+
+  Frequency frequency = kFrequencyUnknown;
+  DWORD error = ERROR_SUCCESS;
+  DWORD data_size = 0;
+  PWLAN_CONNECTION_ATTRIBUTES wlan_connection_attributes = NULL;
+  PWLAN_BSS_LIST bss_list = NULL;
+  error = WlanQueryInterface_function_(
+      client_,
+      &interface_guid_,
+      wlan_intf_opcode_current_connection,
+      NULL,
+      &data_size,
+      reinterpret_cast<PVOID*>(&wlan_connection_attributes),
+      NULL);
+  if (error == ERROR_SUCCESS &&
+      wlan_connection_attributes != NULL &&
+      wlan_connection_attributes->isState == wlan_interface_state_connected) {
+    WLAN_ASSOCIATION_ATTRIBUTES& connected_wlan =
+        wlan_connection_attributes->wlanAssociationAttributes;
+    // Try to find connected frequency based on bss.
+    if (GUIDFromSSID(connected_wlan.dot11Ssid) == network_guid &&
+        WlanGetNetworkBssList_function_ != NULL) {
+      error = WlanGetNetworkBssList_function_(client_,
+                                              &interface_guid_,
+                                              &connected_wlan.dot11Ssid,
+                                              connected_wlan.dot11BssType,
+                                              FALSE,
+                                              NULL,
+                                              &bss_list);
+      if (error == ERROR_SUCCESS && NULL != bss_list) {
+        // Go through bss_list and find matching BSSID.
+        for (size_t bss = 0; bss < bss_list->dwNumberOfItems; ++bss) {
+          const WLAN_BSS_ENTRY& bss_entry(bss_list->wlanBssEntries[bss]);
+          if (0 == memcmp(bss_entry.dot11Bssid,
+                          connected_wlan.dot11Bssid,
+                          sizeof(bss_entry.dot11Bssid))) {
+            frequency = GetNormalizedFrequency(
+                bss_entry.ulChCenterFrequency / 1000);
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  // Clean up.
+  if (wlan_connection_attributes != NULL) {
+    WlanFreeMemory_function_(wlan_connection_attributes);
+  }
+
+  if (bss_list != NULL) {
+    WlanFreeMemory_function_(bss_list);
+  }
+
+  return frequency;
+}
+
+WiFiService::Frequency WiFiServiceImpl::GetFrequencyToConnect(
+    const std::string& network_guid) const {
+  // Check whether desired frequency is set in |connect_properties_|.
+  const DictionaryValue* properties;
+  const DictionaryValue* wifi;
+  int frequency;
+  if (connect_properties_.GetDictionaryWithoutPathExpansion(
+          network_guid, &properties) &&
+      properties->GetDictionary(onc::network_type::kWiFi, &wifi) &&
+      wifi->GetInteger(onc::wifi::kFrequency, &frequency)) {
+    return GetNormalizedFrequency(frequency);
+  }
+  return kFrequencyAny;
+}
+
 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,
+                                          &ssid,
+                                          dot11_BSS_type_infrastructure,
                                           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;
-
+      bss_frequency = GetNormalizedFrequency(
+          bss_entry.ulChCenterFrequency / 1000);
       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);
       DVLOG(1) << "Quality: " << best_quality << " BSS: "
           << NetworkProperties::MacAddressAsString(bss_entry.dot11Bssid);
     } else {
       error = ERROR_NOT_FOUND;
     }
   }
 
-  // clean up
+  // Clean up.
   if (bss_list != NULL) {
     WlanFreeMemory_function_(bss_list);
   }
   return error;
 }
 
+WiFiService::Frequency WiFiServiceImpl::GetNormalizedFrequency(
+    int frequency_in_mhz) const {
+  if (frequency_in_mhz == 0)
+    return kFrequencyAny;
+  if (frequency_in_mhz < 3000)
+    return kFrequency2400;
+  return kFrequency5000;
+}
 
 DWORD WiFiServiceImpl::Connect(const std::string& network_guid,
                                Frequency frequency) {
   if (client_ == NULL) {
     NOTREACHED();
     return ERROR_NOINTERFACE;
   }
 
   DWORD error = ERROR_SUCCESS;
   DOT11_SSID ssid = SSIDFromGUID(network_guid);
@@ skipping 80 matching lines @@
                                    &interface_guid_,
                                    profile_name.c_str(),
                                    NULL,
                                    &str_profile_xml,
                                    NULL,
                                    NULL);
 
   if (error == ERROR_SUCCESS && str_profile_xml != NULL) {
     *profile_xml = base::UTF16ToUTF8(str_profile_xml);
   }
-  // clean up
+  // Clean up.
   if (str_profile_xml != NULL) {
     WlanFreeMemory_function_(str_profile_xml);
   }
 
   return error;
 }
 
 bool WiFiServiceImpl::HaveProfile(const std::string& network_guid) {
   DWORD error = ERROR_SUCCESS;
   std::string profile_xml;
@@ skipping 22 matching lines @@
     NetworkGuidList changed_networks(1, network_guid);
     message_loop_proxy_->PostTask(
         FROM_HERE,
         base::Bind(networks_changed_observer_, changed_networks));
   }
 }
 
 WiFiService* WiFiService::Create() { return new WiFiServiceImpl(); }
 
 }  // namespace wifi