blob: ca744de4e330c502857babae1974b1f5aa0298de [file] [log] [blame]
// Copyright 2017 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#include <string.h>
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <unordered_map>
#include "src/main/cpp/util/file_platform.h"
#include "src/main/cpp/util/path_platform.h"
#include "src/main/cpp/util/strings.h"
#include "src/main/native/windows/file.h"
using std::ifstream;
using std::string;
using std::stringstream;
using std::unordered_map;
using std::wstring;
#ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
#define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
#endif
namespace {
const wchar_t* manifest_filename;
const wchar_t* runfiles_base_dir;
string GetLastErrorString() {
DWORD last_error = GetLastError();
if (last_error == 0) {
return string();
}
char* message_buffer;
size_t size = FormatMessageA(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPSTR)&message_buffer, 0, NULL);
stringstream result;
result << "(error: " << last_error << "): " << message_buffer;
LocalFree(message_buffer);
return result.str();
}
void die(const wchar_t* format, ...) {
va_list ap;
va_start(ap, format);
fputws(L"build-runfiles error: ", stderr);
vfwprintf(stderr, format, ap);
va_end(ap);
fputwc(L'\n', stderr);
fputws(L"manifest file name: ", stderr);
fputws(manifest_filename, stderr);
fputwc(L'\n', stderr);
fputws(L"runfiles base directory: ", stderr);
fputws(runfiles_base_dir, stderr);
fputwc(L'\n', stderr);
exit(1);
}
wstring AsAbsoluteWindowsPath(const wchar_t* path) {
wstring wpath;
string error;
if (!blaze_util::AsAbsoluteWindowsPath(path, &wpath, &error)) {
die(L"Couldn't convert %s to absolute Windows path: %hs", path,
error.c_str());
}
return wpath;
}
bool DoesDirectoryPathExist(const wchar_t* path) {
DWORD dwAttrib = GetFileAttributesW(AsAbsoluteWindowsPath(path).c_str());
return (dwAttrib != INVALID_FILE_ATTRIBUTES &&
(dwAttrib & FILE_ATTRIBUTE_DIRECTORY));
}
wstring GetParentDirFromPath(const wstring& path) {
return path.substr(0, path.find_last_of(L"\\/"));
}
inline void Trim(wstring& str) {
str.erase(0, str.find_first_not_of(' '));
str.erase(str.find_last_not_of(' ') + 1);
}
bool ReadSymlink(const wstring& abs_path, wstring* target, wstring* error) {
switch (bazel::windows::ReadSymlinkOrJunction(abs_path, target, error)) {
case bazel::windows::ReadSymlinkOrJunctionResult::kSuccess:
return true;
case bazel::windows::ReadSymlinkOrJunctionResult::kAccessDenied:
*error = L"access is denied";
break;
case bazel::windows::ReadSymlinkOrJunctionResult::kDoesNotExist:
*error = L"path does not exist";
break;
case bazel::windows::ReadSymlinkOrJunctionResult::kNotALink:
*error = L"path is not a link";
break;
case bazel::windows::ReadSymlinkOrJunctionResult::kUnknownLinkType:
*error = L"unknown link type";
break;
default:
// This is bazel::windows::ReadSymlinkOrJunctionResult::kError (1).
// The JNI code puts a custom message in 'error'.
break;
}
return false;
}
} // namespace
class RunfilesCreator {
typedef std::unordered_map<std::wstring, std::wstring> ManifestFileMap;
public:
RunfilesCreator(const wstring& manifest_path,
const wstring& runfiles_output_base)
: manifest_path_(manifest_path),
runfiles_output_base_(runfiles_output_base) {
SetupOutputBase();
if (!SetCurrentDirectoryW(runfiles_output_base_.c_str())) {
die(L"SetCurrentDirectoryW failed (%s): %hs",
runfiles_output_base_.c_str(), GetLastErrorString().c_str());
}
}
void ReadManifest(bool allow_relative, bool ignore_metadata) {
ifstream manifest_file(
AsAbsoluteWindowsPath(manifest_path_.c_str()).c_str());
if (!manifest_file) {
die(L"Couldn't open MANIFEST file: %s", manifest_path_.c_str());
}
string line;
int lineno = 0;
while (getline(manifest_file, line)) {
lineno++;
// Skip metadata lines. They are used solely for
// dependency checking.
if (ignore_metadata && lineno % 2 == 0) {
continue;
}
size_t space_pos = line.find_first_of(' ');
wstring wline = blaze_util::CstringToWstring(line);
wstring link, target;
if (space_pos == string::npos) {
link = wline;
target = wstring();
} else {
link = wline.substr(0, space_pos);
target = wline.substr(space_pos + 1);
}
// Removing leading and trailing spaces
Trim(link);
Trim(target);
// We sometimes need to create empty files under the runfiles tree.
// For example, for python binary, __init__.py is needed under every
// directory. Storing an entry with an empty target indicates we need to
// create such a file when creating the runfiles tree.
if (!allow_relative && !target.empty() &&
!blaze_util::IsAbsolute(target)) {
die(L"Target cannot be relative path: %hs", line.c_str());
}
link = AsAbsoluteWindowsPath(link.c_str());
if (!target.empty()) {
target = AsAbsoluteWindowsPath(target.c_str());
}
manifest_file_map.insert(make_pair(link, target));
}
}
void CreateRunfiles() {
bool symlink_needs_privilege =
DoesCreatingSymlinkNeedAdminPrivilege(runfiles_output_base_);
ScanTreeAndPrune(runfiles_output_base_);
CreateFiles(symlink_needs_privilege);
CopyManifestFile();
}
private:
void SetupOutputBase() {
if (!DoesDirectoryPathExist(runfiles_output_base_.c_str())) {
MakeDirectoriesOrDie(runfiles_output_base_);
}
}
void MakeDirectoriesOrDie(const wstring& path) {
if (!blaze_util::MakeDirectoriesW(path, 0755)) {
die(L"MakeDirectoriesW failed (%s): %hs", path.c_str(),
GetLastErrorString().c_str());
}
}
void RemoveDirectoryOrDie(const wstring& path) {
if (!RemoveDirectoryW(path.c_str())) {
die(L"RemoveDirectoryW failed (%s): %hs", GetLastErrorString().c_str());
}
}
void DeleteFileOrDie(const wstring& path) {
SetFileAttributesW(path.c_str(), GetFileAttributesW(path.c_str()) &
~FILE_ATTRIBUTE_READONLY);
if (!DeleteFileW(path.c_str())) {
die(L"DeleteFileW failed (%s): %hs", path.c_str(),
GetLastErrorString().c_str());
}
}
bool DoesCreatingSymlinkNeedAdminPrivilege(const wstring& runfiles_base_dir) {
wstring dummy_link = runfiles_base_dir + L"\\dummy_link";
wstring dummy_target = runfiles_base_dir + L"\\dummy_target";
// Try creating symlink without admin privilege.
if (CreateSymbolicLinkW(dummy_link.c_str(), dummy_target.c_str(),
SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE)) {
DeleteFileOrDie(dummy_link);
return false;
}
// Try creating symlink with admin privilege
if (CreateSymbolicLinkW(dummy_link.c_str(), dummy_target.c_str(), 0)) {
DeleteFileOrDie(dummy_link);
return true;
}
// If we couldn't create symlink, print out an error message and exit.
if (GetLastError() == ERROR_PRIVILEGE_NOT_HELD) {
die(L"CreateSymbolicLinkW failed:\n%hs\n",
"Bazel needs to create symlink for building runfiles tree.\n"
"Creating symlink on Windows requires either of the following:\n"
" 1. Program is running with elevated privileges (Admin rights).\n"
" 2. The system version is Windows 10 Creators Update (1703) or "
"later and "
"developer mode is enabled.",
GetLastErrorString().c_str());
} else {
die(L"CreateSymbolicLinkW failed: %hs", GetLastErrorString().c_str());
}
return true;
}
// This function scan the current directory, remove all
// files/symlinks/directories that are not presented in manifest file. If a
// symlink already exists and points to the correct target, this function
// erases its entry from manifest_file_map, so that we won't recreate it.
void ScanTreeAndPrune(const wstring& path) {
static const wstring kDot(L".");
static const wstring kDotDot(L"..");
WIN32_FIND_DATAW metadata;
HANDLE handle = ::FindFirstFileW((path + L"\\*").c_str(), &metadata);
if (handle == INVALID_HANDLE_VALUE) {
return; // directory does not exist or is empty
}
do {
if (kDot != metadata.cFileName && kDotDot != metadata.cFileName) {
wstring subpath = path + L"\\" + metadata.cFileName;
subpath = AsAbsoluteWindowsPath(subpath.c_str());
bool is_dir =
(metadata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
bool is_symlink =
(metadata.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0;
if (is_symlink) {
wstring target, werror;
if (!ReadSymlink(subpath, &target, &werror)) {
die(L"ReadSymlinkW failed (%s): %hs", subpath.c_str(),
werror.c_str());
}
target = AsAbsoluteWindowsPath(target.c_str());
ManifestFileMap::iterator expected_target =
manifest_file_map.find(subpath);
if (expected_target == manifest_file_map.end() ||
expected_target->second.empty()
// Both paths are normalized paths in lower case, we can compare
// them directly.
|| target != expected_target->second.c_str() ||
blaze_util::IsDirectoryW(target) != is_dir) {
if (is_dir) {
RemoveDirectoryOrDie(subpath);
} else {
DeleteFileOrDie(subpath);
}
} else {
manifest_file_map.erase(expected_target);
}
} else {
if (is_dir) {
ScanTreeAndPrune(subpath);
// If the directory is empty, then we remove the directory.
// Otherwise RemoveDirectory will fail with ERROR_DIR_NOT_EMPTY,
// which we can just ignore.
// Because if the directory is not empty, it means it contains some
// symlinks already pointing to the correct targets (we just called
// ScanTreeAndPrune). Then this directory shouldn't be removed in
// the first place.
if (!RemoveDirectoryW(subpath.c_str()) &&
GetLastError() != ERROR_DIR_NOT_EMPTY) {
die(L"RemoveDirectoryW failed (%s): %hs", subpath.c_str(),
GetLastErrorString().c_str());
}
} else {
DeleteFileOrDie(subpath);
}
}
}
} while (::FindNextFileW(handle, &metadata));
::FindClose(handle);
}
void CreateFiles(bool creating_symlink_needs_admin_privilege) {
DWORD privilege_flag = creating_symlink_needs_admin_privilege
? 0
: SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE;
for (const auto& it : manifest_file_map) {
// Ensure the parent directory exists
wstring parent_dir = GetParentDirFromPath(it.first);
if (!DoesDirectoryPathExist(parent_dir.c_str())) {
MakeDirectoriesOrDie(parent_dir);
}
if (it.second.empty()) {
// Create an empty file
HANDLE h = CreateFileW(it.first.c_str(), // name of the file
GENERIC_WRITE, // open for writing
// Must share for reading, otherwise
// symlink-following file existence checks (e.g.
// java.nio.file.Files.exists()) fail.
FILE_SHARE_READ,
0, // use default security descriptor
CREATE_ALWAYS, // overwrite if exists
FILE_ATTRIBUTE_NORMAL, 0);
if (h != INVALID_HANDLE_VALUE) {
CloseHandle(h);
} else {
die(L"CreateFileW failed (%s): %hs", it.first.c_str(),
GetLastErrorString().c_str());
}
} else {
DWORD create_dir = 0;
if (blaze_util::IsDirectoryW(it.second.c_str())) {
create_dir = SYMBOLIC_LINK_FLAG_DIRECTORY;
}
if (!CreateSymbolicLinkW(it.first.c_str(), it.second.c_str(),
privilege_flag | create_dir)) {
die(L"CreateSymbolicLinkW failed (%s -> %s): %hs", it.first.c_str(),
it.second.c_str(), GetLastErrorString().c_str());
}
}
}
}
void CopyManifestFile() {
wstring new_manifest_file = runfiles_output_base_ + L"\\MANIFEST";
if (!CopyFileW(manifest_path_.c_str(), new_manifest_file.c_str(),
/*bFailIfExists=*/FALSE)) {
die(L"CopyFileW failed (%s -> %s): %hs", manifest_path_.c_str(),
new_manifest_file.c_str(), GetLastErrorString().c_str());
}
}
private:
wstring manifest_path_;
wstring runfiles_output_base_;
ManifestFileMap manifest_file_map;
};
int wmain(int argc, wchar_t** argv) {
argc--;
argv++;
bool allow_relative = false;
bool ignore_metadata = false;
while (argc >= 1) {
if (wcscmp(argv[0], L"--allow_relative") == 0) {
allow_relative = true;
argc--;
argv++;
} else if (wcscmp(argv[0], L"--use_metadata") == 0) {
// If --use_metadata is passed, it means manifest file contains metadata
// lines, which we should ignore when reading manifest file.
ignore_metadata = true;
argc--;
argv++;
} else {
break;
}
}
if (argc != 2) {
fprintf(stderr,
"usage: [--allow_relative] [--use_metadata] "
"<manifest_file> <runfiles_base_dir>\n");
return 1;
}
manifest_filename = argv[0];
runfiles_base_dir = argv[1];
wstring manifest_absolute_path = AsAbsoluteWindowsPath(manifest_filename);
wstring output_base_absolute_path = AsAbsoluteWindowsPath(runfiles_base_dir);
RunfilesCreator runfiles_creator(manifest_absolute_path,
output_base_absolute_path);
runfiles_creator.ReadManifest(allow_relative, ignore_metadata);
runfiles_creator.CreateRunfiles();
return 0;
}