Cast: Allow extension to control wifi options on windows

net/base/net_util_win.cc

 // Copyright (c) 2012 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 "net/base/net_util.h"
 
 #include <iphlpapi.h>
 #include <wlanapi.h>
 
 #include <algorithm>
 
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
+#include "base/memory/lifetime_interface.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 #include "net/base/escape.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
 struct WlanApi {
   typedef DWORD (WINAPI *WlanOpenHandleFunc)(
       DWORD, VOID*, DWORD*, HANDLE*);
   typedef DWORD (WINAPI *WlanEnumInterfacesFunc)(
       HANDLE, VOID*, WLAN_INTERFACE_INFO_LIST**);
   typedef DWORD (WINAPI *WlanQueryInterfaceFunc)(
       HANDLE, const GUID*, WLAN_INTF_OPCODE, VOID*, DWORD*, VOID**,
       WLAN_OPCODE_VALUE_TYPE*);
+  typedef DWORD (WINAPI *WlanSetInterfaceFunc)(
+      HANDLE, const GUID*, WLAN_INTF_OPCODE, DWORD, const VOID*, VOID*);
   typedef VOID (WINAPI *WlanFreeMemoryFunc)(VOID*);
   typedef DWORD (WINAPI *WlanCloseHandleFunc)(HANDLE, VOID*);
 
   WlanApi() : initialized(false) {
     // Use an absolute path to load the DLL to avoid DLL preloading attacks.
     static const wchar_t* const kDLL = L"%WINDIR%\\system32\\wlanapi.dll";
     wchar_t path[MAX_PATH] = {0};
     ExpandEnvironmentStrings(kDLL, path, arraysize(path));
     module = ::LoadLibraryEx(path, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
     if (!module)
       return;
 
     open_handle_func = reinterpret_cast<WlanOpenHandleFunc>(
         ::GetProcAddress(module, "WlanOpenHandle"));
     enum_interfaces_func = reinterpret_cast<WlanEnumInterfacesFunc>(
         ::GetProcAddress(module, "WlanEnumInterfaces"));
     query_interface_func = reinterpret_cast<WlanQueryInterfaceFunc>(
         ::GetProcAddress(module, "WlanQueryInterface"));
+    set_interface_func = reinterpret_cast<WlanSetInterfaceFunc>(
+        ::GetProcAddress(module, "WlanSetInterface"));
     free_memory_func = reinterpret_cast<WlanFreeMemoryFunc>(
         ::GetProcAddress(module, "WlanFreeMemory"));
     close_handle_func = reinterpret_cast<WlanCloseHandleFunc>(
         ::GetProcAddress(module, "WlanCloseHandle"));
     initialized = open_handle_func && enum_interfaces_func &&
                   query_interface_func && free_memory_func &&
                   close_handle_func;
   }
 
   template <typename T>
   DWORD OpenHandle(DWORD client_version, DWORD* cur_version, T* handle) const {
     HANDLE temp_handle;
     DWORD result = open_handle_func(client_version, NULL, cur_version,
                                     &temp_handle);
     if (result != ERROR_SUCCESS)
       return result;
     handle->Set(temp_handle);
     return ERROR_SUCCESS;
   }
 
   HMODULE module;
   WlanOpenHandleFunc open_handle_func;
   WlanEnumInterfacesFunc enum_interfaces_func;
   WlanQueryInterfaceFunc query_interface_func;
+  WlanSetInterfaceFunc set_interface_func;
   WlanFreeMemoryFunc free_memory_func;
   WlanCloseHandleFunc close_handle_func;
   bool initialized;
 };
 
 // Converts Windows defined types to NetworkInterfaceType.
 NetworkChangeNotifier::ConnectionType GetNetworkInterfaceType(DWORD ifType) {
   // Bail out for pre-Vista versions of Windows which are documented to give
   // inaccurate results like returning Ethernet for WiFi.
   // http://msdn.microsoft.com/en-us/library/windows/desktop/aa366058.aspx
@@ skipping 117 matching lines @@
       }
     }
   }
 
   if (ipv6_address.get()) {
     networks->push_back(*(ipv6_address.get()));
   }
   return true;
 }
 
-WifiPHYLayerProtocol GetWifiPHYLayerProtocol() {
-  static base::LazyInstance<WlanApi>::Leaky lazy_wlanapi =
-      LAZY_INSTANCE_INITIALIZER;
+namespace {

[pauljensen, 2014/09/16 15:01:18]

I think moving this up into the anonymous namespace at the top of the file might
be cleaner.

[hubbe, 2014/09/16 21:06:50]

Done.

+base::LazyInstance<WlanApi>::Leaky lazy_wlanapi =
+  LAZY_INSTANCE_INITIALIZER;
 
   struct WlanApiHandleTraits {
     typedef HANDLE Handle;
 
     static bool CloseHandle(HANDLE handle) {
       return lazy_wlanapi.Get().close_handle_func(handle, NULL) ==
           ERROR_SUCCESS;
     }
     static bool IsHandleValid(HANDLE handle) {
       return base::win::HandleTraits::IsHandleValid(handle);
     }
     static HANDLE NullHandle() {
       return base::win::HandleTraits::NullHandle();
     }
   };
 
   typedef base::win::GenericScopedHandle<
       WlanApiHandleTraits,
       base::win::DummyVerifierTraits> WlanHandle;
 
   struct WlanApiDeleter {
     inline void operator()(void* ptr) const {
       lazy_wlanapi.Get().free_memory_func(ptr);
     }
   };
+};

[pauljensen, 2014/09/16 15:01:18]

// namespace

[hubbe, 2014/09/16 21:06:51]

No longer relevant.

 
+WifiPHYLayerProtocol GetWifiPHYLayerProtocol() {
   const WlanApi& wlanapi = lazy_wlanapi.Get();
   if (!wlanapi.initialized)
     return WIFI_PHY_LAYER_PROTOCOL_NONE;
 
   WlanHandle client;
   DWORD cur_version = 0;
   const DWORD kMaxClientVersion = 2;
   DWORD result = wlanapi.OpenHandle(kMaxClientVersion, &cur_version, &client);
   if (result != ERROR_SUCCESS)
     return WIFI_PHY_LAYER_PROTOCOL_NONE;
@@ skipping 42 matching lines @@
       return WIFI_PHY_LAYER_PROTOCOL_B;
     case dot11_phy_type_erp:
       return WIFI_PHY_LAYER_PROTOCOL_G;
     case dot11_phy_type_ht:
       return WIFI_PHY_LAYER_PROTOCOL_N;
     default:
       return WIFI_PHY_LAYER_PROTOCOL_UNKNOWN;
   }
 }
 
+class WifiOptionSetter : public base::LifetimeInterface {
+ public:
+ WifiOptionSetter(int options) {

[pauljensen, 2014/09/16 15:01:18]

indent

[hubbe, 2014/09/16 21:06:50]

Done (finally configured emacs on my windows box, yay!)

+    const WlanApi& wlanapi = lazy_wlanapi.Get();
+    if (!wlanapi.initialized)
+      return;
+
+    DWORD cur_version = 0;
+    const DWORD kMaxClientVersion = 2;

[pauljensen, 2014/09/16 15:01:18]

Please add a comment about where this 0 and 2 come from and imply.

[hubbe, 2014/09/16 21:06:50]

Gladly, but I don't know. I copied this from line 252

+    DWORD result = wlanapi.OpenHandle(
+        kMaxClientVersion, &cur_version, &client_);
+    if (result != ERROR_SUCCESS)
+      return;
+
+    WLAN_INTERFACE_INFO_LIST* interface_list_ptr = NULL;
+    result = wlanapi.enum_interfaces_func(client_, NULL, &interface_list_ptr);
+    if (result != ERROR_SUCCESS)
+      return;
+    scoped_ptr<WLAN_INTERFACE_INFO_LIST, WlanApiDeleter> interface_list(
+        interface_list_ptr);
+
+    // Assume at most one connected wifi interface.

[pauljensen, 2014/09/16 15:01:18]

"at most one"?  This function appears to loop through all interfaces.  The
comment for SetWifiOptions also says all interfaces.

[hubbe, 2014/09/16 21:06:50]

Oops, removed.

+    WLAN_INTERFACE_INFO* info = NULL;
+    for (unsigned i = 0; i < interface_list->dwNumberOfItems; ++i) {
+      if (options & WIFI_OPTIONS_DISABLE_SCAN) {
+        BOOL data = false;
+        wlanapi.set_interface_func(client_,
+                                   &info->InterfaceGuid,
+                                   wlan_intf_opcode_background_scan_enabled,
+                                   sizeof(data),
+                                   &data,
+                                   NULL);
+      }
+      if (options & WIFI_OPTIONS_MEDIA_STREAMING_MODE) {
+        BOOL data = true;
+        wlanapi.set_interface_func(client_,
+                                   &info->InterfaceGuid,
+                                   wlan_intf_opcode_media_streaming_mode,
+                                   sizeof(data),
+                                   &data,
+                                   NULL);
+      }
+    }
+  }
+

[pauljensen, 2014/09/16 15:01:18]

Maybe I'm missing something, but shouldn't there be a destructor here the resets
these options back?

[hubbe, 2014/09/16 21:06:51]

If I'm reading the documentation correctly, the OS sets these options only as
long as some client wants them. This means that when the client handle is
closed, the options are reset.

I also tested this manually to make sure and added a comment to make it less
confusing.

+private:
+  WlanHandle client_;
+};
+
+scoped_ptr<base::LifetimeInterface> SetWifiOptions(int options) {
+  return scoped_ptr<base::LifetimeInterface>(
+      new WifiOptionSetter(options));
+}
+
 }  // namespace net