process.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_PROCESS_HEADER
#define LIBFILEZILLA_PROCESS_HEADER
 
#include "libfilezilla.hpp"
#include "fsresult.hpp"
#include "event.hpp"
#include "time.hpp"
 
#include <vector>
 
namespace fz {
class event_handler;
class impersonation_token;
class thread_pool;
 
 
enum class process_event_flag
{
    read = 0x1,
 
    write = 0x2,
};
 
struct process_event_type;
 
class process;
 
typedef simple_event<process_event_type, process*, process_event_flag> process_event;
 
class FZ_PUBLIC_SYMBOL process final
{
public:
    process();
 
    process(thread_pool & pool, event_handler & handler);
 
    ~process();
    process(process const&) = delete;
    process& operator=(process const&) = delete;
 
    enum class io_redirection {
        redirect, 
        none, 
        closeall 
    };
 
    bool spawn(native_string const& cmd, std::vector<native_string> const& args = std::vector<native_string>(), io_redirection redirect_mode = io_redirection::redirect);
 
    bool spawn(std::vector<native_string> const& command_with_args, io_redirection redirect_mode = io_redirection::redirect);
 
#if FZ_WINDOWS || FZ_UNIX
    bool spawn(impersonation_token const& it, native_string const& cmd, std::vector<native_string> const& args, io_redirection redirect_mode = io_redirection::redirect);
#endif
 
#ifndef FZ_WINDOWS
    bool spawn(native_string const& cmd, std::vector<native_string> const& args, std::vector<int> const& extra_fds, io_redirection redirect_mode = io_redirection::redirect);
 
    bool spawn(impersonation_token const& it, native_string const& cmd, std::vector<native_string> const& args, std::vector<int> const& extra_fds, io_redirection redirect_mode = io_redirection::redirect);
#endif
 
    void kill();
 
    bool stop(duration const& timeout = {});
 
    rwresult read(void* buffer, size_t len);
 
    rwresult write(void const* buffer, size_t len);
 
    inline rwresult write(std::string_view const& s) {
        return write(s.data(), s.size());
    }
 
#if FZ_WINDOWS
    void* handle() const;
#endif
 
private:
    class impl;
    impl* impl_;
};
 
 
bool FZ_PUBLIC_SYMBOL spawn_detached_process(std::vector<native_string> const& cmd_with_args);
 
#if !FZ_WINDOWS
class FZ_PUBLIC_SYMBOL forkblock final
{
public:
    forkblock();
    ~forkblock();
 
    forkblock(forkblock const&) = delete;
    forkblock& operator=(forkblock const&) = delete;
};
#endif
 
}
 
#endif