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