subprocess.h

#ifndef WREPORT_SUBPROCESS_H
#define WREPORT_SUBPROCESS_H
 
#include <vector>
#include <string>
#include <sys/types.h>
 
namespace wreport {
namespace 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::string cwd;
 
    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();
 
    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);
};
 
 
}
}
 
#endif