public:

Executor(const Executor&) = delete;

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

// Initialized with a path to the process that the Executor class will

// execute

Executor(

absl::string_view path, absl::Span<const std::string> argv,

absl::Span<const std::string> envp = absl::MakeConstSpan(CopyEnviron()))

: path_(std::string(path)),

argv_(argv.begin(), argv.end()),

envp_(envp.begin(), envp.end()) {

CHECK(!path_.empty());

SetUpServerSideCommsFd();

}

// Executor will own this file-descriptor, so if intend to use it, pass here

// dup(fd) instead

Executor(

int exec_fd, absl::Span<const std::string> argv,

absl::Span<const std::string> envp = absl::MakeConstSpan(CopyEnviron()))

: exec_fd_(exec_fd),

argv_(argv.begin(), argv.end()),

envp_(envp.begin(), envp.end()) {

CHECK_GE(exec_fd, 0);

SetUpServerSideCommsFd();

}

// Uses a custom ForkServer (which the supplied ForkClient can communicate

// with), which knows how to fork (or even execute) new sandboxed processes

// (hence, no need to supply path/argv/envp here)

explicit Executor(ForkClient* fork_client)

: enable_sandboxing_pre_execve_(false), fork_client_(fork_client) {

CHECK(fork_client != nullptr);

SetUpServerSideCommsFd();

}

// Creates a new process which will act as a custom ForkServer. Should be used

// with custom fork servers only.

// This function returns immediately and returns a nullptr on failure.

std::unique_ptr<ForkClient> StartForkServer();

// Accessors

IPC* ipc() { return &ipc_; }

Limits* limits() { return &limits_; }

Executor& set_enable_sandbox_before_exec(bool value) {

enable_sandboxing_pre_execve_ = value;

return *this;

}

Executor& set_cwd(std::string value) {

cwd_ = std::move(value);

return *this;

}

int libunwind_recursion_depth() { return libunwind_recursion_depth_; }

bool is_pre_execve_sandboxing_enabled() const {

return enable_sandboxing_pre_execve_;

}

private:

friend class MonitorBase;

friend class StackTracePeer;

// Internal constructor for executing libunwind on the given pid

// enable_sandboxing_pre_execve=false as we are not going to execve.

explicit Executor(pid_t libunwind_sbox_for_pid, int libunwind_recursion_depth)

: libunwind_sbox_for_pid_(libunwind_sbox_for_pid),

libunwind_recursion_depth_(libunwind_recursion_depth),

enable_sandboxing_pre_execve_(false) {

CHECK_GE(libunwind_sbox_for_pid_, 0);

SetUpServerSideCommsFd();

}

// Creates a copy of the environment

static std::vector<std::string> CopyEnviron();

// Creates a server-side Comms end-point using a pre-connected file

// descriptor.

void SetUpServerSideCommsFd();

// Starts a new process which is connected with this Executor instance via a

// Comms channel.

// For clone_flags refer to Linux' 'man 2 clone'.

absl::StatusOr<SandboxeeProcess> StartSubProcess(

int clone_flags, const Namespace* ns = nullptr,

bool allow_speculation = false,

MonitorType type = FORKSERVER_MONITOR_PTRACE);

// Whether the Executor has been started yet

bool started_ = false;

// If this executor is running the libunwind sandbox for a process,

// this variable will hold the PID of the process. Otherwise it is zero.

pid_t libunwind_sbox_for_pid_ = 0;

int libunwind_recursion_depth_ = 0;

// Should the sandboxing be enabled before execve() occurs, or the binary will

// do it by itself, using the Client object's methods

bool enable_sandboxing_pre_execve_ = true;

// Alternate (path/fd)/argv/envp to be used the in the __NR_execve call.

sapi::file_util::fileops::FDCloser exec_fd_;

std::string path_;

std::vector<std::string> argv_;

std::vector<std::string> envp_;

// chdir to cwd_, if set. Defaults to current working directory.

std::string cwd_ = []() {

std::string cwd = sapi::file_util::fileops::GetCWD();

if (cwd.empty()) {

PLOG(WARNING) << "Getting current working directory";

}

return cwd;

}();

// Client (sandboxee) end-point of a socket-pair used to create Comms channel

sapi::file_util::fileops::FDCloser client_comms_fd_;

// ForkClient connecting to the ForkServer - not owned by the object

ForkClient* fork_client_ = nullptr;

IPC ipc_; // Used for communication with the sandboxee

Limits limits_; // Defines server- and client-side limits