utils::Daemon Class Reference

#include <Daemon.h>

Collaboration diagram for utils::Daemon:

Public Member Functions
	Daemon ()=delete
	~Daemon ()=delete

Static Public Member Functions
static void	startDaemon (const std::string &pidFileName, const std::string &userName, const std::string &groupName)
static pid_t	stopDaemon (const std::string &pidFileName)
static void	erasePidFile (const std::string &pidFileName)

Detailed Description

Definition at line 81 of file Daemon.h.

Constructor & Destructor Documentation

Daemon()

utils::Daemon::Daemon ( )

delete

~Daemon()

utils::Daemon::~Daemon ( )

delete

Member Function Documentation

erasePidFile()

void utils::Daemon::erasePidFile ( const std::string &  pidFileName )

static

Definition at line 200 of file Daemon.cpp.

                                                          {
        (void) seteuid(getuid());             // In case we are here seteguid can not fail
        (void) setegid(getgid());             // In case we are here setegid can not fail
        std::filesystem::remove(pidFileName); // In case we are here std::Filesystem::remove can not fail
    }

Referenced by stopDaemon(), and utils::Config::terminate().

Here is the caller graph for this function:

startDaemon()

void utils::Daemon::startDaemon ( const std::string &  pidFileName, const std::string &  userName, const std::string &  groupName  )

static

Definition at line 75 of file Daemon.cpp.

                                                                                                                {
        if (std::filesystem::exists(pidFileName)) {
            throw DaemonFailure("Pid file '" + pidFileName + "' exists. Daemon already running?");
        }
        errno = 0;
 
        /* Fork off the parent process */
        pid_t pid = fork();
        if (pid < 0) {
            /* An error occurred */
            throw DaemonError("First fork()");
        }
        if (pid > 0) {
            /* Success: Let the parent terminate */
            throw DaemonSignaled("Lead new session", pid);
        }
 
        if (setsid() < 0) {
            /* On success: The child process becomes session leader */
            throw DaemonError("setsid()");
        }
 
        if (signal(SIGHUP, SIG_IGN) == SIG_ERR) {
            /* Ignore signal sent from parent to child process */
            throw DaemonError("signal()");
        }
 
        /* Fork off for the second time*/
        pid = fork();
        if (pid < 0) {
            /* An error occurred */
            throw DaemonError("Second fork()");
        }
        if (pid > 0) {
            /* Success: Let the second parent terminate */
            std::ofstream pidFile(pidFileName, std::ofstream::out);
 
            if (!pidFile.good()) {
                kill(pid, SIGTERM);
                throw DaemonError("Writing pid file '" + pidFileName);
            }
            pidFile << pid << std::endl;
            pidFile.close();
 
            throw DaemonSignaled("Drop session lead", pid);
        }
 
        struct passwd* pw = nullptr;
        struct group* gr = nullptr;
 
        if (((void) (errno = 0), gr = getgrnam(groupName.c_str())) == nullptr) {
            if (errno != 0) {
                throw DaemonError("getgrnam()");
            }
            throw DaemonFailure("getgrname() group not existing");
        }
        if (setegid(gr->gr_gid) != 0) {
            throw DaemonError("setegid()");
        }
        if (((void) (errno = 0), (pw = getpwnam(userName.c_str())) == nullptr)) {
            if (errno != 0) {
                throw DaemonError("getpwnam()");
            }
            throw DaemonFailure("getpwnam() user not existing");
        }
        if (seteuid(pw->pw_uid) != 0) {
            throw DaemonError("seteuid()");
        } /* Set new file permissions */
        umask(0);
        chdir("/");
 
        close(STDIN_FILENO);
        close(STDOUT_FILENO);
        close(STDERR_FILENO);
 
        if (std::freopen("/dev/null", "r", stdin) == nullptr) {
        }
        if (std::freopen("/dev/null", "w+", stdout) == nullptr) {
        }
        if (std::freopen("/dev/null", "w+", stderr) == nullptr) {
        }
    }

References utils::DaemonError::DaemonError(), utils::DaemonFailure::DaemonFailure(), and utils::DaemonSignaled::DaemonSignaled().

Referenced by utils::Config::bootstrap().

Here is the call graph for this function:

Here is the caller graph for this function:

stopDaemon()

pid_t utils::Daemon::stopDaemon ( const std::string &  pidFileName )

static

Definition at line 158 of file Daemon.cpp.

                                                         {
        if (pidFileName.empty()) {
            throw DaemonFailure("No pid file given");
        } /* Try to read PID of daemon to from lockfile and kill the daemon */
        std::ifstream pidFile(pidFileName, std::ifstream::in);
 
        if (!pidFile.good()) {
            pidFile.close();
            throw DaemonError("Reading pid file '" + pidFileName + "'");
        }
        pid_t pid = 0;
        pidFile >> pid;
        pidFile.close();
 
        const int pidfd = static_cast<int>(syscall(SYS_pidfd_open, pid, 0)); // NOLINT
 
        if (pidfd == -1) {
            erasePidFile(pidFileName);
            throw DaemonFailure("Daemon not running");
        }
        if (kill(pid, SIGTERM) != 0) {
            throw DaemonError("kill()");
        }
        struct pollfd pollfd{};
        pollfd.fd = pidfd;
        pollfd.events = POLLIN;
 
        const int ready = core::system::poll(&pollfd, 1, 5000);
        close(pidfd);
 
        if (ready == -1) {
            throw DaemonError("poll()");
        }
        if (ready == 0) {
            kill(pid, SIGKILL);
            erasePidFile(pidFileName);
            throw DaemonFailure("Daemon not responding - killed");
        }
 
        return pid;
    }

References utils::DaemonError::DaemonError(), utils::DaemonFailure::DaemonFailure(), and erasePidFile().

Referenced by utils::Config::parse1().

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• utils/Daemon.h
• utils/Daemon.cpp