process.h

// Copyright (c) 1999-2018 David Muse
// See the COPYING file for more information.
 
#ifndef RUDIMENTS_PROCESS_H
#define RUDIMENTS_PROCESS_H
 
#include <rudiments/private/processincludes.h>
 
enum childstatechange {
        EXIT_CHILDSTATECHANGE=0,
        TERMINATED_CHILDSTATECHANGE,
        STOPPED_CHILDSTATECHANGE,
        CONTINUED_CHILDSTATECHANGE
};
 
class RUDIMENTS_DLLSPEC process {
        public:
 
                static int64_t  checkForPidFile(const char *filename);
 
                static bool     createPidFile(const char *filename,
                                                mode_t permissions);
 
                static  pid_t   getProcessId();
 
                static  pid_t   getParentProcessId();
 
                static  pid_t   getProcessGroupId();
 
                static  pid_t   getProcessGroupId(pid_t pid);
 
                static  bool    setProcessGroupId();
 
                static  bool    setProcessGroupId(pid_t pgid);
 
                static  bool    setProcessGroupId(pid_t pid, pid_t pgid);
 
                static  pid_t   getSessionId();
 
                static  pid_t   getSessionId(pid_t pid);
 
                static  pid_t   createNewSession();
 
                static  uid_t   getUserId();
 
                static  uid_t   getEffectiveUserId();
 
                static bool     setUserId(uid_t uid);
 
                static bool     setUser(const char *username);
 
                static bool     setEffectiveUserId(uid_t uid);
 
                static bool     setEffectiveUser(const char *username);
 
                static bool     setRealAndEffectiveUserId(uid_t uid,
                                                                uid_t euid);
 
                static  gid_t   getGroupId();
 
                static  gid_t   getEffectiveGroupId();
 
                static bool     setGroupId(gid_t gid);
 
                static bool     setGroup(const char *groupname);
 
                static bool     setEffectiveGroupId(gid_t gid);
 
                static bool     setEffectiveGroup(const char *groupname);
 
                static bool     setRealAndEffectiveGroupId(gid_t gid,
                                                                gid_t egid);
 
                static mode_t   setFileCreationMask(mode_t mask);
 
                static pid_t    fork();
 
                static bool     supportsFork();
 
                static bool     exec(const char *command,
                                        const char * const *args);
 
                static pid_t    spawn(const char *command,
                                        const char * const *args,
                                        bool detached);
 
                static bool     detach();
 
                static void     exit(int32_t status);
 
                static void     exitImmediately(int32_t status);
 
                static  bool    sendSignal(pid_t processid, int32_t signum);
 
                static  bool    raiseSignal(int32_t signum);
                
                static  void    exitOnCrashOrShutDown();
 
                static void     exitOnShutDown();
 
                static void     exitOnCrash();
                
                static  void    setShutDownFlagOnCrashOrShutDown();
 
                static void     setShutDownFlagOnShutDown();
 
                static void     setShutDownFlagOnCrash();
 
                static bool     registerExitHandler(void (*handler)(void));
 
                static  void    setShutDownHandler(
                                        void (*shutdownhandler)(int32_t));
 
                static  void    setCrashHandler(void (*crashhandler)(int32_t));
 
                static  void    setShutDownFlag(bool shutdownflag);
 
                static  bool    getShutDownFlag();
 
                static  void    setShutDownSignal(int32_t signum);
 
                static  int32_t getShutDownSignal();
 
                static  signalhandler   *getCrashSignalHandler();
 
                static  signalhandler   *getShutDownSignalHandler();
 
                static  void    setWaitForChildren(bool wait);
 
                static  bool    wait(pid_t pid);
 
                static  bool    wait(pid_t pid, int32_t *exitstatus);
 
                static pid_t    getChildStateChange(pid_t pid,
                                                bool wait,
                                                bool ignorestop,
                                                bool ignorecontinue,
                                                childstatechange *newstate,
                                                int32_t *exitstatus,
                                                int32_t *signum,
                                                bool *coredump);
 
                static bool     supportsGetChildStateChange();
 
                static void     setRetryFailedFork(bool retry);
 
                static bool     getRetryFailedFork();
 
                static void     writeBacktrace(output *out, uint32_t maxframes);
 
                static void     writeBacktrace(output *out);
 
                static void     writeBacktrace(const char *filename);
 
                static void     writeBacktrace(const char *filename,
                                                mode_t perms,
                                                uint32_t maxframes);
 
        #include <rudiments/private/process.h>
};
 
#endif