[net] Add WifiPhyMode to SystemProfile

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/bind.h"
+#include "base/bind_helpers.h"
 #include "base/file_path.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/scoped_native_library.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/escape.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 
@@ skipping 97 matching lines @@
           std::string name = adapter->AdapterName;
           networks->push_back(NetworkInterface(name, endpoint.address()));
         }
       }
     }
   }
 
   return true;
 }
 
+WifiPhyMode GetWifiPhyMode() {
+  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 VOID (WINAPI *WlanFreeMemoryFunc)(VOID*);
+  typedef DWORD (WINAPI *WlanCloseHandleFunc)(HANDLE, VOID*);
+
+  base::ScopedNativeLibrary wlanapi(
+      FilePath(FILE_PATH_LITERAL("wlanapi.dll")));

[Ryan Sleevi, 2013/02/11 18:32:28]

See rvargas' previous comments re: ScopedNativeLibrary being "wrong", and it
being ok to just open an HMODULE and leak it.

If this is always called on the IO thread, 'static HMODULE ... =
LoadLibrary(...)'. See also his feedback of making sure that the DLL search
paths are explicitly set, to avoid DLL sideloading.

[szym, 2013/02/11 22:51:19]

From my experiments, this takes a while, on WindowsXP T61, the median was ~10ms,
with 99% in the seconds. Perhaps this was because of some overhead of
ScopedNativeLibrary, but I don't think this should ever be called from the IO
thread.

This will almost certainly be called from a worker pool.

Wrapped it up as WlanApi and used LazyInstance::Leaky.

+  WlanOpenHandleFunc open_handle_func = reinterpret_cast<WlanOpenHandleFunc>(
+      wlanapi.GetFunctionPointer("WlanOpenHandle"));
+  WlanEnumInterfacesFunc enum_interfaces_func =
+      reinterpret_cast<WlanEnumInterfacesFunc>(
+          wlanapi.GetFunctionPointer("WlanEnumInterfaces"));
+  WlanQueryInterfaceFunc query_interface_func =
+      reinterpret_cast<WlanQueryInterfaceFunc>(
+          wlanapi.GetFunctionPointer("WlanQueryInterface"));
+  WlanFreeMemoryFunc free_memory_func = reinterpret_cast<WlanFreeMemoryFunc>(
+      wlanapi.GetFunctionPointer("WlanFreeMemory"));
+  WlanCloseHandleFunc close_handle_func =
+      reinterpret_cast<WlanCloseHandleFunc>(
+          wlanapi.GetFunctionPointer("WlanCloseHandle"));
+  if (!(open_handle_func && enum_interfaces_func && query_interface_func &&
+        free_memory_func && close_handle_func)) {
+    return WIFI_PHY_MODE_NONE;
+  }
+
+  HANDLE client = NULL;
+  DWORD cur_version = 0;
+  DWORD result = open_handle_func(2 /* max_client */, NULL, &cur_version,

[Ryan Sleevi, 2013/02/11 18:32:28]

Can you make this a meaningful constant?

const DWORD kMaxVersion = 2;

[szym, 2013/02/11 22:51:19]

Done.

+                                  &client);
+  if (result != ERROR_SUCCESS)
+    return WIFI_PHY_MODE_NONE;
+  base::ScopedClosureRunner close_handle(
+      base::Bind(base::IgnoreResult(close_handle_func), client, (VOID*)NULL));

[Ryan Sleevi, 2013/02/11 18:32:28]

style nit: c-style casts are no good.

Other points: Why are you using a ScopedClosureRunner rather than a scoped_ptr
with a custom deleter?

[szym, 2013/02/11 22:51:19]

I didn't think HANDLE can be scoped_ptr'ed. 

+
+  WLAN_INTERFACE_INFO_LIST* interface_list = NULL;
+  result = enum_interfaces_func(client, NULL, &interface_list);
+  if (result != ERROR_SUCCESS)
+    return WIFI_PHY_MODE_NONE;
+  base::ScopedClosureRunner free_interfaces(
+      base::Bind(free_memory_func, interface_list));

[Ryan Sleevi, 2013/02/11 18:32:28]

same here

+
+  if (interface_list->dwNumberOfItems == 0)
+    return WIFI_PHY_MODE_NONE;
+
+  // Assume one wifi interface.

[Ryan Sleevi, 2013/02/11 18:32:28]

Why?

Should we be treating the results as a collection, similar to the interface
list?

Is it possible to have multiple wifi interfaces - one or more offline, one or
more online? Is it safe/correct to assume that the first interface will always
be online?

I didn't find an answer to these questions in MSDN. EnumInterfaces only remarks
about "Enabled", but that's not necessarily the same.

[szym, 2013/02/11 22:51:19]

Yes. No. But I'd guesstimate this works for >95% of the devices out there.

+  WLAN_INTERFACE_INFO& info = interface_list->InterfaceInfo[0];
+  if (info.isState != wlan_interface_state_connected)
+    return WIFI_PHY_MODE_NONE;
+
+  WLAN_CONNECTION_ATTRIBUTES* conn_info = NULL;
+  DWORD conn_info_size = 0;
+  WLAN_OPCODE_VALUE_TYPE op_code;
+
+  result = query_interface_func(
+      client, &info.InterfaceGuid, wlan_intf_opcode_current_connection, NULL,
+      &conn_info_size, (VOID**)&conn_info, &op_code);

[Ryan Sleevi, 2013/02/11 18:32:28]

style nit: wrong casts

[szym, 2013/02/11 22:51:19]

Done.

+  if (result != ERROR_SUCCESS)
+    return WIFI_PHY_MODE_UNKNOWN;
+  base::ScopedClosureRunner free_conn_info(
+      base::Bind(free_memory_func, conn_info));
+
+  switch (conn_info->wlanAssociationAttributes.dot11PhyType) {
+    case dot11_phy_type_fhss:
+      return WIFI_PHY_MODE_ANCIENT;
+    case dot11_phy_type_dsss:
+      return WIFI_PHY_MODE_B;
+    case dot11_phy_type_irbaseband:
+      return WIFI_PHY_MODE_ANCIENT;
+    case dot11_phy_type_ofdm:
+      return WIFI_PHY_MODE_A;
+    case dot11_phy_type_hrdsss:
+      return WIFI_PHY_MODE_B;
+    case dot11_phy_type_erp:
+      return WIFI_PHY_MODE_G;
+    case dot11_phy_type_ht:
+      return WIFI_PHY_MODE_N;
+    default:
+      return WIFI_PHY_MODE_UNKNOWN;
+  }
+}
+
 }  // namespace net