SigAction.hxx

#pragma once
 
// Linux
#include <signal.h>
 
// C++
#include <optional>
 
// cosmos
#include <cosmos/BitMask.hxx>
#include <cosmos/proc/SigSet.hxx>
#include <cosmos/memory.hxx>
 
namespace cosmos {
 
class SigInfo;
class SigAction;
 
namespace signal {
        void set_action(const Signal sig, const SigAction &action, SigAction *old);
        void get_action(const Signal, SigAction&);
}
 
 
class COSMOS_API SigAction {
        friend void signal::set_action(const Signal, const SigAction&, SigAction*);
        friend void signal::get_action(const Signal, SigAction&);
public: // types
 
        enum class Flag : int {
                NO_CHILD_STOP  = SA_NOCLDSTOP,
                NO_CHILD_WAIT  = SA_NOCLDWAIT,
                NO_DEFER       = SA_NODEFER,
                ON_STACK       = SA_ONSTACK,
                /*
                 * This is the highest bit of the `int` and conflicts with the
                 * signedness of `int` when being used in an enum. Cast it explicitly
                 * to int to get around that.
                 */
                RESET_HANDLER  = static_cast<int>(SA_RESETHAND),
                RESTART        = SA_RESTART,
                SIGINFO        = SA_SIGINFO,
                /* The rest here did not make it into the user space headers (yet?) */
                RESTORER       = 0x04000000, /*SA_RESTORER*/
#if 0
                UNSUPPORTED    = SA_UNSUPPORTED,
                EXPOSE_TAGBITS = SA_EXPOSE_TAGBITS,
#endif
        };
 
        using Flags = BitMask<Flag>;
 
        using SimpleHandler = void (*)(const Signal);
        using InfoHandler = void (*)(const SigInfo&);
 
        static const SimpleHandler IGNORE;
        static const SimpleHandler DEFAULT;
        static const SimpleHandler UNKNOWN;
 
public: // functions
 
        SigAction() {
                clear();
        }
 
 
        explicit SigAction(const no_init_t) {}
 
        void clear() {
                zero_object(m_raw);
        }
 
 
        void setFlags(const Flags flags) {
                const auto had_siginfo = (m_raw.sa_flags & SA_SIGINFO) != 0;
                m_raw.sa_flags = flags.raw();
 
                if (had_siginfo) {
                        m_raw.sa_flags |= SA_SIGINFO;
                } else {
                        m_raw.sa_flags &= ~SA_SIGINFO;
                }
        }
 
        Flags getFlags() const {
                return Flags{m_raw.sa_flags};
        }
 
        const SigSet& mask() const {
                const auto mask = reinterpret_cast<const SigSet*>(&m_raw.sa_mask);
                return *mask;
        }
 
 
        SigSet& mask() {
                auto mask = reinterpret_cast<SigSet*>(&m_raw.sa_mask);
                return *mask;
        }
 
 
        void setHandler(SimpleHandler handler);
 
 
        void setHandler(InfoHandler handler);
 
 
        std::optional<SimpleHandler> getSimpleHandler() const {
                if (std::holds_alternative<SimpleHandler>(m_handler)) {
                        return std::get<SimpleHandler>(m_handler);
                }
 
                return {};
        }
 
        std::optional<InfoHandler> getInfoHandler() const {
                if (std::holds_alternative<InfoHandler>(m_handler)) {
                        return std::get<InfoHandler>(m_handler);
                }
 
                return {};
        }
 
        const struct sigaction* raw() const {
                return &m_raw;
        }
 
protected: // functions
 
        struct sigaction* raw() {
                return &m_raw;
        }
 
        void updateFromOld(InfoHandler info, SimpleHandler simple);
 
protected: // data
 
        struct sigaction m_raw;
 
        std::variant<SimpleHandler,InfoHandler> m_handler;
};
 
} // end ns