| // Copyright 2022 The Centipede Authors. | |
| // | |
| // 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. | |
| #include "./centipede/command.h" | |
| #ifndef _WIN32 | |
| #include <errno.h> | |
| #include <fcntl.h> | |
| #include <spawn.h> | |
| #include <sys/poll.h> | |
| #include <sys/stat.h> | |
| #include <sys/types.h> | |
| #include <sys/wait.h> | |
| #include <unistd.h> | |
| #endif // _WIN32 | |
| #ifdef __APPLE__ | |
| #include <inttypes.h> | |
| #include <libproc.h> | |
| #endif // __APPLE__ | |
| #include <algorithm> | |
| #include <atomic> | |
| #include <csignal> | |
| #include <cstdint> | |
| #include <cstdlib> | |
| #include <filesystem> // NOLINT | |
| #include <fstream> | |
| #include <memory> | |
| #include <optional> | |
| #include <string> | |
| #include <string_view> | |
| #include <system_error> // NOLINT | |
| #include <utility> | |
| #include <vector> | |
| #include "absl/base/const_init.h" | |
| #include "absl/status/status.h" | |
| #include "absl/status/statusor.h" | |
| #include "absl/strings/match.h" | |
| #include "absl/strings/numbers.h" | |
| #include "absl/strings/str_cat.h" | |
| #include "absl/strings/str_format.h" | |
| #include "absl/strings/str_join.h" | |
| #include "absl/strings/str_replace.h" | |
| #include "absl/strings/str_split.h" | |
| #include "absl/synchronization/mutex.h" | |
| #include "absl/time/clock.h" | |
| #include "absl/time/time.h" | |
| #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/btree_map.h" | |
| #include "absl/strings/ascii.h" // NOLINT | |
| #include "./common/windows_includes.h" | |
| #endif | |
| #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; | |
| #endif | |
| namespace fuzztest::internal { | |
| namespace { | |
| // See the definition of --fork_server flag. | |
| 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) { | |
| #if defined(__APPLE__) | |
| struct proc_bsdinfo info = {}; | |
| if (proc_pidinfo(pid, PROC_PIDTBSDINFO, 0, &info, PROC_PIDTBSDINFO_SIZE) != | |
| PROC_PIDTBSDINFO_SIZE) { | |
| return absl::InternalError( | |
| absl::StrCat("failed to get proc bsdinfo for ", pid)); | |
| } | |
| return absl::StrFormat("%" PRIu64 ".%06" PRIu64, info.pbi_start_tvsec, | |
| info.pbi_start_tvusec); | |
| #else | |
| constexpr int kFieldIndexOfStartTimeAfterComm = 19; // From `man procfs` | |
| const std::string proc_stat_path = absl::StrFormat("/proc/%d/stat", pid); | |
| std::string proc_stat_line; | |
| // Cannot use `ReadFromLocalFile` on procfs since seek does not work. | |
| // This seems to work assuming the filename of the command does not contain | |
| // newline, which should be in our control when the process is ours. | |
| if (std::getline(std::ifstream(proc_stat_path), proc_stat_line).bad()) { | |
| return absl::InternalError(absl::StrCat("failed to read ", proc_stat_path)); | |
| } | |
| // According to the current format of `/proc/[pid]/stat`, only the comm field | |
| // can contain ')'. | |
| const size_t comm_end_pos = proc_stat_line.find_last_of(')'); | |
| if (comm_end_pos == proc_stat_line.npos) { | |
| return absl::NotFoundError( | |
| absl::StrCat("cannot find the end of command in the first line of ", | |
| proc_stat_path, ": ", proc_stat_line)); | |
| } | |
| std::string_view proc_stat_after_comm = | |
| std::string_view(proc_stat_line).substr(comm_end_pos + 1); | |
| const std::vector<std::string_view> fields = | |
| absl::StrSplit(proc_stat_after_comm, ' ', absl::SkipEmpty()); | |
| if (fields.size() <= kFieldIndexOfStartTimeAfterComm) { | |
| return absl::NotFoundError( | |
| absl::StrCat("not enough fields in the first line of ", proc_stat_path, | |
| ": ", proc_stat_line)); | |
| } | |
| return std::string(fields[kFieldIndexOfStartTimeAfterComm]); | |
| #endif // __APPLE__ | |
| } | |
| #endif // _WIN32 | |
| std::string GetUniqueSuffix() { | |
| static std::atomic<uint64_t> suffix_counter = {0}; | |
| return absl::StrCat(suffix_counter++); | |
| } | |
| } // namespace | |
| // TODO(ussuri): Encapsulate as much of the fork server functionality from | |
| // this source as possible in this struct, and make it a class. | |
| #ifdef _WIN32 | |
| struct Command::PlatformContext { | |
| HANDLE win_process_handle = INVALID_HANDLE_VALUE; | |
| ~PlatformContext() { | |
| if (win_process_handle != INVALID_HANDLE_VALUE) { | |
| CloseHandle(win_process_handle); | |
| } | |
| } | |
| }; | |
| #else | |
| struct ForkServerProps { | |
| // The file paths of the comms pipes. | |
| std::string fifo_path_[2]; | |
| // The file descriptors of the comms pipes. | |
| int pipe_[2] = {-1, -1}; | |
| // The file path to write the PID of the fork server process to. | |
| std::string pid_file_path_; | |
| // The PID of the fork server process. Used to verify that the fork server is | |
| // running and the pipes are ready for comms. | |
| pid_t pid_ = -1; | |
| // The creation stamp of the fork server process. Used to detect that the | |
| // running process with `pid_` is still the original fork server, not a PID | |
| // recycled by the OS. | |
| std::string creation_stamp; | |
| template <typename T> | |
| bool ReadPipe(absl::Time deadline, T& out) { | |
| struct pollfd poll_fd = {}; | |
| int poll_ret = -1; | |
| do { | |
| poll_fd = { | |
| /*fd=*/pipe_[1], | |
| /*events=*/POLLIN, | |
| }; | |
| poll_ret = poll(&poll_fd, 1, PollTimeoutMs(deadline - absl::Now())); | |
| // The `poll()` syscall can get interrupted: it sets errno==EINTR in that | |
| // case. We should tolerate that. | |
| } while (poll_ret < 0 && errno == EINTR); | |
| if (poll_ret == 1 && (poll_fd.revents & POLLIN)) { | |
| FUZZTEST_CHECK_EQ(sizeof(T), read(pipe_[1], &out, sizeof(T))); | |
| return true; | |
| } else if (poll_ret == 0) { | |
| FUZZTEST_LOG(ERROR) << "poll timed out on fork server pipe"; | |
| } else { | |
| FUZZTEST_PLOG(ERROR) << "poll on fork server pipe returned " << poll_ret; | |
| } | |
| return false; | |
| } | |
| ~ForkServerProps() { | |
| for (int i = 0; i < 2; ++i) { | |
| if (pipe_[i] >= 0 && close(pipe_[i]) != 0) { | |
| FUZZTEST_LOG(ERROR) | |
| << "Failed to close fork server pipe for " << fifo_path_[i]; | |
| } | |
| std::error_code ec; | |
| if (!fifo_path_[i].empty() && | |
| !std::filesystem::remove(fifo_path_[i], ec)) { | |
| FUZZTEST_LOG(ERROR) << "Failed to remove fork server pipe file " | |
| << fifo_path_[i] << ": " << ec; | |
| } | |
| } | |
| } | |
| }; | |
| 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 PlatformContext is complete (that's by-the-book | |
| // PIMPL). | |
| Command::~Command() { | |
| if (is_executing()) { | |
| FUZZTEST_LOG(WARNING) << "Destructing Command object for " << path() | |
| << " with " | |
| #ifdef _WIN32 | |
| << "PID " | |
| << 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); | |
| } | |
| ResetRedirectionFiles(/*new_suffix=*/""); | |
| } | |
| Command::Command(std::string_view path, Options 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(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() + /*in/out/err*/ 3); | |
| // env. | |
| ss.push_back("exec env"); | |
| std::vector<std::string> env_to_set; | |
| env_to_set.reserve(options_.env_diff.size()); | |
| // Arguments that unset environment variables must appear first. | |
| for (std::string_view var : options_.env_diff) { | |
| if (absl::StartsWith(var, "-")) { | |
| ss.push_back(absl::StrCat("-u ", var.substr(1))); | |
| } else { | |
| env_to_set.emplace_back(var); | |
| } | |
| } | |
| for (auto& var : env_to_set) { | |
| ss.push_back(ShellEscape(var)); | |
| } | |
| // path. | |
| std::string path = path_; | |
| // Strip the % prefixes, if any. | |
| if (absl::StartsWith(path, kNoForkServerRequestPrefix)) { | |
| path = path.substr(kNoForkServerRequestPrefix.size()); | |
| } | |
| // Replace @@ with temp_file_path_. | |
| constexpr std::string_view kTempFileWildCard = "@@"; | |
| if (absl::StrContains(path, kTempFileWildCard)) { | |
| FUZZTEST_CHECK(!options_.temp_file_path.empty()); | |
| path = absl::StrReplaceAll(path, | |
| {{kTempFileWildCard, options_.temp_file_path}}); | |
| } | |
| ss.push_back(std::move(path)); | |
| // args. | |
| for (const auto& arg : options_.args) { | |
| ss.push_back(ShellEscape(arg)); | |
| } | |
| // 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("> ", ShellEscape(stdout_file_))); | |
| } | |
| if (!stderr_file_.empty()) { | |
| if (stdout_file_ != 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_ && !platform_context_->fork_server); | |
| FUZZTEST_VLOG(2) << "Starting fork server for " << path(); | |
| ResetRedirectionFiles(GetUniqueSuffix()); | |
| command_line_ = ToString(); | |
| 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(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, | |
| // so failures will never propagate to the caller of `system()`. Instead, we | |
| // save out the background process's PID to a file and use it later to assert | |
| // that the process has started and is still running. | |
| static constexpr std::string_view kForkServerCommandStub = R"sh( | |
| { | |
| CENTIPEDE_FORK_SERVER_FIFO0="%s" \ | |
| CENTIPEDE_FORK_SERVER_FIFO1="%s" \ | |
| %s | |
| } & | |
| printf "%%s" $! > "%s" | |
| )sh"; | |
| const std::string fork_server_command = absl::StrFormat( | |
| 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()); | |
| // Check if `system()` was able to parse and run the command at all. | |
| if (exit_code != EXIT_SUCCESS) { | |
| LogProblemInfo( | |
| "Failed to parse or run command to launch fork server; will proceed " | |
| "without it"); | |
| return false; | |
| } | |
| // The fork server is probably running now. However, one failure scenario is | |
| // that it starts and exits early. Try opening the read/write comms pipes with | |
| // it: if that fails, something is wrong. | |
| // We use non-blocking I/O to open the pipes. That is good and safe, because: | |
| // 1) This prevents the `open()` calls from hanging when the fork server fails | |
| // to open the pipes on its side (note the use of O_RDWR, not O_WRONLY, to | |
| // avoid ENXIO). | |
| // 2) In `Command::Execute`, we wait for the return channel pipe with a | |
| // `poll()`, so it should always have data when we attempt to `read()` from | |
| // it. | |
| // See more at | |
| // https://www.gnu.org/software/libc/manual/html_node/Operating-Modes.html. | |
| 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"); | |
| return false; | |
| } | |
| std::string pid_str; | |
| ReadFromLocalFile(pid_file_path, pid_str); | |
| 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 " | |
| "proceed without it " | |
| "(failure status: ", | |
| creation_stamp.status(), ")")); | |
| return false; | |
| } | |
| platform_context_->fork_server->creation_stamp = *std::move(creation_stamp); | |
| return true; | |
| #endif // _WIN32 | |
| } | |
| void Command::ResetRedirectionFiles(std::string_view new_suffix) { | |
| if (!stdout_file_.empty()) { | |
| std::error_code ec; | |
| (void)std::filesystem::remove(stdout_file_, ec); | |
| } | |
| if (!stderr_file_.empty() && stderr_file_ != stdout_file_) { | |
| std::error_code ec; | |
| (void)std::filesystem::remove(stderr_file_, ec); | |
| } | |
| if (!options_.stdout_file_prefix.empty() && !new_suffix.empty()) { | |
| stdout_file_ = absl::StrCat(options_.stdout_file_prefix, new_suffix); | |
| } else { | |
| stdout_file_.clear(); | |
| } | |
| if (!options_.stderr_file_prefix.empty() && !new_suffix.empty()) { | |
| stderr_file_ = absl::StrCat(options_.stderr_file_prefix, new_suffix); | |
| } else { | |
| stderr_file_.clear(); | |
| } | |
| } | |
| 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(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(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(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(platform_context_->fork_server->pid_); | |
| if (!creation_stamp.ok()) return creation_stamp.status(); | |
| if (*creation_stamp != platform_context_->fork_server->creation_stamp) { | |
| return absl::UnknownError(absl::StrCat( | |
| "Fork server's creation stamp changed (new process?) - expected ", | |
| platform_context_->fork_server->creation_stamp, ", but got ", | |
| *creation_stamp)); | |
| } | |
| return absl::OkStatus(); | |
| #endif // _WIN32 | |
| } | |
| bool Command::ExecuteAsync() { | |
| FUZZTEST_CHECK(!is_executing()); | |
| #ifdef _WIN32 | |
| FUZZTEST_CHECK_EQ(platform_context_->win_process_handle, | |
| INVALID_HANDLE_VALUE); | |
| ResetRedirectionFiles(GetUniqueSuffix()); | |
| command_line_ = ToString(); | |
| struct CaseInsensitiveCompare { | |
| using is_transparent = void; | |
| bool operator()(std::string_view a, std::string_view b) const { | |
| return std::lexicographical_compare( | |
| a.begin(), a.end(), b.begin(), b.end(), | |
| [](unsigned char ca, unsigned char cb) { | |
| return static_cast<unsigned char>(absl::ascii_tolower(ca)) < | |
| static_cast<unsigned char>(absl::ascii_tolower(cb)); | |
| }); | |
| } | |
| }; | |
| absl::btree_map<std::string, std::string, CaseInsensitiveCompare> 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 != entry.npos) { | |
| env_map[entry.substr(0, eq_pos)] = | |
| std::string(entry.substr(eq_pos + 1)); | |
| } else { | |
| env_map[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(key); | |
| } else { | |
| auto pos = env_var.find('='); | |
| if (pos != env_var.npos) { | |
| env_map[env_var.substr(0, pos)] = std::string(env_var.substr(pos + 1)); | |
| } | |
| } | |
| } | |
| std::string env_block = absl::StrJoin(env_map, absl::string_view("\0", 1), | |
| absl::PairFormatter("=")); | |
| env_block.append(2, '\0'); | |
| STARTUPINFOEXA si = {}; | |
| si.StartupInfo.cb = sizeof(si); | |
| si.StartupInfo.dwFlags = STARTF_USESTDHANDLES; | |
| PROCESS_INFORMATION pi = {}; | |
| SECURITY_ATTRIBUTES sa = {sizeof(sa), NULL, TRUE}; | |
| HANDLE handle_in = INVALID_HANDLE_VALUE; | |
| HANDLE handle_out = INVALID_HANDLE_VALUE; | |
| HANDLE handle_err = INVALID_HANDLE_VALUE; | |
| absl::Cleanup close_handles = [&] { | |
| if (handle_in != INVALID_HANDLE_VALUE) CloseHandle(handle_in); | |
| if (handle_out != INVALID_HANDLE_VALUE) CloseHandle(handle_out); | |
| if (handle_err != INVALID_HANDLE_VALUE) CloseHandle(handle_err); | |
| }; | |
| if (!options_.stdin_file_path.empty()) { | |
| handle_in = CreateFileA(options_.stdin_file_path.c_str(), GENERIC_READ, | |
| FILE_SHARE_READ, &sa, OPEN_EXISTING, | |
| FILE_ATTRIBUTE_NORMAL, NULL); | |
| if (handle_in == INVALID_HANDLE_VALUE) { | |
| FUZZTEST_LOG(ERROR) << "Failed to open stdin file: " | |
| << options_.stdin_file_path; | |
| return false; | |
| } | |
| si.StartupInfo.hStdInput = handle_in; | |
| } else { | |
| si.StartupInfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE); | |
| } | |
| if (!stdout_file_.empty()) { | |
| handle_out = | |
| CreateFileA(stdout_file_.c_str(), GENERIC_WRITE, FILE_SHARE_READ, &sa, | |
| CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); | |
| if (handle_out == INVALID_HANDLE_VALUE) { | |
| FUZZTEST_LOG(ERROR) << "Failed to open stdout file: " << stdout_file_; | |
| return false; | |
| } | |
| si.StartupInfo.hStdOutput = handle_out; | |
| } else { | |
| si.StartupInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE); | |
| } | |
| if (!stderr_file_.empty()) { | |
| if (stderr_file_ == stdout_file_) { | |
| si.StartupInfo.hStdError = si.StartupInfo.hStdOutput; | |
| } else { | |
| handle_err = | |
| CreateFileA(stderr_file_.c_str(), GENERIC_WRITE, FILE_SHARE_READ, &sa, | |
| CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); | |
| if (handle_err == INVALID_HANDLE_VALUE) { | |
| FUZZTEST_LOG(ERROR) << "Failed to open stderr file: " << stderr_file_; | |
| return false; | |
| } | |
| si.StartupInfo.hStdError = handle_err; | |
| } | |
| } else { | |
| si.StartupInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE); | |
| } | |
| std::vector<HANDLE> handles_to_inherit; | |
| for (HANDLE h : {si.StartupInfo.hStdInput, si.StartupInfo.hStdOutput, | |
| si.StartupInfo.hStdError}) { | |
| if (h != nullptr && h != INVALID_HANDLE_VALUE && | |
| std::find(handles_to_inherit.begin(), handles_to_inherit.end(), h) == | |
| handles_to_inherit.end()) { | |
| SetHandleInformation(h, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT); | |
| handles_to_inherit.push_back(h); | |
| } | |
| } | |
| SIZE_T attr_list_size = 0; | |
| InitializeProcThreadAttributeList(nullptr, 1, 0, &attr_list_size); | |
| auto attr_list_buffer = std::make_unique<uint8_t[]>(attr_list_size); | |
| si.lpAttributeList = | |
| reinterpret_cast<PPROC_THREAD_ATTRIBUTE_LIST>(attr_list_buffer.get()); | |
| if (!InitializeProcThreadAttributeList(si.lpAttributeList, 1, 0, | |
| &attr_list_size)) { | |
| DWORD err = GetLastError(); | |
| FUZZTEST_LOG(ERROR) << "InitializeProcThreadAttributeList failed: " << err; | |
| return false; | |
| } | |
| absl::Cleanup delete_attr_list = [&] { | |
| DeleteProcThreadAttributeList(si.lpAttributeList); | |
| }; | |
| if (!handles_to_inherit.empty()) { | |
| if (!UpdateProcThreadAttribute( | |
| si.lpAttributeList, 0, PROC_THREAD_ATTRIBUTE_HANDLE_LIST, | |
| handles_to_inherit.data(), | |
| handles_to_inherit.size() * sizeof(HANDLE), nullptr, nullptr)) { | |
| DWORD err = GetLastError(); | |
| FUZZTEST_LOG(ERROR) << "UpdateProcThreadAttribute failed: " << err; | |
| return false; | |
| } | |
| } | |
| std::string cmd = command_line_; | |
| const BOOL cp_res = CreateProcessA( | |
| NULL, cmd.data(), NULL, NULL, | |
| /*bInheritHandles=*/!handles_to_inherit.empty(), | |
| EXTENDED_STARTUPINFO_PRESENT, env_block.empty() ? NULL : env_block.data(), | |
| NULL, &si.StartupInfo, &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()) { | |
| LogProblemInfo(absl::StrCat("Fork server should be running, but isn't: ", | |
| status.message())); | |
| return false; | |
| } | |
| // Wake up the fork server. | |
| char x = ' '; | |
| if (write(platform_context_->fork_server->pipe_[0], &x, 1) != 1) { | |
| LogProblemInfo( | |
| absl::StrCat("Failed to write to fork server pipe. Errno: ", errno)); | |
| return false; | |
| } | |
| // Read the one-byte ack. | |
| // Use 60s as an arbitrary duration to wait for the process to load and | |
| // enter the fork server. | |
| if (!platform_context_->fork_server->ReadPipe( | |
| absl::Now() + absl::Seconds(60), x)) { | |
| LogProblemInfo("Failed to read from fork server pipe."); | |
| return false; | |
| } | |
| } else { | |
| FUZZTEST_CHECK_EQ(platform_context_->pid, -1); | |
| ResetRedirectionFiles(GetUniqueSuffix()); | |
| command_line_ = ToString(); | |
| FUZZTEST_VLOG(1) << "Executing command '" << command_line_ << "'..."; | |
| std::vector<std::string> argv_strs = {"/bin/sh", "-c", command_line_}; | |
| std::vector<char*> argv; | |
| argv.reserve(argv_strs.size() + 1); | |
| for (auto& argv_str : argv_strs) { | |
| argv.push_back(argv_str.data()); | |
| } | |
| argv.push_back(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()) { | |
| // Round up so that we do not time out before `deadline`, and clamp to | |
| // avoid wrapping around or accidentally passing `INFINITE`. | |
| const int64_t ms = absl::ToInt64Milliseconds( | |
| absl::Ceil(std::max(deadline - absl::Now(), absl::ZeroDuration()), | |
| absl::Milliseconds(1))); | |
| timeout_ms = | |
| static_cast<DWORD>(std::min<int64_t>(ms, int64_t{INFINITE} - 1)); | |
| } | |
| const 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; | |
| } | |
| FUZZTEST_CHECK_EQ(res, WAIT_OBJECT_0) | |
| << "WaitForSingleObject failed: error=" << GetLastError(); | |
| DWORD exit_code = 0; | |
| FUZZTEST_CHECK( | |
| GetExitCodeProcess(platform_context_->win_process_handle, &exit_code)) | |
| << "GetExitCodeProcess failed: error=" << GetLastError(); | |
| 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 (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 (!platform_context_->fork_server->ReadPipe(deadline, exit_code)) { | |
| VlogProblemInfo( | |
| absl::StrCat("Waiting for fork server failed, deadline is ", | |
| deadline), | |
| /*vlog_level=*/1); | |
| return std::nullopt; | |
| } | |
| } else { | |
| FUZZTEST_CHECK_NE(platform_context_->pid, -1); | |
| while (true) { | |
| const pid_t r = waitpid(platform_context_->pid, &exit_code, WNOHANG); | |
| FUZZTEST_CHECK_NE(r, -1); | |
| 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()) { | |
| const auto duration = std::clamp<useconds_t>( | |
| absl::ToInt64Microseconds(timeout), 0, 100000); | |
| usleep(duration); // NOLINT: early return on SIGCHLD is desired. | |
| continue; | |
| } else { | |
| VlogProblemInfo( | |
| absl::StrCat( | |
| "Timeout while waiting for the command process: deadline is ", | |
| deadline), | |
| /*vlog_level=*/1); | |
| return std::nullopt; | |
| } | |
| } | |
| platform_context_->pid = -1; | |
| } | |
| is_executing_ = false; | |
| // When the command is actually a wrapper shell launching the binary(-es) | |
| // (e.g. a Docker container), the shell will preserve a normal exit code | |
| // returned by the binary (the legal range for such codes that can be | |
| // passed to `exit()` is [0..125]); but the shell will specially encode | |
| // the exit code returned by the binary when the binary is killed by a | |
| // signal by adding 128 to the signal number and returning the result as | |
| // a normal exit code. This encoding is used in `bash` and `dash` but may be | |
| // different in other shells, e.g., `ksh`. | |
| // | |
| // For more details, see https://tldp.org/LDP/abs/html/exitcodes.html. | |
| // | |
| // Therefore, to handle this case, we need to first unpack these special | |
| // pseudo-normal exit codes before analyzing them further. After | |
| // reassigning `WEXITSTATUS()` to exit_code, the if-else below will take | |
| // the else-branch and unpack the signal number from the updated value. This | |
| // has experimentally been observed to work with existing implementations of | |
| // the `wait` macros but there is no definitive documentation for it. | |
| if (WIFEXITED(exit_code) && WEXITSTATUS(exit_code) > 128 && | |
| WEXITSTATUS(exit_code) < 255) { | |
| exit_code = WEXITSTATUS(exit_code); | |
| } | |
| if (WIFEXITED(exit_code) && WEXITSTATUS(exit_code) != EXIT_SUCCESS) { | |
| const auto exit_status = WEXITSTATUS(exit_code); | |
| VlogProblemInfo( | |
| absl::StrCat("Command errored out: exit status=", exit_status), | |
| /*vlog_level=*/1); | |
| exit_code = exit_status; | |
| } else if (WIFSIGNALED(exit_code)) { | |
| const auto signal = WTERMSIG(exit_code); | |
| if (signal == SIGINT) { | |
| if (stop_condition != nullptr) { | |
| stop_condition->RequestStop( | |
| EXIT_FAILURE, "Command killed: signal=SIGINT (likely Ctrl-C)"); | |
| } | |
| // When the user kills Centipede via ^C, they are unlikely to be | |
| // interested in any of the subprocesses' outputs. Also, ^C terminates all | |
| // the subprocesses, including all the runners, so all their outputs would | |
| // get printed simultaneously, flooding the log. Hence log at a high | |
| // `vlog_level`. | |
| VlogProblemInfo("Command killed: signal=SIGINT (likely Ctrl-C)", | |
| /*vlog_level=*/10); | |
| } else { | |
| // The fork server subprocess was killed by something other than ^C: log | |
| // at a lower `vlog_level` to help diagnose problems. | |
| VlogProblemInfo(absl::StrCat("Command killed: signal=", signal), | |
| /*vlog_level=*/1); | |
| } | |
| // TODO(ussuri): Consider changing this to exit_code = EXIT_FAILURE. | |
| exit_code = signal; | |
| } | |
| return exit_code; | |
| #endif // _WIN32 | |
| } | |
| void Command::RequestStop(bool force) { | |
| FUZZTEST_CHECK(is_executing()); | |
| #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(platform_context_->fork_server->pid_, force ? SIGUSR1 : SIGTERM); | |
| return; | |
| } | |
| FUZZTEST_CHECK_NE(platform_context_->pid, -1); | |
| kill(platform_context_->pid, force ? SIGKILL : SIGTERM); | |
| #endif // _WIN32 | |
| } | |
| std::string Command::ReadRedirectedStdout() const { | |
| std::string ret; | |
| if (!stdout_file_.empty()) { | |
| ReadFromLocalFile(stdout_file_, ret); | |
| if (ret.empty()) ret = "<EMPTY>"; | |
| } | |
| return ret; | |
| } | |
| std::string Command::ReadRedirectedStderr() const { | |
| std::string ret; | |
| if (!stderr_file_.empty()) { | |
| if (stderr_file_ == stdout_file_) { | |
| ret = "<DUPED TO STDOUT>"; | |
| } else { | |
| ReadFromLocalFile(stderr_file_, ret); | |
| if (ret.empty()) ret = "<EMPTY>"; | |
| } | |
| } | |
| return ret; | |
| } | |
| void Command::LogProblemInfo(std::string_view message) const { | |
| absl::MutexLock lock(GetExecutionLoggingMutex()); | |
| FUZZTEST_LOG(ERROR) << message; | |
| FUZZTEST_LOG(ERROR).NoPrefix() << "=== COMMAND ==="; | |
| FUZZTEST_LOG(ERROR).NoPrefix() << command_line_; | |
| FUZZTEST_LOG(ERROR).NoPrefix() << "=== STDOUT ==="; | |
| for (const auto& line : absl::StrSplit(ReadRedirectedStdout(), '\n')) { | |
| FUZZTEST_LOG(ERROR).NoPrefix() << line; | |
| } | |
| FUZZTEST_LOG(ERROR).NoPrefix() << "=== STDERR ==="; | |
| for (const auto& line : absl::StrSplit(ReadRedirectedStderr(), '\n')) { | |
| FUZZTEST_LOG(ERROR).NoPrefix() << line; | |
| } | |
| } | |
| void Command::VlogProblemInfo(std::string_view message, int vlog_level) const { | |
| if (FUZZTEST_VLOG_IS_ON(vlog_level)) LogProblemInfo(message); | |
| } | |
| absl::Mutex& GetExecutionLoggingMutex() { | |
| static absl::Mutex mu{absl::kConstInit}; | |
| return mu; | |
| } | |
| } // namespace fuzztest::internal |