124 lines
2.4 KiB
C++
124 lines
2.4 KiB
C++
#pragma once
|
|
///@file
|
|
|
|
#include "types.hh"
|
|
#include "error.hh"
|
|
#include "logging.hh"
|
|
#include "ansicolor.hh"
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <dirent.h>
|
|
#include <unistd.h>
|
|
#include <signal.h>
|
|
|
|
#include <boost/lexical_cast.hpp>
|
|
|
|
#include <atomic>
|
|
#include <functional>
|
|
#include <map>
|
|
#include <sstream>
|
|
#include <optional>
|
|
|
|
namespace nix {
|
|
|
|
struct Sink;
|
|
struct Source;
|
|
|
|
class Pid
|
|
{
|
|
pid_t pid = -1;
|
|
bool separatePG = false;
|
|
int killSignal = SIGKILL;
|
|
public:
|
|
Pid();
|
|
Pid(pid_t pid);
|
|
~Pid();
|
|
void operator =(pid_t pid);
|
|
operator pid_t();
|
|
int kill();
|
|
int wait();
|
|
|
|
void setSeparatePG(bool separatePG);
|
|
void setKillSignal(int signal);
|
|
pid_t release();
|
|
};
|
|
|
|
|
|
/**
|
|
* Kill all processes running under the specified uid by sending them
|
|
* a SIGKILL.
|
|
*/
|
|
void killUser(uid_t uid);
|
|
|
|
|
|
/**
|
|
* Fork a process that runs the given function, and return the child
|
|
* pid to the caller.
|
|
*/
|
|
struct ProcessOptions
|
|
{
|
|
std::string errorPrefix = "";
|
|
bool dieWithParent = true;
|
|
bool runExitHandlers = false;
|
|
bool allowVfork = false;
|
|
/**
|
|
* use clone() with the specified flags (Linux only)
|
|
*/
|
|
int cloneFlags = 0;
|
|
};
|
|
|
|
pid_t startProcess(std::function<void()> fun, const ProcessOptions & options = ProcessOptions());
|
|
|
|
|
|
/**
|
|
* Run a program and return its stdout in a string (i.e., like the
|
|
* shell backtick operator).
|
|
*/
|
|
std::string runProgram(Path program, bool searchPath = false,
|
|
const Strings & args = Strings(),
|
|
const std::optional<std::string> & input = {}, bool isInteractive = false);
|
|
|
|
struct RunOptions
|
|
{
|
|
Path program;
|
|
bool searchPath = true;
|
|
Strings args;
|
|
std::optional<uid_t> uid;
|
|
std::optional<uid_t> gid;
|
|
std::optional<Path> chdir;
|
|
std::optional<std::map<std::string, std::string>> environment;
|
|
std::optional<std::string> input;
|
|
Source * standardIn = nullptr;
|
|
Sink * standardOut = nullptr;
|
|
bool mergeStderrToStdout = false;
|
|
bool isInteractive = false;
|
|
};
|
|
|
|
std::pair<int, std::string> runProgram(RunOptions && options);
|
|
|
|
void runProgram2(const RunOptions & options);
|
|
|
|
|
|
class ExecError : public Error
|
|
{
|
|
public:
|
|
int status;
|
|
|
|
template<typename... Args>
|
|
ExecError(int status, const Args & ... args)
|
|
: Error(args...), status(status)
|
|
{ }
|
|
};
|
|
|
|
|
|
/**
|
|
* Convert the exit status of a child as returned by wait() into an
|
|
* error string.
|
|
*/
|
|
std::string statusToString(int status);
|
|
|
|
bool statusOk(int status);
|
|
|
|
}
|