blob: 460ae694c90e2866602d6de041e0f434fce50661 [file] [log] [blame] [edit]
// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#include "platform/globals.h"
#if defined(DART_HOST_OS_WINDOWS)
#include "bin/directory.h"
#include <errno.h> // NOLINT
#include <sys/stat.h> // NOLINT
#include "bin/crypto.h"
#include "bin/dartutils.h"
#include "bin/file.h"
#include "bin/file_win.h"
#include "bin/namespace.h"
#include "bin/utils.h"
#include "bin/utils_win.h"
#include "platform/syslog.h"
#include "platform/utils.h"
#undef DeleteFile
namespace dart {
namespace bin {
PathBuffer::PathBuffer() : length_(0) {
data_ = calloc(MAX_LONG_PATH + 1, sizeof(wchar_t)); // NOLINT
}
PathBuffer::~PathBuffer() {
free(data_);
}
char* PathBuffer::AsString() const {
UNREACHABLE();
return nullptr;
}
wchar_t* PathBuffer::AsStringW() const {
return reinterpret_cast<wchar_t*>(data_);
}
const char* PathBuffer::AsScopedString() const {
return StringUtilsWin::WideToUtf8(AsStringW());
}
bool PathBuffer::Add(const char* name) {
const auto wide_name = Utf8ToWideChar(name);
return AddW(wide_name.get());
}
bool PathBuffer::AddW(const wchar_t* name) {
wchar_t* data = AsStringW();
int written =
_snwprintf(data + length_, MAX_LONG_PATH - length_, L"%s", name);
data[MAX_LONG_PATH] = L'\0';
if ((written <= MAX_LONG_PATH - length_) && (written >= 0) &&
(static_cast<size_t>(written) == wcsnlen(name, MAX_LONG_PATH + 1))) {
length_ += written;
return true;
} else {
SetLastError(ERROR_BUFFER_OVERFLOW);
return false;
}
}
void PathBuffer::Reset(intptr_t new_length) {
length_ = new_length;
AsStringW()[length_] = L'\0';
}
// If link_name points to a link, IsBrokenLink will return true if link_name
// points to an invalid target.
static bool IsBrokenLink(const wchar_t* link_name) {
HANDLE handle = CreateFileW(
link_name, 0, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
if (handle == INVALID_HANDLE_VALUE) {
return true;
} else {
CloseHandle(handle);
return false;
}
}
// A linked list structure holding a link target's unique file system ID.
// Used to detect loops in the file system when listing recursively.
struct LinkList {
DWORD volume;
DWORD id_low;
DWORD id_high;
LinkList* next;
};
// Forward declarations.
static bool DeleteRecursively(PathBuffer* path);
static ListType HandleFindFile(DirectoryListing* listing,
DirectoryListingEntry* entry,
const WIN32_FIND_DATAW& find_file_data) {
if (!listing->path_buffer().AddW(find_file_data.cFileName)) {
return kListError;
}
DWORD attributes = find_file_data.dwFileAttributes;
if ((attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
if (!listing->follow_links()) {
return kListLink;
}
HANDLE handle = CreateFileW(
listing->path_buffer().AsStringW(), 0,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr,
OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
if (handle == INVALID_HANDLE_VALUE) {
// Report as (broken) link.
return kListLink;
}
if ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
// Check the seen link targets to see if we are in a file system loop.
LinkList current_link;
BY_HANDLE_FILE_INFORMATION info;
// Get info
if (!GetFileInformationByHandle(handle, &info)) {
DWORD error = GetLastError();
CloseHandle(handle);
SetLastError(error);
return kListError;
}
CloseHandle(handle);
current_link.volume = info.dwVolumeSerialNumber;
current_link.id_low = info.nFileIndexLow;
current_link.id_high = info.nFileIndexHigh;
current_link.next = entry->link();
LinkList* previous = entry->link();
while (previous != nullptr) {
if ((previous->volume == current_link.volume) &&
(previous->id_low == current_link.id_low) &&
(previous->id_high == current_link.id_high)) {
// Report the looping link as a link, rather than following it.
return kListLink;
}
previous = previous->next;
}
// Recurse into the directory, adding current link to the seen links list.
if ((wcscmp(find_file_data.cFileName, L".") == 0) ||
(wcscmp(find_file_data.cFileName, L"..") == 0)) {
return entry->Next(listing);
}
entry->set_link(new LinkList(current_link));
return kListDirectory;
}
}
if ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
if ((wcscmp(find_file_data.cFileName, L".") == 0) ||
(wcscmp(find_file_data.cFileName, L"..") == 0)) {
return entry->Next(listing);
}
return kListDirectory;
} else {
return kListFile;
}
}
ListType DirectoryListingEntry::Next(DirectoryListing* listing) {
if (done_) {
return kListDone;
}
WIN32_FIND_DATAW find_file_data;
if (lister_ == 0) {
const wchar_t* tail = parent_ == nullptr ? L"*" : L"\\*";
if (!listing->path_buffer().AddW(tail)) {
done_ = true;
return kListError;
}
path_length_ = listing->path_buffer().length() - 1;
HANDLE find_handle =
FindFirstFileW(listing->path_buffer().AsStringW(), &find_file_data);
if (find_handle == INVALID_HANDLE_VALUE) {
done_ = true;
return kListError;
}
lister_ = reinterpret_cast<intptr_t>(find_handle);
listing->path_buffer().Reset(path_length_);
return HandleFindFile(listing, this, find_file_data);
}
// Reset.
listing->path_buffer().Reset(path_length_);
ResetLink();
if (FindNextFileW(reinterpret_cast<HANDLE>(lister_), &find_file_data) != 0) {
return HandleFindFile(listing, this, find_file_data);
}
done_ = true;
if (GetLastError() != ERROR_NO_MORE_FILES) {
return kListError;
}
return kListDone;
}
DirectoryListingEntry::~DirectoryListingEntry() {
ResetLink();
if (lister_ != 0) {
FindClose(reinterpret_cast<HANDLE>(lister_));
}
}
void DirectoryListingEntry::ResetLink() {
if ((link_ != nullptr) &&
((parent_ == nullptr) || (parent_->link_ != link_))) {
delete link_;
link_ = nullptr;
}
if (parent_ != nullptr) {
link_ = parent_->link_;
}
}
namespace {
class RecursiveDeleter {
public:
RecursiveDeleter() : path_() {}
// Delete the given directory recursively. Expects an absolute long prefixed
// path - which allows deletion to proceed without checking if path needs to
// be prefixed while recursing.
bool DeleteRecursively(const std::unique_ptr<wchar_t[]>& path) {
ASSERT(wcsncmp(path.get(), L"\\\\?\\", 4) == 0);
path_.Reset(0);
if (path == nullptr || !path_.AddW(path.get()) || path_.length() == 0) {
return false;
}
if (path_.AsStringW()[path_.length() - 1] == '\\') {
// Strip trailing slash otherwise FindFirstFileW will fail.
path_.Reset(path_.length() - 1);
}
return DeleteDirectory();
}
private:
const wchar_t* path() const { return path_.AsStringW(); }
bool DeleteDirectory() {
DWORD attributes = GetFileAttributesW(path());
if (attributes == INVALID_FILE_ATTRIBUTES) {
return false;
}
// If the directory is a junction, it's pointing to some other place in the
// filesystem that we do not want to recurse into.
if ((attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
// Just delete the junction itself.
return RemoveDirectoryW(path()) != 0;
}
// If it's a file, remove it directly.
if ((attributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
return DeleteFile();
}
if (!path_.AddW(L"\\*")) {
return false;
}
WIN32_FIND_DATAW find_file_data;
HANDLE find_handle = FindFirstFileW(path(), &find_file_data);
if (find_handle == INVALID_HANDLE_VALUE) {
return false;
}
// Adjust the path by removing the '*' used for the search.
const int path_length = path_.length() - 1;
path_.Reset(path_length);
do {
if (!DeleteEntry(&find_file_data)) {
break;
}
path_.Reset(path_length); // DeleteEntry adds to the path.
} while (FindNextFileW(find_handle, &find_file_data) != 0);
DWORD last_error = GetLastError();
// Always close handle.
FindClose(find_handle);
if (last_error != ERROR_NO_MORE_FILES) {
// Unexpected error, set and return.
SetLastError(last_error);
return false;
}
// All content deleted successfully, try to delete directory.
// Drop the "\" from the end of the path.
path_.Reset(path_length - 1);
return RemoveDirectoryW(path()) != 0;
}
bool DeleteEntry(LPWIN32_FIND_DATAW find_file_data) {
wchar_t* entry_name = find_file_data->cFileName;
if ((wcscmp(entry_name, L".") == 0) || (wcscmp(entry_name, L"..") == 0)) {
return true;
}
if (!path_.AddW(entry_name)) {
return false;
}
DWORD attributes = find_file_data->dwFileAttributes;
if ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
return DeleteDirectory();
} else {
return DeleteFile();
}
}
bool DeleteFile() {
if (DeleteFileW(path()) != 0) {
return true;
}
// If we failed because the file is read-only, make it writeable and try
// again. This mirrors Linux/Mac where a directory containing read-only
// files can still be recursively deleted.
if (GetLastError() == ERROR_ACCESS_DENIED) {
DWORD attributes = GetFileAttributesW(path());
if (attributes == INVALID_FILE_ATTRIBUTES) {
return false;
}
if ((attributes & FILE_ATTRIBUTE_READONLY) == FILE_ATTRIBUTE_READONLY) {
attributes &= ~FILE_ATTRIBUTE_READONLY;
if (SetFileAttributesW(path(), attributes) == 0) {
return false;
}
return DeleteFileW(path()) != 0;
}
}
return false;
}
PathBuffer path_;
};
} // namespace
Directory::ExistsResult Directory::Exists(const wchar_t* dir_name) {
DWORD attributes = GetFileAttributesW(dir_name);
if (attributes == INVALID_FILE_ATTRIBUTES) {
DWORD last_error = GetLastError();
if ((last_error == ERROR_FILE_NOT_FOUND) ||
(last_error == ERROR_PATH_NOT_FOUND)) {
return Directory::DOES_NOT_EXIST;
} else {
// We might not be able to get the file attributes for other
// reasons such as lack of permissions. In that case we do
// not know if the directory exists.
return Directory::UNKNOWN;
}
}
bool exists = (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
exists = exists && !IsBrokenLink(dir_name);
return exists ? Directory::EXISTS : Directory::DOES_NOT_EXIST;
}
Directory::ExistsResult Directory::Exists(Namespace* namespc,
const char* dir_name) {
const auto path = ToWinAPIPath(dir_name);
return Exists(path.get());
}
char* Directory::CurrentNoScope() {
int length = GetCurrentDirectoryW(0, nullptr);
if (length == 0) {
return nullptr;
}
wchar_t* current = new wchar_t[length + 1];
GetCurrentDirectoryW(length + 1, current);
int utf8_len = WideCharToMultiByte(CP_UTF8, 0, current, -1, nullptr, 0,
nullptr, nullptr);
char* result = reinterpret_cast<char*>(malloc(utf8_len));
WideCharToMultiByte(CP_UTF8, 0, current, -1, result, utf8_len, nullptr,
nullptr);
delete[] current;
return result;
}
bool Directory::Create(Namespace* namespc, const char* dir_name) {
const auto path = ToWinAPIPath(dir_name);
int create_status = CreateDirectoryW(path.get(), nullptr);
// If the directory already existed, treat it as a success.
if ((create_status == 0) && (GetLastError() == ERROR_ALREADY_EXISTS) &&
(Exists(path.get()) == EXISTS)) {
return true;
}
return (create_status != 0);
}
const char* Directory::SystemTemp(Namespace* namespc) {
PathBuffer path;
// Remove \ at end.
path.Reset(GetTempPathW(MAX_LONG_PATH, path.AsStringW()) - 1);
return path.AsScopedString();
}
// Creates a new temporary directory with a UUID as suffix.
static const char* CreateTempFromUUID(const char* prefix) {
PathBuffer path;
const auto system_prefix = Utf8ToWideChar(prefix);
if (!path.AddW(system_prefix.get())) {
return nullptr;
}
// Length of xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx is 36.
if (path.length() > MAX_LONG_PATH - 36) {
return nullptr;
}
UUID uuid;
RPC_STATUS status = UuidCreateSequential(&uuid);
if ((status != RPC_S_OK) && (status != RPC_S_UUID_LOCAL_ONLY)) {
return nullptr;
}
wchar_t* uuid_string;
status = UuidToStringW(&uuid, &uuid_string);
if (status != RPC_S_OK) {
return nullptr;
}
// RPC_WSTR is an unsigned short*, so we cast to wchar_t*.
if (!path.AddW(uuid_string)) {
return nullptr;
}
RpcStringFreeW(&uuid_string);
if (!CreateDirectoryW(path.AsStringW(), nullptr)) {
return nullptr;
}
return path.AsScopedString();
}
// Creates a new, unused directory, adding characters to the end of prefix, and
// returns the directory's name.
//
// Creates this directory, with a default security descriptor inherited from its
// parent directory. The return value is Dart_ScopeAllocated.
//
// First, attempts appending a suffix created from a random uint32_t. If that
// name is already taken, falls back on using a UUID for the suffix.
//
// Note: More attempts at finding an available short suffix would more reliably
// avoid a uuid suffix. We choose one attempt here because it is simpler, and
// to have a small bound on the number of calls to CreateDirectoryW().
const char* Directory::CreateTemp(Namespace* namespc, const char* prefix) {
PathBuffer path;
const auto system_prefix = Utf8ToWideChar(prefix);
if (!path.AddW(system_prefix.get())) {
return nullptr;
}
// Adding 8 hex digits.
if (path.length() > MAX_LONG_PATH - 8) {
// No fallback, there won't be enough room for the UUID, either.
return nullptr;
}
// First try a short suffix using the rng, then if that fails fall back on
// a uuid.
uint32_t suffix_bytes = 0;
const int kSuffixSize = sizeof(suffix_bytes);
if (!Crypto::GetRandomBytes(kSuffixSize,
reinterpret_cast<uint8_t*>(&suffix_bytes))) {
// Getting random bytes failed, maybe the UUID will work?
return CreateTempFromUUID(prefix);
}
// Two digits per byte plus null.
char suffix[kSuffixSize * 2 + 1];
Utils::SNPrint(suffix, sizeof(suffix), "%x", suffix_bytes);
if (!path.Add(suffix)) {
// Adding to the path failed, maybe because of low-memory. Don't fall back.
return nullptr;
}
if (!CreateDirectoryW(path.AsStringW(), nullptr)) {
// Creation failed, possibly because an entry with the name already exists.
// Fall back to using the UUID suffix.
return CreateTempFromUUID(prefix);
}
return path.AsScopedString();
}
bool Directory::Delete(Namespace* namespc,
const char* dir_name,
bool recursive) {
const auto path = ToWinAPIPath(dir_name);
bool result = false;
if (!recursive) {
if (File::GetType(path.get(), /*follow_links=*/true) ==
File::kIsDirectory) {
result = (RemoveDirectoryW(path.get()) != 0);
} else {
SetLastError(ERROR_FILE_NOT_FOUND);
}
} else {
RecursiveDeleter deleter;
result = deleter.DeleteRecursively(path);
}
return result;
}
bool Directory::Rename(Namespace* namespc,
const char* old_name,
const char* new_name) {
const auto old_path = ToWinAPIPath(old_name);
ExistsResult exists = Exists(old_path.get());
if (exists != EXISTS) {
SetLastError(ERROR_FILE_NOT_FOUND);
return false;
}
const auto new_path = ToWinAPIPath(new_name);
DWORD flags = MOVEFILE_WRITE_THROUGH;
int move_status = MoveFileExW(old_path.get(), new_path.get(), flags);
return (move_status != 0);
}
} // namespace bin
} // namespace dart
#endif // defined(DART_HOST_OS_WINDOWS)