subprocess.h

#ifndef WREPORT_SUBPROCESS_H
#define WREPORT_SUBPROCESS_H

#include <string>
#include <sys/types.h>
#include <vector>

namespace wreport::subprocess {

enum class Redirect {
    PIPE,

    DEVNULL,

    STDOUT,

    FD,

    UNCHANGED,
};

class Child
{
protected:
    pid_t m_pid              = 0;
    int m_returncode         = 0;
    bool m_terminated        = false;
    int m_stdin[2]           = {-1, -1};
    int m_stdout[2]          = {-1, -1};
    int m_stderr[2]          = {-1, -1};
    Redirect m_stdin_action  = Redirect::UNCHANGED;
    Redirect m_stdout_action = Redirect::UNCHANGED;
    Redirect m_stderr_action = Redirect::UNCHANGED;

    virtual void pre_fork();

    virtual void post_fork_parent();

    virtual void post_fork_child();

    virtual int main() noexcept = 0;

public:
    bool close_fds = true;

    std::vector<int> pass_fds = std::vector<int>();

    std::string cwd = std::string();

    bool start_new_session = false;

    int get_stdin() const;
    int get_stdout() const;
    int get_stderr() const;

    void set_stdin(int fd);
    void set_stdin(Redirect val);
    void set_stdout(int fd);
    void set_stdout(Redirect val);
    void set_stderr(int fd);
    void set_stderr(Redirect val);

    void close_stdin();
    void close_stdout();
    void close_stderr();

    Child()             = default;
    Child(const Child&) = delete;
    Child(Child&&)      = delete;
    virtual ~Child();

    Child& operator=(const Child&) = delete;
    Child& operator=(Child&&)      = delete;

    void fork();

    pid_t pid() const { return m_pid; }

    int returncode() const;

    int raw_returncode() const { return m_returncode; }

    bool started() const { return m_pid != 0; }

    bool terminated() const { return m_terminated; }

    bool poll();

    int wait();

    bool wait(int msecs);

    void send_signal(int sig);

    void terminate();

    void kill();

    static std::string format_raw_returncode(int raw_returncode);
};

class Popen : public Child
{
protected:
    int main() noexcept override;

public:
    std::vector<std::string> args;
    std::string executable;
    std::vector<std::string> env;

    using Child::Child;

    Popen() = default;
    Popen(std::initializer_list<std::string> args);

    void copy_env_from_parent();

    void setenv(const std::string& key, const std::string& val);
};

} // namespace wreport::subprocess

#endif