--- /dev/null
+// system headers
+#include <algorithm>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <utility>
+#include <unistd.h>
+#include <memory.h>
+#include <wait.h>
+
+// local headers
+#include "includes/process.h"
+#include "includes/subprocess.h"
+#include "includes/assert.h"
+
+// shorter than using namespace ...
+using namespace linuxdeploy::subprocess;
+
+int process::pid() const {
+ return child_pid_;
+}
+
+int process::stdout_fd() const {
+ return stdout_fd_;
+}
+
+int process::stderr_fd() const {
+ return stderr_fd_;
+}
+
+process::process(std::initializer_list<std::string> args, const subprocess_env_map_t& env)
+ : process(std::vector<std::string>(args), env) {}
+
+process::process(const std::vector<std::string>& args, const subprocess_env_map_t& env) {
+ // preconditions
+ util::assert::assert_not_empty(args);
+
+ // pipes for both stdout and stderr
+ // the order is, as seen from the child: [read, write]
+ int stdout_pipe_fds[2];
+ int stderr_pipe_fds[2];
+
+ // FIXME: for debugging of #150
+ auto create_pipe = [](int fds[]) {
+ const auto rv = pipe(fds);
+
+ if (rv != 0) {
+ const auto error = errno;
+ throw std::logic_error("failed to create pipe: " + std::string(strerror(error)));
+ }
+ };
+
+ // create actual pipes
+ create_pipe(stdout_pipe_fds);
+ create_pipe(stderr_pipe_fds);
+
+ // create child process
+ child_pid_ = fork();
+
+ if (child_pid_ < 0) {
+ throw std::runtime_error{"fork() failed"};
+ }
+
+ if (child_pid_ == 0) {
+ // we're in the child process
+
+ // first step: close the read end of both pipes
+ close_pipe_fd_(stdout_pipe_fds[READ_END_]);
+ close_pipe_fd_(stderr_pipe_fds[READ_END_]);
+
+ auto connect_fd = [](int fd, int fileno) {
+ for (;;) {
+ if (dup2(fd, fileno) == -1) {
+ const auto error = errno;
+ if (error != EINTR) {
+ throw std::logic_error{"failed to connect pipes: " + std::string(strerror(error))};
+ }
+ continue;
+ }
+
+ break;
+ }
+ };
+
+ connect_fd(stdout_pipe_fds[WRITE_END_], STDOUT_FILENO);
+ connect_fd(stderr_pipe_fds[WRITE_END_], STDERR_FILENO);
+
+ // now, we also have to close the write end of both pipes
+ close_pipe_fd_(stdout_pipe_fds[WRITE_END_]);
+ close_pipe_fd_(stderr_pipe_fds[WRITE_END_]);
+
+ // prepare arguments for exec*
+ auto exec_args = make_args_vector_(args);
+ auto exec_env = make_env_vector_(env);
+
+ // call subprocess
+ execvpe(args.front().c_str(), exec_args.data(), exec_env.data());
+
+ // only reached if exec* fails
+
+ // clean up memory if exec should ever return
+ // prevents memleaks if the exception below would be handled by a caller
+ auto deleter = [](char* ptr) {
+ free(ptr);
+ ptr = nullptr;
+ };
+
+ std::for_each(exec_args.begin(), exec_args.end(), deleter);
+ std::for_each(exec_env.begin(), exec_env.end(), deleter);
+
+ throw std::runtime_error{"exec() failed: " + std::string(strerror(errno))};
+ }
+
+ // parent code
+
+ // we do not intend to write to the processes
+ close_pipe_fd_(stdout_pipe_fds[WRITE_END_]);
+ close_pipe_fd_(stderr_pipe_fds[WRITE_END_]);
+
+ // store file descriptors
+ stdout_fd_ = stdout_pipe_fds[READ_END_];
+ stderr_fd_ = stderr_pipe_fds[READ_END_];
+}
+
+int process::close() {
+ if (!exited_) {
+ close_pipe_fd_(stdout_fd_);
+ stdout_fd_ = -1;
+
+ close_pipe_fd_(stderr_fd_);
+ stderr_fd_ = -1;
+
+ {
+ int status;
+
+ if (waitpid(child_pid_, &status, 0) == -1) {
+ throw std::logic_error{"waitpid() failed"};
+ }
+
+ exited_ = true;
+ exit_code_ = check_waitpid_status_(status);
+ }
+ }
+
+ return exit_code_;
+}
+
+process::~process() {
+ (void) close();
+}
+
+std::vector<char*> process::make_args_vector_(const std::vector<std::string>& args) {
+ std::vector<char*> rv{};
+ rv.reserve(args.size());
+
+ for (const auto& arg : args) {
+ rv.emplace_back(strdup(arg.c_str()));
+ }
+
+ // execv* want a nullptr-terminated array
+ rv.emplace_back(nullptr);
+
+ return rv;
+}
+
+std::vector<char*> process::make_env_vector_(const subprocess_env_map_t& env) {
+ std::vector<char*> rv;
+
+ // first, copy existing environment
+ // we cannot reserve space in the vector unfortunately, as we don't know the size of environ before the iteration
+ if (environ != nullptr) {
+ for (auto** current_env_var = environ; *current_env_var != nullptr; ++current_env_var) {
+ rv.emplace_back(strdup(*current_env_var));
+ }
+ }
+
+ // add own environment variables, overwriting existing ones if necessary
+ for (const auto& env_var : env) {
+ const auto& key = env_var.first;
+ const auto& value = env_var.second;
+
+ auto predicate = [&key](char* existing_env_var) {
+ char* equal_sign = strstr(existing_env_var, "=");
+
+ if (equal_sign == nullptr) {
+ throw std::runtime_error{"no equal sign in environment variable"};
+ }
+
+ return strncmp(existing_env_var, key.c_str(), std::distance(equal_sign, existing_env_var)) == 0;
+ };
+
+ // delete existing env var, if any
+ rv.erase(std::remove_if(rv.begin(), rv.end(), predicate), rv.end());
+
+ // insert new value
+ std::ostringstream oss;
+ oss << key;
+ oss << "=";
+ oss << value;
+
+ rv.emplace_back(strdup(oss.str().c_str()));
+ }
+
+ // exec*e want a nullptr-terminated array
+ rv.emplace_back(nullptr);
+
+ return rv;
+}
+
+void process::kill(int signal) const {
+ if (::kill(child_pid_, signal) != 0) {
+ throw std::logic_error{"failed to kill child process"};
+ }
+
+ if (waitpid(child_pid_, nullptr, 0)) {
+ throw std::logic_error{"failed to wait for killed child"};
+ }
+}
+
+bool process::is_running() {
+ if (exited_) {
+ return false;
+ }
+
+ int status;
+ auto result = waitpid(child_pid_, &status, WNOHANG);
+
+ if (result == 0) {
+ return true;
+ }
+
+ if (result == child_pid_) {
+ // TODO: extract the following lines from both this method and close() to eliminate duplicate code
+ close_pipe_fd_(stdout_fd_);
+ stdout_fd_ = -1;
+
+ close_pipe_fd_(stderr_fd_);
+ stderr_fd_ = -1;
+
+ exited_ = true;
+ exit_code_ = check_waitpid_status_(status);
+
+ return false;
+ }
+
+ if (result < 0) {
+ // TODO: check errno == ECHILD
+ throw std::logic_error{"waitpid() failed: " + std::string(strerror(errno))};
+ }
+
+ // can only happen if waitpid() returns an unknown process ID
+ throw std::logic_error{"unknown error occured"};
+}
+
+int process::check_waitpid_status_(int status) {
+ if (WIFSIGNALED(status) != 0) {
+ // TODO: consider treating child exit caused by signals separately
+ return WTERMSIG(status);
+ } else if (WIFEXITED(status) != 0) {
+ return WEXITSTATUS(status);
+ }
+
+ throw std::logic_error{"unknown child process state"};
+}
+
+void process::close_pipe_fd_(int fd) {
+ const auto rv = ::close(fd);
+
+ if (rv != 0) {
+ const auto error = errno;
+ throw std::logic_error("failed to close pipe fd: " + std::string(strerror(error)));
+ }
+}
projects / goodguy / cinelerra.git / blobdiff