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