diff --git a/dev/tests/sub_instance.lua b/dev/tests/sub_instance.lua new file mode 100644 index 000000000..ab56ef354 --- /dev/null +++ b/dev/tests/sub_instance.lua @@ -0,0 +1,31 @@ +app.create_memory_device("memtest") + +local script_path = "config:subprocess.lua" +local log_path = "config:subprocess.log" + +file.write(script_path, [[ + debug.log("hello from sub-instance") + sleep(1) +]]) + +local handle = app.start_background_instance(script_path, log_path) +assert(handle >= 0) + +local stdin = app.get_stdin_stream(handle) +assert(stdin ~= nil) +stdin:write_line("sub_instance_test") +stdin:flush() + +app.sleep_until(function() return not app.is_instance_alive(handle) end) +assert(not app.is_instance_alive(handle)) + +local stdout = app.get_stdout_stream(handle) +assert(stdout ~= nil) +local output = table.concat(table.map(stdout:read(1e6), function(_, line) return ""..line end), '\n') +print(output) +assert(output and output:find("hello from sub-instance", 1, true) ~= nil) +assert(output and output:find('stdin-cmd] unknown command "sub_instance_test"', 1, true) ~= nil) +stdout:close() + +file.remove(script_path) +assert(not app.terminate_instance(handle)) diff --git a/res/scripts/stdlib.lua b/res/scripts/stdlib.lua index 3573bda07..0b86243e7 100644 --- a/res/scripts/stdlib.lua +++ b/res/scripts/stdlib.lua @@ -27,6 +27,7 @@ local function tb_frame_tostring(frame) end local __vc__app_script_coroutine +local __vc_process_streams = { stdin = {}, stdout = {} } local function complete_app_lib(app) local __app_load_content = app.load_content @@ -35,6 +36,45 @@ local function complete_app_lib(app) local __app_tick = coroutine.yield local __app_set_setting = app.set_setting local __app_quit = app.quit + local __app_get_stdout_stream = app.get_stdout_stream + local __app_get_stdin_stream = app.get_stdin_stream + local io_stream = require "core:io_stream" + local stdio_stream_lib = { + read = file.__read_descriptor, + write = file.__write_descriptor, + seek = file.__seek_descriptor, + tell = file.__tell_descriptor, + flush = file.__flush_descriptor, + available = file.__available_descriptor, + is_alive = file.__has_descriptor, + close = file.__close_descriptor, + } + + local function get_process_stream(kind, handle, getter) + local cache = __vc_process_streams[kind] + local stream = cache[handle] + if stream and stream:is_alive() then + return stream + end + cache[handle] = nil + + local descriptor = getter(handle) + if descriptor == nil then + return nil + end + + stream = io_stream.new(descriptor, false, stdio_stream_lib) + cache[handle] = stream + return stream + end + + app.get_stdout_stream = function(handle) + return get_process_stream("stdout", handle, __app_get_stdout_stream) + end + + app.get_stdin_stream = function(handle) + return get_process_stream("stdin", handle, __app_get_stdin_stream) + end app.sleep = sleep app.script = __VC_SCRIPT_NAME diff --git a/src/devtools/stdin_cmd_reader.cpp b/src/devtools/stdin_cmd_reader.cpp index 90dc07e2b..1e72fa158 100644 --- a/src/devtools/stdin_cmd_reader.cpp +++ b/src/devtools/stdin_cmd_reader.cpp @@ -28,6 +28,7 @@ void cmd::start_stdin_cmd_reader(Engine& engine) { if (line.empty()) { continue; } + logger.debug() << "input received: " << line; engine.postRunnable([line, &interpreter] () { try { auto result = interpreter.execute(line); diff --git a/src/interfaces/SystemProcess.hpp b/src/interfaces/SystemProcess.hpp new file mode 100644 index 000000000..dffb2634b --- /dev/null +++ b/src/interfaces/SystemProcess.hpp @@ -0,0 +1,11 @@ +#pragma once + +#include "interfaces/Process.hpp" + +class SystemProcess : public Process { +public: + virtual ~SystemProcess() override = default; + + virtual int getStdinDescriptor() const = 0; + virtual int getStdoutDescriptor() const = 0; +}; diff --git a/src/io/fd_istream.hpp b/src/io/fd_istream.hpp new file mode 100644 index 000000000..74af1e6b7 --- /dev/null +++ b/src/io/fd_istream.hpp @@ -0,0 +1,132 @@ +#pragma once + +#include +#include +#include +#include + +#ifdef _WIN32 +#include +#endif + +#ifndef _WIN32 +#include +#endif + +class fd_istreambuf final : public std::streambuf { + static constexpr size_t BUFFER_SIZE = 4096; +public: +#ifdef _WIN32 + explicit fd_istreambuf(HANDLE handle) + : handle(handle) { + setg(buffer.data(), buffer.data(), buffer.data()); + } + + ~fd_istreambuf() override { + if (handle != nullptr && handle != INVALID_HANDLE_VALUE) { + CloseHandle(handle); + handle = INVALID_HANDLE_VALUE; + } + } + +protected: + int_type underflow() override { + if (handle == nullptr || handle == INVALID_HANDLE_VALUE) { + return traits_type::eof(); + } + if (gptr() != egptr()) { + return traits_type::to_int_type(*gptr()); + } + + std::array chunk {}; + DWORD readCount = 0; + if (!ReadFile( + handle, + chunk.data(), + static_cast(chunk.size()), + &readCount, + nullptr + ) || + readCount == 0) { + return traits_type::eof(); + } + + buffer.assign(chunk.begin(), chunk.begin() + readCount); + setg(buffer.data(), buffer.data(), buffer.data() + buffer.size()); + return traits_type::to_int_type(*gptr()); + } + + pos_type seekoff(off_type, std::ios_base::seekdir, std::ios_base::openmode) + override { + return pos_type(off_type(-1)); + } + + pos_type seekpos(pos_type, std::ios_base::openmode) override { + return pos_type(off_type(-1)); + } +private: + HANDLE handle; + std::vector buffer; +#else + explicit fd_istreambuf(int fd) + : fd(fd) { + setg(buffer.data(), buffer.data(), buffer.data()); + } + + ~fd_istreambuf() override { + if (fd >= 0) { + ::close(fd); + fd = -1; + } + } + +protected: + int_type underflow() override { + if (fd < 0) { + return traits_type::eof(); + } + if (gptr() != egptr()) { + return traits_type::to_int_type(*gptr()); + } + + buffer.resize(BUFFER_SIZE); + const auto count = ::read(fd, buffer.data(), buffer.size()); + if (count <= 0) { + return traits_type::eof(); + } + buffer.resize(static_cast(count)); + setg(buffer.data(), buffer.data(), buffer.data() + buffer.size()); + return traits_type::to_int_type(*gptr()); + } + + pos_type seekoff( + off_type, + std::ios_base::seekdir, + std::ios_base::openmode + ) override { + return pos_type(off_type(-1)); + } + + pos_type seekpos(pos_type, std::ios_base::openmode) override { + return pos_type(off_type(-1)); + } + +private: + int fd; + std::vector buffer; +#endif +}; + +class fd_istream final : public std::istream { +public: +#ifdef _WIN32 + explicit fd_istream(HANDLE handle) + : std::istream(&buf), buf(handle) {} +#else + explicit fd_istream(int fd) + : std::istream(&buf), buf(fd) {} +#endif + +private: + fd_istreambuf buf; +}; diff --git a/src/io/fd_ostream.hpp b/src/io/fd_ostream.hpp new file mode 100644 index 000000000..b5131a54d --- /dev/null +++ b/src/io/fd_ostream.hpp @@ -0,0 +1,158 @@ +#pragma once + +#include +#include +#include + +#ifdef _WIN32 +#include +#endif + +#ifndef _WIN32 +#include +#endif + + +class fd_ostreambuf final : public std::streambuf { + static constexpr size_t BUFFER_SIZE = 4096; +public: +#ifdef _WIN32 + explicit fd_ostreambuf(HANDLE handle) : handle(handle) { + setp(buffer.data(), buffer.data() + buffer.size()); + } + + ~fd_ostreambuf() override { + fd_ostreambuf::sync(); + if (handle != nullptr && handle != INVALID_HANDLE_VALUE) { + CloseHandle(handle); + handle = INVALID_HANDLE_VALUE; + } + } +protected: + int_type overflow(int_type ch) override { + if (ch == traits_type::eof()) { + return traits_type::not_eof(ch); + } + if (pptr() == epptr()) { + if (sync() != 0) { + return traits_type::eof(); + } + } + *pptr() = traits_type::to_char_type(ch); + pbump(1); + return ch; + } + + int sync() override { + if (handle == nullptr || handle == INVALID_HANDLE_VALUE) { + return -1; + } + + const auto size = static_cast(pptr() - pbase()); + if (size == 0) { + return 0; + } + + DWORD written = 0; + if (!WriteFile( + handle, pbase(), static_cast(size), &written, nullptr + )) { + return -1; + } + + setp(buffer.data(), buffer.data() + buffer.size()); + return 0; + } + + pos_type seekoff(off_type, std::ios_base::seekdir, std::ios_base::openmode) + override { + return pos_type(off_type(-1)); + } + + pos_type seekpos(pos_type, std::ios_base::openmode) override { + return pos_type(off_type(-1)); + } +private: + HANDLE handle; + std::array buffer {}; +#else + explicit fd_ostreambuf(int fd) : fd(fd) { + setp(buffer.data(), buffer.data() + buffer.size()); + } + + ~fd_ostreambuf() override { + fd_ostreambuf::sync(); + if (fd >= 0) { + ::close(fd); + fd = -1; + } + } +protected: + int_type overflow(int_type ch) override { + if (ch == traits_type::eof()) { + return traits_type::not_eof(ch); + } + if (pptr() == epptr()) { + if (sync() != 0) { + return traits_type::eof(); + } + } + *pptr() = traits_type::to_char_type(ch); + pbump(1); + return ch; + } + + int sync() override { + if (fd < 0) { + return -1; + } + + const auto size = static_cast(pptr() - pbase()); + if (size == 0) { + return 0; + } + + char* ptr = pbase(); + size_t remaining = size; + while (remaining > 0) { + const auto written = ::write(fd, ptr, remaining); + if (written < 0) { + if (errno == EINTR) { + continue; + } + return -1; + } + ptr += written; + remaining -= static_cast(written); + } + + setp(buffer.data(), buffer.data() + buffer.size()); + return 0; + } + + pos_type seekoff(off_type, std::ios_base::seekdir, std::ios_base::openmode) + override { + return pos_type(off_type(-1)); + } + + pos_type seekpos(pos_type, std::ios_base::openmode) override { + return pos_type(off_type(-1)); + } +private: + int fd; + std::array buffer {}; +#endif +}; + +class fd_ostream final : public std::ostream { +public: +#ifdef _WIN32 + explicit fd_ostream(HANDLE handle) : std::ostream(&buf), buf(handle) { + } +#else + explicit fd_ostream(int fd) : std::ostream(&buf), buf(fd) { + } +#endif +private: + fd_ostreambuf buf; +}; diff --git a/src/logic/scripting/io_descriptors.cpp b/src/logic/scripting/io_descriptors.cpp index ead8566d1..71811141a 100644 --- a/src/logic/scripting/io_descriptors.cpp +++ b/src/logic/scripting/io_descriptors.cpp @@ -19,6 +19,18 @@ namespace { std::unique_ptr out; }; std::vector> descriptors; + + int add_descriptor(StreamDescriptor descriptor) { + for (int i = 0; i < static_cast(descriptors.size()); ++i) { + if (!descriptors[i].has_value()) { + descriptors[i] = std::move(descriptor); + return i; + } + } + + descriptors.emplace_back(std::move(descriptor)); + return static_cast(descriptors.size() - 1); + } } std::istream* io_descriptors::get_input(int id) { @@ -121,6 +133,18 @@ void io_descriptors::close(int id) { ::descriptors[id] = std::nullopt; } +int io_descriptors::add_descriptor(std::unique_ptr stream) { + return add_descriptor(StreamDescriptor { + std::move(stream), nullptr + }); +} + +int io_descriptors::add_descriptor(std::unique_ptr stream) { + return add_descriptor(StreamDescriptor { + nullptr, std::move(stream) + }); +} + int io_descriptors::open_descriptor(const io::path& path, bool write, bool read) { std::unique_ptr in; std::unique_ptr out; @@ -138,15 +162,9 @@ int io_descriptors::open_descriptor(const io::path& path, bool write, bool read) return -1; } - for (int i = 0; i < static_cast(descriptors.size()); ++i) { - if (!descriptors[i].has_value()) { - descriptors[i] = StreamDescriptor{ std::move(in), std::move(out) }; - return i; - } - } - - ::descriptors.emplace_back(StreamDescriptor{ std::move(in), std::move(out) }); - return static_cast(::descriptors.size() - 1); + return add_descriptor(StreamDescriptor{ + std::move(in), std::move(out) + }); } diff --git a/src/logic/scripting/io_descriptors.hpp b/src/logic/scripting/io_descriptors.hpp index 56ed21a7a..c3dd5985d 100644 --- a/src/logic/scripting/io_descriptors.hpp +++ b/src/logic/scripting/io_descriptors.hpp @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include "io/fwd.hpp" @@ -22,6 +23,8 @@ namespace scripting::io_descriptors { void close(int id); int open_descriptor(const io::path& path, bool write, bool read); + int add_descriptor(std::unique_ptr stream); + int add_descriptor(std::unique_ptr stream); void close_all_descriptors(); } diff --git a/src/logic/scripting/lua/libs/libapp.cpp b/src/logic/scripting/lua/libs/libapp.cpp index 0058fcada..243c9a154 100644 --- a/src/logic/scripting/lua/libs/libapp.cpp +++ b/src/logic/scripting/lua/libs/libapp.cpp @@ -21,11 +21,13 @@ #include "world/Level.hpp" #include +#include using namespace scripting; namespace { - static std::array, MAX_SUBPROCESSES> processes; + static std::unordered_map> processes; + static int next_process_id = 1; } /// @brief Check if content is loaded @@ -429,6 +431,7 @@ static int l_start_background_instance(lua::State* L) { "--sub-depth", std::to_string(engine->getCoreParameters() .subProcessDepth + 1), "--log", io::resolve(outputPath).u8string(), + "--stdin-cmd", }; args.emplace_back("--project"); args.emplace_back(io::resolve(engine->getProject().path).u8string()); @@ -444,25 +447,17 @@ static int l_start_background_instance(lua::State* L) { } } - int handle = -1; - for (int i = 0; i < ::processes.size(); i++) { - if (!::processes[i] || !::processes[i]->isActive()) { - handle = i; - break; - } - } - if (handle == -1) { + if (::processes.size() >= MAX_SUBPROCESSES) { throw std::runtime_error("sub-processes limit exceeded"); } - ::processes[handle] = - platform::new_engine_instance(std::move(args), "", true); - - return lua::pushinteger(L, handle); + int id = ::next_process_id++; + ::processes[id] = platform::new_engine_instance(std::move(args), "", true); + return lua::pushinteger(L, id); } static int l_is_instance_alive(lua::State* L) { int handle = lua::tointeger(L, 1); - if (handle < 0 || handle >= ::processes.size()) { + if (handle < 0 || ::processes.find(handle) == ::processes.end()) { throw std::runtime_error("invalid process handle"); } auto& process = ::processes[handle]; @@ -471,16 +466,42 @@ static int l_is_instance_alive(lua::State* L) { static int l_terminate_instance(lua::State* L) { int handle = lua::tointeger(L, 1); - if (handle < 0 || handle >= ::processes.size()) { + if (handle < 0 || ::processes.find(handle) == ::processes.end()) { + throw std::runtime_error("invalid process handle"); + } + auto it = ::processes.find(handle); + if (it->second == nullptr) { + ::processes.erase(it); + return lua::pushboolean(L, false); + } + bool active = it->second->isActive(); + it->second.reset(); + ::processes.erase(it); + return lua::pushboolean(L, active); +} + +static int l_get_stdin_stream(lua::State* L) { + int handle = lua::tointeger(L, 1); + if (handle < 0 || ::processes.find(handle) == ::processes.end()) { throw std::runtime_error("invalid process handle"); } auto& process = ::processes[handle]; if (process == nullptr) { - return lua::pushboolean(L, false); + return 0; } - bool active = process->isActive(); - process.reset(); - return lua::pushboolean(L, active); + return lua::pushinteger(L, process->getStdinDescriptor()); +} + +static int l_get_stdout_stream(lua::State* L) { + int handle = lua::tointeger(L, 1); + if (handle < 0 || ::processes.find(handle) == ::processes.end()) { + throw std::runtime_error("invalid process handle"); + } + auto& process = ::processes[handle]; + if (process == nullptr) { + return 0; + } + return lua::pushinteger(L, process->getStdoutDescriptor()); } const luaL_Reg applib[] = { @@ -515,9 +536,12 @@ const luaL_Reg applib[] = { /// other {"get_version", lua::wrap}, {"create_memory_device", lua::wrap}, + // sub-instances {"start_debug_instance", lua::wrap}, {"start_background_instance", lua::wrap}, {"is_instance_alive", lua::wrap}, {"terminate_instance", lua::wrap}, + {"get_stdin_stream", lua::wrap}, + {"get_stdout_stream", lua::wrap}, {nullptr, nullptr} }; diff --git a/src/main.cpp b/src/main.cpp index 9d8d8e551..078fde478 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -33,6 +33,9 @@ int main(int argc, char** argv) { std::cerr << err.what() << std::endl; return EXIT_FAILURE; } +#ifndef _WIN32 + std::signal(SIGPIPE, SIG_IGN); +#endif std::signal(SIGTERM, sigterm_handler); #ifdef NDEBUG std::signal(SIGINT, sigterm_handler); diff --git a/src/util/platform.cpp b/src/util/platform.cpp index 278fbaa1b..996236dc3 100644 --- a/src/util/platform.cpp +++ b/src/util/platform.cpp @@ -1,7 +1,6 @@ #include "platform.hpp" #include - #include #include #include @@ -11,6 +10,10 @@ #include "typedefs.hpp" #include "debug/Logger.hpp" #include "frontend/locale.hpp" +#include "interfaces/SystemProcess.hpp" +#include "logic/scripting/io_descriptors.hpp" +#include "io/fd_istream.hpp" +#include "io/fd_ostream.hpp" #ifdef _WIN32 #include @@ -22,9 +25,13 @@ #include #include #include +#include +#include #endif #ifdef __linux__ #include +#endif +#if defined(__linux__) || defined(__APPLE__) #include #endif @@ -71,23 +78,17 @@ void platform::sleep(size_t millis) { return tc.wPeriodMin; }(); - // Set the timer resolution to the minimum for the Sleep call timeBeginPeriod(periodMin); - - // Wait... Sleep(static_cast(millis)); - - // Reset the timer resolution back to the system default timeEndPeriod(periodMin); } int platform::get_process_id() { - return GetCurrentProcessId(); + return GetCurrentProcessId(); } bool platform::open_url(const std::string& url) { if (url.empty()) return false; - // UTF-8 → UTF-16 int wlen = MultiByteToWideChar(CP_UTF8, 0, url.c_str(), -1, nullptr, 0); if (wlen <= 0) return false; @@ -105,11 +106,10 @@ bool platform::open_url(const std::string& url) { void platform::configure_encoding() { } - + std::string platform::detect_locale() { const char* const programLocaleName = setlocale(LC_ALL, nullptr); - const char* const preferredLocaleName = - setlocale(LC_ALL, ""); // locale name format: ll_CC.encoding + const char* const preferredLocaleName = setlocale(LC_ALL, ""); if (programLocaleName && preferredLocaleName) { setlocale(LC_ALL, programLocaleName); @@ -224,34 +224,46 @@ std::filesystem::path platform::get_executable_path() { #endif } -class SystemProcess final : public Process { +class SystemProcessImpl final : public SystemProcess { public: -#ifdef __linux__ - SystemProcess(pid_t pid) : pid(pid) { +#if defined(__linux__) || defined(__APPLE__) + SystemProcessImpl( + pid_t pid, int stdinDescriptor = -1, int stdoutDescriptor = -1 + ) + : pid(pid), + stdinDescriptor(stdinDescriptor), + stdoutDescriptor(stdoutDescriptor) { } - ~SystemProcess() { + ~SystemProcessImpl() { terminate(); } #elif defined(_WIN32) - SystemProcess(const PROCESS_INFORMATION& pi) - : processHandle(pi.hProcess), pid(pi.dwProcessId) { + SystemProcessImpl( + const PROCESS_INFORMATION& pi, + int stdinDescriptor = -1, + int stdoutDescriptor = -1 + ) + : processHandle(pi.hProcess), + pid(pi.dwProcessId), + stdinDescriptor(stdinDescriptor), + stdoutDescriptor(stdoutDescriptor) { if (pi.hThread != nullptr) { CloseHandle(pi.hThread); } } - ~SystemProcess() { + ~SystemProcessImpl() { terminate(); } #endif - SystemProcess(const SystemProcess&) = delete; - SystemProcess(SystemProcess&&) noexcept = default; - SystemProcess& operator=(const SystemProcess&) = delete; + SystemProcessImpl(const SystemProcessImpl&) = delete; + SystemProcessImpl(SystemProcessImpl&&) noexcept = default; + SystemProcessImpl& operator=(const SystemProcessImpl&) = delete; - SystemProcess& operator=(SystemProcess&& other) noexcept { + SystemProcessImpl& operator=(SystemProcessImpl&& other) noexcept { if (this != &other) { -#ifdef __linux__ +#if defined(__linux__) || defined(__APPLE__) pid = other.pid; #elif defined(_WIN32) if (processHandle != nullptr) { @@ -262,16 +274,36 @@ public: other.processHandle = nullptr; other.pid = 0; #endif + stdinDescriptor = other.stdinDescriptor; + stdoutDescriptor = other.stdoutDescriptor; + other.stdinDescriptor = -1; + other.stdoutDescriptor = -1; } return *this; } bool isActive() const override { -#ifdef __linux__ - if (kill(pid, 0) == 0) { +#if defined(__linux__) || defined(__APPLE__) + if (pid <= 0) { + return false; + } + + // fixme: ugly ugly ugly + int status = 0; + pid_t result = waitpid(pid, &status, WNOHANG); + if (result == -1) { + if (errno == ECHILD) { + const_cast(this)->pid = 0; + return false; + } + return false; + } + if (result == 0) { return true; } - return errno != ESRCH; + + const_cast(this)->pid = 0; + return false; #elif defined(_WIN32) if (processHandle == nullptr) { return false; @@ -283,6 +315,7 @@ public: return false; #elif defined(__APPLE__) // FIXME: completely implement SystemProcess for MacOS +#else return false; #endif } @@ -290,8 +323,12 @@ public: void update() override {} void waitForEnd() override { -#ifdef __linux__ +#if defined(__linux__) || defined(__APPLE__) + if (pid <= 0) { + return; + } waitpid(pid, nullptr, 0); + pid = 0; #elif defined(_WIN32) if (processHandle != nullptr) { WaitForSingleObject(processHandle, INFINITE); @@ -300,7 +337,10 @@ public: }; void terminate() final override { -#ifdef __linux__ +#if defined(__linux__) || defined(__APPLE__) + if (pid <= 0) { + return; + } logger.info() << "terminating " << pid; kill(pid, SIGTERM); #elif defined(_WIN32) @@ -310,16 +350,149 @@ public: } #endif } + + int getStdinDescriptor() const override { + return stdinDescriptor; + } + + int getStdoutDescriptor() const override { + return stdoutDescriptor; + } + private: -#ifdef __linux__ +#if defined(__linux__) || defined(__APPLE__) pid_t pid; + int stdinDescriptor; + int stdoutDescriptor; #elif defined(_WIN32) HANDLE processHandle = nullptr; DWORD pid = 0; + int stdinDescriptor; + int stdoutDescriptor; #endif }; -std::unique_ptr platform::new_engine_instance( +#ifndef _WIN32 +static void close_fd(int& fd) { + if (fd >= 0) { + close(fd); + fd = -1; + } +} + +static bool make_cloexec_pipe(int fds[2]) { +#ifdef __linux__ + return pipe2(fds, O_CLOEXEC) == 0; +#else + if (pipe(fds) != 0) { + return false; + } + fcntl(fds[0], F_SETFD, FD_CLOEXEC); + fcntl(fds[1], F_SETFD, FD_CLOEXEC); + return true; +#endif +} + +static void report_error_and_exit(int fd) { + int err = errno; + [[maybe_unused]] ssize_t _ = write(fd, &err, sizeof(err)); + _exit(127); +} + +// TODO: make sub-process die with parent in MacOS +static std::unique_ptr start_engine_subprocess( + const std::filesystem::path& executable, + const std::vector& args +) { + int stdinPipe[2] = {-1, -1}; + int stdoutPipe[2] = {-1, -1}; + int execPipe[2] = {-1, -1}; + auto closeAll = [&]() { + for (int* fd : + {&stdinPipe[0], + &stdinPipe[1], + &stdoutPipe[0], + &stdoutPipe[1], + &execPipe[0], + &execPipe[1]}) { + close_fd(*fd); + } + }; + + if (!make_cloexec_pipe(stdinPipe) || !make_cloexec_pipe(stdoutPipe) || + !make_cloexec_pipe(execPipe)) { + closeAll(); + throw std::runtime_error("failed to create subprocess pipes"); + } + + std::string path = executable.string(); + std::vector argv; + argv.reserve(args.size() + 2); + argv.push_back(path.data()); + for (const auto& arg : args) { + argv.push_back(const_cast(arg.c_str())); + } + argv.push_back(nullptr); + +#ifdef __linux__ + const pid_t parentPid = getpid(); +#endif + const pid_t pid = fork(); + if (pid < 0) { + int err = errno; + closeAll(); + throw std::runtime_error("fork failed: "s + std::strerror(err)); + } + + if (pid == 0) { +#ifdef __linux__ + prctl(PR_SET_PDEATHSIG, SIGTERM); + if (getppid() != parentPid) { + _exit(1); + } + prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0); +#endif + if (dup2(stdinPipe[0], STDIN_FILENO) < 0 || + dup2(stdoutPipe[1], STDOUT_FILENO) < 0 || + dup2(stdoutPipe[1], STDERR_FILENO) < 0) { + report_error_and_exit(execPipe[1]); + } + execv(argv[0], argv.data()); + report_error_and_exit(execPipe[1]); + } + + close_fd(stdinPipe[0]); + close_fd(stdoutPipe[1]); + close_fd(execPipe[1]); + + int childErrno = 0; + ssize_t n; + do { + n = read(execPipe[0], &childErrno, sizeof(childErrno)); + } while (n < 0 && errno == EINTR); + close_fd(execPipe[0]); + + if (n > 0) { + waitpid(pid, nullptr, 0); + closeAll(); + throw std::runtime_error( + "starting an engine instance failed: "s + std::strerror(childErrno) + ); + } + + const int stdinDescriptorId = scripting::io_descriptors::add_descriptor( + std::make_unique(stdinPipe[1]) + ); + const int stdoutDescriptorId = scripting::io_descriptors::add_descriptor( + std::make_unique(stdoutPipe[0]) + ); + return std::make_unique( + pid, stdinDescriptorId, stdoutDescriptorId + ); +} +#endif + +std::unique_ptr platform::new_engine_instance( const std::vector& args, std::filesystem::path outputFile, bool subProcess @@ -334,7 +507,7 @@ std::unique_ptr platform::new_engine_instance( } auto toWString = [](const std::string& src) -> std::wstring { - if (src.empty()) + if (src.empty()) return L""; int size = MultiByteToWideChar(CP_UTF8, 0, src.c_str(), -1, nullptr, 0); if (size == 0) { @@ -358,10 +531,81 @@ std::unique_ptr platform::new_engine_instance( auto commandString = toWString(ss.str()); STARTUPINFOW si = { sizeof(si) }; + PROCESS_INFORMATION pi = { 0 }; + + if (subProcess) { + SECURITY_ATTRIBUTES pipeAttributes{}; + pipeAttributes.nLength = sizeof(pipeAttributes); + pipeAttributes.bInheritHandle = TRUE; + + HANDLE stdinRead = nullptr; + HANDLE stdinWrite = nullptr; + HANDLE stdoutRead = nullptr; + HANDLE stdoutWrite = nullptr; + + if (!CreatePipe(&stdinRead, &stdinWrite, &pipeAttributes, 0) || + !CreatePipe(&stdoutRead, &stdoutWrite, &pipeAttributes, 0)) { + throw std::runtime_error( + "CreatePipe failed with code: " + std::to_string(GetLastError()) + ); + } + + if (!SetHandleInformation(stdinWrite, HANDLE_FLAG_INHERIT, 0) || + !SetHandleInformation(stdoutRead, HANDLE_FLAG_INHERIT, 0)) { + CloseHandle(stdinRead); + CloseHandle(stdinWrite); + CloseHandle(stdoutRead); + CloseHandle(stdoutWrite); + throw std::runtime_error( + "SetHandleInformation failed with code: " + std::to_string(GetLastError()) + ); + } + + si.dwFlags = STARTF_USESTDHANDLES; + si.hStdInput = stdinRead; + si.hStdOutput = stdoutWrite; + si.hStdError = stdoutWrite; + + const DWORD flags = CREATE_NEW_PROCESS_GROUP | DETACHED_PROCESS; + const BOOL success = CreateProcessW( + nullptr, + commandString.data(), + nullptr, + nullptr, + TRUE, + flags, + nullptr, + nullptr, + &si, + &pi + ); + + CloseHandle(stdinRead); + CloseHandle(stdoutWrite); + + if (!success) { + CloseHandle(stdinWrite); + CloseHandle(stdoutRead); + throw std::runtime_error( + "starting an engine instance failed with code: " + + std::to_string(GetLastError()) + ); + } + + int stdinDescriptor = scripting::io_descriptors::add_descriptor( + std::make_unique(stdinWrite) + ); + int stdoutDescriptor = scripting::io_descriptors::add_descriptor( + std::make_unique(stdoutRead) + ); + return std::make_unique(pi, stdinDescriptor, stdoutDescriptor); + } + if (!outputFile.empty()) { si.dwFlags |= STARTF_USESTDHANDLES; + const auto outputPath = toWString(outputFile.u8string()); si.hStdOutput = CreateFileW( - toWString(outputFile.empty() ? outputFile.u8string() : "NUL"s).data(), + outputPath.c_str(), GENERIC_WRITE, FILE_SHARE_WRITE | FILE_SHARE_READ, nullptr, @@ -371,15 +615,13 @@ std::unique_ptr platform::new_engine_instance( ); if (si.hStdOutput == INVALID_HANDLE_VALUE) { throw std::runtime_error( - "CreateFileW failed with code: " + - std::to_string(GetLastError()) + "CreateFileW failed with code: " + std::to_string(GetLastError()) ); } } - PROCESS_INFORMATION pi = { 0 }; - DWORD flags = CREATE_NEW_PROCESS_GROUP | DETACHED_PROCESS; - // | CREATE_NO_WINDOW; - BOOL success = CreateProcessW( + + const DWORD flags = CREATE_NEW_PROCESS_GROUP | DETACHED_PROCESS; + const BOOL success = CreateProcessW( nullptr, commandString.data(), nullptr, @@ -391,38 +633,6 @@ std::unique_ptr platform::new_engine_instance( &si, &pi ); - if (subProcess) { - HANDLE job = CreateJobObjectW(nullptr, nullptr); - - JOBOBJECT_EXTENDED_LIMIT_INFORMATION info{}; - info.BasicLimitInformation.LimitFlags = - JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE; - - try { - if (!SetInformationJobObject( - job, - JobObjectExtendedLimitInformation, - &info, - sizeof(info))) { - throw std::runtime_error( - "SetInformationJobObject failed with code: " + - std::to_string(GetLastError()) - ); - } - if (!AssignProcessToJobObject(job, pi.hProcess)) { - throw std::runtime_error( - "SetInformationJobObject failed with code: " + - std::to_string(GetLastError()) - ); - } - return std::make_unique(pi); - } catch (const std::exception& err) { - CloseHandle(job); - CloseHandle(pi.hProcess); - CloseHandle(pi.hThread); - return nullptr; - } - } if (success) { CloseHandle(pi.hProcess); CloseHandle(pi.hThread); @@ -433,51 +643,12 @@ std::unique_ptr platform::new_engine_instance( ); } #else - -// TODO: implement -#ifndef __APPLE__ if (subProcess) { - pid_t pid = fork(); - - if (outputFile.empty()) { - outputFile = "/dev/null"; - } - int fd = open( - outputFile.string().c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0644 - ); - - if (pid == 0) { - prctl(PR_SET_PDEATHSIG, SIGTERM); - - if (getppid() == 1) { - _exit(1); - } - - dup2(fd, STDOUT_FILENO); - dup2(fd, STDERR_FILENO); - close(fd); - - std::vector argv(args.size() + 2); - argv[0] = const_cast(executable.c_str()); - for (int i = 0; i < args.size(); i++) { - argv[i + 1] = args[i].c_str(); - } - argv[args.size() + 1] = nullptr; - - prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0); - execvp(executable.c_str(), const_cast(argv.data())); - - _exit(127); - } else { - close(fd); - usleep(1000); // waiting for execvp call - return std::make_unique(pid); - } + return start_engine_subprocess(executable, args); } -#endif std::stringstream ss; - ss << executable; + ss << util::quote(executable.u8string()); for (int i = 0; i < args.size(); i++) { ss << " " << util::quote(args[i]); } @@ -501,7 +672,22 @@ std::unique_ptr platform::new_engine_instance( bool platform::stdin_has_data() { #ifdef _WIN32 - return _kbhit(); + const HANDLE inputHandle = GetStdHandle(STD_INPUT_HANDLE); + if (inputHandle == nullptr || inputHandle == INVALID_HANDLE_VALUE) { + return false; + } + + DWORD mode = 0; + if (GetConsoleMode(inputHandle, &mode)) { + return _kbhit() != 0; + } + + DWORD available = 0; + if (!PeekNamedPipe(inputHandle, nullptr, 0, nullptr, &available, nullptr)) { + const DWORD error = GetLastError(); + return error != ERROR_BROKEN_PIPE && error != ERROR_INVALID_HANDLE; + } + return available > 0; #else struct pollfd fds; fds.fd = STDIN_FILENO; diff --git a/src/util/platform.hpp b/src/util/platform.hpp index 18dc052b6..457642fd3 100644 --- a/src/util/platform.hpp +++ b/src/util/platform.hpp @@ -5,7 +5,7 @@ #include #include -#include "interfaces/Process.hpp" +#include "interfaces/SystemProcess.hpp" namespace platform { void configure_encoding(); @@ -21,7 +21,7 @@ namespace platform { /// @brief Get current process running executable path std::filesystem::path get_executable_path(); /// @brief Run a separate engine instance with specified arguments - std::unique_ptr new_engine_instance( + std::unique_ptr new_engine_instance( const std::vector& args, std::filesystem::path outputFile, bool subProcess