Windows support 1/x: centipede:command. `Command` previously relied on `posix_spawn` with `/bin/sh`, the POSIX `env` utility for environment variable modifications, and shell `<` redirection syntax in arguments. These mechanisms are not portable to Windows. Refactor `Command` to support native Windows process management alongside POSIX: - Introduce `Command::PlatformContext` to encapsulate platform-specific process handles (`HANDLE` on Windows vs. `pid_t` and `ForkServerProps` on POSIX). - Implement Windows process creation, environment block construction (`Options::env_diff`), and standard stream redirection in `Command::ExecuteAsync()` using `CreateProcessA`. - Add `Options::stdin_file_path` to handle input redirection directly rather than appending `"<"` to command arguments, and update `SymbolTable` to use it. - Escape command-line arguments, environment variables, and file paths in `Command::ToString()` on both POSIX (`ShellEscape`) and Windows. - Update `command_test_helper` and `command_test` to verify arguments, environment variables, standard input, and signals portably without relying on `bash`, and enable `centipede:command_test` on Windows CI. - Update `GetDataDependencyFilepath` to return executable path suffixed with `.exe` under Windows. PiperOrigin-RevId: 959298250
diff --git a/.github/workflows/bazel_test_centipede.yml b/.github/workflows/bazel_test_centipede.yml index 1bbcba0..b9d38b3 100644 --- a/.github/workflows/bazel_test_centipede.yml +++ b/.github/workflows/bazel_test_centipede.yml
@@ -30,6 +30,8 @@ # TODO(xinhaoyuan): Bump to 24.04 after https://github.com/llvm/llvm-project/issues/102443 # is fixed. runs-on: ubuntu-22.04 + permissions: + contents: read timeout-minutes: 60 strategy: matrix: @@ -39,13 +41,13 @@ run: | sudo sysctl -w kernel.core_pattern="" - name: Checkout repository - uses: actions/checkout@v4 + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - name: Install dependencies run: | sudo apt-get update && sudo apt-get install -yq \ clang llvm libssl-dev - name: Restore latest cache - uses: actions/cache/restore@v4 + uses: actions/cache/restore@caa296126883cff596d87d8935842f9db880ef25 # v5.1.0 with: path: "~/.cache/bazel" key: bazel-centipede-cache-${{ matrix.config }} @@ -84,19 +86,21 @@ bazel test --no//fuzztest:use_riegeli --test_output=errors --linkopt=-fsanitize=address --copt=-fsanitize=address --test_env=ASAN_OPTIONS=detect_leaks=0 --platform_suffix=asan --test_timeout=600 centipede/puzzles:all - name: Save new cache based on main if: github.ref == 'refs/heads/main' - uses: actions/cache/save@v4 + uses: actions/cache/save@caa296126883cff596d87d8935842f9db880ef25 # v5.1.0 with: path: "~/.cache/bazel" key: bazel-centipede-cache-${{ matrix.config }}-${{ github.run_id }} run_tests_mac: name: Run Centipede tests (MacOS) runs-on: macos-15 + permissions: + contents: read timeout-minutes: 60 steps: - name: Checkout repository - uses: actions/checkout@v4 + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - name: Restore latest cache - uses: actions/cache/restore@v4 + uses: actions/cache/restore@caa296126883cff596d87d8935842f9db880ef25 # v5.1.0 with: path: "~/.cache/bazel" key: bazel-centipede-cache-mac @@ -127,7 +131,38 @@ bazel --output_user_root="${HOME}/.cache/bazel" test --test_output=errors --no//fuzztest:use_riegeli --linkopt=-fsanitize=address --copt=-fsanitize=address --test_env=ASAN_OPTIONS=detect_leaks=0 --platform_suffix=asan --test_timeout=600 centipede/puzzles:all - name: Save new cache based on main if: github.ref == 'refs/heads/main' - uses: actions/cache/save@v4 + uses: actions/cache/save@caa296126883cff596d87d8935842f9db880ef25 # v5.1.0 with: path: "~/.cache/bazel" key: bazel-centipede-cache-mac-${{ github.run_id }} + run_tests_win: + name: Run Centipede tests (Windows) + runs-on: windows-latest + permissions: + contents: read + timeout-minutes: 60 + steps: + - name: Checkout repository + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + - name: Restore latest cache + uses: actions/cache/restore@caa296126883cff596d87d8935842f9db880ef25 # v5.1.0 + with: + path: "~/.cache/bazel" + key: bazel-centipede-cache-win + restore-keys: bazel-centipede-cache-win- + - name: Set environment variable + run: echo "USE_BAZEL_VERSION=8.7.0" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append + - name: Run unit tests + if: ${{ !cancelled() }} + run: | + <# Only supported libraries are tested here. #> ` + bazelisk test --disk_cache=~/.cache/bazel --local_test_jobs=1 --test_output=errors --no//fuzztest:use_riegeli ` + --extra_toolchains=@local_config_cc//:cc-toolchain-x64_windows-clang-cl ` + --extra_execution_platforms=//:x64_windows-clang-cl --enable_runfiles ` + -- centipede:util_test centipede:command_test + - name: Save new cache based on main + if: github.ref == 'refs/heads/main' + uses: actions/cache/save@caa296126883cff596d87d8935842f9db880ef25 # v5.1.0 + with: + path: "~/.cache/bazel" + key: bazel-centipede-cache-win-${{ github.run_id }}
diff --git a/BUILD b/BUILD index 17cbe3f..e8b953e 100644 --- a/BUILD +++ b/BUILD
@@ -13,3 +13,12 @@ # limitations under the License. exports_files(["MODULE.bazel"]) + +platform( + name = "x64_windows-clang-cl", + constraint_values = [ + "@platforms//cpu:x86_64", + "@platforms//os:windows", + "@bazel_tools//tools/cpp:clang-cl", + ], +)
diff --git a/MODULE.bazel b/MODULE.bazel index 0a0dc3e..f99e39c 100644 --- a/MODULE.bazel +++ b/MODULE.bazel
@@ -23,6 +23,10 @@ name = "rules_cc", version = "0.2.17", ) + +cc_configure = use_extension("@rules_cc//cc:extensions.bzl", "cc_configure_extension") +use_repo(cc_configure, "local_config_cc") + bazel_dep( name = "rules_shell", version = "0.6.1",
diff --git a/centipede/BUILD b/centipede/BUILD index 036f7e2..8150ff2 100644 --- a/centipede/BUILD +++ b/centipede/BUILD
@@ -228,6 +228,7 @@ "@com_google_fuzztest//common:hash", "@com_google_fuzztest//common:logging", "@com_google_fuzztest//common:remote_file", + "@com_google_fuzztest//common:windows_includes", ], ) @@ -598,6 +599,9 @@ ":stop", ":util", "@abseil-cpp//absl/base:core_headers", + "@abseil-cpp//absl/cleanup", + "@abseil-cpp//absl/container:flat_hash_map", + "@abseil-cpp//absl/hash", "@abseil-cpp//absl/status", "@abseil-cpp//absl/status:statusor", "@abseil-cpp//absl/strings", @@ -605,6 +609,8 @@ "@abseil-cpp//absl/synchronization", "@abseil-cpp//absl/time", "@com_google_fuzztest//common:logging", + "@com_google_fuzztest//common:windows_includes", + "@com_google_fuzztest//fuzztest/internal:escaping", ], ) @@ -1385,7 +1391,12 @@ cc_test( name = "util_test", srcs = ["util_test.cc"], - copts = ["-fno-signed-char"], + copts = select({ + "@platforms//os:windows": [ + "/J", # Make unsigned char the default + ], + "//conditions:default": ["-fno-signed-char"], + }), deps = [ ":feature", ":thread_pool", @@ -1732,10 +1743,14 @@ name = "command_test_helper", srcs = ["command_test_helper.cc"], deps = [ - ":runner_fork_server", "@abseil-cpp//absl/base:nullability", + "@abseil-cpp//absl/strings", "@abseil-cpp//absl/time", - ], + "@com_google_fuzztest//common:windows_includes", + ] + select({ + "@platforms//os:windows": [], + "//conditions:default": [":runner_fork_server"], + }), ) cc_test(
diff --git a/centipede/command.cc b/centipede/command.cc index 48ca89f..27e977e 100644 --- a/centipede/command.cc +++ b/centipede/command.cc
@@ -14,6 +14,7 @@ #include "./centipede/command.h" +#ifndef _WIN32 #include <errno.h> #include <fcntl.h> #include <spawn.h> @@ -22,6 +23,7 @@ #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> +#endif // _WIN32 #ifdef __APPLE__ #include <inttypes.h> @@ -35,6 +37,7 @@ #include <cstdlib> #include <filesystem> // NOLINT #include <fstream> +#include <memory> #include <optional> #include <string> #include <string_view> @@ -58,8 +61,16 @@ #include "./centipede/stop.h" #include "./centipede/util.h" #include "./common/logging.h" +#include "./fuzztest/internal/escaping.h" +#ifdef _WIN32 +#include "absl/cleanup/cleanup.h" +#include "absl/container/flat_hash_map.h" +#include "absl/hash/hash.h" +#include "absl/strings/ascii.h" // NOLINT +#include "./common/windows_includes.h" +#endif -#if !defined(_MSC_VER) +#ifndef _WIN32 // Needed to pass the current environment to posix_spawn, which needs an // explicit envp without an option to inherit implicitly. extern char** environ; @@ -72,8 +83,11 @@ constexpr std::string_view kCommandLineSeparator(" \\\n"); constexpr std::string_view kNoForkServerRequestPrefix("%f"); +#ifdef _WIN32 +// Do not define `GetProcessCreationStamp`, which is for fork servers. +#else absl::StatusOr<std::string> GetProcessCreationStamp(pid_t pid) { -#ifdef __APPLE__ +#if defined(__APPLE__) struct proc_bsdinfo info = {}; if (proc_pidinfo(pid, PROC_PIDTBSDINFO, 0, &info, PROC_PIDTBSDINFO_SIZE) != PROC_PIDTBSDINFO_SIZE) { @@ -110,8 +124,9 @@ ": ", proc_stat_line)); } return std::string(fields[kFieldIndexOfStartTimeAfterComm]); -#endif +#endif // __APPLE__ } +#endif // _WIN32 std::string GetUniqueSuffix() { static std::atomic<uint64_t> suffix_counter = {0}; @@ -122,7 +137,12 @@ // TODO(ussuri): Encapsulate as much of the fork server functionality from // this source as possible in this struct, and make it a class. -struct Command::ForkServerProps { +#ifdef _WIN32 +struct Command::PlatformContext { + HANDLE win_process_handle = INVALID_HANDLE_VALUE; +}; +#else +struct ForkServerProps { // The file paths of the comms pipes. std::string fifo_path_[2]; // The file descriptors of the comms pipes. @@ -177,30 +197,85 @@ } }; +struct Command::PlatformContext { + pid_t pid = -1; + std::unique_ptr<ForkServerProps> fork_server; +}; +#endif // _WIN32 + // NOTE: Because std::unique_ptr<T> requires T to be a complete type wherever // the deleter is instantiated, the special member functions must be defined -// out-of-line here, now that ForkServerProps is complete (that's by-the-book +// out-of-line here, now that PlatformContext is complete (that's by-the-book // PIMPL). Command::~Command() { if (is_executing()) { FUZZTEST_LOG(WARNING) << "Destructing Command object for " << path() << " with " - << (fork_server_ ? absl::StrCat("fork server PID ", - fork_server_->pid_) - : absl::StrCat("PID ", pid_)) +#ifdef _WIN32 + << GetProcessId(platform_context_->win_process_handle) +#else + << (platform_context_->fork_server + ? absl::StrCat( + "fork server PID ", + platform_context_->fork_server->pid_) + : absl::StrCat("PID ", + platform_context_->pid)) +#endif << " still running. Requesting it to force-stop " "without waiting for it..."; RequestStop(/*force=*/true); +#ifdef _WIN32 + FUZZTEST_CHECK_NE(platform_context_->win_process_handle, + INVALID_HANDLE_VALUE); + CloseHandle(platform_context_->win_process_handle); +#endif } ResetRedirectionFiles(/*new_suffix=*/""); } Command::Command(std::string_view path, Options options) - : path_(path), options_(std::move(options)) {} + : path_(path), + options_(std::move(options)), + platform_context_(std::make_unique<PlatformContext>()) {} Command::Command(std::string_view path) : Command{path, {}} {} std::string Command::ToString() const { +#ifdef _WIN32 + std::string path = path_; + if (absl::StartsWith(path, kNoForkServerRequestPrefix)) { + path = path.substr(kNoForkServerRequestPrefix.size()); + } + constexpr std::string_view kTempFileWildCard = "@@"; + if (absl::StrContains(path, kTempFileWildCard)) { + FUZZTEST_CHECK(!options_.temp_file_path.empty()); + std::string temp_file = options_.temp_file_path; + path = absl::StrReplaceAll(path, {{kTempFileWildCard, temp_file}}); + } + std::string binary_cmd = path; + auto Escape = [](std::string_view s) { + std::string r = "\""; + size_t num_bs = 0; + for (size_t i = 0; i < s.size(); ++i) { + if (s[i] == '"') { + r.append(std::string(num_bs + 1, '\\')); + num_bs = 0; + } else if (s[i] == '\\') { + ++num_bs; + } else { + num_bs = 0; + } + r += s[i]; + } + r.append(num_bs, '\\'); + r += '"'; + return r; + }; + for (const auto& arg : options_.args) { + absl::StrAppend(&binary_cmd, " ", Escape(arg)); + } + return binary_cmd; +#else // _WIN32 std::vector<std::string> ss; ss.reserve(/*env*/ 1 + options_.env_diff.size() + /*path*/ 1 + /*args*/ options_.args.size() + /*out/err*/ 2); @@ -217,7 +292,7 @@ } } for (auto& var : env_to_set) { - ss.push_back(std::move(var)); + ss.push_back(ShellEscape(var)); } // path. std::string path = path_; @@ -235,46 +310,57 @@ ss.push_back(std::move(path)); // args. for (const auto& arg : options_.args) { - ss.push_back(arg); + ss.push_back(ShellEscape(arg)); } - // out/err. + // in/out/err. + if (!options_.stdin_file_path.empty()) { + ss.push_back(absl::StrCat("< ", ShellEscape(options_.stdin_file_path))); + } if (!stdout_file_.empty()) { - ss.push_back(absl::StrCat("> ", stdout_file_)); + ss.push_back(absl::StrCat("> ", ShellEscape(stdout_file_))); } if (!stderr_file_.empty()) { if (stdout_file_ != stderr_file_) { - ss.push_back(absl::StrCat("2> ", stderr_file_)); + ss.push_back(absl::StrCat("2> ", ShellEscape(stderr_file_))); } else { ss.push_back("2>&1"); } } // Trim trailing space and return. return absl::StrJoin(ss, kCommandLineSeparator); +#endif // _WIN32 } bool Command::StartForkServer(std::string_view temp_dir_path, std::string_view prefix) { +#ifdef _WIN32 + return false; +#else if (absl::StartsWith(path_, kNoForkServerRequestPrefix)) { FUZZTEST_VLOG(2) << "Fork server disabled for " << path(); return false; } - FUZZTEST_CHECK(!is_executing_ && !fork_server_); + FUZZTEST_CHECK(!is_executing_ && !platform_context_->fork_server); FUZZTEST_VLOG(2) << "Starting fork server for " << path(); ResetRedirectionFiles(GetUniqueSuffix()); command_line_ = ToString(); - fork_server_.reset(new ForkServerProps); - fork_server_->fifo_path_[0] = std::filesystem::path(temp_dir_path) - .append(absl::StrCat(prefix, "_FIFO0")); - fork_server_->fifo_path_[1] = std::filesystem::path(temp_dir_path) - .append(absl::StrCat(prefix, "_FIFO1")); + platform_context_->fork_server = std::make_unique<ForkServerProps>(); + platform_context_->fork_server->fifo_path_[0] = + std::filesystem::path(temp_dir_path) + .append(absl::StrCat(prefix, "_FIFO0")); + platform_context_->fork_server->fifo_path_[1] = + std::filesystem::path(temp_dir_path) + .append(absl::StrCat(prefix, "_FIFO1")); const std::string pid_file_path = std::filesystem::path(temp_dir_path).append("pid"); (void)std::filesystem::create_directory(temp_dir_path); // it may not exist. for (int i = 0; i < 2; ++i) { - FUZZTEST_PCHECK(mkfifo(fork_server_->fifo_path_[i].c_str(), 0600) == 0) - << VV(i) << VV(fork_server_->fifo_path_[i]); + FUZZTEST_PCHECK( + mkfifo(platform_context_->fork_server->fifo_path_[i].c_str(), 0600) == + 0) + << VV(i) << VV(platform_context_->fork_server->fifo_path_[i]); } // NOTE: A background process does not return its exit status to the subshell, @@ -290,8 +376,9 @@ printf "%%s" $! > "%s" )sh"; const std::string fork_server_command = absl::StrFormat( - kForkServerCommandStub, fork_server_->fifo_path_[0], - fork_server_->fifo_path_[1], command_line_, pid_file_path); + kForkServerCommandStub, platform_context_->fork_server->fifo_path_[0], + platform_context_->fork_server->fifo_path_[1], command_line_, + pid_file_path); FUZZTEST_VLOG(1) << "Fork server command:" << fork_server_command; const int exit_code = system(fork_server_command.c_str()); @@ -316,10 +403,12 @@ // it. // See more at // https://www.gnu.org/software/libc/manual/html_node/Operating-Modes.html. - if ((fork_server_->pipe_[0] = open(fork_server_->fifo_path_[0].c_str(), - O_RDWR | O_NONBLOCK)) < 0 || - (fork_server_->pipe_[1] = open(fork_server_->fifo_path_[1].c_str(), - O_RDONLY | O_NONBLOCK)) < 0) { + if ((platform_context_->fork_server->pipe_[0] = + open(platform_context_->fork_server->fifo_path_[0].c_str(), + O_RDWR | O_NONBLOCK)) < 0 || + (platform_context_->fork_server->pipe_[1] = + open(platform_context_->fork_server->fifo_path_[1].c_str(), + O_RDONLY | O_NONBLOCK)) < 0) { LogProblemInfo( "Failed to establish communication with fork server; will proceed " "without it"); @@ -328,8 +417,11 @@ std::string pid_str; ReadFromLocalFile(pid_file_path, pid_str); - FUZZTEST_CHECK(absl::SimpleAtoi(pid_str, &fork_server_->pid_)) << VV(pid_str); - auto creation_stamp = GetProcessCreationStamp(fork_server_->pid_); + FUZZTEST_CHECK( + absl::SimpleAtoi(pid_str, &platform_context_->fork_server->pid_)) + << VV(pid_str); + auto creation_stamp = + GetProcessCreationStamp(platform_context_->fork_server->pid_); if (!creation_stamp.ok()) { LogProblemInfo( absl::StrCat("Failed to get the fork server's creation stamp; will " @@ -338,8 +430,9 @@ creation_stamp.status(), ")")); return false; } - fork_server_->creation_stamp = *std::move(creation_stamp); + platform_context_->fork_server->creation_stamp = *std::move(creation_stamp); return true; +#endif // _WIN32 } void Command::ResetRedirectionFiles(std::string_view new_suffix) { @@ -364,37 +457,180 @@ } absl::Status Command::VerifyForkServerIsHealthy() { +#ifdef _WIN32 + return absl::UnimplementedError("Fork server not supported on Windows"); +#else // Preconditions: the callers (`Execute()`) should call us only when the fork // server is presumed to be running (`fork_server_pid_` >= 0). If it is, the // comms pipes are guaranteed to be opened by `StartForkServer()`. - FUZZTEST_CHECK(fork_server_ != nullptr) << "Fork server wasn't started"; - FUZZTEST_CHECK(fork_server_->pid_ >= 0) + FUZZTEST_CHECK(platform_context_->fork_server != nullptr) + << "Fork server wasn't started"; + FUZZTEST_CHECK(platform_context_->fork_server->pid_ >= 0) << "Fork server process failed to start"; - FUZZTEST_CHECK(fork_server_->pipe_[0] >= 0 && fork_server_->pipe_[1] >= 0) + FUZZTEST_CHECK(platform_context_->fork_server->pipe_[0] >= 0 && + platform_context_->fork_server->pipe_[1] >= 0) << "Failed to connect to fork server"; // A process with the fork server PID exists (_some_ process, possibly with a // recycled PID)... - if (kill(fork_server_->pid_, 0) != EXIT_SUCCESS) { - return absl::UnknownError(absl::StrCat( - "Can't communicate with fork server, PID=", fork_server_->pid_)); + if (kill(platform_context_->fork_server->pid_, 0) != EXIT_SUCCESS) { + return absl::UnknownError( + absl::StrCat("Can't communicate with fork server, PID=", + platform_context_->fork_server->pid_)); } // ...and it is a process has the same creation stamp, so it's practically // guaranteed to be our original fork server process. - const auto creation_stamp = GetProcessCreationStamp(fork_server_->pid_); + const auto creation_stamp = + GetProcessCreationStamp(platform_context_->fork_server->pid_); if (!creation_stamp.ok()) return creation_stamp.status(); - if (*creation_stamp != fork_server_->creation_stamp) { + if (*creation_stamp != platform_context_->fork_server->creation_stamp) { return absl::UnknownError(absl::StrCat( "Fork server's creation stamp changed (new process?) - expected ", - fork_server_->creation_stamp, ", but got ", *creation_stamp)); + platform_context_->fork_server->creation_stamp, ", but got ", + *creation_stamp)); } return absl::OkStatus(); +#endif // _WIN32 } bool Command::ExecuteAsync() { FUZZTEST_CHECK(!is_executing()); - if (fork_server_ != nullptr) { +#ifdef _WIN32 + FUZZTEST_CHECK_EQ(platform_context_->win_process_handle, + INVALID_HANDLE_VALUE); + ResetRedirectionFiles(GetUniqueSuffix()); + command_line_ = ToString(); + + struct CaseInsensitiveHash { + size_t operator()(std::string_view s) const { + return absl::Hash<std::string>{}(absl::AsciiStrToLower(s)); + } + }; + + struct CaseInsensitiveEqual { + bool operator()(std::string_view a, std::string_view b) const { + return absl::EqualsIgnoreCase(a, b); + } + }; + + absl::flat_hash_map<std::string, std::string, CaseInsensitiveHash, + CaseInsensitiveEqual> + env_map; + + LPCH env_strings = GetEnvironmentStringsA(); + if (env_strings != nullptr) { + const char* ptr = env_strings; + while (*ptr != '\0') { + std::string_view entry(ptr); + ptr += entry.size() + 1; + size_t eq_pos = entry.find('=', 1); + if (eq_pos != std::string_view::npos) { + env_map[std::string(entry.substr(0, eq_pos))] = + std::string(entry.substr(eq_pos + 1)); + } else { + env_map[std::string(entry)] = ""; + } + } + FreeEnvironmentStringsA(env_strings); + } + + for (std::string_view env_var : options_.env_diff) { + if (absl::StartsWith(env_var, "-")) { + std::string_view key = env_var.substr(1); + if (absl::EndsWith(key, "=")) { + key = key.substr(0, key.size() - 1); + } + env_map.erase(std::string(key)); + } else { + auto pos = env_var.find('='); + if (pos != std::string_view::npos) { + std::string key(env_var.substr(0, pos)); + std::string val(env_var.substr(pos + 1)); + env_map[key] = val; + } + } + } + + std::string env_block = absl::StrJoin(env_map, absl::string_view("\0", 1), + absl::PairFormatter("=")); + env_block.append(2, '\0'); + + STARTUPINFOA si = {sizeof(si)}; + PROCESS_INFORMATION pi = {}; + si.dwFlags = STARTF_USESTDHANDLES; + + SECURITY_ATTRIBUTES sa = {sizeof(sa), NULL, TRUE}; + HANDLE hIn = INVALID_HANDLE_VALUE; + HANDLE hOut = INVALID_HANDLE_VALUE; + HANDLE hErr = INVALID_HANDLE_VALUE; + + absl::Cleanup close_handles = [&] { + if (hIn != INVALID_HANDLE_VALUE) CloseHandle(hIn); + if (hOut != INVALID_HANDLE_VALUE) CloseHandle(hOut); + if (hErr != INVALID_HANDLE_VALUE && hErr != hOut) CloseHandle(hErr); + }; + + if (!options_.stdin_file_path.empty()) { + hIn = CreateFileA(options_.stdin_file_path.c_str(), FILE_READ_DATA, + /*dwShareMode=*/0, &sa, OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, NULL); + if (hIn == INVALID_HANDLE_VALUE) { + FUZZTEST_LOG(ERROR) << "Failed to open stdin file: " + << options_.stdin_file_path; + return false; + } + si.hStdInput = hIn; + } else { + si.hStdInput = GetStdHandle(STD_INPUT_HANDLE); + } + + if (!stdout_file_.empty()) { + hOut = CreateFileA(stdout_file_.c_str(), FILE_WRITE_DATA, FILE_SHARE_READ, + &sa, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); + if (hOut == INVALID_HANDLE_VALUE) { + FUZZTEST_LOG(ERROR) << "Failed to open stdout file: " << stdout_file_; + return false; + } + si.hStdOutput = hOut; + } else { + si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE); + } + + if (!stderr_file_.empty()) { + if (stderr_file_ == stdout_file_) { + si.hStdError = si.hStdOutput; + } else { + hErr = CreateFileA(stderr_file_.c_str(), FILE_WRITE_DATA, FILE_SHARE_READ, + &sa, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); + if (hErr == INVALID_HANDLE_VALUE) { + FUZZTEST_LOG(ERROR) << "Failed to open stderr file: " << stderr_file_; + return false; + } + si.hStdError = hErr; + } + } else { + si.hStdError = GetStdHandle(STD_ERROR_HANDLE); + } + + std::string cmd = command_line_; + const BOOL cp_res = CreateProcessA( + NULL, cmd.data(), NULL, NULL, TRUE, 0, + env_block.empty() ? NULL : env_block.data(), NULL, &si, &pi); + + if (!cp_res) { + DWORD err = GetLastError(); + FUZZTEST_LOG(ERROR) << "CreateProcessA failed for '" << cmd + << "': error=" << err; + return false; + } + + platform_context_->win_process_handle = pi.hProcess; + CloseHandle(pi.hThread); + is_executing_ = true; + return true; +#else // _WIN32 + if (platform_context_->fork_server != nullptr) { FUZZTEST_VLOG(1) << "Sending execution request to fork server"; if (const auto status = VerifyForkServerIsHealthy(); !status.ok()) { @@ -405,13 +641,15 @@ // Wake up the fork server. char x = ' '; - FUZZTEST_CHECK_EQ(1, write(fork_server_->pipe_[0], &x, 1)); + FUZZTEST_CHECK_EQ(1, + write(platform_context_->fork_server->pipe_[0], &x, 1)); // Read the one-byte ack. // Use 60s as an arbitrary duration to wait for the process to load and // enter the fork server. - FUZZTEST_CHECK(fork_server_->ReadPipe(absl::Now() + absl::Seconds(60), x)); + FUZZTEST_CHECK(platform_context_->fork_server->ReadPipe( + absl::Now() + absl::Seconds(60), x)); } else { - FUZZTEST_CHECK_EQ(pid_, -1); + FUZZTEST_CHECK_EQ(platform_context_->pid, -1); ResetRedirectionFiles(GetUniqueSuffix()); command_line_ = ToString(); @@ -424,24 +662,58 @@ argv.push_back(argv_str.data()); } argv.push_back(nullptr); - FUZZTEST_PCHECK(posix_spawn(&pid_, argv[0], /*file_actions=*/nullptr, + FUZZTEST_PCHECK(posix_spawn(&platform_context_->pid, argv[0], + /*file_actions=*/nullptr, /*attrp=*/nullptr, argv.data(), environ) == 0); } is_executing_ = true; return true; +#endif // _WIN32 } std::optional<int> Command::Wait(absl::Time deadline, StopCondition* stop_condition) { FUZZTEST_CHECK(is_executing()); +#ifdef _WIN32 + FUZZTEST_CHECK_NE(platform_context_->win_process_handle, + INVALID_HANDLE_VALUE); + DWORD timeout_ms = INFINITE; + if (deadline != absl::InfiniteFuture()) { + auto dur = deadline - absl::Now(); + if (dur <= absl::ZeroDuration()) { + timeout_ms = 0; + } else { + timeout_ms = static_cast<DWORD>(absl::ToInt64Milliseconds(dur)); + } + } + DWORD res = + WaitForSingleObject(platform_context_->win_process_handle, timeout_ms); + if (res == WAIT_TIMEOUT) { + VlogProblemInfo( + absl::StrCat("Timeout while waiting for command process: deadline is ", + deadline), + /*vlog_level=*/1); + return std::nullopt; + } + DWORD exit_code = 0; + GetExitCodeProcess(platform_context_->win_process_handle, &exit_code); + CloseHandle(platform_context_->win_process_handle); + platform_context_->win_process_handle = INVALID_HANDLE_VALUE; + is_executing_ = false; + if (exit_code == STATUS_CONTROL_C_EXIT && stop_condition != nullptr) { + stop_condition->RequestStop( + EXIT_FAILURE, "Command killed: signal=SIGINT (likely Ctrl-C)"); + } + return static_cast<int>(exit_code); +#else // _WIN32 int exit_code = EXIT_SUCCESS; - if (fork_server_ != nullptr) { + if (platform_context_->fork_server != nullptr) { // The fork server forks, the child is running. Block until some readable // data appears in the pipe (that is, after the fork server writes the // execution result to it). - if (!fork_server_->ReadPipe(deadline, exit_code)) { + if (!platform_context_->fork_server->ReadPipe(deadline, exit_code)) { VlogProblemInfo( absl::StrCat("Waiting for fork server failed, deadline is ", deadline), @@ -449,11 +721,13 @@ return std::nullopt; } } else { - FUZZTEST_CHECK_NE(pid_, -1); + FUZZTEST_CHECK_NE(platform_context_->pid, -1); while (true) { - const pid_t r = waitpid(pid_, &exit_code, WNOHANG); + const pid_t r = waitpid(platform_context_->pid, &exit_code, WNOHANG); FUZZTEST_CHECK_NE(r, -1); - if (r == pid_ && (WIFEXITED(exit_code) || WIFSIGNALED(exit_code))) break; + if (r == platform_context_->pid && + (WIFEXITED(exit_code) || WIFSIGNALED(exit_code))) + break; FUZZTEST_CHECK_EQ(r, 0); const auto timeout = deadline - absl::Now(); if (timeout > absl::ZeroDuration()) { @@ -470,7 +744,7 @@ return std::nullopt; } } - pid_ = -1; + platform_context_->pid = -1; } is_executing_ = false; @@ -528,20 +802,27 @@ } return exit_code; +#endif // _WIN32 } void Command::RequestStop(bool force) { FUZZTEST_CHECK(is_executing()); - if (fork_server_) { - FUZZTEST_CHECK_NE(fork_server_->pid_, -1); +#ifdef _WIN32 + FUZZTEST_CHECK_NE(platform_context_->win_process_handle, + INVALID_HANDLE_VALUE); + TerminateProcess(platform_context_->win_process_handle, 1); +#else + if (platform_context_->fork_server) { + FUZZTEST_CHECK_NE(platform_context_->fork_server->pid_, -1); // Cannot send SIGKILL to the fork server as it kills only the parent // process, but not the child. The fork server would send SIGKILL to the // child on SIGUSR1. - kill(fork_server_->pid_, force ? SIGUSR1 : SIGTERM); + kill(platform_context_->fork_server->pid_, force ? SIGUSR1 : SIGTERM); return; } - FUZZTEST_CHECK_NE(pid_, -1); - kill(pid_, force ? SIGKILL : SIGTERM); + FUZZTEST_CHECK_NE(platform_context_->pid, -1); + kill(platform_context_->pid, force ? SIGKILL : SIGTERM); +#endif // _WIN32 } std::string Command::ReadRedirectedStdout() const {
diff --git a/centipede/command.h b/centipede/command.h index 33c1d14..15d4d70 100644 --- a/centipede/command.h +++ b/centipede/command.h
@@ -52,6 +52,8 @@ // `Command` automatically unlinks any previous redirected files on // execution and destruction. std::string stderr_file_prefix; + // Redirect stdin from this file path if non-empty. + std::string stdin_file_path; // "@@" in the command will be replaced with `temp_file_path`. std::string temp_file_path; }; @@ -125,9 +127,8 @@ const std::string& stderr_file() const { return stderr_file_; } private: - struct ForkServerProps; + struct PlatformContext; - int pid_ = -1; bool is_executing_ = false; // Derived from Options::{stdout,stderr}_file_prefix, with the realized suffix @@ -163,7 +164,7 @@ const Options options_; std::string command_line_; - std::unique_ptr<ForkServerProps> fork_server_; + std::unique_ptr<PlatformContext> platform_context_; }; // Get the shared mutex for execution logging for preventing confusing
diff --git a/centipede/command_test.cc b/centipede/command_test.cc index 48f4d07..0c91cb1 100644 --- a/centipede/command_test.cc +++ b/centipede/command_test.cc
@@ -15,7 +15,9 @@ #include "./centipede/command.h" #include <signal.h> +#ifndef _WIN32 #include <sys/wait.h> // NOLINT(for WTERMSIG) +#endif #include <cstdlib> #include <filesystem> // NOLINT @@ -26,6 +28,7 @@ #include "gmock/gmock.h" #include "gtest/gtest.h" +#include "absl/strings/str_cat.h" #include "absl/strings/substitute.h" #include "absl/time/clock.h" #include "absl/time/time.h" @@ -33,58 +36,120 @@ #include "./centipede/util.h" #include "./common/test_util.h" +#ifdef _WIN32 +#define setenv(n, v, _r) _putenv_s(n, v) +#endif + namespace fuzztest::internal { namespace { +using ::testing::AllOf; +using ::testing::HasSubstr; using ::testing::Optional; -TEST(CommandTest, ToString) { - EXPECT_EQ(Command{"x"}.ToString(), "exec env \\\nx"); - { - Command::Options cmd_options; - cmd_options.args = {"arg1", "arg2"}; - EXPECT_EQ((Command{"path", std::move(cmd_options)}.ToString()), - "exec env \\\npath \\\narg1 \\\narg2"); - } - { - Command::Options cmd_options; - cmd_options.env_diff = {"K1=V1", "K2=V2", "-K3"}; - EXPECT_EQ((Command{"x", std::move(cmd_options)}.ToString()), - "exec env \\\n-u K3 \\\nK1=V1 \\\nK2=V2 \\\nx"); - } -} - TEST(CommandTest, Execute) { + const std::string helper = + GetDataDependencyFilepath("centipede/command_test_helper").string(); StopCondition stop_condition; // Check for default exit code. - Command echo{"echo"}; - EXPECT_EQ(echo.Execute(&stop_condition), 0); + Command::Options options_success; + options_success.args = {"success"}; + Command success_cmd{helper, std::move(options_success)}; + EXPECT_EQ(success_cmd.Execute(&stop_condition), 0); EXPECT_FALSE(stop_condition.ShouldStop()); // Check for exit code 7. - Command exit7{"bash -c 'exit 7'"}; + Command::Options options_ret7; + options_ret7.args = {"ret7"}; + Command exit7{helper, std::move(options_ret7)}; EXPECT_EQ(exit7.Execute(&stop_condition), 7); EXPECT_FALSE(stop_condition.ShouldStop()); } TEST(CommandTest, HandlesInterruptedCommand) { + const std::string helper = + GetDataDependencyFilepath("centipede/command_test_helper").string(); StopCondition stop_condition; - Command self_sigint{"bash -c 'kill -SIGINT $$'"}; - self_sigint.ExecuteAsync(); - self_sigint.Wait(absl::InfiniteFuture(), &stop_condition); + Command::Options options_ctrlc; + options_ctrlc.args = {"ctrlc"}; + Command self_ctrlc{helper, std::move(options_ctrlc)}; + // Cannot set to SIG_IGN as the command would inherit that. + signal(SIGINT, [](int) {}); + self_ctrlc.ExecuteAsync(); + signal(SIGINT, SIG_DFL); + self_ctrlc.Wait(absl::InfiniteFuture(), &stop_condition); EXPECT_TRUE(stop_condition.ShouldStop()); } -TEST(CommandTest, InputFileWildCard) { - Command::Options cmd_options; - cmd_options.temp_file_path = "TEMP_FILE"; - Command cmd{"foo bar @@ baz", std::move(cmd_options)}; - EXPECT_EQ(cmd.ToString(), "exec env \\\nfoo bar TEMP_FILE baz"); +TEST(CommandTest, ExecuteWithOptions) { + const std::filesystem::path test_tmpdir = GetTestTempDir(test_info_->name()); + const std::string helper = + GetDataDependencyFilepath("centipede/command_test_helper").string(); + + { + const std::string log_prefix = (test_tmpdir / "args").string(); + Command::Options cmd_options; + cmd_options.args = {"echo_args", "arg1", "arg2"}; + cmd_options.stdout_file_prefix = log_prefix; + Command cmd{helper, std::move(cmd_options)}; + EXPECT_EQ(cmd.Execute(), 0); + std::string log_contents; + ReadFromLocalFile(cmd.stdout_file(), log_contents); + EXPECT_THAT(log_contents, + AllOf(HasSubstr("arg[0]=arg1\n"), HasSubstr("arg[1]=arg2\n"))); + } + + { + setenv("K3", "V3", 1); + const std::string log_prefix = (test_tmpdir / "env").string(); + Command::Options cmd_options; + cmd_options.args = {"echo_env", "K1", "K2", "K3"}; + cmd_options.env_diff = {"K1=V1", "K2=V2", "-K3"}; + cmd_options.stdout_file_prefix = log_prefix; + Command cmd{helper, std::move(cmd_options)}; + EXPECT_EQ(cmd.Execute(), 0); + std::string log_contents; + ReadFromLocalFile(cmd.stdout_file(), log_contents); + EXPECT_THAT(log_contents, AllOf(HasSubstr("K1=V1\n"), HasSubstr("K2=V2\n"), + HasSubstr("K3=<UNSET>\n"))); + } + + { + const std::string stdin_file = (test_tmpdir / "input.txt").string(); + WriteToLocalFile(stdin_file, "hello stdin"); + const std::string log_prefix = (test_tmpdir / "stdin").string(); + Command::Options cmd_options; + cmd_options.args = {"echo_stdin"}; + cmd_options.stdin_file_path = stdin_file; + cmd_options.stdout_file_prefix = log_prefix; + Command cmd{helper, std::move(cmd_options)}; + EXPECT_EQ(cmd.Execute(), 0); + std::string log_contents; + ReadFromLocalFile(cmd.stdout_file(), log_contents); + EXPECT_THAT(log_contents, HasSubstr("hello stdin")); + } } +TEST(CommandTest, InputFileWildCard) { + const std::filesystem::path test_tmpdir = GetTestTempDir(test_info_->name()); + const std::string helper = + GetDataDependencyFilepath("centipede/command_test_helper").string(); + const std::string log_prefix = (test_tmpdir / "wildcard").string(); + + Command::Options cmd_options; + cmd_options.temp_file_path = "TEMP_FILE"; + cmd_options.stdout_file_prefix = log_prefix; + Command cmd{absl::StrCat(helper, " @@"), std::move(cmd_options)}; + EXPECT_EQ(cmd.Execute(), 17); + std::string log_contents; + ReadFromLocalFile(cmd.stdout_file(), log_contents); + EXPECT_EQ(log_contents, "Got input: TEMP_FILE\n"); +} + +#ifndef _WIN32 TEST(CommandTest, ForkServer) { - const std::string test_tmpdir = GetTestTempDir(test_info_->name()); + const std::filesystem::path test_tmpdir = GetTestTempDir(test_info_->name()); const std::string helper = GetDataDependencyFilepath("centipede/command_test_helper"); @@ -92,93 +157,93 @@ { const std::string input = "success"; - const std::string log_prefix = std::filesystem::path{test_tmpdir} / input; + const std::string log_prefix = test_tmpdir / input; Command::Options cmd_options; cmd_options.args = {input}; cmd_options.stdout_file_prefix = log_prefix; cmd_options.stderr_file_prefix = log_prefix; Command cmd{helper, std::move(cmd_options)}; - EXPECT_TRUE(cmd.StartForkServer(test_tmpdir, "ForkServer")); + EXPECT_TRUE(cmd.StartForkServer(test_tmpdir.string(), "ForkServer")); EXPECT_EQ(cmd.Execute(), EXIT_SUCCESS); std::string log_contents; ReadFromLocalFile(cmd.stdout_file(), log_contents); - EXPECT_EQ(log_contents, absl::Substitute("Got input: $0", input)); + EXPECT_EQ(log_contents, absl::Substitute("Got input: $0\n", input)); } { const std::string input = "fail"; - const std::string log_prefix = std::filesystem::path{test_tmpdir} / input; + const std::string log_prefix = test_tmpdir / input; Command::Options cmd_options; cmd_options.args = {input}; cmd_options.stdout_file_prefix = log_prefix; cmd_options.stderr_file_prefix = log_prefix; Command cmd{helper, std::move(cmd_options)}; - EXPECT_TRUE(cmd.StartForkServer(test_tmpdir, "ForkServer")); + EXPECT_TRUE(cmd.StartForkServer(test_tmpdir.string(), "ForkServer")); EXPECT_EQ(cmd.Execute(), EXIT_FAILURE); std::string log_contents; ReadFromLocalFile(cmd.stdout_file(), log_contents); - EXPECT_EQ(log_contents, absl::Substitute("Got input: $0", input)); + EXPECT_EQ(log_contents, absl::Substitute("Got input: $0\n", input)); } { const std::string input = "ret42"; - const std::string log_prefix = std::filesystem::path{test_tmpdir} / input; + const std::string log_prefix = test_tmpdir / input; Command::Options cmd_options; cmd_options.args = {input}; cmd_options.stdout_file_prefix = log_prefix; cmd_options.stderr_file_prefix = log_prefix; Command cmd{helper, std::move(cmd_options)}; - EXPECT_TRUE(cmd.StartForkServer(test_tmpdir, "ForkServer")); + EXPECT_TRUE(cmd.StartForkServer(test_tmpdir.string(), "ForkServer")); EXPECT_EQ(cmd.Execute(), 42); std::string log_contents; ReadFromLocalFile(cmd.stdout_file(), log_contents); - EXPECT_EQ(log_contents, absl::Substitute("Got input: $0", input)); + EXPECT_EQ(log_contents, absl::Substitute("Got input: $0\n", input)); } { const std::string input = "abort"; - const std::string log_prefix = std::filesystem::path{test_tmpdir} / input; + const std::string log_prefix = test_tmpdir / input; Command::Options cmd_options; cmd_options.args = {input}; cmd_options.stdout_file_prefix = log_prefix; cmd_options.stderr_file_prefix = log_prefix; Command cmd{helper, std::move(cmd_options)}; - EXPECT_TRUE(cmd.StartForkServer(test_tmpdir, "ForkServer")); + EXPECT_TRUE(cmd.StartForkServer(test_tmpdir.string(), "ForkServer")); // WTERMSIG() needs an lvalue on some platforms. const int ret = cmd.Execute(); EXPECT_EQ(WTERMSIG(ret), SIGABRT); std::string log_contents; ReadFromLocalFile(cmd.stdout_file(), log_contents); - EXPECT_EQ(log_contents, absl::Substitute("Got input: $0", input)); + EXPECT_EQ(log_contents, absl::Substitute("Got input: $0\n", input)); } { const std::string input = "sleep"; - const std::string log_prefix = std::filesystem::path{test_tmpdir} / input; + const std::string log_prefix = test_tmpdir / input; Command::Options cmd_options; cmd_options.args = {input}; cmd_options.stdout_file_prefix = log_prefix; cmd_options.stderr_file_prefix = log_prefix; Command cmd{helper, std::move(cmd_options)}; - ASSERT_TRUE(cmd.StartForkServer(test_tmpdir, "ForkServer")); + ASSERT_TRUE(cmd.StartForkServer(test_tmpdir.string(), "ForkServer")); ASSERT_TRUE(cmd.ExecuteAsync()); EXPECT_EQ(cmd.Wait(absl::Now() + absl::Seconds(2)), std::nullopt); cmd.RequestStop(/*force=*/false); EXPECT_THAT(cmd.Wait(absl::Now() + absl::Seconds(2)), Optional(SIGTERM)); std::string log_contents; ReadFromLocalFile(cmd.stdout_file(), log_contents); - EXPECT_EQ(log_contents, absl::Substitute("Got input: $0", input)); + EXPECT_EQ(log_contents, absl::Substitute("Got input: $0\n", input)); } { const std::string input = "hang"; - const std::string log_prefix = std::filesystem::path{test_tmpdir} / input; + const std::string log_prefix = test_tmpdir / input; Command::Options cmd_options; cmd_options.args = {input}; cmd_options.stdout_file_prefix = log_prefix; cmd_options.stderr_file_prefix = log_prefix; Command cmd{helper, std::move(cmd_options)}; - ASSERT_TRUE(cmd.StartForkServer(test_tmpdir, "ForkServer")); + ASSERT_TRUE(cmd.StartForkServer(test_tmpdir.string(), "ForkServer")); ASSERT_TRUE(cmd.ExecuteAsync()); EXPECT_EQ(cmd.Wait(absl::Now() + absl::Seconds(2)), std::nullopt); cmd.RequestStop(/*force=*/false); @@ -187,11 +252,12 @@ EXPECT_THAT(cmd.Wait(absl::Now() + absl::Seconds(2)), Optional(SIGKILL)); std::string log_contents; ReadFromLocalFile(cmd.stdout_file(), log_contents); - EXPECT_EQ(log_contents, absl::Substitute("Got input: $0", input)); + EXPECT_EQ(log_contents, absl::Substitute("Got input: $0\n", input)); } // TODO(kcc): [impl] test what happens if the child is interrupted. } +#endif } // namespace } // namespace fuzztest::internal
diff --git a/centipede/command_test_helper.cc b/centipede/command_test_helper.cc index d3153a8..31b6100 100644 --- a/centipede/command_test_helper.cc +++ b/centipede/command_test_helper.cc
@@ -12,33 +12,92 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include <unistd.h> - #include <cassert> #include <csignal> #include <cstdio> #include <cstdlib> #include <cstring> +#ifdef _WIN32 +#include <fcntl.h> +#include <io.h> + +#include "./common/windows_includes.h" +#endif + #include "absl/base/nullability.h" +#include "absl/strings/match.h" +#include "absl/strings/numbers.h" +#include "absl/strings/string_view.h" #include "absl/time/clock.h" #include "absl/time/time.h" // A binary linked with the fork server that exits/crashes in different ways. int main(int argc, char** absl_nonnull argv) { - assert(argc == 2); - printf("Got input: %s", argv[1]); +#ifdef _WIN32 + // Disable the automatic \n -> \r\n conversion. + _setmode(1, _O_BINARY); +#endif + + assert(argc >= 2); + printf("Got input: %s\n", argv[1]); + + if (!strcmp(argv[1], "echo_args")) { + for (int i = 2; i < argc; ++i) { + printf("arg[%d]=%s\n", i - 2, argv[i]); + } + fflush(stdout); + return EXIT_SUCCESS; + } + + if (!strcmp(argv[1], "echo_env")) { + for (int i = 2; i < argc; ++i) { + const char* val = getenv(argv[i]); + printf("%s=%s\n", argv[i], val ? val : "<UNSET>"); + } + fflush(stdout); + return EXIT_SUCCESS; + } + + if (!strcmp(argv[1], "echo_stdin")) { + char buf[1024]; + while (fgets(buf, sizeof(buf), stdin)) { + fputs(buf, stdout); + } + fflush(stdout); + return EXIT_SUCCESS; + } + fflush(stdout); + if (!strcmp(argv[1], "success")) return EXIT_SUCCESS; if (!strcmp(argv[1], "fail")) return EXIT_FAILURE; - if (!strcmp(argv[1], "ret42")) return 42; + + int ret_code = 0; + if (absl::StartsWith(argv[1], "ret") && + absl::SimpleAtoi(argv[1] + 3, &ret_code)) { + return ret_code; + } + if (!strcmp(argv[1], "abort")) abort(); + if (!strcmp(argv[1], "ctrlc")) { +#ifdef _WIN32 + SetConsoleCtrlHandler(NULL, FALSE); + GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0); + Sleep(INFINITE); +#else + raise(SIGINT); +#endif + return EXIT_SUCCESS; + } // Sleep longer than kTimeout in CommandDeathTest_ForkServerHangingBinary. if (!strcmp(argv[1], "sleep")) absl::SleepFor(absl::Seconds(5)); if (!strcmp(argv[1], "hang")) { +#ifndef _WIN32 struct sigaction act{}; act.sa_handler = [](int) {}; sigaction(SIGTERM, &act, nullptr); +#endif absl::SleepFor(absl::Seconds(10)); }
diff --git a/centipede/symbol_table.cc b/centipede/symbol_table.cc index e693b48..6e58ebd 100644 --- a/centipede/symbol_table.cc +++ b/centipede/symbol_table.cc
@@ -120,10 +120,9 @@ "--no-inlines", "-e", std::string(dso_path), - "<", - std::string(pcs_file.path()), }; - cmd_options.stdout_file_prefix = symbols_file_prefix; + cmd_options.stdin_file_path = std::string(pcs_file.path()); + cmd_options.stdout_file_prefix = symbols_file_prefix.string(); Command cmd{symbolizer_path, std::move(cmd_options)}; int exit_code = cmd.Execute(); if (exit_code != EXIT_SUCCESS) {
diff --git a/centipede/util.cc b/centipede/util.cc index 583cc1f..8a9064e 100644 --- a/centipede/util.cc +++ b/centipede/util.cc
@@ -17,8 +17,12 @@ #include "./centipede/util.h" +#ifdef _WIN32 +#include "./common/windows_includes.h" +#else #include <sys/mman.h> #include <unistd.h> +#endif #include <algorithm> #include <cctype> @@ -47,6 +51,7 @@ #include "absl/base/const_init.h" #include "absl/base/nullability.h" #include "absl/base/thread_annotations.h" +#include "absl/strings/match.h" #include "absl/strings/str_format.h" #include "absl/strings/str_replace.h" #include "absl/strings/str_split.h" @@ -63,8 +68,13 @@ size_t GetRandomSeed(size_t seed) { if (seed != 0) return seed; +#ifdef _WIN32 + return time(nullptr) + GetCurrentProcessId() + + std::hash<std::thread::id>{}(std::this_thread::get_id()); +#else return time(nullptr) + getpid() + std::hash<std::thread::id>{}(std::this_thread::get_id()); +#endif } std::string AsPrintableString(ByteSpan data, size_t max_len) { @@ -83,7 +93,7 @@ template <typename Container> void ReadFromLocalFile(std::string_view file_path, Container &data) { - std::ifstream f(std::string{file_path}); + std::ifstream f(std::string{file_path}, std::ios::in | std::ios::binary); if (!f) return; f.seekg(0, std::ios_base::end); auto size = f.tellg(); @@ -112,12 +122,13 @@ } void ClearLocalFileContents(std::string_view file_path) { - std::ofstream f(std::string{file_path}, std::ios::out | std::ios::trunc); + std::ofstream f(std::string{file_path}, + std::ios::out | std::ios::trunc | std::ios::binary); FUZZTEST_CHECK(f) << "Failed to clear the file: " << file_path; } void WriteToLocalFile(std::string_view file_path, ByteSpan data) { - std::ofstream f(std::string{file_path}); + std::ofstream f(std::string{file_path}, std::ios::out | std::ios::binary); FUZZTEST_CHECK(f) << "Failed to open local file: " << file_path; f.write(reinterpret_cast<const char *>(data.data()), static_cast<int64_t>(data.size())); @@ -136,13 +147,15 @@ void WriteToLocalHashedFileInDir(std::string_view dir_path, ByteSpan data) { if (dir_path.empty()) return; - std::string file_path = std::filesystem::path(dir_path).append(Hash(data)); + std::string file_path = + std::filesystem::path(dir_path).append(Hash(data)).string(); WriteToLocalFile(file_path, data); } void WriteToRemoteHashedFileInDir(std::string_view dir_path, ByteSpan data) { if (dir_path.empty()) return; - std::string file_path = std::filesystem::path(dir_path).append(Hash(data)); + std::string file_path = + std::filesystem::path(dir_path).append(Hash(data)).string(); FUZZTEST_CHECK_OK( RemoteFileSetContents(file_path, std::string(data.begin(), data.end()))); } @@ -155,17 +168,24 @@ } std::string ProcessAndThreadUniqueID(std::string_view prefix) { - // operator << is the only way to serialize std::this_thread::get_id(). std::ostringstream oss; +#ifdef _WIN32 + oss << prefix << GetCurrentProcessId() << "-" << GetCurrentThreadId(); +#else + // operator << is the only way to serialize std::this_thread::get_id(). oss << prefix << getpid() << "-" << std::this_thread::get_id(); +#endif return oss.str(); } std::string TemporaryLocalDirPath() { const char *TMPDIR = getenv("TMPDIR"); + if (!TMPDIR) TMPDIR = getenv("TEMP"); + if (!TMPDIR) TMPDIR = getenv("TMP"); std::string tmp = TMPDIR ? TMPDIR : "/tmp"; - return std::filesystem::path(tmp).append( - ProcessAndThreadUniqueID("centipede-")); + return std::filesystem::path(tmp) + .append(ProcessAndThreadUniqueID("centipede-")) + .string(); } // We need to maintain a global set of dirs that CreateLocalDirRemovedAtExit() @@ -189,13 +209,19 @@ void CreateLocalDirRemovedAtExit(std::string_view path) { // Safeguard against removing dirs not created by TemporaryLocalDirPath(). - FUZZTEST_CHECK_NE(path.find("/centipede-"), std::string::npos); + FUZZTEST_CHECK(absl::StrContains(path, "/centipede-") || + absl::StrContains(path, "\\centipede-")); // Create the dir. std::error_code error; - std::filesystem::remove_all(path, error); - FUZZTEST_LOG_IF(ERROR, error) - << "Unable to clean up existing dir " << path << ": " << error.message(); - std::filesystem::create_directories(path); + std::filesystem::path p(path); + if (std::filesystem::exists(p, error)) { + std::filesystem::remove_all(p, error); + FUZZTEST_LOG_IF(ERROR, error) + << "Unable to clean up existing dir " << p << ": " << error.message(); + } + std::filesystem::create_directories(p, error); + FUZZTEST_CHECK(!error) << "Failed to create local dir " << p << ": " + << error.message(); // Add to dirs_to_delete_at_exit. absl::MutexLock lock(dirs_to_delete_at_exit_mutex); if (!dirs_to_delete_at_exit) { @@ -206,7 +232,7 @@ } ScopedFile::ScopedFile(std::string_view dir_path, std::string_view name) - : my_path_(std::filesystem::path(dir_path) / name) {} + : my_path_((std::filesystem::path(dir_path) / name).string()) {} ScopedFile::~ScopedFile() { std::error_code error; @@ -359,16 +385,85 @@ return res; } +#ifdef _WIN32 +// On Windows, we use the first page for the magic cookies of mmapped regions so +// that our VEH can handle it properly. +static constexpr std::string_view kMmapMagicCookie = "CENTIPED"; + +static const auto page_size = []() { + SYSTEM_INFO si; + GetSystemInfo(&si); + return static_cast<size_t>(si.dwPageSize); +}(); + +static LONG CALLBACK +AutoCommitPageFaultHandler(PEXCEPTION_POINTERS exception_info) { + auto record = exception_info->ExceptionRecord; + if (record->ExceptionCode != EXCEPTION_ACCESS_VIOLATION || + record->NumberParameters < 2) { + return EXCEPTION_CONTINUE_SEARCH; + } + auto fault_addr = reinterpret_cast<LPVOID>(record->ExceptionInformation[1]); + MEMORY_BASIC_INFORMATION mbi; + if (VirtualQuery(fault_addr, &mbi, sizeof(mbi)) != sizeof(mbi)) { + return EXCEPTION_CONTINUE_SEARCH; + } + if (mbi.State != MEM_RESERVE) { + return EXCEPTION_CONTINUE_SEARCH; + } + auto cookie_addr = reinterpret_cast<const uint8_t*>(mbi.AllocationBase); + if (VirtualQuery(cookie_addr, &mbi, sizeof(mbi)) != sizeof(mbi)) { + return EXCEPTION_CONTINUE_SEARCH; + } + if (mbi.State != MEM_COMMIT) { + return EXCEPTION_CONTINUE_SEARCH; + } + if (std::memcmp(cookie_addr, kMmapMagicCookie.data(), + kMmapMagicCookie.size()) != 0) { + return EXCEPTION_CONTINUE_SEARCH; + } + if (VirtualAlloc(fault_addr, 1, MEM_COMMIT, PAGE_READWRITE) == nullptr) { + return EXCEPTION_CONTINUE_SEARCH; + } + return EXCEPTION_CONTINUE_EXECUTION; +} +#endif + uint8_t *MmapNoReserve(size_t size) { +#ifdef _WIN32 + // Set up page fault handler to commit page on demand. + [[maybe_unused]] static bool installed_veh = []() { + // Must use `First=0` as it could otherwise conflict with e.g. sanitizers. + AddVectoredExceptionHandler(/*First=*/0, AutoCommitPageFaultHandler); + return true; + }(); + // MEM_RESERVE has different semantics and does not contradict with + // MAP_NORESERVE for mmap. + auto result = reinterpret_cast<uint8_t*>( + VirtualAlloc(nullptr, size + page_size, MEM_RESERVE, PAGE_READWRITE)); + FUZZTEST_CHECK(result != nullptr) + << "VirtualAlloc failed for size " << size << " err=" << GetLastError(); + FUZZTEST_CHECK(VirtualAlloc(result, kMmapMagicCookie.size(), MEM_COMMIT, + PAGE_READWRITE) != nullptr) + << "VirtualAlloc failed to commit the memory region cookie"; + std::memcpy(result, kMmapMagicCookie.data(), kMmapMagicCookie.size()); + return result + page_size; +#else auto result = mmap(0, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_NORESERVE, -1, 0); FUZZTEST_CHECK(result != MAP_FAILED); return reinterpret_cast<uint8_t *>(result); +#endif } void Munmap(uint8_t *ptr, size_t size) { +#ifdef _WIN32 + BOOL result = VirtualFree(ptr - page_size, 0, MEM_RELEASE); + FUZZTEST_CHECK(result != 0); +#else auto result = munmap(ptr, size); FUZZTEST_CHECK_EQ(result, 0); +#endif } int PollTimeoutMs(absl::Duration timeout) {
diff --git a/centipede/util_test.cc b/centipede/util_test.cc index 6f26650..52041aa 100644 --- a/centipede/util_test.cc +++ b/centipede/util_test.cc
@@ -32,6 +32,10 @@ #include "./common/hash.h" #include "./common/logging.h" +#ifdef _WIN32 +#define setenv(n, v, _r) _putenv_s(n, v) +#endif + namespace fuzztest::internal { TEST(UtilTest, AsString) { @@ -116,7 +120,8 @@ auto temp_dir = TemporaryLocalDirPath(); // Create dir, create a file there, write to file, read from it, remove dir. std::filesystem::create_directories(temp_dir); - std::string temp_file_path = std::filesystem::path(temp_dir).append("blah"); + std::string temp_file_path = + std::filesystem::path(temp_dir).append("blah").string(); ByteArray written_data{1, 2, 3}; WriteToLocalFile(temp_file_path, written_data); ByteArray read_data; @@ -162,8 +167,8 @@ EXPECT_TRUE(std::filesystem::exists(tmpdir)); setenv("CENTIPEDE_UTIL_TEST_TEMP_DIR", tmpdir.c_str(), 1); // Create two subdirs via CreateLocalDirRemovedAtExit. - std::string subdir1 = std::filesystem::path(tmpdir).append("1"); - std::string subdir2 = std::filesystem::path(tmpdir).append("2"); + std::string subdir1 = std::filesystem::path(tmpdir).append("1").string(); + std::string subdir2 = std::filesystem::path(tmpdir).append("2").string(); CreateLocalDirRemovedAtExit(subdir1); CreateLocalDirRemovedAtExit(subdir2); EXPECT_TRUE(std::filesystem::exists(subdir1)); @@ -293,6 +298,15 @@ testing::ElementsAre(std::vector<int>{1}, std::vector<int>{3})); } +TEST(UtilTest, MmapTest) { + static constexpr size_t kBufSize = 1 << 30; // 1 GiB + auto* buf = MmapNoReserve(kBufSize); + ASSERT_NE(buf, nullptr); + EXPECT_EQ(buf[1234], 0); + EXPECT_EQ(buf[567890], 0); + Munmap(buf, kBufSize); +} + TEST(UtilTest, PollTimeoutMsWorks) { EXPECT_GT(PollTimeoutMs(absl::ZeroDuration()), 0); EXPECT_GT(PollTimeoutMs(-absl::InfiniteDuration()), 0);
diff --git a/common/BUILD b/common/BUILD index bbdb792..296b140 100644 --- a/common/BUILD +++ b/common/BUILD
@@ -208,6 +208,7 @@ ":blob_file", ":defs", ":logging", + ":windows_includes", "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:str_format", "@googletest//:gtest", @@ -225,6 +226,11 @@ ], ) +cc_library( + name = "windows_includes", + hdrs = ["windows_includes.h"], +) + ### Tests cc_test(
diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt index 671195e..b775763 100644 --- a/common/CMakeLists.txt +++ b/common/CMakeLists.txt
@@ -150,6 +150,13 @@ fuzztest_cc_library( NAME + windows_includes + HDRS + "windows_includes.h" +) + +fuzztest_cc_library( + NAME test_util HDRS "test_util.h" @@ -159,6 +166,7 @@ fuzztest::common_logging fuzztest::blob_file fuzztest::defs + fuzztest::windows_includes absl::strings absl::str_format GTest::gtest
diff --git a/common/test_util.cc b/common/test_util.cc index 3232d55..8bc7063 100644 --- a/common/test_util.cc +++ b/common/test_util.cc
@@ -18,10 +18,20 @@ #include <string_view> #include <system_error> // NOLINT +#ifdef _WIN32 +#include "./common/windows_includes.h" +#else +#include <unistd.h> +#endif + #include "gtest/gtest.h" #include "absl/strings/str_cat.h" #include "./common/logging.h" +#ifdef _WIN32 +#define setenv(n, v, _r) _putenv_s(n, v) +#endif + namespace fuzztest::internal { std::filesystem::path GetTestTempDir(std::string_view subdir) { @@ -35,11 +45,18 @@ FUZZTEST_CHECK(!error) << "Failed to create dir: " VV(dir) << error.message(); } - return std::filesystem::canonical(dir); + return std::filesystem::absolute(dir); } std::string GetTempFilePath(std::string_view subdir, size_t i) { - return GetTestTempDir(subdir) / absl::StrCat("tmp.", getpid(), ".", i); + return (GetTestTempDir(subdir) / absl::StrCat("tmp.", +#ifdef _WIN32 + GetCurrentProcessId(), +#else + getpid(), +#endif + ".", i)) + .string(); } std::filesystem::path GetTestRunfilesDir() { @@ -59,8 +76,15 @@ const auto runfiles_dir = GetTestRunfilesDir(); auto path = runfiles_dir; path.append(rel_path); - FUZZTEST_CHECK(std::filesystem::exists(path)) // - << "No such path: " << VV(path) << VV(runfiles_dir) << VV(rel_path); + std::error_code ec; +#ifdef _WIN32 + auto win_path = path; + win_path += ".exe"; + if (std::filesystem::exists(win_path, ec)) return win_path; +#endif + FUZZTEST_CHECK(std::filesystem::exists(path, ec)) // + << "No such path: " << VV(path) << VV(runfiles_dir) << VV(rel_path) + << VV(ec); return path; }
diff --git a/common/test_util.h b/common/test_util.h index c859bff..e363f18 100644 --- a/common/test_util.h +++ b/common/test_util.h
@@ -79,7 +79,7 @@ const std::filesystem::path& path() const { return path_; } std::string GetFilePath(std::string_view file_name) const { - return path_ / file_name; + return (path_ / file_name).string(); } std::string CreateSubdir(std::string_view name) const {
diff --git a/common/windows_includes.h b/common/windows_includes.h new file mode 100644 index 0000000..e946797 --- /dev/null +++ b/common/windows_includes.h
@@ -0,0 +1,39 @@ +// Copyright 2026 Google LLC +// +// 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 +// +// https://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 FUZZTEST_COMMON_WINDOWS_INCLUDES_H_ +#define FUZZTEST_COMMON_WINDOWS_INCLUDES_H_ + +#ifdef _WIN32 + +// clang-format off +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif + +#ifndef NOMINMAX +#define NOMINMAX +#endif + +#ifndef NOGDI +#define NOGDI +#endif + +#include <windows.h> + +// clang-format on + +#endif // _WIN32 + +#endif // FUZZTEST_COMMON_WINDOWS_INCLUDES_H_