process.h

#ifndef UVW_PROCESS_INCLUDE_H
#define UVW_PROCESS_INCLUDE_H
 
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include <uv.h>
#include "config.h"
#include "enum.hpp"
#include "handle.hpp"
#include "loop.h"
#include "stream.h"
#include "util.h"
 
namespace uvw {
 
namespace details {
 
enum class uvw_process_flags : std::underlying_type_t<uv_process_flags> {
    SETUID = UV_PROCESS_SETUID,
    SETGID = UV_PROCESS_SETGID,
    WINDOWS_VERBATIM_ARGUMENTS = UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS,
    DETACHED = UV_PROCESS_DETACHED,
    WINDOWS_HIDE = UV_PROCESS_WINDOWS_HIDE,
    WINDOWS_HIDE_CONSOLE = UV_PROCESS_WINDOWS_HIDE_CONSOLE,
    WINDOWS_HIDE_GUI = UV_PROCESS_WINDOWS_HIDE_GUI,
    _UVW_ENUM = 0
};
 
enum class uvw_stdio_flags : std::underlying_type_t<uv_stdio_flags> {
    IGNORE_STREAM = UV_IGNORE,
    CREATE_PIPE = UV_CREATE_PIPE,
    INHERIT_FD = UV_INHERIT_FD,
    INHERIT_STREAM = UV_INHERIT_STREAM,
    READABLE_PIPE = UV_READABLE_PIPE,
    WRITABLE_PIPE = UV_WRITABLE_PIPE,
    OVERLAPPED_PIPE = UV_OVERLAPPED_PIPE,
    _UVW_ENUM = 0
};
 
} // namespace details
 
struct exit_event {
    explicit exit_event(int64_t code, int sig) noexcept;
 
    int64_t status; 
    int signal;     
};
 
class process_handle final: public handle<process_handle, uv_process_t, exit_event> {
    static void exit_callback(uv_process_t *hndl, int64_t exit_status, int term_signal);
 
public:
    using process_flags = details::uvw_process_flags;
    using stdio_flags = details::uvw_stdio_flags;
 
    process_handle(loop::token token, std::shared_ptr<loop> ref);
 
    static void disable_stdio_inheritance() noexcept;
 
    static bool kill(int pid, int signum) noexcept;
 
    int init() final;
 
    int spawn(const char *file, char **args, char **env = nullptr);
 
    int kill(int signum);
 
    int pid() noexcept;
 
    process_handle &cwd(const std::string &path) noexcept;
 
    process_handle &flags(process_flags flags) noexcept;
 
    template<typename T, typename U, typename... E>
    process_handle &stdio(stream_handle<T, U, E...> &stream, stdio_flags flags) {
        uv_stdio_container_t container;
        container.flags = static_cast<uv_stdio_flags>(flags);
        container.data.stream = reinterpret_cast<uv_stream_t *>(stream.raw());
        po_stream_stdio.push_back(std::move(container));
        return *this;
    }
 
    process_handle &stdio(file_handle fd, stdio_flags flags);
 
    process_handle &uid(uid_type id);
 
    process_handle &gid(gid_type id);
 
private:
    std::string po_cwd;
    process_flags po_flags;
    std::vector<uv_stdio_container_t> po_fd_stdio;
    std::vector<uv_stdio_container_t> po_stream_stdio;
    uid_type po_uid;
    gid_type po_gid;
};
 
} // namespace uvw
 
#ifndef UVW_AS_LIB
#    include "process.cpp"
#endif
 
#endif // UVW_PROCESS_INCLUDE_H