// 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 "base/files/file_util.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include "base/bind.h" #include "base/callback.h" #include "base/debug/alias.h" #include "base/files/file_enumerator.h" #include "base/files/file_path.h" #include "base/files/memory_mapped_file.h" #include "base/guid.h" #include "base/location.h" #include "base/logging.h" #include "base/metrics/histogram_functions.h" #include "base/numerics/safe_conversions.h" #include "base/process/process_handle.h" #include "base/rand_util.h" #include "base/strings/strcat.h" #include "base/strings/string_number_conversions.h" #include "base/strings/string_piece.h" #include "base/strings/string_util.h" #include "base/strings/string_util_win.h" #include "base/strings/utf_string_conversions.h" #include "base/task/bind_post_task.h" #include "base/task/sequenced_task_runner.h" #include "base/task/thread_pool.h" #include "base/threading/scoped_blocking_call.h" #include "base/threading/scoped_thread_priority.h" #include "base/threading/sequenced_task_runner_handle.h" #include "base/time/time.h" #include "base/win/scoped_handle.h" #include "base/win/windows_types.h" #include "base/win/windows_version.h" namespace base { namespace { const DWORD kFileShareAll = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE; // Returns the Win32 last error code or ERROR_SUCCESS if the last error code is // ERROR_FILE_NOT_FOUND or ERROR_PATH_NOT_FOUND. This is useful in cases where // the absence of a file or path is a success condition (e.g., when attempting // to delete an item in the filesystem). DWORD ReturnLastErrorOrSuccessOnNotFound() { const DWORD error_code = ::GetLastError(); return (error_code == ERROR_FILE_NOT_FOUND || error_code == ERROR_PATH_NOT_FOUND) ? ERROR_SUCCESS : error_code; } // Deletes all files and directories in a path. // Returns ERROR_SUCCESS on success or the Windows error code corresponding to // the first error encountered. ERROR_FILE_NOT_FOUND and ERROR_PATH_NOT_FOUND // are considered success conditions, and are therefore never returned. DWORD DeleteFileRecursive(const FilePath& path, const FilePath::StringType& pattern, bool recursive) { FileEnumerator traversal(path, false, FileEnumerator::FILES | FileEnumerator::DIRECTORIES, pattern); DWORD result = ERROR_SUCCESS; for (FilePath current = traversal.Next(); !current.empty(); current = traversal.Next()) { // Try to clear the read-only bit if we find it. FileEnumerator::FileInfo info = traversal.GetInfo(); if ((info.find_data().dwFileAttributes & FILE_ATTRIBUTE_READONLY) && (recursive || !info.IsDirectory())) { ::SetFileAttributes( current.value().c_str(), info.find_data().dwFileAttributes & ~DWORD{FILE_ATTRIBUTE_READONLY}); } DWORD this_result = ERROR_SUCCESS; if (info.IsDirectory()) { if (recursive) { this_result = DeleteFileRecursive(current, pattern, true); DCHECK_NE(static_cast(this_result), ERROR_FILE_NOT_FOUND); DCHECK_NE(static_cast(this_result), ERROR_PATH_NOT_FOUND); if (this_result == ERROR_SUCCESS && !::RemoveDirectory(current.value().c_str())) { this_result = ReturnLastErrorOrSuccessOnNotFound(); } } } else if (!::DeleteFile(current.value().c_str())) { this_result = ReturnLastErrorOrSuccessOnNotFound(); } if (result == ERROR_SUCCESS) result = this_result; } return result; } // Appends |mode_char| to |mode| before the optional character set encoding; see // https://msdn.microsoft.com/library/yeby3zcb.aspx for details. void AppendModeCharacter(wchar_t mode_char, std::wstring* mode) { size_t comma_pos = mode->find(L','); mode->insert(comma_pos == std::wstring::npos ? mode->length() : comma_pos, 1, mode_char); } bool DoCopyFile(const FilePath& from_path, const FilePath& to_path, bool fail_if_exists) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); if (from_path.ReferencesParent() || to_path.ReferencesParent()) return false; // NOTE: I suspect we could support longer paths, but that would involve // analyzing all our usage of files. if (from_path.value().length() >= MAX_PATH || to_path.value().length() >= MAX_PATH) { return false; } // Mitigate the issues caused by loading DLLs on a background thread // (http://crbug/973868). SCOPED_MAY_LOAD_LIBRARY_AT_BACKGROUND_PRIORITY(); // Unlike the posix implementation that copies the file manually and discards // the ACL bits, CopyFile() copies the complete SECURITY_DESCRIPTOR and access // bits, which is usually not what we want. We can't do much about the // SECURITY_DESCRIPTOR but at least remove the read only bit. const wchar_t* dest = to_path.value().c_str(); if (!::CopyFile(from_path.value().c_str(), dest, fail_if_exists)) { // Copy failed. return false; } DWORD attrs = GetFileAttributes(dest); if (attrs == INVALID_FILE_ATTRIBUTES) { return false; } if (attrs & FILE_ATTRIBUTE_READONLY) { SetFileAttributes(dest, attrs & ~DWORD{FILE_ATTRIBUTE_READONLY}); } return true; } bool DoCopyDirectory(const FilePath& from_path, const FilePath& to_path, bool recursive, bool fail_if_exists) { // NOTE(maruel): Previous version of this function used to call // SHFileOperation(). This used to copy the file attributes and extended // attributes, OLE structured storage, NTFS file system alternate data // streams, SECURITY_DESCRIPTOR. In practice, this is not what we want, we // want the containing directory to propagate its SECURITY_DESCRIPTOR. ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); // NOTE: I suspect we could support longer paths, but that would involve // analyzing all our usage of files. if (from_path.value().length() >= MAX_PATH || to_path.value().length() >= MAX_PATH) { return false; } // This function does not properly handle destinations within the source. FilePath real_to_path = to_path; if (PathExists(real_to_path)) { real_to_path = MakeAbsoluteFilePath(real_to_path); if (real_to_path.empty()) return false; } else { real_to_path = MakeAbsoluteFilePath(real_to_path.DirName()); if (real_to_path.empty()) return false; } FilePath real_from_path = MakeAbsoluteFilePath(from_path); if (real_from_path.empty()) return false; if (real_to_path == real_from_path || real_from_path.IsParent(real_to_path)) return false; int traverse_type = FileEnumerator::FILES; if (recursive) traverse_type |= FileEnumerator::DIRECTORIES; FileEnumerator traversal(from_path, recursive, traverse_type); if (!PathExists(from_path)) { DLOG(ERROR) << "CopyDirectory() couldn't stat source directory: " << from_path.value().c_str(); return false; } // TODO(maruel): This is not necessary anymore. DCHECK(recursive || DirectoryExists(from_path)); FilePath current = from_path; bool from_is_dir = DirectoryExists(from_path); bool success = true; FilePath from_path_base = from_path; if (recursive && DirectoryExists(to_path)) { // If the destination already exists and is a directory, then the // top level of source needs to be copied. from_path_base = from_path.DirName(); } while (success && !current.empty()) { // current is the source path, including from_path, so append // the suffix after from_path to to_path to create the target_path. FilePath target_path(to_path); if (from_path_base != current) { if (!from_path_base.AppendRelativePath(current, &target_path)) { success = false; break; } } if (from_is_dir) { if (!DirectoryExists(target_path) && !::CreateDirectory(target_path.value().c_str(), NULL)) { DLOG(ERROR) << "CopyDirectory() couldn't create directory: " << target_path.value().c_str(); success = false; } } else if (!DoCopyFile(current, target_path, fail_if_exists)) { DLOG(ERROR) << "CopyDirectory() couldn't create file: " << target_path.value().c_str(); success = false; } current = traversal.Next(); if (!current.empty()) from_is_dir = traversal.GetInfo().IsDirectory(); } return success; } // Returns ERROR_SUCCESS on success, or a Windows error code on failure. DWORD DoDeleteFile(const FilePath& path, bool recursive) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); if (path.empty()) return ERROR_SUCCESS; if (path.value().length() >= MAX_PATH) return ERROR_BAD_PATHNAME; // Handle any path with wildcards. if (path.BaseName().value().find_first_of(FILE_PATH_LITERAL("*?")) != FilePath::StringType::npos) { const DWORD error_code = DeleteFileRecursive(path.DirName(), path.BaseName().value(), recursive); DCHECK_NE(static_cast(error_code), ERROR_FILE_NOT_FOUND); DCHECK_NE(static_cast(error_code), ERROR_PATH_NOT_FOUND); return error_code; } // Report success if the file or path does not exist. const DWORD attr = ::GetFileAttributes(path.value().c_str()); if (attr == INVALID_FILE_ATTRIBUTES) return ReturnLastErrorOrSuccessOnNotFound(); // Clear the read-only bit if it is set. if ((attr & FILE_ATTRIBUTE_READONLY) && !::SetFileAttributes(path.value().c_str(), attr & ~DWORD{FILE_ATTRIBUTE_READONLY})) { // It's possible for |path| to be gone now under a race with other deleters. return ReturnLastErrorOrSuccessOnNotFound(); } // Perform a simple delete on anything that isn't a directory. if (!(attr & FILE_ATTRIBUTE_DIRECTORY)) { return ::DeleteFile(path.value().c_str()) ? ERROR_SUCCESS : ReturnLastErrorOrSuccessOnNotFound(); } if (recursive) { const DWORD error_code = DeleteFileRecursive(path, FILE_PATH_LITERAL("*"), true); DCHECK_NE(static_cast(error_code), ERROR_FILE_NOT_FOUND); DCHECK_NE(static_cast(error_code), ERROR_PATH_NOT_FOUND); if (error_code != ERROR_SUCCESS) return error_code; } return ::RemoveDirectory(path.value().c_str()) ? ERROR_SUCCESS : ReturnLastErrorOrSuccessOnNotFound(); } // Deletes the file/directory at |path| (recursively if |recursive| and |path| // names a directory), returning true on success. Sets the Windows last-error // code and returns false on failure. bool DeleteFileOrSetLastError(const FilePath& path, bool recursive) { const DWORD error = DoDeleteFile(path, recursive); if (error == ERROR_SUCCESS) return true; ::SetLastError(error); return false; } constexpr int kMaxDeleteAttempts = 9; void LogFileDeleteRetryCount(bool recursive, int attempt) { UmaHistogramExactLinear(recursive ? "Windows.PathRecursivelyDeleteRetryCount" : "Windows.FileDeleteRetryCount", attempt, kMaxDeleteAttempts); } void DeleteFileWithRetry(const FilePath& path, bool recursive, int attempt, OnceCallback reply_callback) { // Retry every 250ms for up to two seconds. These values were pulled out of // thin air, and may be adjusted in the future based on the metrics collected. static constexpr TimeDelta kDeleteFileRetryDelay = Milliseconds(250); if (DeleteFileOrSetLastError(path, recursive)) { // Log how many times we had to retry the RetryDeleteFile operation before // it succeeded. This will be from 0 to kMaxDeleteAttempts - 1. LogFileDeleteRetryCount(recursive, attempt); // Consider introducing further retries until the item has been removed from // the filesystem and its name is ready for reuse; see the comments in // chrome/installer/mini_installer/delete_with_retry.cc for details. if (!reply_callback.is_null()) std::move(reply_callback).Run(true); return; } ++attempt; DCHECK_LE(attempt, kMaxDeleteAttempts); if (attempt == kMaxDeleteAttempts) { // Log kMaxDeleteAttempts to indicate failure after exhausting all attempts. LogFileDeleteRetryCount(recursive, attempt); if (!reply_callback.is_null()) std::move(reply_callback).Run(false); return; } ThreadPool::PostDelayedTask(FROM_HERE, {TaskPriority::BEST_EFFORT, MayBlock()}, BindOnce(&DeleteFileWithRetry, path, recursive, attempt, std::move(reply_callback)), kDeleteFileRetryDelay); } OnceClosure GetDeleteFileCallbackInternal( const FilePath& path, bool recursive, OnceCallback reply_callback) { OnceCallback bound_callback; if (!reply_callback.is_null()) { bound_callback = BindPostTask(SequencedTaskRunnerHandle::Get(), std::move(reply_callback)); } return BindOnce(&DeleteFileWithRetry, path, recursive, /*attempt=*/0, std::move(bound_callback)); } } // namespace OnceClosure GetDeleteFileCallback(const FilePath& path, OnceCallback reply_callback) { return GetDeleteFileCallbackInternal(path, /*recursive=*/false, std::move(reply_callback)); } OnceClosure GetDeletePathRecursivelyCallback( const FilePath& path, OnceCallback reply_callback) { return GetDeleteFileCallbackInternal(path, /*recursive=*/true, std::move(reply_callback)); } FilePath MakeAbsoluteFilePath(const FilePath& input) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); wchar_t file_path[MAX_PATH]; if (!_wfullpath(file_path, input.value().c_str(), MAX_PATH)) return FilePath(); return FilePath(file_path); } bool DeleteFile(const FilePath& path) { return DeleteFileOrSetLastError(path, /*recursive=*/false); } bool DeletePathRecursively(const FilePath& path) { return DeleteFileOrSetLastError(path, /*recursive=*/true); } bool DeleteFileAfterReboot(const FilePath& path) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); if (path.value().length() >= MAX_PATH) return false; return ::MoveFileEx(path.value().c_str(), nullptr, MOVEFILE_DELAY_UNTIL_REBOOT); } bool ReplaceFile(const FilePath& from_path, const FilePath& to_path, File::Error* error) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); // Alias paths for investigation of shutdown hangs. crbug.com/1054164 FilePath::CharType from_path_str[MAX_PATH]; base::wcslcpy(from_path_str, from_path.value().c_str(), std::size(from_path_str)); base::debug::Alias(from_path_str); FilePath::CharType to_path_str[MAX_PATH]; base::wcslcpy(to_path_str, to_path.value().c_str(), std::size(to_path_str)); base::debug::Alias(to_path_str); // Assume that |to_path| already exists and try the normal replace. This will // fail with ERROR_FILE_NOT_FOUND if |to_path| does not exist. When writing to // a network share, we may not be able to change the ACLs. Ignore ACL errors // then (REPLACEFILE_IGNORE_MERGE_ERRORS). if (::ReplaceFile(to_path.value().c_str(), from_path.value().c_str(), NULL, REPLACEFILE_IGNORE_MERGE_ERRORS, NULL, NULL)) { return true; } File::Error replace_error = File::OSErrorToFileError(GetLastError()); // Try a simple move next. It will only succeed when |to_path| doesn't already // exist. if (::MoveFile(from_path.value().c_str(), to_path.value().c_str())) return true; // In the case of FILE_ERROR_NOT_FOUND from ReplaceFile, it is likely that // |to_path| does not exist. In this case, the more relevant error comes // from the call to MoveFile. if (error) { *error = replace_error == File::FILE_ERROR_NOT_FOUND ? File::GetLastFileError() : replace_error; } return false; } bool CopyDirectory(const FilePath& from_path, const FilePath& to_path, bool recursive) { return DoCopyDirectory(from_path, to_path, recursive, false); } bool CopyDirectoryExcl(const FilePath& from_path, const FilePath& to_path, bool recursive) { return DoCopyDirectory(from_path, to_path, recursive, true); } bool PathExists(const FilePath& path) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); return (GetFileAttributes(path.value().c_str()) != INVALID_FILE_ATTRIBUTES); } namespace { bool PathHasAccess(const FilePath& path, DWORD dir_desired_access, DWORD file_desired_access) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); const wchar_t* const path_str = path.value().c_str(); DWORD fileattr = GetFileAttributes(path_str); if (fileattr == INVALID_FILE_ATTRIBUTES) return false; bool is_directory = fileattr & FILE_ATTRIBUTE_DIRECTORY; DWORD desired_access = is_directory ? dir_desired_access : file_desired_access; DWORD flags_and_attrs = is_directory ? FILE_FLAG_BACKUP_SEMANTICS : FILE_ATTRIBUTE_NORMAL; win::ScopedHandle file(CreateFile(path_str, desired_access, kFileShareAll, nullptr, OPEN_EXISTING, flags_and_attrs, nullptr)); return file.is_valid(); } } // namespace bool PathIsReadable(const FilePath& path) { return PathHasAccess(path, FILE_LIST_DIRECTORY, GENERIC_READ); } bool PathIsWritable(const FilePath& path) { return PathHasAccess(path, FILE_ADD_FILE, GENERIC_WRITE); } bool DirectoryExists(const FilePath& path) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); DWORD fileattr = GetFileAttributes(path.value().c_str()); if (fileattr != INVALID_FILE_ATTRIBUTES) return (fileattr & FILE_ATTRIBUTE_DIRECTORY) != 0; return false; } bool GetTempDir(FilePath* path) { wchar_t temp_path[MAX_PATH + 1]; DWORD path_len = ::GetTempPath(MAX_PATH, temp_path); if (path_len >= MAX_PATH || path_len <= 0) return false; // TODO(evanm): the old behavior of this function was to always strip the // trailing slash. We duplicate this here, but it shouldn't be necessary // when everyone is using the appropriate FilePath APIs. *path = FilePath(temp_path).StripTrailingSeparators(); return true; } FilePath GetHomeDir() { wchar_t result[MAX_PATH]; if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_PROFILE, NULL, SHGFP_TYPE_CURRENT, result)) && result[0]) { return FilePath(result); } // Fall back to the temporary directory on failure. FilePath temp; if (GetTempDir(&temp)) return temp; // Last resort. return FilePath(FILE_PATH_LITERAL("C:\\")); } File CreateAndOpenTemporaryFileInDir(const FilePath& dir, FilePath* temp_file) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); // Open the file with exclusive r/w/d access, and allow the caller to decide // to mark it for deletion upon close after the fact. constexpr uint32_t kFlags = File::FLAG_CREATE | File::FLAG_READ | File::FLAG_WRITE | File::FLAG_WIN_EXCLUSIVE_READ | File::FLAG_WIN_EXCLUSIVE_WRITE | File::FLAG_CAN_DELETE_ON_CLOSE; // Use GUID instead of ::GetTempFileName() to generate unique file names. // "Due to the algorithm used to generate file names, GetTempFileName can // perform poorly when creating a large number of files with the same prefix. // In such cases, it is recommended that you construct unique file names based // on GUIDs." // https://msdn.microsoft.com/library/windows/desktop/aa364991.aspx FilePath temp_name; File file; // Although it is nearly impossible to get a duplicate name with GUID, we // still use a loop here in case it happens. for (int i = 0; i < 100; ++i) { temp_name = dir.Append(FormatTemporaryFileName(UTF8ToWide(GenerateGUID()))); file.Initialize(temp_name, kFlags); if (file.IsValid()) break; } if (!file.IsValid()) { DPLOG(WARNING) << "Failed to get temporary file name in " << dir.value(); return file; } wchar_t long_temp_name[MAX_PATH + 1]; const DWORD long_name_len = GetLongPathName(temp_name.value().c_str(), long_temp_name, MAX_PATH); if (long_name_len != 0 && long_name_len <= MAX_PATH) { *temp_file = FilePath(FilePath::StringPieceType(long_temp_name, long_name_len)); } else { // GetLongPathName() failed, but we still have a temporary file. *temp_file = std::move(temp_name); } return file; } bool CreateTemporaryFileInDir(const FilePath& dir, FilePath* temp_file) { return CreateAndOpenTemporaryFileInDir(dir, temp_file).IsValid(); } FilePath FormatTemporaryFileName(FilePath::StringPieceType identifier) { return FilePath(StrCat({identifier, FILE_PATH_LITERAL(".tmp")})); } ScopedFILE CreateAndOpenTemporaryStreamInDir(const FilePath& dir, FilePath* path) { // Open file in binary mode, to avoid problems with fwrite. On Windows // it replaces \n's with \r\n's, which may surprise you. // Reference: http://msdn.microsoft.com/en-us/library/h9t88zwz(VS.71).aspx return ScopedFILE( FileToFILE(CreateAndOpenTemporaryFileInDir(dir, path), "wb+")); } bool CreateTemporaryDirInDir(const FilePath& base_dir, const FilePath::StringType& prefix, FilePath* new_dir) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); FilePath path_to_create; for (int count = 0; count < 50; ++count) { // Try create a new temporary directory with random generated name. If // the one exists, keep trying another path name until we reach some limit. std::wstring new_dir_name; new_dir_name.assign(prefix); new_dir_name.append(AsWString(NumberToString16(GetCurrentProcId()))); new_dir_name.push_back('_'); new_dir_name.append(AsWString( NumberToString16(RandInt(0, std::numeric_limits::max())))); path_to_create = base_dir.Append(new_dir_name); if (::CreateDirectory(path_to_create.value().c_str(), NULL)) { *new_dir = path_to_create; return true; } } return false; } bool CreateNewTempDirectory(const FilePath::StringType& prefix, FilePath* new_temp_path) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); FilePath system_temp_dir; if (!GetTempDir(&system_temp_dir)) return false; return CreateTemporaryDirInDir(system_temp_dir, prefix, new_temp_path); } bool CreateDirectoryAndGetError(const FilePath& full_path, File::Error* error) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); // If the path exists, we've succeeded if it's a directory, failed otherwise. const wchar_t* const full_path_str = full_path.value().c_str(); const DWORD fileattr = ::GetFileAttributes(full_path_str); if (fileattr != INVALID_FILE_ATTRIBUTES) { if ((fileattr & FILE_ATTRIBUTE_DIRECTORY) != 0) { return true; } DLOG(WARNING) << "CreateDirectory(" << full_path_str << "), " << "conflicts with existing file."; if (error) *error = File::FILE_ERROR_NOT_A_DIRECTORY; ::SetLastError(ERROR_FILE_EXISTS); return false; } // Invariant: Path does not exist as file or directory. // Attempt to create the parent recursively. This will immediately return // true if it already exists, otherwise will create all required parent // directories starting with the highest-level missing parent. FilePath parent_path(full_path.DirName()); if (parent_path.value() == full_path.value()) { if (error) *error = File::FILE_ERROR_NOT_FOUND; ::SetLastError(ERROR_FILE_NOT_FOUND); return false; } if (!CreateDirectoryAndGetError(parent_path, error)) { DLOG(WARNING) << "Failed to create one of the parent directories."; DCHECK(!error || *error != File::FILE_OK); return false; } if (::CreateDirectory(full_path_str, NULL)) return true; const DWORD error_code = ::GetLastError(); if (error_code == ERROR_ALREADY_EXISTS && DirectoryExists(full_path)) { // This error code ERROR_ALREADY_EXISTS doesn't indicate whether we were // racing with someone creating the same directory, or a file with the same // path. If DirectoryExists() returns true, we lost the race to create the // same directory. return true; } if (error) *error = File::OSErrorToFileError(error_code); ::SetLastError(error_code); DPLOG(WARNING) << "Failed to create directory " << full_path_str; return false; } bool NormalizeFilePath(const FilePath& path, FilePath* real_path) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); File file(path, File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WIN_SHARE_DELETE); if (!file.IsValid()) return false; // The expansion of |path| into a full path may make it longer. constexpr int kMaxPathLength = MAX_PATH + 10; wchar_t native_file_path[kMaxPathLength]; // kMaxPathLength includes space for trailing '\0' so we subtract 1. // Returned length, used_wchars, does not include trailing '\0'. // Failure is indicated by returning 0 or >= kMaxPathLength. DWORD used_wchars = ::GetFinalPathNameByHandle( file.GetPlatformFile(), native_file_path, kMaxPathLength - 1, FILE_NAME_NORMALIZED | VOLUME_NAME_NT); if (used_wchars >= kMaxPathLength || used_wchars == 0) return false; // GetFinalPathNameByHandle() returns the \\?\ syntax for file names and // existing code expects we return a path starting 'X:\' so we call // DevicePathToDriveLetterPath rather than using VOLUME_NAME_DOS above. return DevicePathToDriveLetterPath( FilePath(FilePath::StringPieceType(native_file_path, used_wchars)), real_path); } bool DevicePathToDriveLetterPath(const FilePath& nt_device_path, FilePath* out_drive_letter_path) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); // Get the mapping of drive letters to device paths. const int kDriveMappingSize = 1024; wchar_t drive_mapping[kDriveMappingSize] = {'\0'}; if (!::GetLogicalDriveStrings(kDriveMappingSize - 1, drive_mapping)) { DLOG(ERROR) << "Failed to get drive mapping."; return false; } // The drive mapping is a sequence of null terminated strings. // The last string is empty. wchar_t* drive_map_ptr = drive_mapping; wchar_t device_path_as_string[MAX_PATH]; wchar_t drive[] = FILE_PATH_LITERAL(" :"); // For each string in the drive mapping, get the junction that links // to it. If that junction is a prefix of |device_path|, then we // know that |drive| is the real path prefix. while (*drive_map_ptr) { drive[0] = drive_map_ptr[0]; // Copy the drive letter. if (QueryDosDevice(drive, device_path_as_string, MAX_PATH)) { FilePath device_path(device_path_as_string); if (device_path == nt_device_path || device_path.IsParent(nt_device_path)) { *out_drive_letter_path = FilePath(drive + nt_device_path.value().substr( wcslen(device_path_as_string))); return true; } } // Move to the next drive letter string, which starts one // increment after the '\0' that terminates the current string. while (*drive_map_ptr++) {} } // No drive matched. The path does not start with a device junction // that is mounted as a drive letter. This means there is no drive // letter path to the volume that holds |device_path|, so fail. return false; } FilePath MakeLongFilePath(const FilePath& input) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); DWORD path_long_len = ::GetLongPathName(input.value().c_str(), nullptr, 0); if (path_long_len == 0UL) return FilePath(); std::wstring path_long_str; path_long_len = ::GetLongPathName(input.value().c_str(), WriteInto(&path_long_str, path_long_len), path_long_len); if (path_long_len == 0UL) return FilePath(); return FilePath(path_long_str); } bool CreateWinHardLink(const FilePath& to_file, const FilePath& from_file) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); return ::CreateHardLink(to_file.value().c_str(), from_file.value().c_str(), nullptr); } // TODO(rkc): Work out if we want to handle NTFS junctions here or not, handle // them if we do decide to. bool IsLink(const FilePath& file_path) { return false; } bool GetFileInfo(const FilePath& file_path, File::Info* results) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); WIN32_FILE_ATTRIBUTE_DATA attr; if (!GetFileAttributesEx(file_path.value().c_str(), GetFileExInfoStandard, &attr)) { return false; } ULARGE_INTEGER size; size.HighPart = attr.nFileSizeHigh; size.LowPart = attr.nFileSizeLow; // TODO(crbug.com/1333521): Change Info::size to uint64_t and eliminate this // cast. results->size = checked_cast(size.QuadPart); results->is_directory = (attr.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0; results->last_modified = Time::FromFileTime(attr.ftLastWriteTime); results->last_accessed = Time::FromFileTime(attr.ftLastAccessTime); results->creation_time = Time::FromFileTime(attr.ftCreationTime); return true; } FILE* OpenFile(const FilePath& filename, const char* mode) { // 'N' is unconditionally added below, so be sure there is not one already // present before a comma in |mode|. DCHECK( strchr(mode, 'N') == nullptr || (strchr(mode, ',') != nullptr && strchr(mode, 'N') > strchr(mode, ','))); ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); std::wstring w_mode = UTF8ToWide(mode); AppendModeCharacter(L'N', &w_mode); return _wfsopen(filename.value().c_str(), w_mode.c_str(), _SH_DENYNO); } FILE* FileToFILE(File file, const char* mode) { DCHECK(!file.async()); if (!file.IsValid()) return NULL; int fd = _open_osfhandle(reinterpret_cast(file.GetPlatformFile()), 0); if (fd < 0) return NULL; file.TakePlatformFile(); FILE* stream = _fdopen(fd, mode); if (!stream) _close(fd); return stream; } File FILEToFile(FILE* file_stream) { if (!file_stream) return File(); int fd = _fileno(file_stream); DCHECK_GE(fd, 0); intptr_t file_handle = _get_osfhandle(fd); DCHECK_NE(file_handle, reinterpret_cast(INVALID_HANDLE_VALUE)); HANDLE other_handle = nullptr; if (!::DuplicateHandle( /*hSourceProcessHandle=*/GetCurrentProcess(), reinterpret_cast(file_handle), /*hTargetProcessHandle=*/GetCurrentProcess(), &other_handle, /*dwDesiredAccess=*/0, /*bInheritHandle=*/FALSE, /*dwOptions=*/DUPLICATE_SAME_ACCESS)) { return File(File::GetLastFileError()); } return File(ScopedPlatformFile(other_handle)); } int ReadFile(const FilePath& filename, char* data, int max_size) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); win::ScopedHandle file(CreateFile(filename.value().c_str(), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL)); if (!file.is_valid() || max_size < 0) return -1; DWORD read; if (::ReadFile(file.get(), data, static_cast(max_size), &read, NULL)) { // TODO(crbug.com/1333521): Change to return some type with a uint64_t size // and eliminate this cast. return checked_cast(read); } return -1; } int WriteFile(const FilePath& filename, const char* data, int size) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); win::ScopedHandle file(CreateFile(filename.value().c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL)); if (!file.is_valid() || size < 0) { DPLOG(WARNING) << "WriteFile failed for path " << filename.value(); return -1; } DWORD written; BOOL result = ::WriteFile(file.get(), data, static_cast(size), &written, NULL); if (result && static_cast(written) == size) return static_cast(written); if (!result) { // WriteFile failed. DPLOG(WARNING) << "writing file " << filename.value() << " failed"; } else { // Didn't write all the bytes. DLOG(WARNING) << "wrote" << written << " bytes to " << filename.value() << " expected " << size; } return -1; } bool AppendToFile(const FilePath& filename, span data) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); win::ScopedHandle file(CreateFile(filename.value().c_str(), FILE_APPEND_DATA, 0, nullptr, OPEN_EXISTING, 0, nullptr)); if (!file.is_valid()) { VPLOG(1) << "CreateFile failed for path " << filename.value(); return false; } DWORD written; DWORD size = checked_cast(data.size()); BOOL result = ::WriteFile(file.get(), data.data(), size, &written, nullptr); if (result && written == size) return true; if (!result) { // WriteFile failed. VPLOG(1) << "Writing file " << filename.value() << " failed"; } else { // Didn't write all the bytes. VPLOG(1) << "Only wrote " << written << " out of " << size << " byte(s) to " << filename.value(); } return false; } bool AppendToFile(const FilePath& filename, StringPiece data) { return AppendToFile(filename, as_bytes(make_span(data))); } bool GetCurrentDirectory(FilePath* dir) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); wchar_t system_buffer[MAX_PATH]; system_buffer[0] = 0; DWORD len = ::GetCurrentDirectory(MAX_PATH, system_buffer); if (len == 0 || len > MAX_PATH) return false; // TODO(evanm): the old behavior of this function was to always strip the // trailing slash. We duplicate this here, but it shouldn't be necessary // when everyone is using the appropriate FilePath APIs. *dir = FilePath(FilePath::StringPieceType(system_buffer)) .StripTrailingSeparators(); return true; } bool SetCurrentDirectory(const FilePath& directory) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); return ::SetCurrentDirectory(directory.value().c_str()) != 0; } int GetMaximumPathComponentLength(const FilePath& path) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); wchar_t volume_path[MAX_PATH]; if (!GetVolumePathNameW(path.NormalizePathSeparators().value().c_str(), volume_path, std::size(volume_path))) { return -1; } DWORD max_length = 0; if (!GetVolumeInformationW(volume_path, NULL, 0, NULL, &max_length, NULL, NULL, 0)) { return -1; } // Length of |path| with path separator appended. size_t prefix = path.StripTrailingSeparators().value().size() + 1; // The whole path string must be shorter than MAX_PATH. That is, it must be // prefix + component_length < MAX_PATH (or equivalently, <= MAX_PATH - 1). int whole_path_limit = std::max(0, MAX_PATH - 1 - static_cast(prefix)); return std::min(whole_path_limit, static_cast(max_length)); } bool CopyFile(const FilePath& from_path, const FilePath& to_path) { return DoCopyFile(from_path, to_path, false); } bool SetNonBlocking(int fd) { unsigned long nonblocking = 1; if (ioctlsocket(static_cast(fd), static_cast(FIONBIO), &nonblocking) == 0) return true; return false; } namespace { // ::PrefetchVirtualMemory() is only available on Windows 8 and above. Chrome // supports Windows 7, so we need to check for the function's presence // dynamically. using PrefetchVirtualMemoryPtr = decltype(&::PrefetchVirtualMemory); // Returns null if ::PrefetchVirtualMemory() is not available. PrefetchVirtualMemoryPtr GetPrefetchVirtualMemoryPtr() { HMODULE kernel32_dll = ::GetModuleHandleA("kernel32.dll"); return reinterpret_cast( GetProcAddress(kernel32_dll, "PrefetchVirtualMemory")); } } // namespace bool PreReadFile(const FilePath& file_path, bool is_executable, int64_t max_bytes) { DCHECK_GE(max_bytes, 0); // On Win8 and higher use ::PrefetchVirtualMemory(). This is better than a // simple data file read, more from a RAM perspective than CPU. This is // because reading the file as data results in double mapping to // Image/executable pages for all pages of code executed. static PrefetchVirtualMemoryPtr prefetch_virtual_memory = GetPrefetchVirtualMemoryPtr(); if (prefetch_virtual_memory == nullptr) return internal::PreReadFileSlow(file_path, max_bytes); if (max_bytes == 0) { // PrefetchVirtualMemory() fails when asked to read zero bytes. // base::MemoryMappedFile::Initialize() fails on an empty file. return true; } // PrefetchVirtualMemory() fails if the file is opened with write access. MemoryMappedFile::Access access = is_executable ? MemoryMappedFile::READ_CODE_IMAGE : MemoryMappedFile::READ_ONLY; MemoryMappedFile mapped_file; if (!mapped_file.Initialize(file_path, access)) return internal::PreReadFileSlow(file_path, max_bytes); const ::SIZE_T length = std::min(base::saturated_cast<::SIZE_T>(max_bytes), base::saturated_cast<::SIZE_T>(mapped_file.length())); ::_WIN32_MEMORY_RANGE_ENTRY address_range = {mapped_file.data(), length}; if (!prefetch_virtual_memory(::GetCurrentProcess(), /*NumberOfEntries=*/1, &address_range, /*Flags=*/0)) { return internal::PreReadFileSlow(file_path, max_bytes); } return true; } // ----------------------------------------------------------------------------- namespace internal { bool MoveUnsafe(const FilePath& from_path, const FilePath& to_path) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); // NOTE: I suspect we could support longer paths, but that would involve // analyzing all our usage of files. if (from_path.value().length() >= MAX_PATH || to_path.value().length() >= MAX_PATH) { return false; } if (MoveFileEx(from_path.value().c_str(), to_path.value().c_str(), MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING) != 0) return true; // Keep the last error value from MoveFileEx around in case the below // fails. bool ret = false; DWORD last_error = ::GetLastError(); if (DirectoryExists(from_path)) { // MoveFileEx fails if moving directory across volumes. We will simulate // the move by using Copy and Delete. Ideally we could check whether // from_path and to_path are indeed in different volumes. ret = internal::CopyAndDeleteDirectory(from_path, to_path); } if (!ret) { // Leave a clue about what went wrong so that it can be (at least) picked // up by a PLOG entry. ::SetLastError(last_error); } return ret; } bool CopyAndDeleteDirectory(const FilePath& from_path, const FilePath& to_path) { ScopedBlockingCall scoped_blocking_call(FROM_HERE, BlockingType::MAY_BLOCK); if (CopyDirectory(from_path, to_path, true)) { if (DeletePathRecursively(from_path)) return true; // Like Move, this function is not transactional, so we just // leave the copied bits behind if deleting from_path fails. // If to_path exists previously then we have already overwritten // it by now, we don't get better off by deleting the new bits. } return false; } } // namespace internal } // namespace base