Windows-specific implementation of Networking Private API.

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>
+
+#include "base/base_paths_win.h"
+#include "base/bind.h"
+#include "base/files/file_path.h"
+#include "base/memory/ref_counted.h"
+#include "base/message_loop/message_loop.h"
+#include "base/path_service.h"
+#include "base/strings/string16.h"
+#include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/win/registry.h"
+#include "components/onc/onc_constants.h"
+
+namespace {
+const char kWiFiServiceError[] = "Error.WiFiService";
+const wchar_t kNwCategoryWizardRegKey[] =
+    L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Network\\"
+    L"NwCategoryWizard";
+const wchar_t kNwCategoryWizardRegValue[] = L"Show";
+const wchar_t kWlanApiDll[] = L"wlanapi.dll";
+const char kWlanGetNetworkBssList[] = "WlanGetNetworkBssList";
+}  // namespace
+
+namespace wifi {
+
+// Implementation of WiFiService for Windows.
+class WiFiServiceImpl : public WiFiService, base::NonThreadSafe {
+ public:
+  WiFiServiceImpl();
+  virtual ~WiFiServiceImpl();
+
+  // WiFiService interface implementation.
+
+  virtual void GetProperties(const std::string& network_guid,
+                             const NetworkPropertiesCallback& callback,
+                             const ErrorCallback& error_callback) OVERRIDE;
+
+  virtual void GetState(const std::string& network_guid,
+                        const NetworkPropertiesCallback& callback,
+                        const ErrorCallback& error_callback) OVERRIDE;
+
+  virtual void GetManagedProperties(
+      const std::string& network_guid,
+      const DictionaryResultCallback& callback,
+      const ErrorCallback& error_callback) OVERRIDE;
+
+  virtual void SetProperties(const std::string& network_guid,
+                             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,
+                            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;
+
+  virtual void SetNetworkListChangedObserver(
+      const NetworkGuidListCallback& observer) OVERRIDE;
+
+ private:
+  // Static callback for Windows WLAN_NOTIFICATION. Calls OnWlanNotification
+  // on WiFiServiceImpl passed back as |context|.
+  static void __stdcall OnWlanNotificationCallback(
+      PWLAN_NOTIFICATION_DATA wlan_notification_data,
+      PVOID context);
+
+  // Callback for Windows WLAN_NOTIFICATION. Called on random thread from
+  // OnWlanNotificationCallback. Handles network connectivity and scan complete
+  // notification and posts tasks to main thread.
+  void OnWlanNotification(PWLAN_NOTIFICATION_DATA wlan_notification_data);
+
+  // Handles NetworkScanComplete notification on main thread. Sends
+  // |NetworkListChanged| event with new list of visible networks.
+  void OnNetworkScanCompleteOnMainThread();
+
+  // Wait up to |kMaxAttempts| with |kAttemptDelayMs| delay for connection
+  // to network with |network_guid|. Reset DHCP and Notify that |NetworkChanged|
+  // upon success.
+  void WaitForNetworkConnect(const std::string& network_guid, int attempt);
+
+  // Check |error_code| and if is not |ERROR_SUCCESS|, then run |error_callback|
+  // with |error_name|.
+  bool CheckError(const ErrorCallback& error_callback,
+                  const std::string& error_name,
+                  DWORD error_code) const;
+
+  // Return |iterator| to network identified by |network_guid| in |networks|
+  // list.
+  NetworkList::iterator FindNetwork(NetworkList& networks,
+                                    const std::string& network_guid);
+
+  // Save currently connected network profile and return its
+  // |connected_network_guid|, so it can be re-connected later.
+  DWORD SaveCurrentConnectedNetwork(std::string* connected_network_guid);
+
+  // Sort networks, so connected/connecting is up front, then by type:
+  // Ethernet, WiFi, Cellular, VPN
+  static void SortNetworks(NetworkList* networks);
+
+  // Open a WLAN client handle, register for WLAN notifications.
+  DWORD OpenClientHandle();
+
+  // Reset DHCP on wireless network to work around an issue when Windows
+  // takes forever to connect to the network, e.g. after Chromecast
+  // device reset.
+  DWORD ResetDHCP();
+
+  // Find |adapter_index_map| by |interface_guid| for DHCP reset.
+  DWORD FindAdapterIndexMapByGUID(const GUID& interface_guid,
+                                  IP_ADAPTER_INDEX_MAP* adapter_index_map);
+
+  // Avoid the network location wizard to pop up when network is connected.
+  // Preserve current value in |saved_nw_category_wizard_|.
+  DWORD DisableNwCategoryWizard();
+
+  // Restore network location wizard to value saved by DisableNwCategoryWizard.
+  DWORD RestoreNwCategoryWizard();
+
+  // Ensure that |client_| handle is initialized.
+  DWORD EnsureInitialized();
+
+  // Close |client_| handle if it is open.
+  DWORD CloseClientHandle();
+
+  // Get |profile_name| from unique |network_guid|.
+  base::string16 ProfileNameFromGUID(const std::string& network_guid) const {
+    return base::UTF8ToUTF16(network_guid);
+  }
+
+  // Get |dot11_ssid| from unique |network_guid|.
+  DOT11_SSID SSIDFromGUID(const std::string& network_guid) const;
+
+  // Get unique |network_guid| string based on |dot11_ssid|.
+  std::string GUIDFromSSID(const DOT11_SSID& dot11_ssid) const {
+    return std::string(reinterpret_cast<const char*>(dot11_ssid.ucSSID),
+                       dot11_ssid.uSSIDLength);
+  }
+
+  // Get network |ssid| string based on |wlan|.
+  std::string SSIDFromWLAN(const WLAN_AVAILABLE_NETWORK& wlan) const {
+    return GUIDFromSSID(wlan.dot11Ssid);
+  }
+
+  // Get unique |network_guid| string based on |wlan|.
+  std::string GUIDFromWLAN(const WLAN_AVAILABLE_NETWORK& wlan) const {
+    return SSIDFromWLAN(wlan);
+  }
+
+  // Deduce |onc::wifi| security from |alg|.
+  std::string SecurityFromDot11AuthAlg(DOT11_AUTH_ALGORITHM alg) const;
+
+  // Populate |properties| based on |wlan| and its corresponding bss info from
+  // |wlan_bss_list|.
+  void NetworkPropertiesFromAvailableNetwork(const WLAN_AVAILABLE_NETWORK& wlan,
+                                             const WLAN_BSS_LIST& wlan_bss_list,
+                                             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);
+
+  // Disconnect from currently connected network if any.
+  DWORD Disconnect();
+
+  // 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
+  // changed to |networks|.
+  void NotifyNetworkListChanged(const NetworkList& networks);
+
+  // Notify |networks_changed_observer_| that network |network_guid| status has
+  // changed.
+  void NotifyNetworkChanged(const std::string& network_guid);
+
+  // Load WlanApi.dll from SystemDirectory and get Api function pointers.
+  DWORD LoadWlanLibrary();
+
+  // WlanGetNetworkBssList
+  typedef DWORD (WINAPI* WlanGetNetworkBssListFunction)(
+      HANDLE hClientHandle,
+      const GUID* pInterfaceGuid,
+      const  PDOT11_SSID pDot11Ssid,
+      DOT11_BSS_TYPE dot11BssType,
+      BOOL bSecurityEnabled,
+      PVOID pReserved,
+      PWLAN_BSS_LIST* ppWlanBssList
+  );
+
+  // Instance of WlanApi.dll.
+  HINSTANCE wlan_api_library_;
+  // WlanGetNetworkBssList function may not be avaiable on Windows XP.
+  WlanGetNetworkBssListFunction WlanGetNetworkBssList_function_;

[Jói, 2013/10/25 11:09:42]

You need to manually bind all of the functions that you're going to use from
WlanApi.dll and not link to it in any way, only load it explicitly via
LoadLibrary(Ex).

See e.g. content/browser/geolocation/wifi_data_provider_win.cc which does this
for the same library.

You may want to make the function pointers global (or static) rather than
instance variables, in case you expect there to be more than one instance of
WifiService during the lifetime of the program, to avoid unnecessary multiple
initialization.

[mef, 2013/10/25 15:09:05]

Done.

+  // 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_;
+  // 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_;
+  // Task runner to post tasks on main thread.
+  scoped_refptr<base::TaskRunner> task_runner_;
+  // If |false|, then |networks_changed_observer_| is not notified.
+  bool enable_notify_network_changed_;
+  // Number of attempts to check that network has connected successfully.
+  static const int kMaxAttempts = 100;
+  // Delay between attempts to check that network has connected successfully.
+  static const int kAttemptDelayMs = 100;
+
+  DISALLOW_COPY_AND_ASSIGN(WiFiServiceImpl);
+};
+
+WiFiServiceImpl::WiFiServiceImpl()
+    : wlan_api_library_(NULL),
+      WlanGetNetworkBssList_function_(NULL),
+      client_(NULL),
+      enable_notify_network_changed_(true) {}
+
+WiFiServiceImpl::~WiFiServiceImpl() { CloseClientHandle(); }
+
+void WiFiServiceImpl::GetProperties(const std::string& network_guid,
+                                    const NetworkPropertiesCallback& callback,
+                                    const ErrorCallback& error_callback) {
+  DWORD error = EnsureInitialized();

[cpu_(ooo_6.6-7.5), 2013/10/25 16:51:09]

shouldn't be an Initialize method that the client needs to call instead of
peppering EnsureInitialized() everywhere?

[mef, 2013/10/25 18:00:38]

Sounds good, will do.

[mef, 2013/10/25 19:43:17]

Done.

+  if (error == ERROR_SUCCESS) {
+    NetworkList network_list;
+    error = GetVisibleNetworkList(&network_list);
+    if (error == ERROR_SUCCESS && !network_list.empty()) {
+      NetworkList::const_iterator it = FindNetwork(network_list, network_guid);
+      if (it != network_list.end()) {
+        DLOG(INFO) << "Get Properties: " << network_guid << ":"
+                   << it->connection_state;
+        callback.Run(network_guid, *it);
+        return;
+      } else {
+        error = ERROR_NOT_FOUND;
+      }
+    }
+  }
+
+  CheckError(error_callback, kWiFiServiceError, error);
+}
+
+void WiFiServiceImpl::GetState(const std::string& network_guid,
+                               const NetworkPropertiesCallback& callback,
+                               const ErrorCallback& error_callback) {
+  // This method is not implemented in first version as it is not used by
+  // Google Cast extension.
+  CheckError(error_callback, kWiFiServiceError, ERROR_CALL_NOT_IMPLEMENTED);
+}
+
+void WiFiServiceImpl::GetManagedProperties(
+    const std::string& network_guid,
+    const DictionaryResultCallback& callback,
+    const ErrorCallback& error_callback) {
+  // This method is not implemented in first version as it is not used by
+  // Google Cast extension.
+  CheckError(error_callback, kWiFiServiceError, ERROR_CALL_NOT_IMPLEMENTED);
+}
+
+void WiFiServiceImpl::SetProperties(const std::string& network_guid,
+                                    const base::DictionaryValue& properties,
+                                    const StringResultCallback& callback,
+                                    const ErrorCallback& error_callback) {
+  // This method is not implemented in first version as it is not used by
+  // Google Cast extension.
+  CheckError(error_callback, kWiFiServiceError, ERROR_CALL_NOT_IMPLEMENTED);
+}
+
+void WiFiServiceImpl::GetVisibleNetworks(const NetworkListCallback& callback,
+                                         const ErrorCallback& error_callback) {
+  DWORD error = EnsureInitialized();
+
+  if (error == ERROR_SUCCESS) {
+    NetworkList network_list;
+    error = GetVisibleNetworkList(&network_list);
+    if (error == ERROR_SUCCESS && !network_list.empty()) {
+      SortNetworks(&network_list);
+      callback.Run(network_list);
+      return;
+    }
+  }
+
+  CheckError(error_callback, kWiFiServiceError, error);
+}
+
+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,
+                                   const StringResultCallback& callback,
+                                   const ErrorCallback& error_callback) {
+  DLOG(INFO) << "Start Connect: " << network_guid;
+  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);
+      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()) {
+          // 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;
+        }
+      }
+    }
+  }
+  CheckError(error_callback, kWiFiServiceError, error);
+}
+
+void WiFiServiceImpl::StartDisconnect(const std::string& network_guid,
+                                      const StringResultCallback& callback,
+                                      const ErrorCallback& error_callback) {
+  DLOG(INFO) << "Start Disconnect: " << network_guid;
+  DWORD error = EnsureInitialized();
+  if (error == ERROR_SUCCESS) {
+    std::string connected_network_guid;
+    error = SaveCurrentConnectedNetwork(&connected_network_guid);
+    if (error == ERROR_SUCCESS && network_guid == connected_network_guid) {
+      error = Disconnect();
+      if (error == ERROR_SUCCESS) {
+        callback.Run(network_guid);
+        NotifyNetworkChanged(network_guid);
+        return;
+      }
+    }
+  }
+  CheckError(error_callback, kWiFiServiceError, error);
+}
+
+void WiFiServiceImpl::SetNetworksChangedObserver(
+    const NetworkGuidListCallback& observer) {
+  networks_changed_observer_ = observer;
+}
+
+void WiFiServiceImpl::SetNetworkListChangedObserver(
+    const NetworkGuidListCallback& observer) {
+  network_list_changed_observer_ = observer;
+}
+
+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) {
+  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,
+                     base::Unretained(this),
+                     GUIDFromSSID(wlan_connection_data->dot11Ssid)));
+      break;
+    }
+    case wlan_notification_acm_scan_complete:
+      task_runner_->PostTask(
+          FROM_HERE,
+          base::Bind(&WiFiServiceImpl::OnNetworkScanCompleteOnMainThread,
+                     base::Unretained(this)));
+      break;
+  }
+}
+
+void WiFiServiceImpl::OnNetworkScanCompleteOnMainThread() {
+  NetworkList networks;
+  // Get current list of visible networks and notify that network list has
+  // changed.
+  DWORD error = GetVisibleNetworkList(&networks);
+  DCHECK(error == ERROR_SUCCESS);
+  if (error == ERROR_SUCCESS)
+    NotifyNetworkListChanged(networks);
+}
+
+void WiFiServiceImpl::WaitForNetworkConnect(const std::string& network_guid,
+                                            int attempt) {
+  // If network didn't get connected in |kMaxAttempts|, then restore automatic
+  // network change notifications and stop waiting.
+  if (attempt > kMaxAttempts) {
+    DLOG(ERROR) << kMaxAttempts << " attempts exceeded waiting for connect to "
+                << network_guid;
+    enable_notify_network_changed_ = true;
+    RestoreNwCategoryWizard();
+    return;
+  }
+  std::string connected_network_guid;
+  DWORD error = FindConnectedNetwork(&connected_network_guid);
+  if (network_guid == connected_network_guid) {
+    DLOG(INFO) << "WiFi Connected, Reset DHCP: " << network_guid;
+    // Even though wireless network is now connected, it may still be unusable,
+    // e.g. after Chromecast device reset. Reset DHCP on wireless network to
+    // work around this issue.
+    error = ResetDHCP();
+    // Restore previously suppressed notifications.
+    enable_notify_network_changed_ = true;
+    RestoreNwCategoryWizard();
+    NotifyNetworkChanged(network_guid);
+  } else {
+    // Continue waiting for network connection state change.
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&WiFiServiceImpl::WaitForNetworkConnect,
+                   base::Unretained(this),
+                   network_guid,
+                   ++attempt),
+        base::TimeDelta::FromMilliseconds(kAttemptDelayMs));
+  }
+}
+
+bool WiFiServiceImpl::CheckError(const ErrorCallback& error_callback,
+                                 const std::string& error_name,
+                                 DWORD error_code) const {
+  if (error_code != ERROR_SUCCESS) {
+    DLOG(ERROR) << "WiFiService Error " << error_code << ": " << error_name;
+    scoped_ptr<base::DictionaryValue> error_data(new base::DictionaryValue);
+    error_data->SetInteger("Win32ErrorCode", error_code);
+    error_callback.Run(error_name, error_data.Pass());
+    return true;
+  }
+  return false;
+}
+
+WiFiService::NetworkList::iterator WiFiServiceImpl::FindNetwork(
+    NetworkList& networks,
+    const std::string& network_guid) {
+  for (NetworkList::iterator it = networks.begin(); it != networks.end();
+       ++it) {
+    if (it->guid == network_guid)
+      return it;
+  }
+  return networks.end();
+}
+
+DWORD WiFiServiceImpl::SaveCurrentConnectedNetwork(
+    std::string* connected_network_guid) {
+  // Find currently connected network.
+  DWORD error = FindConnectedNetwork(connected_network_guid);
+  if (error == ERROR_SUCCESS && !connected_network_guid->empty()) {
+    if (error == ERROR_SUCCESS) {
+      SaveTempProfile(*connected_network_guid);
+      std::string profile_xml;
+      error = GetProfile(*connected_network_guid, &profile_xml);
+      if (error == ERROR_SUCCESS) {
+        saved_profiles_xml_[*connected_network_guid] = profile_xml;
+      }
+    }
+  }
+  return error;
+}
+
+void WiFiServiceImpl::SortNetworks(NetworkList* networks) {
+  networks->sort(NetworkProperties::OrderByType);
+}
+
+
+DWORD WiFiServiceImpl::LoadWlanLibrary() {
+  // Use an absolute path to load the DLL to avoid DLL preloading attacks.
+  base::FilePath path;
+  if (!PathService::Get(base::DIR_SYSTEM, &path)) {
+    DLOG(ERROR) << "Unable to get system path.";
+    return ERROR_NOT_FOUND;
+  }
+  wlan_api_library_ = ::LoadLibraryEx(path.Append(kWlanApiDll).value().c_str(),
+                                      NULL,
+                                      LOAD_WITH_ALTERED_SEARCH_PATH);
+  if (!wlan_api_library_) {
+    DLOG(ERROR) << "Unable to load WlanApi.dll.";
+    return ERROR_NOT_FOUND;
+  }
+  WlanGetNetworkBssList_function_ =
+      reinterpret_cast<WlanGetNetworkBssListFunction>(
+          ::GetProcAddress(wlan_api_library_, "WlanGetNetworkBssList"));
+  if (!WlanGetNetworkBssList_function_) {
+    DLOG(ERROR) << "Unable to find WlanGetNetworkBssList function.";

[Jói, 2013/10/25 11:09:42]

This is an expected case on XP and as such shouldn't be an ERROR but perhaps a
WARNING or INFO.

[mef, 2013/10/25 15:09:05]

Done.

+    FreeLibrary(wlan_api_library_);
+    wlan_api_library_ = NULL;
+    return ERROR_NOT_FOUND;
+  }
+
+  return ERROR_SUCCESS;
+}
+
+DWORD WiFiServiceImpl::OpenClientHandle() {
+  CloseClientHandle();
+
+  DWORD error = LoadWlanLibrary();
+  DWORD service_version = 0;
+
+  if (error != ERROR_SUCCESS)
+    return error;
+
+  // Open a handle to the service.
+  error = ::WlanOpenHandle(1, NULL, &service_version, &client_);

[cpu_(ooo_6.6-7.5), 2013/10/25 16:51:09]

this does not work on XP sp2, see
https://support.google.com/chrome/answer/95411?hl=en

[mef, 2013/10/25 18:00:38]

Done. I've changed all WlanApi functions to be explicitly resolved at runtime
instead of linking and delay loading the dll.

+
+  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.
+        for (DWORD itf = 0; itf < interface_list->dwNumberOfItems; ++itf) {
+          if (interface_list->InterfaceInfo[itf].isState ==
+              wlan_interface_state_connected) {
+            // Found connected interface, remember it!
+            interface_guid_ = interface_list->InterfaceInfo[itf].InterfaceGuid;
+            break;
+          }
+        }
+        ::WlanRegisterNotification(client_,
+                                   WLAN_NOTIFICATION_SOURCE_ALL,
+                                   FALSE,
+                                   OnWlanNotificationCallback,
+                                   this,
+                                   NULL,
+                                   NULL);
+      } else {
+        error = ERROR_NOINTERFACE;
+      }
+    }
+    // Clean up.
+    if (interface_list != NULL)
+      ::WlanFreeMemory(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) {
+    error = ::IpReleaseAddress(&adapter_index_map);
+    if (error == ERROR_SUCCESS) {
+      error = ::IpRenewAddress(&adapter_index_map);
+    }
+  }
+  return error;
+}
+
+DWORD WiFiServiceImpl::FindAdapterIndexMapByGUID(
+    const GUID& interface_guid,
+    IP_ADAPTER_INDEX_MAP* adapter_index_map) {
+  string16 guid_string;
+  const int kGUIDSize = 39;
+  ::StringFromGUID2(
+      interface_guid, WriteInto(&guid_string, kGUIDSize), kGUIDSize);
+
+  ULONG buffer_length = 0;
+  DWORD error = ::GetInterfaceInfo(NULL, &buffer_length);
+  if (error == ERROR_INSUFFICIENT_BUFFER) {
+    scoped_ptr<unsigned char[]> buffer(new unsigned char[buffer_length]);
+    IP_INTERFACE_INFO* interface_info =
+        reinterpret_cast<IP_INTERFACE_INFO*>(buffer.get());
+    error = GetInterfaceInfo(interface_info, &buffer_length);
+    if (error == ERROR_SUCCESS) {
+      for (int adapter = 0; adapter < interface_info->NumAdapters; ++adapter) {
+        if (EndsWith(
+                interface_info->Adapter[adapter].Name, guid_string, false)) {
+          *adapter_index_map = interface_info->Adapter[adapter];
+          break;
+        }
+      }
+    }
+  }
+  return error;
+}
+
+DWORD WiFiServiceImpl::DisableNwCategoryWizard() {
+  base::win::RegKey nw_category_wizard;
+  DWORD error = nw_category_wizard.Open(HKEY_CURRENT_USER,
+                                        kNwCategoryWizardRegKey,
+                                        KEY_READ | KEY_SET_VALUE);
+  if (error == ERROR_SUCCESS) {
+    // Save current value if present.
+    if (nw_category_wizard.HasValue(kNwCategoryWizardRegValue)) {
+      saved_nw_category_wizard_.reset(new(DWORD));
+      error = nw_category_wizard.ReadValueDW(kNwCategoryWizardRegValue,
+                                             saved_nw_category_wizard_.get());
+    }
+    // Disable network location wizard.
+    error = nw_category_wizard.WriteValue(kNwCategoryWizardRegValue,
+                                          static_cast<DWORD>(0));

[cpu_(ooo_6.6-7.5), 2013/10/25 16:51:09]

what if you crash after setting this? no wizard for the user?

[mef, 2013/10/25 18:00:38]

I guess so. I can preserve it using another value in the same registry key and
restore it if the preserved value is present on startup. 

[mef, 2013/10/25 19:43:17]

Done.

+  }
+
+  return error;
+}
+
+DWORD WiFiServiceImpl::RestoreNwCategoryWizard() {
+  base::win::RegKey nw_category_wizard;
+  DWORD error = nw_category_wizard.Open(HKEY_CURRENT_USER,
+                                        kNwCategoryWizardRegKey,
+                                        KEY_SET_VALUE);
+  if (error == ERROR_SUCCESS) {
+    // Restore saved value if any, or delete value from the key.
+    if (saved_nw_category_wizard_.get()) {
+      error = nw_category_wizard.WriteValue(kNwCategoryWizardRegValue,
+                                            *saved_nw_category_wizard_);
+      saved_nw_category_wizard_.reset();
+    } else {
+      error = nw_category_wizard.DeleteValue(kNwCategoryWizardRegValue);
+    }
+  }
+
+  return error;
+}
+
+DWORD WiFiServiceImpl::EnsureInitialized() {
+  DCHECK(CalledOnValidThread());
+  if (client_ != NULL)
+    return ERROR_SUCCESS;
+  if (task_runner_.get() == NULL)
+    task_runner_ = base::MessageLoopProxy::current();
+
+  return OpenClientHandle();
+}
+
+DWORD WiFiServiceImpl::CloseClientHandle() {
+  DWORD error = ERROR_SUCCESS;
+  if (client_ != NULL) {
+    error = ::WlanCloseHandle(client_, NULL);
+    client_ = NULL;
+  }
+  if (wlan_api_library_ != NULL) {
+    WlanGetNetworkBssList_function_ = NULL;
+    ::FreeLibrary(wlan_api_library_);

[cpu_(ooo_6.6-7.5), 2013/10/25 16:51:09]

If it was me, I would not attempt to unload this dll.

[mef, 2013/10/25 18:00:38]

Sounds good, but could you elaborate on the motivation?

+    wlan_api_library_ = NULL;
+  }
+  return error;
+}
+
+DOT11_SSID WiFiServiceImpl::SSIDFromGUID(
+    const std::string& network_guid) const {
+  DOT11_SSID ssid = {0};
+  if (network_guid.length() <= DOT11_SSID_MAX_LENGTH) {
+    ssid.uSSIDLength = network_guid.length();
+    strncpy(reinterpret_cast<char*>(ssid.ucSSID),
+            network_guid.c_str(),
+            ssid.uSSIDLength);
+  } else {
+    NOTREACHED();
+  }
+  return ssid;
+}
+
+std::string WiFiServiceImpl::SecurityFromDot11AuthAlg(
+    DOT11_AUTH_ALGORITHM alg) const {
+  switch (alg) {
+    case DOT11_AUTH_ALGO_RSNA:
+      return onc::wifi::kWPA_EAP;
+    case DOT11_AUTH_ALGO_RSNA_PSK:
+      return onc::wifi::kWPA_PSK;
+    case DOT11_AUTH_ALGO_80211_SHARED_KEY:
+      return onc::wifi::kWEP_PSK;
+    case DOT11_AUTH_ALGO_80211_OPEN:
+      return onc::wifi::kNone;
+    default:
+      return onc::wifi::kWPA_EAP;
+  }
+}
+
+void WiFiServiceImpl::NetworkPropertiesFromAvailableNetwork(
+    const WLAN_AVAILABLE_NETWORK& wlan,
+    const WLAN_BSS_LIST& wlan_bss_list,
+    NetworkProperties* properties) {
+  if (wlan.dwFlags & WLAN_AVAILABLE_NETWORK_CONNECTED) {
+    properties->connection_state = onc::connection_state::kConnected;
+  } else {
+    properties->connection_state = onc::connection_state::kNotConnected;
+  }
+
+  properties->ssid = SSIDFromWLAN(wlan);
+  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_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;
+}
+
+// Get the list of visible wireless networks
+DWORD WiFiServiceImpl::GetVisibleNetworkList(NetworkList* network_list) {
+  if (client_ == NULL) {
+    NOTREACHED();
+    return ERROR_NOINTERFACE;
+  }
+
+  DWORD error = ERROR_SUCCESS;
+  PWLAN_AVAILABLE_NETWORK_LIST available_network_list = NULL;
+  PWLAN_BSS_LIST bss_list = NULL;
+
+  error = ::WlanGetAvailableNetworkList(
+      client_,
+      &interface_guid_,
+      WLAN_AVAILABLE_NETWORK_INCLUDE_ALL_MANUAL_HIDDEN_PROFILES,
+      NULL,
+      &available_network_list);
+
+  std::set<std::string> network_guids;
+
+  if (error == ERROR_SUCCESS && NULL != available_network_list) {
+    // 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_function_(client_,

[Jói, 2013/10/25 11:09:42]

You shouldn't call this function unless it is available, i.e. NULL-check it
before calling it.

[mef, 2013/10/25 15:09:05]

Done.

+                                            &interface_guid_,
+                                            NULL,
+                                            dot11_BSS_type_any,
+                                            FALSE,
+                                            NULL,
+                                            &bss_list);
+    if (error == ERROR_SUCCESS && NULL != bss_list) {
+      for (DWORD i = 0; i < available_network_list->dwNumberOfItems; ++i) {
+        NetworkProperties network_properties;
+        NetworkPropertiesFromAvailableNetwork(
+            available_network_list->Network[i],
+            *bss_list,
+            &network_properties);
+        // Check for duplicate network guids.
+        if (network_guids.count(network_properties.guid)) {
+          // There should be no difference between properties except for
+          // |connection_state|, so mark it as |kConnected| if either one is.
+          if (network_properties.connection_state ==
+              onc::connection_state::kConnected) {
+            NetworkList::iterator previous_network_properties =
+                FindNetwork(*network_list, network_properties.guid);
+            DCHECK(previous_network_properties != network_list->end());
+            previous_network_properties->connection_state =
+                network_properties.connection_state;
+          }
+        } else {
+          network_list->push_back(network_properties);
+        }
+        network_guids.insert(network_properties.guid);
+      }
+    }
+  }
+
+  // clean up
+  if (available_network_list != NULL) {
+    ::WlanFreeMemory(available_network_list);
+  }
+  if (bss_list != NULL) {
+    ::WlanFreeMemory(bss_list);
+  }
+  return error;
+}
+
+// Find currently connected network.
+DWORD WiFiServiceImpl::FindConnectedNetwork(
+    std::string* connected_network_guid) {
+  if (client_ == NULL) {
+    NOTREACHED();
+    return ERROR_NOINTERFACE;
+  }
+
+  DWORD error = ERROR_SUCCESS;
+  PWLAN_AVAILABLE_NETWORK_LIST available_network_list = NULL;
+  error = ::WlanGetAvailableNetworkList(
+      client_, &interface_guid_, 0, NULL, &available_network_list);
+
+  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
+  if (available_network_list != NULL) {
+    ::WlanFreeMemory(available_network_list);
+  }
+
+  return error;
+}
+
+DWORD WiFiServiceImpl::Connect(const std::string& network_guid) {
+  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);
+  }
+
+  return error;
+}
+
+DWORD WiFiServiceImpl::Disconnect() {
+  if (client_ == NULL) {
+    NOTREACHED();
+    return ERROR_NOINTERFACE;
+  }
+
+  DWORD error = ERROR_SUCCESS;
+  error = ::WlanDisconnect(client_, &interface_guid_, NULL);
+  return error;
+}
+
+DWORD WiFiServiceImpl::SaveTempProfile(const std::string& network_guid) {
+  if (client_ == NULL) {
+    NOTREACHED();
+    return ERROR_NOINTERFACE;
+  }
+
+  DWORD error = ERROR_SUCCESS;
+  base::string16 profile_name = ProfileNameFromGUID(network_guid);
+  // TODO(mef): WlanSaveTemporaryProfile is not available on XP. If XP support
+  // is needed, then different method of saving network profile will have to be
+  // used.
+  error = ::WlanSaveTemporaryProfile(client_,
+                                     &interface_guid_,
+                                     profile_name.c_str(),
+                                     NULL,
+                                     WLAN_PROFILE_USER,
+                                     true,
+                                     NULL);
+  return error;
+}
+
+DWORD WiFiServiceImpl::GetProfile(const std::string& network_guid,
+                                  std::string* profile_xml) {
+  if (client_ == NULL) {
+    NOTREACHED();
+    return ERROR_NOINTERFACE;
+  }
+
+  DWORD error = ERROR_SUCCESS;
+  base::string16 profile_name = ProfileNameFromGUID(network_guid);
+  LPWSTR str_profile_xml = NULL;
+  error = ::WlanGetProfile(client_,
+                           &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
+  if (str_profile_xml != NULL) {
+    ::WlanFreeMemory(str_profile_xml);
+  }
+
+  return error;
+}
+
+bool WiFiServiceImpl::HaveProfile(const std::string& network_guid) {
+  DWORD error = ERROR_SUCCESS;
+  std::string profile_xml;
+  return GetProfile(network_guid, &profile_xml) == ERROR_SUCCESS;
+}
+
+void WiFiServiceImpl::NotifyNetworkListChanged(const NetworkList& networks) {
+  if (network_list_changed_observer_.is_null())
+    return;
+
+  NetworkGuidList current_networks;
+  for (NetworkList::const_iterator it = networks.begin();
+       it != networks.end();
+       ++it) {
+    current_networks.push_back(it->guid);
+  }
+  network_list_changed_observer_.Run(current_networks);
+}
+
+void WiFiServiceImpl::NotifyNetworkChanged(const std::string& network_guid) {
+  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