OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2010 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 // Windows Vista uses the Native Wifi (WLAN) API for accessing WiFi cards. See |
| 6 // http://msdn.microsoft.com/en-us/library/ms705945(VS.85).aspx. Windows XP |
| 7 // Service Pack 3 (and Windows XP Service Pack 2, if upgraded with a hot fix) |
| 8 // also support a limited version of the WLAN API. See |
| 9 // http://msdn.microsoft.com/en-us/library/bb204766.aspx. The WLAN API uses |
| 10 // wlanapi.h, which is not part of the SDK used by Gears, so is replicated |
| 11 // locally using data from the MSDN. |
| 12 // |
| 13 // Windows XP from Service Pack 2 onwards supports the Wireless Zero |
| 14 // Configuration (WZC) programming interface. See |
| 15 // http://msdn.microsoft.com/en-us/library/ms706587(VS.85).aspx. |
| 16 // |
| 17 // The MSDN recommends that one use the WLAN API where available, and WZC |
| 18 // otherwise. |
| 19 // |
| 20 // However, it seems that WZC fails for some wireless cards. Also, WLAN seems |
| 21 // not to work on XP SP3. So we use WLAN on Vista, and use NDIS directly |
| 22 // otherwise. |
| 23 |
| 24 #include "content/browser/geolocation/wifi_data_provider_win.h" |
| 25 |
| 26 #include <windows.h> |
| 27 #include <winioctl.h> |
| 28 #include <wlanapi.h> |
| 29 |
| 30 #include "base/memory/free_deleter.h" |
| 31 #include "base/metrics/histogram.h" |
| 32 #include "base/strings/utf_string_conversions.h" |
| 33 #include "base/win/windows_version.h" |
| 34 #include "content/browser/geolocation/wifi_data_provider_common.h" |
| 35 #include "content/browser/geolocation/wifi_data_provider_common_win.h" |
| 36 #include "content/browser/geolocation/wifi_data_provider_manager.h" |
| 37 |
| 38 // Taken from ndis.h for WinCE. |
| 39 #define NDIS_STATUS_INVALID_LENGTH ((NDIS_STATUS)0xC0010014L) |
| 40 #define NDIS_STATUS_BUFFER_TOO_SHORT ((NDIS_STATUS)0xC0010016L) |
| 41 |
| 42 namespace content { |
| 43 namespace { |
| 44 // The limits on the size of the buffer used for the OID query. |
| 45 const int kInitialBufferSize = 2 << 12; // Good for about 50 APs. |
| 46 const int kMaximumBufferSize = 2 << 20; // 2MB |
| 47 |
| 48 // Length for generic string buffers passed to Windows APIs. |
| 49 const int kStringLength = 512; |
| 50 |
| 51 // The time periods, in milliseconds, between successive polls of the wifi data. |
| 52 const int kDefaultPollingInterval = 10000; // 10s |
| 53 const int kNoChangePollingInterval = 120000; // 2 mins |
| 54 const int kTwoNoChangePollingInterval = 600000; // 10 mins |
| 55 const int kNoWifiPollingIntervalMilliseconds = 20 * 1000; // 20s |
| 56 |
| 57 // WlanOpenHandle |
| 58 typedef DWORD (WINAPI* WlanOpenHandleFunction)(DWORD dwClientVersion, |
| 59 PVOID pReserved, |
| 60 PDWORD pdwNegotiatedVersion, |
| 61 PHANDLE phClientHandle); |
| 62 |
| 63 // WlanEnumInterfaces |
| 64 typedef DWORD (WINAPI* WlanEnumInterfacesFunction)( |
| 65 HANDLE hClientHandle, |
| 66 PVOID pReserved, |
| 67 PWLAN_INTERFACE_INFO_LIST* ppInterfaceList); |
| 68 |
| 69 // WlanGetNetworkBssList |
| 70 typedef DWORD (WINAPI* WlanGetNetworkBssListFunction)( |
| 71 HANDLE hClientHandle, |
| 72 const GUID* pInterfaceGuid, |
| 73 const PDOT11_SSID pDot11Ssid, |
| 74 DOT11_BSS_TYPE dot11BssType, |
| 75 BOOL bSecurityEnabled, |
| 76 PVOID pReserved, |
| 77 PWLAN_BSS_LIST* ppWlanBssList |
| 78 ); |
| 79 |
| 80 // WlanFreeMemory |
| 81 typedef VOID (WINAPI* WlanFreeMemoryFunction)(PVOID pMemory); |
| 82 |
| 83 // WlanCloseHandle |
| 84 typedef DWORD (WINAPI* WlanCloseHandleFunction)(HANDLE hClientHandle, |
| 85 PVOID pReserved); |
| 86 |
| 87 |
| 88 // Local classes and functions |
| 89 class WindowsWlanApi : public WifiDataProviderCommon::WlanApiInterface { |
| 90 public: |
| 91 ~WindowsWlanApi() override; |
| 92 // Factory function. Will return NULL if this API is unavailable. |
| 93 static WindowsWlanApi* Create(); |
| 94 |
| 95 // WlanApiInterface |
| 96 bool GetAccessPointData(WifiData::AccessPointDataSet* data) override; |
| 97 |
| 98 private: |
| 99 // Takes ownership of the library handle. |
| 100 explicit WindowsWlanApi(HINSTANCE library); |
| 101 |
| 102 // Loads the required functions from the DLL. |
| 103 void GetWLANFunctions(HINSTANCE wlan_library); |
| 104 int GetInterfaceDataWLAN(HANDLE wlan_handle, |
| 105 const GUID& interface_id, |
| 106 WifiData::AccessPointDataSet* data); |
| 107 |
| 108 // Logs number of detected wlan interfaces. |
| 109 static void LogWlanInterfaceCount(int count); |
| 110 |
| 111 // Handle to the wlanapi.dll library. |
| 112 HINSTANCE library_; |
| 113 |
| 114 // Function pointers for WLAN |
| 115 WlanOpenHandleFunction WlanOpenHandle_function_; |
| 116 WlanEnumInterfacesFunction WlanEnumInterfaces_function_; |
| 117 WlanGetNetworkBssListFunction WlanGetNetworkBssList_function_; |
| 118 WlanFreeMemoryFunction WlanFreeMemory_function_; |
| 119 WlanCloseHandleFunction WlanCloseHandle_function_; |
| 120 }; |
| 121 |
| 122 class WindowsNdisApi : public WifiDataProviderCommon::WlanApiInterface { |
| 123 public: |
| 124 ~WindowsNdisApi() override; |
| 125 static WindowsNdisApi* Create(); |
| 126 |
| 127 // WlanApiInterface |
| 128 bool GetAccessPointData(WifiData::AccessPointDataSet* data) override; |
| 129 |
| 130 private: |
| 131 static bool GetInterfacesNDIS( |
| 132 std::vector<base::string16>* interface_service_names_out); |
| 133 |
| 134 // Swaps in content of the vector passed |
| 135 explicit WindowsNdisApi(std::vector<base::string16>* interface_service_names); |
| 136 |
| 137 bool GetInterfaceDataNDIS(HANDLE adapter_handle, |
| 138 WifiData::AccessPointDataSet* data); |
| 139 // NDIS variables. |
| 140 std::vector<base::string16> interface_service_names_; |
| 141 |
| 142 // Remembers scan result buffer size across calls. |
| 143 int oid_buffer_size_; |
| 144 }; |
| 145 |
| 146 // Extracts data for an access point and converts to Gears format. |
| 147 bool GetNetworkData(const WLAN_BSS_ENTRY& bss_entry, |
| 148 AccessPointData* access_point_data); |
| 149 bool UndefineDosDevice(const base::string16& device_name); |
| 150 bool DefineDosDeviceIfNotExists(const base::string16& device_name); |
| 151 HANDLE GetFileHandle(const base::string16& device_name); |
| 152 // Makes the OID query and returns a Windows API error code. |
| 153 int PerformQuery(HANDLE adapter_handle, |
| 154 BYTE* buffer, |
| 155 DWORD buffer_size, |
| 156 DWORD* bytes_out); |
| 157 bool ResizeBuffer(int requested_size, |
| 158 std::unique_ptr<BYTE, base::FreeDeleter>* buffer); |
| 159 // Gets the system directory and appends a trailing slash if not already |
| 160 // present. |
| 161 bool GetSystemDirectory(base::string16* path); |
| 162 } // namespace |
| 163 |
| 164 WifiDataProvider* WifiDataProviderManager::DefaultFactoryFunction() { |
| 165 return new WifiDataProviderWin(); |
| 166 } |
| 167 |
| 168 WifiDataProviderWin::WifiDataProviderWin() { |
| 169 } |
| 170 |
| 171 WifiDataProviderWin::~WifiDataProviderWin() { |
| 172 } |
| 173 |
| 174 WifiDataProviderCommon::WlanApiInterface* WifiDataProviderWin::NewWlanApi() { |
| 175 // Use the WLAN interface if we're on Vista and if it's available. Otherwise, |
| 176 // use NDIS. |
| 177 WlanApiInterface* api = WindowsWlanApi::Create(); |
| 178 if (api) { |
| 179 return api; |
| 180 } |
| 181 return WindowsNdisApi::Create(); |
| 182 } |
| 183 |
| 184 WifiPollingPolicy* WifiDataProviderWin::NewPollingPolicy() { |
| 185 return new GenericWifiPollingPolicy<kDefaultPollingInterval, |
| 186 kNoChangePollingInterval, |
| 187 kTwoNoChangePollingInterval, |
| 188 kNoWifiPollingIntervalMilliseconds>; |
| 189 } |
| 190 |
| 191 // Local classes and functions |
| 192 namespace { |
| 193 |
| 194 // WindowsWlanApi |
| 195 WindowsWlanApi::WindowsWlanApi(HINSTANCE library) |
| 196 : library_(library) { |
| 197 GetWLANFunctions(library_); |
| 198 } |
| 199 |
| 200 WindowsWlanApi::~WindowsWlanApi() { |
| 201 FreeLibrary(library_); |
| 202 } |
| 203 |
| 204 WindowsWlanApi* WindowsWlanApi::Create() { |
| 205 if (base::win::GetVersion() < base::win::VERSION_VISTA) |
| 206 return NULL; |
| 207 // We use an absolute path to load the DLL to avoid DLL preloading attacks. |
| 208 base::string16 system_directory; |
| 209 if (!GetSystemDirectory(&system_directory)) { |
| 210 return NULL; |
| 211 } |
| 212 DCHECK(!system_directory.empty()); |
| 213 base::string16 dll_path = system_directory + L"wlanapi.dll"; |
| 214 HINSTANCE library = LoadLibraryEx(dll_path.c_str(), |
| 215 NULL, |
| 216 LOAD_WITH_ALTERED_SEARCH_PATH); |
| 217 if (!library) { |
| 218 return NULL; |
| 219 } |
| 220 return new WindowsWlanApi(library); |
| 221 } |
| 222 |
| 223 void WindowsWlanApi::GetWLANFunctions(HINSTANCE wlan_library) { |
| 224 DCHECK(wlan_library); |
| 225 WlanOpenHandle_function_ = reinterpret_cast<WlanOpenHandleFunction>( |
| 226 GetProcAddress(wlan_library, "WlanOpenHandle")); |
| 227 WlanEnumInterfaces_function_ = reinterpret_cast<WlanEnumInterfacesFunction>( |
| 228 GetProcAddress(wlan_library, "WlanEnumInterfaces")); |
| 229 WlanGetNetworkBssList_function_ = |
| 230 reinterpret_cast<WlanGetNetworkBssListFunction>( |
| 231 GetProcAddress(wlan_library, "WlanGetNetworkBssList")); |
| 232 WlanFreeMemory_function_ = reinterpret_cast<WlanFreeMemoryFunction>( |
| 233 GetProcAddress(wlan_library, "WlanFreeMemory")); |
| 234 WlanCloseHandle_function_ = reinterpret_cast<WlanCloseHandleFunction>( |
| 235 GetProcAddress(wlan_library, "WlanCloseHandle")); |
| 236 DCHECK(WlanOpenHandle_function_ && |
| 237 WlanEnumInterfaces_function_ && |
| 238 WlanGetNetworkBssList_function_ && |
| 239 WlanFreeMemory_function_ && |
| 240 WlanCloseHandle_function_); |
| 241 } |
| 242 |
| 243 void WindowsWlanApi::LogWlanInterfaceCount(int count) { |
| 244 UMA_HISTOGRAM_CUSTOM_COUNTS( |
| 245 "Net.Wifi.InterfaceCount", |
| 246 count, |
| 247 1, |
| 248 5, |
| 249 6); |
| 250 } |
| 251 |
| 252 bool WindowsWlanApi::GetAccessPointData( |
| 253 WifiData::AccessPointDataSet* data) { |
| 254 DCHECK(data); |
| 255 |
| 256 // Get the handle to the WLAN API. |
| 257 DWORD negotiated_version; |
| 258 HANDLE wlan_handle = NULL; |
| 259 // We could be executing on either Windows XP or Windows Vista, so use the |
| 260 // lower version of the client WLAN API. It seems that the negotiated version |
| 261 // is the Vista version irrespective of what we pass! |
| 262 static const int kXpWlanClientVersion = 1; |
| 263 if ((*WlanOpenHandle_function_)(kXpWlanClientVersion, |
| 264 NULL, |
| 265 &negotiated_version, |
| 266 &wlan_handle) != ERROR_SUCCESS) { |
| 267 LogWlanInterfaceCount(0); |
| 268 return false; |
| 269 } |
| 270 DCHECK(wlan_handle); |
| 271 |
| 272 // Get the list of interfaces. WlanEnumInterfaces allocates interface_list. |
| 273 WLAN_INTERFACE_INFO_LIST* interface_list = NULL; |
| 274 if ((*WlanEnumInterfaces_function_)(wlan_handle, NULL, &interface_list) != |
| 275 ERROR_SUCCESS) { |
| 276 LogWlanInterfaceCount(0); |
| 277 return false; |
| 278 } |
| 279 DCHECK(interface_list); |
| 280 |
| 281 LogWlanInterfaceCount(interface_list->dwNumberOfItems); |
| 282 |
| 283 // Go through the list of interfaces and get the data for each. |
| 284 for (int i = 0; i < static_cast<int>(interface_list->dwNumberOfItems); ++i) { |
| 285 // Skip any interface that is midway through association; the |
| 286 // WlanGetNetworkBssList function call is known to hang indefinitely |
| 287 // when it's in this state. http://crbug.com/39300 |
| 288 if (interface_list->InterfaceInfo[i].isState == |
| 289 wlan_interface_state_associating) { |
| 290 LOG(WARNING) << "Skipping wifi scan on adapter " << i << " (" |
| 291 << interface_list->InterfaceInfo[i].strInterfaceDescription |
| 292 << ") in 'associating' state. Repeated occurrences " |
| 293 "indicates a non-responding adapter."; |
| 294 continue; |
| 295 } |
| 296 GetInterfaceDataWLAN(wlan_handle, |
| 297 interface_list->InterfaceInfo[i].InterfaceGuid, |
| 298 data); |
| 299 } |
| 300 |
| 301 // Free interface_list. |
| 302 (*WlanFreeMemory_function_)(interface_list); |
| 303 |
| 304 // Close the handle. |
| 305 if ((*WlanCloseHandle_function_)(wlan_handle, NULL) != ERROR_SUCCESS) { |
| 306 return false; |
| 307 } |
| 308 |
| 309 return true; |
| 310 } |
| 311 |
| 312 // Appends the data for a single interface to the data vector. Returns the |
| 313 // number of access points found, or -1 on error. |
| 314 int WindowsWlanApi::GetInterfaceDataWLAN( |
| 315 const HANDLE wlan_handle, |
| 316 const GUID& interface_id, |
| 317 WifiData::AccessPointDataSet* data) { |
| 318 DCHECK(data); |
| 319 |
| 320 const base::TimeTicks start_time = base::TimeTicks::Now(); |
| 321 |
| 322 // WlanGetNetworkBssList allocates bss_list. |
| 323 WLAN_BSS_LIST* bss_list = NULL; |
| 324 if ((*WlanGetNetworkBssList_function_)(wlan_handle, |
| 325 &interface_id, |
| 326 NULL, // Use all SSIDs. |
| 327 dot11_BSS_type_any, |
| 328 false, // bSecurityEnabled - unused |
| 329 NULL, // reserved |
| 330 &bss_list) != ERROR_SUCCESS) { |
| 331 return -1; |
| 332 } |
| 333 // According to http://www.attnetclient.com/kb/questions.php?questionid=75 |
| 334 // WlanGetNetworkBssList can sometimes return success, but leave the bss |
| 335 // list as NULL. |
| 336 if (!bss_list) |
| 337 return -1; |
| 338 |
| 339 const base::TimeDelta duration = base::TimeTicks::Now() - start_time; |
| 340 |
| 341 UMA_HISTOGRAM_CUSTOM_TIMES( |
| 342 "Net.Wifi.ScanLatency", |
| 343 duration, |
| 344 base::TimeDelta::FromMilliseconds(1), |
| 345 base::TimeDelta::FromMinutes(1), |
| 346 100); |
| 347 |
| 348 |
| 349 int found = 0; |
| 350 for (int i = 0; i < static_cast<int>(bss_list->dwNumberOfItems); ++i) { |
| 351 AccessPointData access_point_data; |
| 352 if (GetNetworkData(bss_list->wlanBssEntries[i], &access_point_data)) { |
| 353 ++found; |
| 354 data->insert(access_point_data); |
| 355 } |
| 356 } |
| 357 |
| 358 (*WlanFreeMemory_function_)(bss_list); |
| 359 |
| 360 return found; |
| 361 } |
| 362 |
| 363 // WindowsNdisApi |
| 364 WindowsNdisApi::WindowsNdisApi( |
| 365 std::vector<base::string16>* interface_service_names) |
| 366 : oid_buffer_size_(kInitialBufferSize) { |
| 367 DCHECK(!interface_service_names->empty()); |
| 368 interface_service_names_.swap(*interface_service_names); |
| 369 } |
| 370 |
| 371 WindowsNdisApi::~WindowsNdisApi() { |
| 372 } |
| 373 |
| 374 WindowsNdisApi* WindowsNdisApi::Create() { |
| 375 std::vector<base::string16> interface_service_names; |
| 376 if (GetInterfacesNDIS(&interface_service_names)) { |
| 377 return new WindowsNdisApi(&interface_service_names); |
| 378 } |
| 379 return NULL; |
| 380 } |
| 381 |
| 382 bool WindowsNdisApi::GetAccessPointData(WifiData::AccessPointDataSet* data) { |
| 383 DCHECK(data); |
| 384 int interfaces_failed = 0; |
| 385 int interfaces_succeeded = 0; |
| 386 |
| 387 for (int i = 0; i < static_cast<int>(interface_service_names_.size()); ++i) { |
| 388 // First, check that we have a DOS device for this adapter. |
| 389 if (!DefineDosDeviceIfNotExists(interface_service_names_[i])) { |
| 390 continue; |
| 391 } |
| 392 |
| 393 // Get the handle to the device. This will fail if the named device is not |
| 394 // valid. |
| 395 HANDLE adapter_handle = GetFileHandle(interface_service_names_[i]); |
| 396 if (adapter_handle == INVALID_HANDLE_VALUE) { |
| 397 continue; |
| 398 } |
| 399 |
| 400 // Get the data. |
| 401 if (GetInterfaceDataNDIS(adapter_handle, data)) { |
| 402 ++interfaces_succeeded; |
| 403 } else { |
| 404 ++interfaces_failed; |
| 405 } |
| 406 |
| 407 // Clean up. |
| 408 CloseHandle(adapter_handle); |
| 409 UndefineDosDevice(interface_service_names_[i]); |
| 410 } |
| 411 |
| 412 // Return true if at least one interface succeeded, or at the very least none |
| 413 // failed. |
| 414 return interfaces_succeeded > 0 || interfaces_failed == 0; |
| 415 } |
| 416 |
| 417 bool WindowsNdisApi::GetInterfacesNDIS( |
| 418 std::vector<base::string16>* interface_service_names_out) { |
| 419 HKEY network_cards_key = NULL; |
| 420 if (RegOpenKeyEx( |
| 421 HKEY_LOCAL_MACHINE, |
| 422 L"Software\\Microsoft\\Windows NT\\CurrentVersion\\NetworkCards", |
| 423 0, |
| 424 KEY_READ, |
| 425 &network_cards_key) != ERROR_SUCCESS) { |
| 426 return false; |
| 427 } |
| 428 DCHECK(network_cards_key); |
| 429 |
| 430 for (int i = 0; ; ++i) { |
| 431 TCHAR name[kStringLength]; |
| 432 DWORD name_size = kStringLength; |
| 433 FILETIME time; |
| 434 if (RegEnumKeyEx(network_cards_key, |
| 435 i, |
| 436 name, |
| 437 &name_size, |
| 438 NULL, |
| 439 NULL, |
| 440 NULL, |
| 441 &time) != ERROR_SUCCESS) { |
| 442 break; |
| 443 } |
| 444 HKEY hardware_key = NULL; |
| 445 if (RegOpenKeyEx(network_cards_key, name, 0, KEY_READ, &hardware_key) != |
| 446 ERROR_SUCCESS) { |
| 447 break; |
| 448 } |
| 449 DCHECK(hardware_key); |
| 450 |
| 451 TCHAR service_name[kStringLength]; |
| 452 DWORD service_name_size = kStringLength; |
| 453 DWORD type = 0; |
| 454 if (RegQueryValueEx(hardware_key, |
| 455 L"ServiceName", |
| 456 NULL, |
| 457 &type, |
| 458 reinterpret_cast<LPBYTE>(service_name), |
| 459 &service_name_size) == ERROR_SUCCESS) { |
| 460 interface_service_names_out->push_back(service_name); |
| 461 } |
| 462 RegCloseKey(hardware_key); |
| 463 } |
| 464 |
| 465 RegCloseKey(network_cards_key); |
| 466 return true; |
| 467 } |
| 468 |
| 469 |
| 470 bool WindowsNdisApi::GetInterfaceDataNDIS(HANDLE adapter_handle, |
| 471 WifiData::AccessPointDataSet* data) { |
| 472 DCHECK(data); |
| 473 |
| 474 std::unique_ptr<BYTE, base::FreeDeleter> buffer( |
| 475 static_cast<BYTE*>(malloc(oid_buffer_size_))); |
| 476 if (buffer == NULL) { |
| 477 return false; |
| 478 } |
| 479 |
| 480 DWORD bytes_out; |
| 481 int result; |
| 482 |
| 483 while (true) { |
| 484 bytes_out = 0; |
| 485 result = PerformQuery(adapter_handle, buffer.get(), |
| 486 oid_buffer_size_, &bytes_out); |
| 487 if (result == ERROR_GEN_FAILURE || // Returned by some Intel cards. |
| 488 result == ERROR_INSUFFICIENT_BUFFER || |
| 489 result == ERROR_MORE_DATA || |
| 490 result == NDIS_STATUS_INVALID_LENGTH || |
| 491 result == NDIS_STATUS_BUFFER_TOO_SHORT) { |
| 492 // The buffer we supplied is too small, so increase it. bytes_out should |
| 493 // provide the required buffer size, but this is not always the case. |
| 494 if (bytes_out > static_cast<DWORD>(oid_buffer_size_)) { |
| 495 oid_buffer_size_ = bytes_out; |
| 496 } else { |
| 497 oid_buffer_size_ *= 2; |
| 498 } |
| 499 if (!ResizeBuffer(oid_buffer_size_, &buffer)) { |
| 500 oid_buffer_size_ = kInitialBufferSize; // Reset for next time. |
| 501 return false; |
| 502 } |
| 503 } else { |
| 504 // The buffer is not too small. |
| 505 break; |
| 506 } |
| 507 } |
| 508 DCHECK(buffer.get()); |
| 509 |
| 510 if (result == ERROR_SUCCESS) { |
| 511 NDIS_802_11_BSSID_LIST* bssid_list = |
| 512 reinterpret_cast<NDIS_802_11_BSSID_LIST*>(buffer.get()); |
| 513 GetDataFromBssIdList(*bssid_list, oid_buffer_size_, data); |
| 514 } |
| 515 |
| 516 return true; |
| 517 } |
| 518 |
| 519 bool GetNetworkData(const WLAN_BSS_ENTRY& bss_entry, |
| 520 AccessPointData* access_point_data) { |
| 521 // Currently we get only MAC address, signal strength and SSID. |
| 522 DCHECK(access_point_data); |
| 523 access_point_data->mac_address = MacAddressAsString16(bss_entry.dot11Bssid); |
| 524 access_point_data->radio_signal_strength = bss_entry.lRssi; |
| 525 // bss_entry.dot11Ssid.ucSSID is not null-terminated. |
| 526 base::UTF8ToUTF16(reinterpret_cast<const char*>(bss_entry.dot11Ssid.ucSSID), |
| 527 static_cast<ULONG>(bss_entry.dot11Ssid.uSSIDLength), |
| 528 &access_point_data->ssid); |
| 529 // TODO(steveblock): Is it possible to get the following? |
| 530 // access_point_data->signal_to_noise |
| 531 // access_point_data->age |
| 532 // access_point_data->channel |
| 533 return true; |
| 534 } |
| 535 |
| 536 bool UndefineDosDevice(const base::string16& device_name) { |
| 537 // We remove only the mapping we use, that is \Device\<device_name>. |
| 538 base::string16 target_path = L"\\Device\\" + device_name; |
| 539 return DefineDosDevice( |
| 540 DDD_RAW_TARGET_PATH | DDD_REMOVE_DEFINITION | DDD_EXACT_MATCH_ON_REMOVE, |
| 541 device_name.c_str(), |
| 542 target_path.c_str()) == TRUE; |
| 543 } |
| 544 |
| 545 bool DefineDosDeviceIfNotExists(const base::string16& device_name) { |
| 546 // We create a DOS device name for the device at \Device\<device_name>. |
| 547 base::string16 target_path = L"\\Device\\" + device_name; |
| 548 |
| 549 TCHAR target[kStringLength]; |
| 550 if (QueryDosDevice(device_name.c_str(), target, kStringLength) > 0 && |
| 551 target_path.compare(target) == 0) { |
| 552 // Device already exists. |
| 553 return true; |
| 554 } |
| 555 |
| 556 if (GetLastError() != ERROR_FILE_NOT_FOUND) { |
| 557 return false; |
| 558 } |
| 559 |
| 560 if (!DefineDosDevice(DDD_RAW_TARGET_PATH, |
| 561 device_name.c_str(), |
| 562 target_path.c_str())) { |
| 563 return false; |
| 564 } |
| 565 |
| 566 // Check that the device is really there. |
| 567 return QueryDosDevice(device_name.c_str(), target, kStringLength) > 0 && |
| 568 target_path.compare(target) == 0; |
| 569 } |
| 570 |
| 571 HANDLE GetFileHandle(const base::string16& device_name) { |
| 572 // We access a device with DOS path \Device\<device_name> at |
| 573 // \\.\<device_name>. |
| 574 base::string16 formatted_device_name = L"\\\\.\\" + device_name; |
| 575 |
| 576 return CreateFile(formatted_device_name.c_str(), |
| 577 GENERIC_READ, |
| 578 FILE_SHARE_READ | FILE_SHARE_WRITE, // share mode |
| 579 0, // security attributes |
| 580 OPEN_EXISTING, |
| 581 0, // flags and attributes |
| 582 INVALID_HANDLE_VALUE); |
| 583 } |
| 584 |
| 585 int PerformQuery(HANDLE adapter_handle, |
| 586 BYTE* buffer, |
| 587 DWORD buffer_size, |
| 588 DWORD* bytes_out) { |
| 589 DWORD oid = OID_802_11_BSSID_LIST; |
| 590 if (!DeviceIoControl(adapter_handle, |
| 591 IOCTL_NDIS_QUERY_GLOBAL_STATS, |
| 592 &oid, |
| 593 sizeof(oid), |
| 594 buffer, |
| 595 buffer_size, |
| 596 bytes_out, |
| 597 NULL)) { |
| 598 return GetLastError(); |
| 599 } |
| 600 return ERROR_SUCCESS; |
| 601 } |
| 602 |
| 603 bool ResizeBuffer(int requested_size, |
| 604 std::unique_ptr<BYTE, base::FreeDeleter>* buffer) { |
| 605 DCHECK_GT(requested_size, 0); |
| 606 DCHECK(buffer); |
| 607 if (requested_size > kMaximumBufferSize) { |
| 608 buffer->reset(); |
| 609 return false; |
| 610 } |
| 611 |
| 612 buffer->reset(reinterpret_cast<BYTE*>( |
| 613 realloc(buffer->release(), requested_size))); |
| 614 return buffer != NULL; |
| 615 } |
| 616 |
| 617 bool GetSystemDirectory(base::string16* path) { |
| 618 DCHECK(path); |
| 619 // Return value includes terminating NULL. |
| 620 int buffer_size = ::GetSystemDirectory(NULL, 0); |
| 621 if (buffer_size == 0) { |
| 622 return false; |
| 623 } |
| 624 std::unique_ptr<base::char16[]> buffer(new base::char16[buffer_size]); |
| 625 |
| 626 // Return value excludes terminating NULL. |
| 627 int characters_written = ::GetSystemDirectory(buffer.get(), buffer_size); |
| 628 if (characters_written == 0) { |
| 629 return false; |
| 630 } |
| 631 DCHECK_EQ(buffer_size - 1, characters_written); |
| 632 |
| 633 path->assign(buffer.get(), characters_written); |
| 634 |
| 635 if (*path->rbegin() != L'\\') { |
| 636 path->append(L"\\"); |
| 637 } |
| 638 DCHECK_EQ(L'\\', *path->rbegin()); |
| 639 return true; |
| 640 } |
| 641 } // namespace |
| 642 |
| 643 } // namespace content |
OLD | NEW |