process.hxx

Go to the documentation of this file.

#pragma once
 
// Linux
#include <sys/wait.h>
 
// C++
#include <iosfwd>
#include <optional>
 
// cosmos
#include <cosmos/BitMask.hxx>
#include <cosmos/fs/DirFD.hxx>
#include <cosmos/proc/PidFD.hxx>
#include <cosmos/proc/types.hxx>
#include <cosmos/proc/SigInfo.hxx>
#include <cosmos/string.hxx>
#include <cosmos/SysString.hxx>
#include <cosmos/types.hxx>
 
namespace cosmos {
 
/*
 * Declare these here, since they require pulling in the fat SigInfo header
 * and sys/wait.h, which would cause conflicts when done so in types.hxx
 * directly.
 *
 * WaitFlags and ChildData is needed across different classes, thus don't
 * place them in the proc sub-namespace.
 */
 
enum class WaitFlag : int {
        WAIT_FOR_EXITED    = WEXITED,
        WAIT_FOR_STOPPED   = WSTOPPED,
        WAIT_FOR_CONTINUED = WCONTINUED,
        NO_HANG            = WNOHANG,
        LEAVE_INFO         = WNOWAIT
};
 
using WaitFlags = BitMask<WaitFlag>;
 
/*
 * This is the same basic structure as found in SigInfo, only that waitid() &
 * friends don't fill in the user and sys times
 */
using ChildData = SigInfo::ChildData;
 
} // end ns
 
namespace cosmos::proc {
 
COSMOS_API ProcessID get_own_pid();
 
COSMOS_API ProcessID get_parent_pid();
 
COSMOS_API UserID get_real_user_id();
 
 
COSMOS_API UserID get_effective_user_id();
 
COSMOS_API GroupID get_real_group_id();
 
 
COSMOS_API GroupID get_effective_group_id();
 
COSMOS_API ProcessGroupID get_own_process_group();
 
 
COSMOS_API ProcessID create_new_session();
 
 
COSMOS_API std::optional<ProcessID> fork();
 
 
COSMOS_API std::optional<ChildData> wait(const ProcessID pid, const WaitFlags flags = WaitFlags{WaitFlag::WAIT_FOR_EXITED});
 
 
COSMOS_API std::optional<ChildData> wait(const ProcessGroupID pgid, const WaitFlags flags = WaitFlags{WaitFlag::WAIT_FOR_EXITED});
 
 
COSMOS_API std::optional<ChildData> wait(const WaitFlags flags = WaitFlags{WaitFlag::WAIT_FOR_EXITED});
 
 
COSMOS_API std::optional<ChildData> wait(const PidFD fd, const WaitFlags flags = WaitFlags{WaitFlag::WAIT_FOR_EXITED});
 
 
COSMOS_API void exec(const SysString path,
                const CStringVector *args = nullptr, const CStringVector *env = nullptr);
 
 
COSMOS_API void exec(const SysString path,
                const StringViewVector &args, const StringViewVector *env = nullptr);
 
 
COSMOS_API void exec(const SysString path,
                const StringVector &args, const StringVector *env = nullptr);
 
 
COSMOS_API void exec_at(const DirFD dir_fd, const SysString path,
                const CStringVector *args = nullptr, const CStringVector *env = nullptr,
                const FollowSymlinks follow_symlinks = FollowSymlinks{false});
 
 
COSMOS_API void fexec(const FileDescriptor fd,
                const CStringVector *args = nullptr, const CStringVector *env = nullptr);
 
 
[[ noreturn ]] COSMOS_API void exit(ExitStatus status);
 
 
COSMOS_API std::optional<SysString> get_env_var(const SysString name);
 
inline bool exists_env_var(const SysString name) {
        return get_env_var(name) != std::nullopt;
}
 
using OverwriteEnv = NamedBool<struct overwrite_env_t, true>;
 
 
COSMOS_API void set_env_var(const SysString name, const SysString val, const OverwriteEnv overwrite);
 
 
COSMOS_API void clear_env_var(const SysString name);
 
struct PidInfo {
 
        PidInfo() :
                own_pid{get_own_pid()},
                parent_pid{get_parent_pid()}
        {}
 
        const ProcessID own_pid;
        const ProcessID parent_pid;
};
 
extern COSMOS_API PidInfo cached_pids;
 
}; // end ns
 
COSMOS_API std::ostream& operator<<(std::ostream &o, const cosmos::ChildData &data);