process.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_process_h
#define INCL_evo_process_h

#include "impl/sys.h"
#include "maplist.h"
#if defined(_WIN32)
    #include "thread.h"
#else
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <signal.h>
    #include <syslog.h>
#endif

namespace evo {


#if defined(_WIN32)
    typedef DWORD ProcessId;
#else
    typedef pid_t ProcessId;    
#endif

inline ProcessId get_pid() {
    #if defined(_WIN32)
        return ::GetCurrentProcessId();
    #else
        return ::getpid();
    #endif
}

#if !defined(_WIN32)
static const uint DAEMONIZE_NO_CD      = 0x01;  
static const uint DAEMONIZE_NO_REDIR   = 0x02;  
static const uint DAEMONIZE_NO_EXIT    = 0x04;  
static const uint DAEMONIZE_USE_STDERR = 0x08;  

inline bool daemonize(uint flags=0) {
    #define EVO_TEMP_LOG_ERR(MSG, ...) { \
        if (use_stderr) \
            fprintf(stderr, "daemonize: " MSG "\n", __VA_ARGS__); \
        else \
            syslog(LOG_ERR, "fork() failed: %s", strerror(errno)); \
    }

    bool use_stderr = (flags & DAEMONIZE_USE_STDERR);
    if (!use_stderr)
        openlog("daemonize", LOG_PID, LOG_DAEMON);

    bool result = false;
    for (;;) {
        // Fork to detach from parent
        pid_t pid = fork();
        if (pid == -1) {
            EVO_TEMP_LOG_ERR("fork() failed: %s", strerror(errno));
            break;
        }
        if (pid > 0)
            _exit(0); // parent

        // New session
        setsid();

        // Fork again to completely detatch from terminal
        pid = fork();
        if (pid == -1) {
            EVO_TEMP_LOG_ERR("fork() failed: %s", strerror(errno));
            break;
        }
        if (pid > 0)
            ::_exit(0); // parent

        // Reset umask, cd root
        umask(0);
        if ((flags & DAEMONIZE_NO_CD) == 0 && chdir("/") != 0)
            EVO_TEMP_LOG_ERR("chdir() on / failed: %s", strerror(errno));

        // Redirect std in/out/err to /dev/null
        if (flags & DAEMONIZE_NO_REDIR) {
            close(STDIN_FILENO);
            close(STDOUT_FILENO);
            if (!use_stderr)
                close(STDERR_FILENO);
            if (open("/dev/null", O_RDWR) != 0) {
                EVO_TEMP_LOG_ERR("open() on /dev/null failed: %s", strerror(errno));
                exit(1);
            }
            if (dup(STDIN_FILENO) == -1)
                EVO_TEMP_LOG_ERR("dup() failed for stdout: %s", strerror(errno));
            if (!use_stderr && dup(STDIN_FILENO) == -1)
                EVO_TEMP_LOG_ERR("dup() failed for stderr: %s", strerror(errno));
        }

        // Success
        result = true;
        break;
    }

    if (!use_stderr)
        closelog();
    if (!result && (flags & DAEMONIZE_NO_EXIT) == 0)
        exit(1);
    return result;

    #undef EVO_TEMP_LOG_ERR
}
#endif


class Signal {
public:
#if defined(_WIN32)
    typedef DWORD SigNumType;
#else
    typedef int SigNumType;     
#endif

    enum Action {
        aDEFAULT,       
        aIGNORE         
    };

    enum Type {
        tUNKNOWN = 0,   
        // Portable (Linux/Unix/Windows)
        tINTERRUPT,     
        tTERMINATE,     
        // Linux/Unix only
        tPIPE,          
        tCHILD,         
        tHUP,           
        tUSER1,         
        tUSER2,         
        // Windows only
        tWIN_BREAK,     
        tWIN_CLOSE,     
        tWIN_LOGOFF,    
        tWIN_SHUTDOWN   
    };

    typedef void (*Handler)(SigNumType, Type);      
    typedef void (*OnShutdown)(SigNumType, Type);   

    struct Main {
        bool error;     

        Main() : error(false) {
        }

        Main(Signal::OnShutdown on_shutdown, bool except=EVO_EXCEPTIONS) : error(false) {
            if (!Signal::set_on_shutdown(on_shutdown)) {
                if (except) {
                    EVO_THROW(Exception, "Signal::set_on_shutdown() failed");
                } else
                    fprintf(stderr, "Signal::set_on_shutdown() failed\n");
                error = true;
            }
        }

        ~Main() {
            Signal::set_on_shutdown(NULL);
            Signal::shutdown_sync();
        }
    };

    template<class T>
    struct MainServer : Main {
        MainServer(T& server, bool except=EVO_EXCEPTIONS) : Main(on_shutdown, except) {
            global_server() = &server;
        }

        static void on_shutdown(Signal::SigNumType, Signal::Type) {
            global_server()->shutdown();
        }

    private:
        static T*& global_server() {
            static T* server = NULL;
            return server;
        }
    };

    static bool set_on_shutdown(OnShutdown on_shutdown) {
        State& state = get_state();
        #if defined(_WIN32)
            Condition::Lock lock(state.condmutex); // locked until return
            if (on_shutdown != NULL && !state.registered) {
                if (::SetConsoleCtrlHandler(main_handler, TRUE) != TRUE)
                    return false;
                state.registered = true;
            }
        #else
            set_handler(tINTERRUPT, NULL);
            set_handler(tTERMINATE, NULL);
        #endif
        state.on_shutdown = on_shutdown;
        return true;
    }

    static void shutdown_sync() {
        #if defined(_WIN32)
            State& state = get_state();
            Condition::Lock lock(state.condmutex);
            state.shutdown_flag = true;
            state.condmutex.notify_all();
        #endif
    }

    static bool set_handler(Type type, Action action) {
        #if defined(_WIN32)
            if (action == aDEFAULT) {
                // Set to default by removing previously added handler
                State& state = get_state();
                Condition::Lock lock(state.condmutex);
                state.handlers.remove(get_signum(type));
                if (state.registered && state.on_shutdown == NULL && state.handlers.empty()) {
                    ::SetConsoleCtrlHandler(main_handler, FALSE);
                    state.registered = false;
                }
                return true;
            } else {
                // Windows can only ignore tINTERRUPT
                if (type != tINTERRUPT)
                    return false;
                return (::SetConsoleCtrlHandler(NULL, TRUE) == TRUE);
            }
        #else
            const int signum = get_signum(type);
            if (signum == INVALID_SIGNUM)
                return false;
            get_state().handlers.remove(signum);

            struct sigaction action_data;
            action_data.sa_handler = (action == aDEFAULT ? SIG_DFL : SIG_IGN);
            action_data.sa_flags = 0;
            sigemptyset(&action_data.sa_mask);

            return (::sigaction(signum, &action_data, NULL) == 0);
        #endif
    }

    static bool set_handler(Type type, Handler handler) {
        State& state = get_state();
        #if defined(_WIN32)
            const DWORD signum = get_signum(type);
            if (signum == INVALID_SIGNUM)
                return false;
            if (handler != NULL) {
                Condition::Lock lock(state.condmutex);
                state.handlers[signum] = handler;
                if (state.registered)
                    return true;
            }
            if (::SetConsoleCtrlHandler(main_handler, TRUE) == TRUE) {
                Condition::Lock lock(state.condmutex);
                state.registered = true;
            }
            return false;
        #else
            const int signum = get_signum(type);
            if (signum == INVALID_SIGNUM)
                return false;
            if (handler != NULL)
                state.handlers[signum] = handler;

            struct sigaction action_data;
            action_data.sa_handler = main_handler;
            action_data.sa_flags = 0;
            sigfillset(&action_data.sa_mask); // block all signals while handling signal

            return (::sigaction(signum, &action_data, NULL) == 0);
        #endif
    }

    static bool send_signal(ProcessId pid, Type signal) {
        const SigNumType signum = get_signum(signal);
        if (signal == tUNKNOWN)
            return false;

        #if defined(_WIN32)
            return (::GenerateConsoleCtrlEvent(signum, pid) == TRUE);
        #else
            return (::kill(pid, signum) == 0);
        #endif
    }

private:
    // Internal state
    struct State {
        #if defined(_WIN32)
            Condition condmutex;
            bool registered;
        #endif

        bool shutdown_flag;
        OnShutdown on_shutdown;
        MapList<SigNumType,Handler> handlers;

        State() {
            #if defined(_WIN32)
                registered = false;
            #endif
            shutdown_flag = false;
            on_shutdown = NULL;
        }
    };

    static State& get_state() {
        static State state;
        return state;
    }

#if defined(_WIN32)
    static const DWORD INVALID_SIGNUM = 0xFFFFFFFF;

    static DWORD get_signum(Type type) {
        switch (type) {
            case tINTERRUPT: return CTRL_C_EVENT;
            case tWIN_BREAK: return CTRL_BREAK_EVENT;
            case tWIN_CLOSE: return CTRL_CLOSE_EVENT;
            case tWIN_LOGOFF: return CTRL_LOGOFF_EVENT;
            case tWIN_SHUTDOWN: return CTRL_SHUTDOWN_EVENT;
            default: break;
        }
        return INVALID_SIGNUM;
    }

    static Type get_sigtype(SigNumType value) {
        switch (value) {
            case CTRL_C_EVENT: return tINTERRUPT;
            case CTRL_BREAK_EVENT: return tWIN_BREAK;
            case CTRL_CLOSE_EVENT: return tWIN_CLOSE;
            case CTRL_LOGOFF_EVENT: return tWIN_LOGOFF;
            case CTRL_SHUTDOWN_EVENT: return tWIN_SHUTDOWN;
            default: break;
        }
        return tUNKNOWN;
    }

    static BOOL WINAPI main_handler(DWORD value) {
        const Type type = get_sigtype(value);
        if (type != tUNKNOWN) {
            State& state = get_state();
            const Handler* h;
            {
                Condition::Lock lock(state.condmutex);
                h = state.handlers.find(value);
            }
            if (h != NULL)
                (*h)(value, type);

            Condition::Lock lock(state.condmutex);
            if (state.registered && state.on_shutdown != NULL) {
                lock.unlock();
                (*state.on_shutdown)(value, type);
                lock.lock();
                while (!state.shutdown_flag)
                    state.condmutex.wait(Condition::INF, true);
            }
        }
        return FALSE;
    }

#else
    static const int INVALID_SIGNUM = -1;

    static int get_signum(Type type) {
        switch (type) {
            case tINTERRUPT: return SIGINT;
            case tTERMINATE: return SIGTERM;
            case tPIPE:  return SIGPIPE;
            case tCHILD: return SIGCHLD;
            case tHUP:   return SIGHUP;
            case tUSER1: return SIGUSR1;
            case tUSER2: return SIGUSR2;
            default: break;
        }
        return INVALID_SIGNUM;
    }

    static Type get_sigtype(bool& shutdown, SigNumType value) {
        shutdown = false;
        switch (value) {
            case SIGINT:  shutdown = true; return tINTERRUPT;
            case SIGTERM: shutdown = true; return tTERMINATE;
            case SIGPIPE: return tPIPE;
            case SIGCHLD: return tCHILD;
            case SIGHUP:  return tHUP;
            case SIGUSR1: return tUSER1;
            case SIGUSR2: return tUSER2;
            default: break;
        }
        return tUNKNOWN;
    }

    static void main_handler(int value) {
        bool shutdown;
        const Type type = get_sigtype(shutdown, value);

        State& state = get_state();
        const Handler* h = state.handlers.find(value);
        if (h != NULL)
            (*h)(value, type);

        if (shutdown && state.on_shutdown != NULL)
            (*state.on_shutdown)(value, type);
    }
#endif
};


}
#endif