net/base/net_util_win.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/base/net_util.h"
   6
   7 #include <iphlpapi.h>
   8 #include <wlanapi.h>
   9
  10 #include <algorithm>
  11
  12 #include "base/files/file_path.h"
  13 #include "base/lazy_instance.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/strings/string_piece.h"
  16 #include "base/strings/string_util.h"
  17 #include "base/strings/sys_string_conversions.h"
  18 #include "base/strings/utf_string_conversions.h"
  19 #include "base/threading/thread_restrictions.h"
  20 #include "base/win/scoped_handle.h"
  21 #include "base/win/windows_version.h"
  22 #include "net/base/escape.h"
  23 #include "net/base/ip_endpoint.h"
  24 #include "net/base/net_errors.h"
  25 #include "url/gurl.h"
  26
  27 namespace net {
  28
  29 namespace {
  30
  31 struct WlanApi {
  32   typedef DWORD (WINAPI *WlanOpenHandleFunc)(
  33       DWORD, VOID*, DWORD*, HANDLE*);
  34   typedef DWORD (WINAPI *WlanEnumInterfacesFunc)(
  35       HANDLE, VOID*, WLAN_INTERFACE_INFO_LIST**);
  36   typedef DWORD (WINAPI *WlanQueryInterfaceFunc)(
  37       HANDLE, const GUID*, WLAN_INTF_OPCODE, VOID*, DWORD*, VOID**,
  38       WLAN_OPCODE_VALUE_TYPE*);
  39   typedef VOID (WINAPI *WlanFreeMemoryFunc)(VOID*);
  40   typedef DWORD (WINAPI *WlanCloseHandleFunc)(HANDLE, VOID*);
  41
  42   WlanApi() : initialized(false) {
  43     // Use an absolute path to load the DLL to avoid DLL preloading attacks.
  44     static const wchar_t* const kDLL = L"%WINDIR%\\system32\\wlanapi.dll";
  45     wchar_t path[MAX_PATH] = {0};
  46     ExpandEnvironmentStrings(kDLL, path, arraysize(path));
  47     module = ::LoadLibraryEx(path, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
  48     if (!module)
  49       return;
  50
  51     open_handle_func = reinterpret_cast<WlanOpenHandleFunc>(
  52         ::GetProcAddress(module, "WlanOpenHandle"));
  53     enum_interfaces_func = reinterpret_cast<WlanEnumInterfacesFunc>(
  54         ::GetProcAddress(module, "WlanEnumInterfaces"));
  55     query_interface_func = reinterpret_cast<WlanQueryInterfaceFunc>(
  56         ::GetProcAddress(module, "WlanQueryInterface"));
  57     free_memory_func = reinterpret_cast<WlanFreeMemoryFunc>(
  58         ::GetProcAddress(module, "WlanFreeMemory"));
  59     close_handle_func = reinterpret_cast<WlanCloseHandleFunc>(
  60         ::GetProcAddress(module, "WlanCloseHandle"));
  61     initialized = open_handle_func && enum_interfaces_func &&
  62                   query_interface_func && free_memory_func &&
  63                   close_handle_func;
  64   }
  65
  66   template <typename T>
  67   DWORD OpenHandle(DWORD client_version, DWORD* cur_version, T* handle) const {
  68     HANDLE temp_handle;
  69     DWORD result = open_handle_func(client_version, NULL, cur_version,
  70                                     &temp_handle);
  71     if (result != ERROR_SUCCESS)
  72       return result;
  73     handle->Set(temp_handle);
  74     return ERROR_SUCCESS;
  75   }
  76
  77   HMODULE module;
  78   WlanOpenHandleFunc open_handle_func;
  79   WlanEnumInterfacesFunc enum_interfaces_func;
  80   WlanQueryInterfaceFunc query_interface_func;
  81   WlanFreeMemoryFunc free_memory_func;
  82   WlanCloseHandleFunc close_handle_func;
  83   bool initialized;
  84 };
  85
  86 // Converts Windows defined types to NetworkInterfaceType.
  87 NetworkChangeNotifier::ConnectionType GetNetworkInterfaceType(DWORD ifType) {
  88   // Bail out for pre-Vista versions of Windows which are documented to give
  89   // inaccurate results like returning Ethernet for WiFi.
  90   // http://msdn.microsoft.com/en-us/library/windows/desktop/aa366058.aspx
  91   if (base::win::GetVersion() < base::win::VERSION_VISTA)
  92     return NetworkChangeNotifier::CONNECTION_UNKNOWN;
  93
  94   NetworkChangeNotifier::ConnectionType type =
  95       NetworkChangeNotifier::CONNECTION_UNKNOWN;
  96   if (ifType == IF_TYPE_ETHERNET_CSMACD) {
  97     type = NetworkChangeNotifier::CONNECTION_ETHERNET;
  98   } else if (ifType == IF_TYPE_IEEE80211) {
  99     type = NetworkChangeNotifier::CONNECTION_WIFI;
 100   }
 101   // TODO(mallinath) - Cellular?
 102   return type;
 103 }
 104
 105 }  // namespace
 106
 107 bool GetNetworkList(NetworkInterfaceList* networks, int policy) {
 108   // GetAdaptersAddresses() may require IO operations.
 109   base::ThreadRestrictions::AssertIOAllowed();
 110   bool is_xp = base::win::GetVersion() < base::win::VERSION_VISTA;
 111   ULONG len = 0;
 112   ULONG flags = is_xp ? GAA_FLAG_INCLUDE_PREFIX : 0;
 113   // First get number of networks.
 114   ULONG result = GetAdaptersAddresses(AF_UNSPEC, flags, NULL, NULL, &len);
 115   if (result != ERROR_BUFFER_OVERFLOW) {
 116     // There are 0 networks.
 117     return true;
 118   }
 119   scoped_ptr<char[]> buf(new char[len]);
 120   IP_ADAPTER_ADDRESSES *adapters =
 121       reinterpret_cast<IP_ADAPTER_ADDRESSES *>(buf.get());
 122   result = GetAdaptersAddresses(AF_UNSPEC, flags, NULL, adapters, &len);
 123   if (result != NO_ERROR) {
 124     LOG(ERROR) << "GetAdaptersAddresses failed: " << result;
 125     return false;
 126   }
 127
 128   // These two variables are used below when this method is asked to pick a
 129   // IPv6 address which has the shortest lifetime.
 130   ULONG ipv6_valid_lifetime = 0;
 131   scoped_ptr<NetworkInterface> ipv6_address;
 132
 133   for (IP_ADAPTER_ADDRESSES *adapter = adapters; adapter != NULL;
 134        adapter = adapter->Next) {
 135     // Ignore the loopback device.
 136     if (adapter->IfType == IF_TYPE_SOFTWARE_LOOPBACK) {
 137       continue;
 138     }
 139
 140     if (adapter->OperStatus != IfOperStatusUp) {
 141       continue;
 142     }
 143
 144     // Ignore any HOST side vmware adapters with a description like:
 145     // VMware Virtual Ethernet Adapter for VMnet1
 146     // but don't ignore any GUEST side adapters with a description like:
 147     // VMware Accelerated AMD PCNet Adapter #2
 148     if (policy == EXCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES &&
 149         strstr(adapter->AdapterName, "VMnet") != NULL) {
 150       continue;
 151     }
 152
 153     for (IP_ADAPTER_UNICAST_ADDRESS* address = adapter->FirstUnicastAddress;
 154          address; address = address->Next) {
 155       int family = address->Address.lpSockaddr->sa_family;
 156       if (family == AF_INET || family == AF_INET6) {
 157         IPEndPoint endpoint;
 158         if (endpoint.FromSockAddr(address->Address.lpSockaddr,
 159                                   address->Address.iSockaddrLength)) {
 160           // XP has no OnLinkPrefixLength field.
 161           size_t net_prefix = is_xp ? 0 : address->OnLinkPrefixLength;
 162           if (is_xp) {
 163             // Prior to Windows Vista the FirstPrefix pointed to the list with
 164             // single prefix for each IP address assigned to the adapter.
 165             // Order of FirstPrefix does not match order of FirstUnicastAddress,
 166             // so we need to find corresponding prefix.
 167             for (IP_ADAPTER_PREFIX* prefix = adapter->FirstPrefix; prefix;
 168                  prefix = prefix->Next) {
 169               int prefix_family = prefix->Address.lpSockaddr->sa_family;
 170               IPEndPoint network_endpoint;
 171               if (prefix_family == family &&
 172                   network_endpoint.FromSockAddr(prefix->Address.lpSockaddr,
 173                       prefix->Address.iSockaddrLength) &&
 174                   IPNumberMatchesPrefix(endpoint.address(),
 175                                         network_endpoint.address(),
 176                                         prefix->PrefixLength)) {
 177                 net_prefix = std::max<size_t>(net_prefix, prefix->PrefixLength);
 178               }
 179             }
 180           }
 181           uint32 index =
 182               (family == AF_INET) ? adapter->IfIndex : adapter->Ipv6IfIndex;
 183           // Pick one IPv6 address with least valid lifetime.
 184           // The reason we are checking |ValidLifeftime| as there is no other
 185           // way identifying the interface type. Usually (and most likely) temp
 186           // IPv6 will have a shorter ValidLifetime value then the permanent
 187           // interface.
 188           if (family == AF_INET6 &&
 189               (policy & INCLUDE_ONLY_TEMP_IPV6_ADDRESS_IF_POSSIBLE)) {
 190             if (ipv6_valid_lifetime == 0 ||
 191                 ipv6_valid_lifetime > address->ValidLifetime) {
 192               ipv6_valid_lifetime = address->ValidLifetime;
 193               ipv6_address.reset(new NetworkInterface(adapter->AdapterName,
 194                                  base::SysWideToNativeMB(adapter->FriendlyName),
 195                                  index,
 196                                  GetNetworkInterfaceType(adapter->IfType),
 197                                  endpoint.address(),
 198                                  net_prefix));
 199               continue;
 200             }
 201           }
 202           networks->push_back(
 203               NetworkInterface(adapter->AdapterName,
 204                                base::SysWideToNativeMB(adapter->FriendlyName),
 205                                index, GetNetworkInterfaceType(adapter->IfType),
 206                                endpoint.address(), net_prefix));
 207         }
 208       }
 209     }
 210   }
 211
 212   if (ipv6_address.get()) {
 213     networks->push_back(*(ipv6_address.get()));
 214   }
 215   return true;
 216 }
 217
 218 WifiPHYLayerProtocol GetWifiPHYLayerProtocol() {
 219   static base::LazyInstance<WlanApi>::Leaky lazy_wlanapi =
 220       LAZY_INSTANCE_INITIALIZER;
 221
 222   struct WlanApiHandleTraits {
 223     typedef HANDLE Handle;
 224
 225     static bool CloseHandle(HANDLE handle) {
 226       return lazy_wlanapi.Get().close_handle_func(handle, NULL) ==
 227           ERROR_SUCCESS;
 228     }
 229     static bool IsHandleValid(HANDLE handle) {
 230       return base::win::HandleTraits::IsHandleValid(handle);
 231     }
 232     static HANDLE NullHandle() {
 233       return base::win::HandleTraits::NullHandle();
 234     }
 235   };
 236
 237   typedef base::win::GenericScopedHandle<
 238       WlanApiHandleTraits,
 239       base::win::DummyVerifierTraits> WlanHandle;
 240
 241   struct WlanApiDeleter {
 242     inline void operator()(void* ptr) const {
 243       lazy_wlanapi.Get().free_memory_func(ptr);
 244     }
 245   };
 246
 247   const WlanApi& wlanapi = lazy_wlanapi.Get();
 248   if (!wlanapi.initialized)
 249     return WIFI_PHY_LAYER_PROTOCOL_NONE;
 250
 251   WlanHandle client;
 252   DWORD cur_version = 0;
 253   const DWORD kMaxClientVersion = 2;
 254   DWORD result = wlanapi.OpenHandle(kMaxClientVersion, &cur_version, &client);
 255   if (result != ERROR_SUCCESS)
 256     return WIFI_PHY_LAYER_PROTOCOL_NONE;
 257
 258   WLAN_INTERFACE_INFO_LIST* interface_list_ptr = NULL;
 259   result = wlanapi.enum_interfaces_func(client, NULL, &interface_list_ptr);
 260   if (result != ERROR_SUCCESS)
 261     return WIFI_PHY_LAYER_PROTOCOL_NONE;
 262   scoped_ptr<WLAN_INTERFACE_INFO_LIST, WlanApiDeleter> interface_list(
 263       interface_list_ptr);
 264
 265   // Assume at most one connected wifi interface.
 266   WLAN_INTERFACE_INFO* info = NULL;
 267   for (unsigned i = 0; i < interface_list->dwNumberOfItems; ++i) {
 268     if (interface_list->InterfaceInfo[i].isState ==
 269         wlan_interface_state_connected) {
 270       info = &interface_list->InterfaceInfo[i];
 271       break;
 272     }
 273   }
 274
 275   if (info == NULL)
 276     return WIFI_PHY_LAYER_PROTOCOL_NONE;
 277
 278   WLAN_CONNECTION_ATTRIBUTES* conn_info_ptr;
 279   DWORD conn_info_size = 0;
 280   WLAN_OPCODE_VALUE_TYPE op_code;
 281   result = wlanapi.query_interface_func(
 282       client, &info->InterfaceGuid, wlan_intf_opcode_current_connection, NULL,
 283       &conn_info_size, reinterpret_cast<VOID**>(&conn_info_ptr), &op_code);
 284   if (result != ERROR_SUCCESS)
 285     return WIFI_PHY_LAYER_PROTOCOL_UNKNOWN;
 286   scoped_ptr<WLAN_CONNECTION_ATTRIBUTES, WlanApiDeleter> conn_info(
 287       conn_info_ptr);
 288
 289   switch (conn_info->wlanAssociationAttributes.dot11PhyType) {
 290     case dot11_phy_type_fhss:
 291       return WIFI_PHY_LAYER_PROTOCOL_ANCIENT;
 292     case dot11_phy_type_dsss:
 293       return WIFI_PHY_LAYER_PROTOCOL_B;
 294     case dot11_phy_type_irbaseband:
 295       return WIFI_PHY_LAYER_PROTOCOL_ANCIENT;
 296     case dot11_phy_type_ofdm:
 297       return WIFI_PHY_LAYER_PROTOCOL_A;
 298     case dot11_phy_type_hrdsss:
 299       return WIFI_PHY_LAYER_PROTOCOL_B;
 300     case dot11_phy_type_erp:
 301       return WIFI_PHY_LAYER_PROTOCOL_G;
 302     case dot11_phy_type_ht:
 303       return WIFI_PHY_LAYER_PROTOCOL_N;
 304     default:
 305       return WIFI_PHY_LAYER_PROTOCOL_UNKNOWN;
 306   }
 307 }
 308
 309 }  // namespace net